accipter posted:

I just wanted to point out Pendulum: http://pendulum.eustace.io/ . It looks like it solves a number of datetime's issues without some of arrow's issues.

kalstrams posted:

ffs this struct thing is getting annoying

code:

. [80, 584024144, 1048576, 524288, '=524288h', 1, 706772912, 122748768, 1048576, 122748768]
. [80, 585072720, 1048576, 524288, '=524288h', 1, 706772912, 121700192, 1048576, 121700192]
. [80, 586121296, 1048576, 524288, '=524288h', 1, 706772912, 120651616, 1048576, 120651616]
. [80, 587169872, 1048576, 524288, '=524288h', 1, 706772912, 119603040, 1048576, 119603040]
. [80, 588218448, 1048576, 524288, '=524288h', 1, 706772912, 118554464, 1048576, 118554464]
Traceback (most recent call last):
  File "script.py", line 128, in <module>
    real=real, datafile=datafile)
  File "/path/codebase.py", line 125, in binary
    data.append(np.array(unpacker.unpack(storage.read(line_bytes)), dtype=np.float32))
struct.error: unpack requires a string argument of length 1048576

so, in that list that's being printed, we have
header in bytes, pointer in bytes, data size to read in bytes (line_bytes), number samples to read (line_samples), sample format (form), irrelevant variable, effective size of the current file in bytes, unread amount of data in the current file in bytes, irrelevant variable, and effective remaining amount of data in bytes

code where it breaks

code:

storage.seek(header + pointer)
data.append(np.array(unpacker.unpack(storage.read(line_bytes)), dtype=np.float32))

where

code:

form = format % (line_samples)
unpacker = struct.Struct(form)

and

code:

storage = io.open(self.source[datafile], 'rb', buffering=0)

for the life of me i cant figure out why it seemingly randomly has broken at that point, if, as you see from earlier in the log (new line = successful read) - it did work just fine before that

kalstrams posted:

Would anyone reasonably familiar with python's (2) struct module mind looking into my problem? I'll post the quote describing it below, sorry for poor formatting and such. Spent better half of this day breaking spears against it at no avail, so likely it's something dumb and obvious.
Basically, I have a method inside class that reads numerical data from binary files. In the executable script there are two for loops, outer that initialises sets of input arguments, and inner that runs bunch of methods in the workflow.

I'm struggling to understand the problem since I can't easily reproduce it on the machine where I am able to use debugger. I can get the exact same error on the exact same data, but it's on a remote workstation, and my personal computer might not be able to handle this exact computation in the event that I had data in situ.

QuarkJets posted:

Unpack is being given an argument of the wrong length. Try running that long set of calls line-by-line and check that the object being returned by storage.read(line_bytes) is actually line_bytes in length.

kalstrams posted:

Beats me how that could be possible but at least now I know where and how to look. Cheers!

yippee cahier posted:

Not sure about your file format, but one reason could be your seek statement... Do you want to skip the pointer or to where your pointer is pointing?

Tigren posted:

For the life of me I can't figure out where to start. Does anyone have any good reads or tutorials on test-driven design? I've found a couple that show TDD with Django, but I'm not really looking to get into the whole Django workflow while learning TDD.

jon joe posted:

This is a pretty basic question, but can I get a good tutorial to help me understand in the ins and outs of classes in python? Something about them makes my eyes bounce off them and brain refuse to understand how they work, no matter how many pages about them that I google and read. This is despite understanding the concept of objects (or so I think).

QuarkJets posted:

Is this your first time using classes in general, or just classes in python?

jon joe posted:

This is a pretty basic question, but can I get a good tutorial to help me understand in the ins and outs of classes in python? Something about them makes my eyes bounce off them and brain refuse to understand how they work, no matter how many pages about them that I google and read. This is despite understanding the concept of objects (or so I think).

Dominoes posted:

Forget objects - you don't need them!

tef posted:

Thermopyle posted:

Objects are useful some percentage of the time.

Thermopyle posted:

The rest of the time they actively make code worse.

jon joe posted:

Examples of this would may also be interesting, if only for entertainment purposes.

jon joe posted:

That's another thing I don't get. Do objects really do anything besides organize code and change the syntax?

jon joe posted:

I like to be able to go dictionary[dictionary][thing], can I go class.class.thing? Do I -want- to go class.class.thing? Will a function I call from a class be different from a function I call from a dictionary? Can I even pass variables into class.class.thing like I can dictionary[dictionary][thing], ala class.class.x, x = thing?

SurgicalOntologist posted:

You technically can't do dictionary[dictionary][thing] because dictionaries aren't hashable. But I don't think you really intended to do that, you just meant dictionary[thing][another_thing], so I apologize for the pedantry.

jon joe posted:

Examples of [OOP making things worse] would may also be interesting, if only for entertainment purposes.

SurgicalOntologist posted:

There's no actual loop because you're only doing an operation once. The operation is "tuple unpacking". Pretty sure this should work in 3.5:

Python code:

(player1, action1), (player2, action2) = action_list.items()

which is short for

Python code:

item1, item2 = action_list.items()
player1, action1 = item1
player2, action2 = item2

Finally, for your own sanity I would recommend not using _list in the variable name for a dictionary.

jon joe posted:

Which is better:

code:

dict = {}
def populate(key, tuple):
    if key in dict:
        dict[key][tuple[0]] = tuple[1]
    else:
        dict[key] = {}
        dict[key][tuple[0]] = tuple[1]

vs

code:

dict = {}
def populate(key, tuple):
    try:
        dict[key][tuple[0]] = tuple[1]
    except KeyError:
        dict[key] = {}
        dict[key][tuple[0]] = tuple[1]

jon joe posted:

Which is better:

code:

dict = {}
def populate(key, tuple):
    if key in dict:
        dict[key][tuple[0]] = tuple[1]
    else:
        dict[key] = {}
        dict[key][tuple[0]] = tuple[1]

vs

code:

dict = {}
def populate(key, tuple):
    try:
        dict[key][tuple[0]] = tuple[1]
    except KeyError:
        dict[key] = {}
        dict[key][tuple[0]] = tuple[1]

Thermopyle posted:

LBYL and EAFP and their pros/cons.

QuarkJets posted:

Hey so I was updating my anaconda's pyside today and anaconda appears to have completely hosed itself; the Python and conda binaries are completely gone. Anyone else ever have this issue (on a centos system)?