Jul 25, 2015

[Python] Trying out PEP0484 Type Hinting, ABCMeta, and PyCharm

After my wife gave birth to our first-born daughter, I started a new Python project and named it after this baby girl. This was a brand new project and did not require me to think about backward compatibility, so I decided to use later version of Python and challenge to employ some ideas that I liked while learning Java: type safety, private properties, explicit overriding with @Override, and organized inheritance. These are things that make me feel safer and comfortable.
Python itself does not actually support them, but I found some can be achieved in certain level with help of modules and IDE.

Type Hinting

I just realized that PEP 0484 was accepted on May. This kind of type hinting was already available with docstrings, but it employed PEP 3107 style annotations to achieve it, so it is now officially a part of Python 3.5 or later. Python 2.7 or 3.2+ can still use backported version of typing module to implement it. I knew, in terms of readability, there was a constructive discussion introduced in Type hinting in Python: focus on readability, but I decided to give this a try.
Utilizing this type hinting, however, included another challenge for me. Since jedi-vim did not support this yet, I had to switch from Vim to PyCharm. PyCharm's support is still limited, but basic features are covered. With the help of IdeaVim plugin, switching cost was much lower than I had ever thought.

Installing typing module

Installing typing was a bit tricky. Regular pip command, `pip install typing`, somehow broke and ended up installing empty ver.0.0, so I had to explicitly set version with `pip install -lv typing==3.5.0b1`. This worked O.K.
With the nature of PEP0484, type checking is not done on runtime, so the type hinting is mostly for static check by other third party modules or IDEs. Therefore I found it really important to know IDEs' current support level. The worst case scenario is that you think your IDE supports PEP 0484 perfectly, you mis-define or miscall the function, but your IDE does not actually support correctly so you end up with no warnings. Here are some limitations I have found so far.

Some limitation with PyCharm

Type aliases

Using type aliases to declare complex type at one place or to give a more meaningful type name seems to be a pretty good idea, but this support is limited with current version of PyCharm.
See the capture below. PyCharm correctly gives warnings when the argument declaration has no type alias or has simple alias with built-in types; but gives no warning for type alias with customized types provided by typing module.

Just like other warnings, you can click on the yellow marked part to see the detailed description.

The tricky thing is that you want to use type alias for complex declaration to avoid miscalling or mis-declaration, but this ironically leads to a bug since the use of type aliases eliminates the chance to see the proper warnings. I stored all complex declarations in types.py and used them in other modules, then I found out it did not work with PyCharm. We must keep this in mind.
It will be supported with PyCharm ver.5.0, though. Let us look forward to it.

Abstract collection types

Although PEP0484 recommends to use abstract collection types for arguments as below, such declaration results in warnings.
Note: Dict , List , Set and FrozenSet are mainly useful for annotating return values. For arguments, prefer the abstract collection types defined below, e.g. Mapping , Sequence or AbstractSet .

I guess this is not supported yet just like the previous one, but as long as you get warnings you have chance to know something is happening and have option to ignore it. So I am not as worried as the previous type alias ignorance.


With type hinting, function signature became more detailed comparing to *args and **kwargs, so I became more interested in what typing module's @overload decorator would do for us.
It did not take so long to find that this decorator can only be used in stub files with .pyi extension, and the actual declaration and implementation stay in .py just like usual. In other words, even though typing module provide us this decorator, we can not declare same-named functions with different signatures.
Let us look at the signature below. This tells us that __getitem__ receives int or slice as an argument, and returns int or bytes as return value. BUT you can not be sure which of int or bytes is returned when you give int as argument.
def __getitem__(self, a: Union[int, slice]) -> Union[int, bytes]:
    if isinstance(a, int):
        # Do something
        # Do something 

In such case, in stub file, we can declare separately with @overload decorator like below:
def __getitem__(self, i: int) -> int: ...

def __getitem__(self, s: slice) -> bytes: ...

This looks more obvious that int argument returns int while slice argument returns bytes. Since I was not going to need such use cases and preparing separate .pyi file seemed a little pain, I did not use this, anyway.

My feedback about type hinting

As I employed type hinting with typing module, I became more cautious about giving arbitrary arguments. Especially for public methods, I stopped using dict, *args, **kwargs. Instead I started to define a JavaBean-like classes to hold those values, use name mangling strategy to provide private-like properties, and set @property for getter methods. As a happy side-effect, I enjoy stronger code completion where PyCharm support type hinting. Now I feel more comfortable and safe.

Structured/Organized inheritance

As I learned Java for several days, I started to like the idea of interface, default modifier, abstract class, @Override annotation, and etc... Those things seem to make me more comfortable in terms of safer design. It is a bit tiring to think about design in detail, though.
I found ABCMeta and Type hinting can support some of them.


