• Interaction: click-and-drag to pan, use the mousewheel to zoom, mouseover for a tooltip
• Updates: automatically updated every 3minutes

What to do next?

1. ssh into your application
2. start the virtual env:
   

   source $OPENSHIFT_HOMEDIR/python/virtenv/bin/activate
   

3. change to the app dir:
   

   cd $OPENSHIFT_HOMEDIR/app-root/repo/wsgi/openshift/
   

4. open the django shell:
   

   python manage.py shell

5. Reset the password:
   

   from django.contrib.auth.models import User
   u=User.objects.get(username__exact=’admin’)
   u.set_password(‘whatever’);
   u.save()
   

#!/usr/bin/env python
# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-

import sys
import ephem

# create the observer
hess = ephem.Observer()
hess.lat = '-23.271333'
hess.long = '16.5'
hess.elevation = 1800
hess.date = ephem.Date(sys.argv[1] + " 12:00")

# calculate rising and setting times
darktime_start = []
darktime_end = []

# moon below horizon
moon = ephem.Moon()
moon.compute(hess)
if moon.alt < hess.horizon:
    darktime_start.append(hess.date)
    darktime_end.append(hess.next_rising(moon))
else:
    darktime_start.append(hess.next_setting(moon))
    darktime_end.append(hess.next_rising(moon))

# sun below -12 degrees
hess.horizon = "-12"
sun = ephem.Sun()
sun.compute(hess)
if sun.alt < hess.horizon:
    darktime_start.append(hess.date)
    darktime_end.append(hess.next_rising(sun))
else:
    darktime_start.append(hess.next_setting(sun))
    darktime_end.append(hess.next_rising(sun))

print "Darktime is from {0!s} UTC to {1!s} UTC".format(
    max(darktime_start), min(darktime_end))

> darktime.py 2013-01-31
Darktime is from 2013/1/31 18:35:36 UTC to 2013/1/31 19:29:22 UTC

Starting with scientific programming in Python?

Triggered by a question from a colleque, I'm going to write a litte about the tools, best practices and techniques I use when developing scientific data analysis software in Python.
Working in the sciences, like Astronomy in my case, one often writes short code snippets, which are run once or twice to produce plots to show at the next meeting but throw away the scripts afterwards. These scripts and their use are very different from the larger software products one might also create in the sciences. But often the small scripts will grow into the larger projects, and then one wishes to have started differently, with more structure, more tests and the bigger picture in mind.
The following tools might help to accomplish the switch from the small snippets to the larger projects with minimal pain.

Python

• Dive into Python
• Scientific Programming with Python
• The Numpy & Scipy tutorials
• The Matplotlib gallery examples

Small Snippets

The python shell in not very useful for most tasks. IPython is much better and you will probably be happy with it.
But there is even something better: IPython with the notebook feature switched on!

> ipython notebook --pylab=inline

plot

Functions in python look like this:

def create_data():
    # Create a numpy array with values from 0 to 100 with a step size of 0.01
    # create a numpy array with the sine of x
    x = np.arange(100,step=0.01)
    y = np.sin(x)
    return x, y

time, amplitude = create_data()

This is a great starting point to turn your snippet into a real program. Unlike the standard python interpreter sessions, notebooks can be saved into normal python files. This example would result in code like this:

# -*- coding: utf-8 -*-
# <nbformat>3.0</nbformat>

# <codecell>

def create_data(start=0, stop=100, step=0.01):
    # Create a numpy array with values from 0 to 100 with a step size of 0.01
    # create a numpy array with the sine of x
    x = np.arange(start,stop, step)
    y = np.sin(x)
    return x, y

# <codecell>

def plot_results(x, y):
    # plot is part of the automatically loaded matplotlib package
    plot(x, y)
    xlabel("time [s]")
    ylabel("amplitude")
    title("My Awesome Plot")

# <codecell>

time, amplitude = create_data()
plot_results(time, amplitude)

# <codecell>

Python Software

