I’m about to embark on a quest to understand the development for custom google-closure components (UI widgets if you will). Reading through the relevant section in “Closure – The Definitive Guide” makes me believe, it’s not all too difficult. But there are still a bunch of concepts which I need to familiarize myself with. This article briefly outlines my aim for this “learning trail”, and starts of with a tiny HelloWorld project using plovr. This article assume a minimal knowledge of google closure (you should know what “provides” and “requires”. “exportSymbol” should also not surprise you) Read the rest of this entry »
According to the Python documentation about __repr__, a call to repr() should give you a valid Python expression if possible. This is a very useful guideline. And it is also something I I like to implement in my Python projects as much as possible.
Now, for mapped database entities, you might argue that it makes sense to have a default constructor as long as it accepts the primary key columns.
By default, it is possible to create new instances by specifying column values in SQLAlchemy. For example:
It should be possible to create such “repr” values automatically for primary keys. All the required meta info is available. Digging through the SA docs, I found that it is possible the customize Base in order to add behaviour to all mapped entities!
Here’s the result:
With this in place, all representations of DB entities will finally make sense and be copy/pasteable directly into your code.
Of course, by nature of ORMs, the new instances created this way will be detached from the session and need to be merged before you can do any DB related operations on them! A simple example:
sess = Session()
user = User(name=u'John Doe', firstname.lastname@example.org')
user = sess.merge(user)
More than once I needed to create files on the staging/production box which I had no need of on the local development box (For example complex logging configuration).
This fragment contains a simple function which tries to do this in a safe manner, and also ensuring proper cleanup in case of failure.
Today I needed to keep an eye on PostgreSQL logs. Luckily, I decided upon installation to log everything using the “csvlog” format. But there’s a small catch, depending how you read that log. This catch is newline characters in database queries.
This has nothing to do with PostgreSQL directly. In fact, it does the right thing, in that it quotes all required fields. Now, a quoted field can contain a newline character. But if you read the file on a line-by-line basis (using methods like file_handle.readline, this will case problems. No matter what programming language you use, if you call readline, it will read up to the next newline character and return that. So, let’s say you have the following CSV record:
If you read this naïvely with “readline” calls, you will get the following:
6: FROM port p1
7: INNER JOIN port p2 USING (link)
8: WHERE p1.device='E'
9: AND p1.scope='provisioned'
10: AND p1.label='Eg'
11: AND (p1.device = p2.device
12: AND p1.scope = p2.scope
13: AND p1.label=p2.label) = false",,,,,,,,,""
Now, this is really annoying if you want to parse the file properly.
Read the file byte-by-byte, and feed a line to the CSV parser only if you hit a newline outside of quoted text. Obviously you should consider the newline style (\n, \r or \r\n) and the proper quote and escape characters when doing this.
What about Python?
It turns out, Python’s csv module suffers from this problem. The builtin CSV module reads files line-by-line. However, it is possible to override the default behavior.
For my own purpose, I wrote a simple script, reading from the postgres log until interrupted.
You are free to use this for your own purpose, modify or extend it as you like.
You can find it here: exhuma/postgresql-logmon
I do a lot of work on the go. Offline. Sometimes it takes a long time to push changes to a remote repository. As always, Murphy’s law applies, and the one repo that explodes into my face is the one with ten days worth of work in it.
While working, suddenly my laptop hang. Music looping. No mouse movement. Nothing. The only possible solution was to do a cold-reboot. I was not worried. Everything was saved, and I only changed a few lines and can easily recover if something went awry. So I rebooted.
Once back in the system, I immediately wanted to do a git status and git diff. Git spat back the following error message:
fatal: object 9bd41c2f96f295924af92a9da175cb3686f13359 is corrupted
My Laptop had shown some strange and erratic behaviour over the last few days already. I already left a memtest running for about 24 hours earlier this week without errors. The only possible explanation left was the hard-disk.
Fun times ahead! 10 days of work at risk… 10 days of important changes! Sweat building up my forehead. Bloody sweat!
I trust my tools to keep my code safe. I trust git. I trust vim. I do microscopic commits, and I knew my current uncommitted changes only involved a few lines. So maybe only the last commit got corrupted? Let’s see…
docutils supports adding a wide range of unicode glyphs into documents, while still keeping the source document readable and plain ASCII.
The character mappings are available in include files, and have to be included into the document before being useful.
For example, adding a horizontal arrow is done by including 'isoamsa.txt' which provides (amongst others) the replacement |hArr|. An example document might be:
This is some text containing an arrow symbol: |hArr|
Hav a look at the extensions available in the official docutils distribution for more information.
When using Doctrine 2 with a MySQL Database which has tables with ENUM datatypes, you might run into the following error message:
‘Unknown database type enum requested, Doctrine\DBAL\Platforms\MySqlPlatform may not support it.’
This is because Doctrine 2 doesn’t support the ENUM DataType natively as you can read here: Doctrine Cookbook.
In their Doctrine Cookbook they give a solution how you can resolve this by mapping the ENUM to a STRING datatype. But if you’re using Zend Framework 2 you’ll probably run into the same question as I have: where do I put this stuff for it to work?
This might not be the perfect solution, but it worked for me.
Adding the required code to the onBootstrap() method of the Module.php file of the “default” module did the job.
public function onBootstrap(MvcEvent $e)
$em = $e->getApplication()->getServiceManager()->get('Doctrine\ORM\EntityManager');
$platform = $em->getConnection()->getDatabasePlatform();
I tend to test my REST services using curl. Most of the time the JSON responses are not pretty-printed, which makes testing larger documents a pain. Copy pasting the results in online JSON formatters was really getting annoying. So I wrote a few lines of python to do that job for me. Note that this is a two-minute-hack and by no means very generic. It works for me, and with curl. The handling for Headers is especially eerie But maybe you will still find it useful.
Without further ado, here it is: https://github.com/exhuma/braindump/tree/master/jsonformat
I actually did not believe it’s this simple.
Creating the tunnel is as easy as typing:
Which can be improved with
See the man page on the details of the extra options.
This will open up port 1080 on your local machine, providing a SOCKS proxy (SOCKS5 if I’m right). You can then specify this in any application supporting SOCKS proxies. This includes Firefox and Chrome. With Firefox it’s straight-forward. You can find it in the usual proxy page in the settings.
For chrome it’s a bit more tricky. While you can specify a SOCKS proxy, it seems to ignore it. If you want to enable your tunnel, you have to run chrome with the following command-line flag:
(or use chrome. Whatever rocks your boat).
Once this is set up, what will happen is that your application/browser will send all requests to your locally running SSH instance. This in turn will forward it to the remote host, where the request will be sent out on the web. The response takes the inverse direction. As stated by linode, this is great if you’re on an untrustworthy network!
While cleaning up my build process using ‘closure’, I stumbled across plovr. After using it for only 20 minutes, I am convinced that this should be in the toolbox of *everyone* developing with the closure library!
While the documentation is still a bit sparse, you can have it set up in no time! There’s no need to regurgitate a basic setup example in this post. Everything necessary is readily availble over at http://plovr.com/!