With a help of ABCMeta, we can create a class with abstract methods and abstract properties that obligate inheriting class to override, and can create default methods that can be overridden. This is a bit like Java's interface that has methods with abstract or default modifiers.

@abstractmethod and @abstractproperty

Method and property with these decorators obligate inheriting class to override. I am really comfortable with PyCharm's assistance giving me the option to override the abstract methods.

It automatically declare the function with the same signature, which I think is pretty neat. So when I want to define behavior, I like to use ABCMeta with @abstractmethod.


In Java, we have @Override annotation, but Python does not provide @override decorator. I missed it at first, but I found it somewhat O.K. since PyCharm gives us warnings for wrongful overriding. Why *somewhat*? It is now safer that PyCharm gives us warnings for mis-overriding, but we still miss the explicitness to indicate the declaring method is overriding the existing one or we are extending the class to declare a new method.

My feedback about abc module

After I started using abc.ABCMeta, I feel more comfortable about declaring behavior in an Java's interface-like class. It is still more casual, but it is nice that we can obligate inheriting class to behave in a certain way by overriding designated abstract methods.


When I work on my personal projects, it is not uncommon that projects are left for relatively a long time. Then I look into the implementation for maintenance purpose, but I do not remember much about them. So I feel more comfortable when things are organized and are explicitly declared.
With that said, things I tried this time are pretty neat, and I am looking forward to having next version of PyCharm.

Further reading

Apr 5, 2015

Added v2.3 support to Facebook::OpenGraph

Last weekend I added Graph API v2.3 support to Facebook::OpenGraph, and released it to CPAN. Basically this module does not require a lot of code change to support different API versions because it focuses on minimal implementation with maximum convenience. When I designed it, I did not want to require developers to cover both Graph API and this module's specification; Client modules should be as thin as possible so developers do not have to be conscious of its existence.
This time, however, Graph API v2.3 has major change on /oauth/access_token response. It used to return URL encoded query string, but is going to return JSON object from its latest version. So I added several new methods and some code change as below:
  • Now Facebook::OpenGraph::Response has methods for Graph API version comparison
  • Facebook::OpenGraph checks API version, and if it is higher than v2.3, it parses the response body as JSON object
These version comparison methods are handy. $response->api_version returns API Version that is returned from Graph API, which I think is safer than using the version given by developers. The designated version and actual experiencing version may differ sometimes as described on document.
we now return an HTTP response header called 'facebook-api-version' which indicates which API version your app is actually experiencing - this may be different to the API version you specify in your request due to upgrades.
I am not creating brand new Facebook App lately, so there might be some edge-cases that I am missing. I will be happy to have your feedback on github.

Jan 18, 2015

Progress Report: Add mbed AudioCODEC (TLV320AIC23B) support to Raspbian

Lately, on last cyber Monday, I purchased a new Raspberry Pi B+ and some peripherals from Adafruit. I already had a RasPi B, and I was fairly satisfied with my previous camcorder project, but those cool features including HAT's concept and improved electrical stability seemed attractive to me. So I decided to migrate my camcorder project to RasPi B+, and hopefully add audio support.
Here are some features my camcorder previously offered:
  • GPS logging
  • Live preview on PiTFT with current driving speed and recording status
  • Video recording
My first plan to add audio recording feature was to connect electret microphone amplifier via ADC, but turned out to be a bad idea; The combination of ADC, I2C connection and linux (time-sliced OS) can not provide enough sampling rate of 40kHz or more.
I decided to use my mbed AudioCODEC, instead. The latest Raspbian kernel does not include support for this device, so I had to go through a lot of search. What I found really helpful were koalo's article and jasaw's project. With their help, what I have done so far are 1) adding device driver, 2) cross compiling Raspbian kernel, 3) applying this modification to running B+, and 4) wiring. I am going to describe each step to show what I did and how things failed.

Add device driver

There are multiple ways to add device driver. You may just build with required files, and then install them. I think it is the fastest way because you will never have to compile the whole Raspbian kernel. However, for my better understanding and later convenience, I chose to add required files to proper location, add modification to Kconfig and Makefile, and cross compile the entire Raspbian kernel. All modifications can be found at here, and are self-explanatory.

Cross compile Raspbian kernel

