In other words, I’m emulating a break statement in the loop, but only for the first match. In code, that is:

I could do this with a list comprension and getting the element at index 0:

…but that means the whole list is created, and what if the list is large and/or the match() function is expensive? I’d really like to just stop looping when I’ve got a match. Generator expressions come in handy here:

Also note that in Python3, functions like filter() return an iterator (which may have a generator under the hood, I’m not sure), so this is possible:

Now I’ve got the first matching value, and I don’t have to match against every item in the list. Hooray for functional Python

So the URL for the page I can stream files from looks like this:

So I tried removing the “index_textbook.php” part, and luckily they didn’t block me from getting a directory listing. I see there’s a “mov/” subdirectory, so I go there, and voila! all the files right in front of me. But why are they .mov files? Aren’t they supposed to be audio files? I download one and try opening it. Each time I open it, it has to buffer for a few seconds. Moreover, the file is only 84 bytes. Ah, so the .mov file is probably just a container with a reference to some network resource. I open it to find out:

Yep, that was it. But what is RTSP? Just some streaming protocol; nothing interesting. Now how do I get the actual audio data? Here’s where VLC comes to the rescue. I look up some documentation on dumping streams. Let’s try a simple command (note, the “vlc://quit” at the end makes sure it terminates when it’s done, otherwise it will hang, waiting for more input):

(a few minutes later)

And there it is, an audio file! The first time I got a file with lots of skips and gaps, so be sure that you dump the stream as it is stored, and transcode later. In this case, the file was an mp4 audio file wrapped in a mov container. If that wasn’t the problem, try running the command again and make sure nothing else on your computer is using a lot of bandwidth.

Using the date, it will also consider daylight saving’s time. Compare it with:

Now I see there is an example if the man-documentation of `date`, along with other options.

[UPDATE]

The above only converts from some other timezone to the one your shell is set to. If you want to go the other way around, you need to change the timezone (temporarily) when the command is run. For example, if you are in the Pacific timezone and want to convert a time to Singapore time, do the following (all on one line):

I would like to get rid of the for-loop and construct such a dictionary at once. I wrote a dict-derived class to do that, but it can do even more. But first, here is how I would do the above:

That’s it!

Notice how it takes a function as its first parameter. This is similar to how defaultdict takes a callable, but instead of taking a 0-arity callable, AccumulationDict takes a binary function. Whenever it “accumulates” a key-value for a key that already exists, the existing value and new value are sent to this function, and the result is what is set as the new value in the dictionary. This function will most likely be addition (rather than the lambda expression one could use operator.add), but it could be anything. Say you’re calculating probabilities of multiple events, you could use operator.mul.

I did not want to break KeyErrors, so accumulating is separate from getting and setting. This means you can still use __setitem__() and update() to reset the values of keys. Accumulation happens in the constructor, in dictionary addition, and with a new accumulate() function. accumulate() is identical to update() in interface, but uses the provided accumulator function to “merge” values when there are key collisions.

The code is below, but it represents a proof-of-concept and could be improved:

When Kimmo Koskenniemi worked out two-level morphology, generative phonology via context-sensitive rewrite rules were the common way of describing morphological systems. These kinds of rules were fairly expressive in generating surface forms from lexical forms, but were nearly useless in lexical analysis, and furthermore were computationally expensive. Johnson 1972, and later Kay and Kaplan in “Phonological Rules and Finite-State Transducers”, 1981, showed that these rules were insufficient and proposed finite-state transducers as cascading rules applied to lexical forms, and further that the sequence of FSTs could be collapsed to a single, very-expressive (and large) FST. In this context, Koskenniemi’s proposed a two-level system where smaller FSTs were applied in parallel instead of in sequence.

Aside from the computationally tractable benefits of two-level morphology, from what I could tell it only addresses the morphophonological changes to a lexical item. For instance, it may define a rule that inserts an e after a consonate-y sequence and before a (morpheme-boundary)-s sequence (as in the English plural “spy” -> “spies”; a separate rule handles the y->i conversion):

I don’t see how the “spy0+s” lexical form gets created, but the generality of +s being plural for all inflectional patterns is convenient. Also, I don’t see how long distance restrictions are modeled, as the rules appear to be limited to immediately-adjacent contexts.

I also found some articles by Koskenniemi (here and here) and Karttunen, Kaplan, Zaenen (here), but I haven’t yet read or written about them.

• to compile the whole thing (after uncommenting the avms)
• do some reading, then write the background/previous-work section
• Koskenniemi’s 2-level automata
• Beesly and Karttunen’s flag diacritics

I added line wrapping and indenting so users don’t have to manually put in line-breaks to get nicer looking outputs, but there is the drawback that it makes the output harder to grep. Perhaps I should add an option to disable the line wrapping.

Here is a longer example with some simple option parsing (apologies for using getopt; I’m currently looking for a better solution).