Open Source Motivation

Just read the article of Lior Kaplan which is about the things that make us to use or develop opensource projects. Link:

I think these are mine reasons about doing that ;)

- Help other people that may have the same problem as you, so you make your code public or help via ML,IRC and etc.
- Opportunity to learn new things and finding areas to apply them.
- Coding about what you like,the topics you are interested.
- Having the feeling that more can do it better than single, so copy everything that is usable for you and continue from there (DRY).
- Becoming expert in area you like without thinking about it.
- Having a good CV(background) about things you have done, talks is cheap i'm showing the code.
- Having the opportunity to start own business without paying anything, you just need the idea
- Working together than alone is more fun.

Btw, i think people who are payed to work on opensource projects are really lucky :) Hope to be one of them ...

I wrote one use mine !

That is the story about a little and probably useless software i wrote. Everything began in 2007 during my internship in Pardus. Pardus uses pisi (a Python based package manager) and pisi doesnt have any sign/verify mechanism (still doesnt have) to secure package transmission. Well we all decided it would be cool to make the verification process via X.509 certificates so we can have more info about signer and etc. And everything began, i started designing the app. The idea was simple we have a package we sign it via X.509 and put the signature in package an send to users for installation. User has on other site a db with trusted certificates, he/she extracts the signature checks if the cert is trusted. If the cert is good to use user computes the hash of all files in package and compares with hash that is in the signature. Simple yes ...

The implementation part was not so easy for me. I heard that there is a Python package for handling SSL things called Python OPenSSL. I was excited it was my first Open Source program but pyOpenSSL didnt have all my needed classes for certification handling, signing and verification parts (if has man i dont know). Than i found M2Crypto it had some ugly Python code and bad exception handling but had all the cool features i needed. And the 'imzaci' was there an alpha verison maybe, it didnt have a code base i was proud of. The application was not accepted by Pardus members and none asked me about it to make it better or to fix sth. Everyone was silent , man probably i wrote the ugliest program in the world if none says sth :)

I thought it was the way how Open Source works. (People can think about things they have experinced) Well Open Source code development doesnt work like that believe me. People discuss,fight,share,apply patches that is the world i was imaging from the beginning. However i didnt make a good start :) The GSOC2008 and FUNC project showed me that secret and cool Opensource World.

Well lets return to our little useless application, after GSOC2008 i have rewritten most of the code maybe better maybe worse i dont know. I changed its name it is not imzaci anymore it is pysign and it is an independent (no written for specific distro) application. Why i have rewritten the program ? I wondered if i became better after those years. Well the code is here [1] and you know what it was not fun to write it. If someone is going to write an app similar to that one please look at my code maybe you can grap some part of it. I wrote it once dont do it again :)

Ok what is the point :) The point ;is it is very very very important to choose community you are going to contribute. Please before you join look at mail listing conversations, look at documentation of project or community has. The start is very important and if you have luck you will be in a place where people respect every bit of your code. That is the Open Source world i was looking for and found at the end :)

There are two kind of programmers, good programmer gets the old code fixes it (if possible) and completes the job in less time, bad programmer writes all the code from scratch (maybe worse than first programmer). Be the good programmer i wrote it dont repeat yourself :)

[1] http://github.com/makkalot/pysign/tree/master

Django Admin ManyToMAny Behaviour

In that post want to share an experience with a Django behaviour that took all my day to solve it. In nowadays , i'm working on a freelance project and trying to finish project due to deadline (hate deadlines). Here is the small part of models i'm using

class SchoolSection(models.Model):
 #snip

class GalleryItem(models.Model):
 school_section = models.ManyToManyField(SchoolSection)
 #snip

A pretty easy structure , the problem occurred when i connected the post_save signal to a method which was using the models above. When a new GalleryItem was saved i wanted to pre-populate some xml files according to new commers. Here is the simple code that was pulling the gallery items :

sc=SchoolSection.objects.all()
gi = GalleryItem.objects.filter(school_section = sc[0])

When i save an object i was not able to see the new added in query above. When i saved the object second time (edit->save) the new entry appeared. In a moment when i was going go crazy someone from #django channel told me that Django doesnt save the m2m relationships immediately due to performance issues. Therefore the solution was to override a method in admin part , here is the solution :

class GalleryItemAdmin(admin.ModelAdmin):
 def save_model(self, request, obj, form, change):
   super(GalleryItemAdmin, self).save_model(request, obj, form, change)
   form.save_m2m()
   obj.save()

That is all, hope to help someone who has the same problem :)

import makkalot

Hello planet and thanks for adding me.

Command pattern in Python

I continue with "x pattern in Python" series, the articles i posted here are not tutorials or some professional learning resource. I poste them here only for myself to rememer the things when i need them :) What is the command pattern and why wee need it ? Well imagine you have a class that controls some operations on files, writing , reading , closing , and maybe many more. In first sight i would complete that like this :