To avoid confusion regarding gcc version issue and OSX's case-sensitivity problem, I prepared a new Debian environment on VirtualBox. This way, if anything happens, I can just get rid of this environment and start all over again.
First I cloned my repository to $HOME/dev/oklahomer/linux/, and tools repository to $HOME/dev/raspberrypi/tools/. Then export some environment variables as below:
➜ linux git:(feature/mbed_support) export CCPREFIX=$HOME/dev/raspberrypi/tools/arm-bcm2708/gcc-linaro-arm-linux-gnueabihf-raspbian-x64/bin/arm-linux-gnueabihf-
➜ linux git:(feature/mbed_support) export MODULE_TEMP_PATH=~/work/modules
Then run `make`. The output of `make menuconfig` is located at here.
➜ linux git:(feature/mbed_support) make ARCH=arm CROSS_COMPILE=${CCPREFIX} menuconfig
➜ linux git:(feature/mbed_support) make ARCH=arm CROSS_COMPILE=${CCPREFIX} -j4
Then it complains about absence of GLIBC_2.14 as below:
/home/oklahomer/dev/raspberrypi/tools/arm-bcm2708/gcc-linaro-arm-linux-gnueabihf-raspbian-x64/bin/arm-linux-gnueabihf-gcc: /lib/x86_64-linux-gnu/libc.so.6: version `GLIBC_2.14' not found (required by /home/oklahomer/dev/raspberrypi/tools/arm-bcm2708/gcc-linaro-arm-linux-gnueabihf-raspbian-x64/bin/arm-linux-gnueabihf-gcc)
Follow the instruction described here, and install glibc >= 2.14.
  1. Add following lines to /etc/apt/sources.list
    deb http://ftp.iinet.net.au/debian/debian wheezy main contrib non-free
    deb http://ftp.iinet.net.au/debian/debian wheezy-backports main
    deb http://ftp.iinet.net.au/debian/debian jessie main contrib non-free
  2. Add following lines to /etc/apt/preferences
    Package: *
    Pin: release a=testing
    Pin-Priority: 10
    Package: *
    Pin: release a=stable
    Pin-Priority: 900
  3. Install
    ➜ linux git:(feature/mbed_support) sudo apt-get install -t testing libc6-dev
Try again.
➜ linux git:(feature/mbed_support) make ARCH=arm CROSS_COMPILE=${CCPREFIX} -j4
➜ linux git:(feature/mbed_support) make ARCH=arm CROSS_COMPILE=${CCPREFIX} INSTALL_MOD_PATH=${MODULE_TEMP_PATH} modules
➜ linux git:(feature/mbed_support) make ARCH=arm CROSS_COMPILE=${CCPREFIX} INSTALL_MOD_PATH=${MODULE_TEMP_PATH} modules_install
Prepare files to scp.
➜ linux git:(feature/mbed_support) find ./ -name zImage
➜ linux git:(feature/mbed_support) mv arch/arm/boot/zImage ~/work/.
➜ linux git:(feature/mbed_support) cd ~/work/
➜ work tar czf modules.tar.gz modules
➜ work  ls -l
total 15576
drwxr-xr-x 3 oklahomer oklahomer     4096 Jan  4 14:36 modules
-rw-r--r-- 1 oklahomer oklahomer 12688435 Jan  4 15:20 modules.tar.gz
-rwxr-xr-x 1 oklahomer oklahomer  3254856 Jan  4 15:14 zImage
Finally send zImage and modules.tar.gz to RasPi B+.

Apply changes

SSH login to RasPi B+.
  1. Place modules
    cd /tmp
    tar xzf modules.tar.gz
    cd /lib
    mv modules modules_org
    mv /tmp/modules/lib/modules /lib
    chown -R root:root /lib/modules
  2. Place kernel image
    cd /boot
    mv kernel.img kernel.img.org
    cp /tmp/zImage kernel.img
  3. Reboot
  4. Check update/upgrade
    1. sudo apt-get update
    2. sudo apt-get upgrade
  5. Add modules to /etc/modules
    # i2c related modules are required for i2s
    # for i2s
    # for mbed AudioCODEC
  6. Reboot
  7. Check i2cdetect.
    It seems O.K. to me since UU on 0x1b indicates that this is reserved by kernel. At least I thought so.
  8. Check aplay.
  9. Check arecord.


RasPi b+ has different GPIO pin layout than older model. For mapping, I referred to this PDF.
I am not 100% sure about the mapping below, and I think it has something to do with the problems I am going to introduce later.
mbed AudioCodec   |     Raspberry Pi
----------------- +---------------------
    BCLK   (I2S)  |       P5 - 03
    3V3           |       3V3
    DIN    (I2S)  |       P5 - 06
    DOUT   (I2S)  |       P5 - 05
    SCLK   (I2C)  |       P1 - 05
    SDIN   (I2C)  |       P1 - 03
    GND           |       GND


Here is the output of `dmesg` that confuses me.
[    5.067470] i2c i2c-1: Failed to register i2c client tas5713 at 0x1b (-16)
[    5.338188] i2c i2c-1: Can't create device at 0x1b
[   11.813418] snd-rpi-mbed snd-rpi-mbed.0:  tlv320aic23-hifi <-> bcm2708-i2s.0 mapping ok
[   11.933579] tlv320aic23-codec 1-001b: ASoC: Capture Source DAPM update failed: -5
The entire output is located at gist. I am not sure if it is the direct reason, but `aplay` does not give me any sound at all. I am going to edit or post when I have any progress.