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]"