When you write software, you should follow a number of best prectices. You will likely think that you have better things to do, but in the end, these will help you safe time and frustration:

• Use version control: chose one of: bazaar, git or mercurial.
  Those are state of the art distributet version control systems. All of them are great (don't believe anyone that one of them is superior to the others, they are just slitely different...). But do not choose cvs and svn if you don't have to.
• Write tests! Really! Early!
• Let your code accept standard parameters: e.g. "-h", "--help",
• Structure your code into several files, folders (in python: modules, packages)
• Prepare your code for distribution to other people.

> sudo apt-get install quickly

> quickly create ubuntu-cli loftsimulator
> cd loftsimulator
> quickly run

• Tell the software who you are in the AUTHORS file.
• Add commandline options in the file

  loftsimulator/__init__.py

• Write tests to make sure your code works. Write the tests first, actually, and code until the tests pass... Often you will think that a specific part of your code is not testable, because it requires user input, large amounts of data, random numbers, etc, but also most of the time it is then best to structure your code is such a way that you can test most of your code. This not only makes your test coverage better, it mostly results also in easier to understand code.
  Running tests is very easy:

  quickly test

• Once the tests pass, run your code:

  quickly run

• Happy with your code? Commit your changes to the version controlsystem:

  quickly save "added a great new feature..."

• Need to share the code with other people (using ubuntu)?

  quickly package

  
  Now you can give away the newly created package loftsimulation.deb, which others can install with a simple

  dpkg -i loftsimulation.deb

Plotting with Python

• The new dataformat: BusinessCard
  A QR code created with this datatype allows the scanning application to directly import the contact details into the address book. The format currently uses the VCard standard, but MECARD will be available in the future.
• The new dataformats: SMS and Call
  When scanning a barcode of this type, you will be asked if you want to send a text message to the encoded phone number or place a call.
• When encoding URLs, you can directly shorten the ULR with the 'ethical shortening service' Is.gd
  Other shortening services (goo.gl, bit.ly, tinyurl.com) are already implemented, but are not selectable until we have a nice solution for preferences...
• QR codes now can have colors!
  Pick your favorite foreground and background colors (but make sure their brightness is reasonably different...)
• Printing is now also possible, as well as Drag'n'Drop
  
• The SoftwareCenterApp dataformat got a boost: its 10 times faster!
  (at least the autocompletion feature :-)

Maybe I should not write blog posts when I'm angry about something... but anyway:

Today was another wasted day, mostly caused by Latex. To sum it up: Although there is no real alternative to Latex, and I will therefore continue to use it in the future: IT SUCKS!

Consider the following problem:
I want no pagenumbers on all pages from the first, until after the list-of-tables.
If Latex would be sensibly designed, somthing like the following would work:

\pagestyle{empty}
\maketitle
\tableofcontents 
\listoffigures 
\listoftables
\pagestyle{headings}

\usepackage{scrpage2}
[...]
\clearpage
\pagestyle{empty}
\renewcommand*{\chapterpagestyle}{empty}
\maketitle
\tableofcontents 
\listoffigures 
\listoftables
\addtocontents{toc}{\protect\thispagestyle{empty}}
\addtocontents{lof}{\protect\thispagestyle{empty}}
\addtocontents{lot}{\protect\thispagestyle{empty}}
\clearpage
\pagestyle{headings}
\renewcommand*{\chapterpagestyle}{plain} 

And then run latex several times ...
That is too much voodoo!

Time to say goodby to Nokia phones and "hello!" to android (and hope for Ubuntu on smartphones...)

Today Nokia and Intel announced the merging of maemo and moblin to form MeeGo (TM).
While this might sound good to some, it is a bit sad for me. The first thing I'm sad of is the focus on C++ and Qt. As you might know, maemo 5, the operating system of the N900, is based on gtk and clutter.

Quote:

GTK and Clutter are also included for application compatibility.

I want Debian Mobile

But the biggest loss in this merge is the packet management system, which will be rpm.
Quote:

Will MeeGo use .rpm or .deb as its packaging system?
MeeGo will use the .rpm format

I have had some trouble to figure out how to use a class as a decorator for a method (as opposed to a decorator for a function). Here is a script that prints some useful information about what is called when and with what parameters.

#!/usr/bin/env python
print "Classes as Decorators of Methods\n"
print "-----Parsing dec"
class dec(object):
    def __init__(self, a):
        print "----- dec init"
        print type(a)
        print "decorated method: ", a.__name__
        self.a = a
    def __get__(self, inst, cls):
        print "-----dec get"
        self._inst = inst
        self._cls = cls
        return self
    def __call__(self, p):
        print "-----dec call"
        print type(self)
        print type(self._inst)
        print type(self._cls)
        return self.a(self._inst, p.upper())

print "-----Parsing C"
class C(object):
    def __init__(self):
        self.X = "Hello"
    @dec
    def run(self, p):
        print p,
        print self.X,
        return "world"

if __name__ == "__main__":
    print "-----Object creation"
    c = C()
    print "-----Object method call"
    print c.run("This is a decorator ")

In contrast: functions as decorators for functions

#!/usr/bin/env python

print "--- Parsing dec"
def dec(f):
    print "--- Run dec"
    print f.__defaults__
    def x(*args, **kwargs):
        print "--- Run x"
        print f.__name__
        print args
        print kwargs
        f(*args, **kwargs)
    return x

print "--- Parsing foo"
@dec
def foo(a, b=3):
    print "--- Run foo"
    print a, b


print "--- Calling foo"
foo(1)
print "--- Calling foo"
foo(2, 4)

Today I realized that the django way of internationalization is not as good as I had thought. Here are two areas where it could be improved:

The models

Django has no default way of translating fields in models. This is a known shortcoming and was addressed in many plugins (transdb, transmeta, multilingual, multilingual-model, translate, ...) and in a Google Summer of Code project by Marc Garcia.
As I see it, the translation of any kind of data should not be in a seperate table or in a metaclass. Why? Because translation should not be the way to think in the first place. If you have a piece of information that is not universally understandable (like an photograph), than you can assign a language or culture to that information. If your site should be available in several languages, then there is no good reason why one language should be superior (and allowed in the model), while other languages are inferior (and have to go into a translation table). So there is no translation of a first, superior string but there is a piece of information in different, equally important languages.
So, with regard to this poll, the only good option would be to state "this field is language specific" and django should create a field for every supported language (mainly like multilingual-model).
The admin interface should display these fields and a bonus would be to be able to create a report based on the missing translation fields.

The urls

But there are other fields where internationalization is also important and where I couldn't find any plugins or snippets. It's the url resolution. Your apps should have human-readable urls that don't change over time. Suppose you have this url in your shop: "/smartphone/linux/N900" and suppose that "smartphone" is a category that was not planned when the shop was planned but rather entered in the admin as a (translatable) categorization of a specific phone. Now if you want to make this translatable, you have to create a pattern like
"(?P.+)/(?P.+)/(?P.+)"
but how is that supposed to be distinguished from
"(?P.+)/(?P.+)/(?P.+)"
if these things should also be translatable? So the point is: the regular expressions in the url resolution mechanism are not translatable (if the strings are dynamical db content).

What could be done?

The could be an url manager that can receive signals about a change in the urls patterns. And there should be an attribute (db-field, function, ...) in every model or view which can take translatable fields as parameters and create and update the corresponding urlpatterns.

1. create a desktop file that describes, what your thumbnailer does:
   /usr/share/thumbnailers/fits-thumbnailer.desktop

   [Desktop Entry]
   Version=1.0
   Encoding=UTF-8
   Type=X-Thumbnailer
   Name=FITS Thumbnailer
   MimeType=image/x-fits;image/fits;application/fits;
   X-Thumbnailer-Exec=python /usr/lib/thunar-thumbnailers/fits-thumbnailer.py %i %o %s
   

2. create the thumbnailer script under:
   /usr/lib/thunar-thumbnailers/fits-thumbnailer.py

       #!/usr/bin/env python
       import pyfits
       import matplotlib.pyplot as plt
       import sys    
       try:
           infile  = sys.argv[1]
           outfile = sys.argv[2]
       except:
           exit(1)    
       try:
           size = sys.argv[3]
       except:
           size = 256    
       hdul = pyfits.open(infile)
       data = None
       # Is the primary HeaderDataUnit an image with data?
       if (hdul[0].header["NAXIS"] != 0):
           data = hdul[0].data
       else:
           # The primary had no data, so we search for the first image!
           for hdu in hdul[1:]:
               if (hdu.header["XTENSION"] == "IMAGE"):
                   data = hdu.data
                   break
       if data != None:
           plt.imshow(data)
           plt.savefig(outfile, transparent=False, format="png")
   

3. regenerate the thumbnailer cache:
   

       /usr/lib/thunar/thunar-vfs-update-thumbnailers-cache-1
   

  
    \begin{figure}[!th]
    \centering
    \includegraphics[width=2.5in]{some_filename}
    \caption{some caption}
    \label{fig:some_image}
    \end{figure}

RefTex

   C-c =

   C-c [
 

Xelatex for greek input

    äöüß
    

    \"a\"o\"u\ss{}
    

    $αβγ = 3μm$

    $\alpha\beta\gamma = 3\mum$
    

    \usepackage{mathspec}
    \setmainfont[Mapping=tex-text]{CMU Serif}
    \setsansfont[Mapping=tex-text]{CMU Sans Serif}
    \setmathsfont(Greek,Latin){CMU Serif}
    \setmathsfont(Digits){Neo Euler}

    C-\ greek RET
    

    
    C-\ 
    

PDFSync

    \usepackage{pdfsync}

    C-c C-v

OrgMode Tables

    \documentclass{article}
    \usepackage{comment}
    \begin{document}
    Hallo!\\
    \end{document}

    M-x orgtbl-mode
    M-x orgtbl-insert-radio-table

    \documentclass{article}
    \usepackage{comment}
    \begin{document}
    Hallo!\\
    % BEGIN RECEIVE ORGTBL atesttable
    % END RECEIVE ORGTBL atesttable
    \begin{comment}
    #+ORGTBL: SEND atesttable orgtbl-to-latex :splice nil :skip 0
    | | |
    \end{comment}
    \end{document}

    C-c C-c

    \documentclass{article}
    \usepackage{comment}
    \begin{document}
    Hallo!\\
    % BEGIN RECEIVE ORGTBL atesttable
    \begin{tabular}{rll}
    Times [sec] & Names & something else \\
    \hline
    3 & John & hi \\
    4 & Elisa & ho \\
    5 & Nobody & hiho \\
     &  &  \\
    \end{tabular}
    % END RECEIVE ORGTBL atesttable
    \begin{comment}
    #+ORGTBL: SEND atesttable orgtbl-to-latex :splice nil :skip 0
    | Times [sec] | Names  | something else |
    |-------------+--------+----------------|
    |           3 | John   | hi             |
    |           4 | Elisa  | ho             |
    |           5 | Nobody | hiho           |
    |             |        |                |
    \end{comment}
    \end{document}

Given that a and b are positive, the calculation:

But is this true in computer languages?

a:1.2345678e-30
b:5.5889944e-28
The real result is: 6.89999252062032 e-58
What do the following programs tell me?

C

#include <math.h>
#include <stdio.h>

int main(){
  double a = 1.2345678e-30;
  double b = 5.5889944e-28;
  double c, d;

  c = a * b;
  d = exp(log(a)+log(b));

  printf("a * b =                %.20e \n", c);
  printf("exp(log(a) + log(b)) = %.20e \n", d);
  return 0;
};

Python

import math
a = 1.2345678e-30
b = 5.5889944e-28
print "----------math----------"
print "a * b =                %s" % repr(a*b)
print "exp(log(a) + log(b)) = %s" % repr(math.exp(math.log(a)+math.log(b)))



import mpmath
mpmath.mp.dps = 20
a = mpmath.mpf(1.2345678e-30)
b = mpmath.mpf(5.5889944e-28)
print "---------mpmath---------"
print "a * b =                %s" % repr(a*b)
print "exp(log(a) + log(b)) = %s" % repr(mpmath.exp(mpmath.log(a)+mpmath.log(b)))

Scheme

R

gcalctool

So what is the result:

• python 2.5 (http://www.python.org)
• numpy (http://www.scipy.org/Download)
• scipy (http://www.scipy.org/Download)
• matplotlib (http://sourceforge.net/projects/matplotlib)
• pyfits (http://www.stsci.edu/resources/software_hardware/pyfits/Download)
• kapteyn (http://www.astro.rug.nl/software/kapteyn/)
• mayavi2 ( http://code.enthought.com/projects/mayavi/docs/development/html/mayavi/installation.html)
• python-sao (http://code.google.com/p/python-sao/)
• pymc (http://code.google.com/p/pymc/)

My Problem:

I have a lot of unsorted scientific papers! Their filenames don't resemble their titles and they are stored in a bunch of places. I tend to download them as I search the internet for papers that help me with a problem and sometimes I even DownThemAll.
Weeks, month later, I try to find the *one paper* that was so interesting and cite it via BibTex in my Latex file. But I can't remember the filename, title, author, year or journal (in any combination).
Or I see a paper, know that I read it, but can't remember if it was that good...

Possible Solution:

Using a search engine (Tracker), a bibliography manager (Referencer) and a file manager (Thunar).
With Thunar, I can mark files as interesting.
With Tracker I can search the text of a document and tag it.
With Referencer I can tag a paper and export the meta-information to a Bibtex file.

Why I'm still unhappy:

It seems that Tracker, Referencer and Thunar don't use the same location to store meta-information about the documents. They all seem to use different databases. I would have to write a plugin for two of them to get the three of them working together.
Not good.

1. open ds9 with the following command:
   

   ds9 -unix "/tmp/.IMT3"

2. in the python shell create an UnixImageDisplay
   

   uid = numdisplay.displaydev.UnixImageDisplay("/tmp/.IMT3")

3. don't really know how to continue ... the wcs stuff seems not to work the way I expect ...

import pysao
ds9 = pysao.ds9()
ds9.view(hdul[6])

Python is a good language for scientists. It basically replaces proprietary software like IDL, Matlab or SAS. What it lacks at the moment is an easy way to display astronomical data saved as fits files containing WCS information.
WCS information standardizes the transformation between pixel coordinates and world coordinates (e.g. position in the sky). There is a good library, pywcs, that deals with this information. Matplotlib, a good choice for plotting data with python, includes Basemap, a toolkit to display maps (of the earth) in various projections. What is missing is a link between these two!

• comments
• a cool admin interface (is it possible to include an emacs-nox into a django admin interface? that would be interesting...)
• file upload with automatic reference from within the blog post. Something like "attachment[1]"

Sometimes I think that there are so many problems to fix on the free desktop...
Today: PDF Annotation!

1. PDFedit: the interface is not very friendly. There is no back/undo button. There is no way to highlight just a word, strike through just a word. Make a box and add some text outside the page borders. AND I DONT NEED 10 colors for my pencil. 3 colors would be more then enough!

   ---

2. OpenOffice 3: The fonts are broken. Every time. If I can't read the PDF, I can't annotate it. And others won't be able to read my annotations. (And I don't even know, if annotations would be possible in OpenOffice...

   ---

3. Inkscape: Fonts are broken too. Only one page is open at a time. NO WAY.

   ---

4. Xournal: Close, but ... A simple box to write some text would be cool. Text highlighting as well. I know that it's not possible if the page is only loaded as an image, but that's what I would need.

   ---

5. Evince: well, there will be Annotation support at some time in the future, ... (hopefully).

   ---