class FileOperator:

def operation1(self):
  pass

def operation2(self):
  pass

#snip snip snip ....

Well that implementation seems enough for now, but what if we want to supply a simple api to users like that

f = FileOperator()
f.process_command()

Well, with current implementation that doesnt seem to be possible, the current implementation is kind fo static and user has to know the internals of the FileOperator class. If the users want some extra functionality like undo or logging, it will not be very easy to be implemented. And every change that has to be done will effect the current client code which is not cool. Also user may want when call the process_command to execute multiple commands like write_to_file and read_contents and etc. What we will do is again the basic OOP remove the parts that can change in the future. We will remove the executer parts and wiill assing them when we need them. Ok when reading it doesnt seem so easy but the code is easier:

Here is my implementation of the Command Pattern : LINK

After that implementation you will able to do things like that :

def test_me_yo():
  """
  Lets see that one
  """
  tmp_file = open("some.txt","w")
  tmp_file.write("hehehe\n")
  tmp_file.close()

  #end of initial data
  #first lets read the contents of the stuff
  fe = FileEditor()
  fileman = FileMan("some.txt")
  fread = FileReadCommand(fileman)
  fwrite=FileWriteCommand(fileman)
  fe.set_command(fread)
  fe.process_command()

  #append some info to the end of it
  fe.set_command(fwrite)
  fe.process_command("add some text here")
  fe.set_command(fread)
  fe.process_command()

  #lets now go and create an command manager
  cm = CommanManager()
  cm.add_commanders(fwrite,fread)
  fe.set_command(cm)

  fe.process_command("\n Add another sting here ")
  print "First undo :"
  fe.undo_process()
  print "Second undo :"
  fe.undo_process()
  print "Thirrd undo :"
  fe.undo_process()

Well it is pretty pluggable design you can combine the commands you like do "undo" all the magic you need. What i learned from Design Patterns is they are based on the same principle "remove the parts that will change in the future" ,separating the concerns is very important ...

Template Design Pattern

The next step in DP land is Template Design Pattern, well what is it ? As far as i understood there is nothing special and new under the hood. You have an abstract class with methods to be overriden by its sunclasses. The main difefrence is you have a one or more template methods which draw the flow of the things. A simple example maybe :

class MainClass(object):

 def operation1(self):
   #do stuff

 def operation2(self):
   #do stuff

 def __template_method(self):
   self.operation1()
   self.operation2()

What we did here is to supply an API for users to override the operation1 and operation2 but we want to control the overflow by template_method, if you want more extendible structure you may also make it public. Well i know that pattern i have used it in lots of places but didnt know its name :) The new thing i learned from Head First is the hook methods , you make them optional for the client code. For example:

class MainClass(object):

 def operation1(self):
   #do stuff

 def operation2(self):
   #do stuff

 def hook(self):
   pass

 def do_you_want_hook(self):
   return True

 def __template_method(self):
   self.operation1()
   self.operation2()
   if self.do_you_want_hook():
     hook()

Ok the difference is if user wants something extra to be executed he/she can override hook and do the extra stuf that is needed there,otherwise that method will not be invoked (well it will be but nothing will happen).
That is all for the template pattern, we know you,you are not new here :)

Factory Pattern in Python

Our next step in DP is object factories. Creating objects with if else clauses sometimes may not be very flexible for our programs. Some of the objects may neeed more complex and long initializations other maybe simple etc. Because of that it is cooler to have some methods or some classes that give you the instance you need. For exmple think about a client program which needs a slash directory or file manager. If you're trying to have your program platform independent you should have different versions for Windows and Linux based machines. Therefore when you client is initializing the File manager it should everytime do

 if linux:
   do sth
 else:
   do another

But for a framework that is not very flexible and when some code of FileManager changes (some code of initialization) you should change your client code which is not cool. It would be better if you have some class that gives you the instance you need, in our example FilemanagerFactory.get_instance() so client code will not care about the platform and other annoying stuf it will just get the instance it needs. Yep that is factory pattern ...
To demonstrate the factory thing i wrote a simple example that is responsible for creating Validators, if you have a string you get a string validator if you have an integer you have integer valiator and etc . Here is the link: LINK

To test the code you need sth like that :

from pyalgorithm.dp.factory import *

def test_facto():
   my_value = "Some_strrrrrrrrr"
   factory = ValidatorFactory()
   validator = factory.create(my_value)
   print validator.validate()

   my_value = 11
   validator = factory.create(my_value)
   print validator.validate()

   my_value = 11.12
   validator = factory.create(my_value)
   if not validator:
       print "No object created ..."

Well that is all, factory pattern may not be very important for little projects but if you have to initialize lots of classes it maybe wisw to have some class to do that for you.