Bundling in Python

There is a nice way to deal with requirements in Python, which is

pip freeze    

with

pip freeze > requirements.txt     

you can easily stor eyour dependencies in a simple txt-file and with

pip install -r requirements.txt

get pip to install requirements as specified in the file in a different environment.

Advertisements

Setting up my own flavour of Django

Okay, so I started doing stuff in python and of course stated playing around with django. And beeing used to padrinorb‘s convenient generators, I had to figure out how to get to my preferred setup. This is what I do:

  1. Run

    django-admin.py startproject projectname

  2. in settings.py
    add

    import os.path
    and add

    os.path.join(os.path.dirname(__file__), ('templates'))
    to TEMPLATE_DIRS

  3. Make dir templates/ in the project folder
  4. Make dir views/ in the project folder
  5. Add an __init__.py file
  6. import your views in __init__ (e.g.

    from index import hello
    if you have a view file called index.py containing a function hello())

  7. In templates I put subdirs for all sites and a base.html which holds the frame for all sites.
  8. Now in urls.py import all views via

    from views import *

So, this gives me a view and a template dir as well as a frame for the sites.

Now that I got the views and template going I would like to have a seperate dir for static contents. Django’s static dir is simply /static whih is fine by me, but making a directory named static and putting stuff in won’t do. You have to put


STATICFILES_DIRS = (os.path.join(os.path.dirname(__file__), 'static/'),)

After putting


{% load staticfiles %}

into the base.html. You can insert static files like css, image and so on by putting


{% static foo/bar.ext %}

into the template tag.

Legacy code and the “SuperProgrammer”

I started an online python course some days ago and part of the assignment is to peer evaluate other peoples code. The task was to print a message on the screen. Yes, I know, a boring task.
There I came upon something like this:

string = "xdxlxrxoxW xoxlxlxexH"
string = string[::-2]
print string

And this, in three lines, is the essence of problems I’ve encountered over the years with big complex projects and legacy code. Remarkably it seems to be a trap each projects “Super-Programmer” falls in…

1. Show-off programming
It’s okay to be proud of ones knowledge but, come on, this is about the job, not your ego.

2. The code is the documentation
NO, definitely not, code is just a small part of any bigger or more complex project. There ususally are configuration, directory structures, external dependencies (libraries) etc. Put it somewhere to be seen, the init file, a readme, a getting-started txt file but don’t assume.

3. Don’t oversmart
You found this very cool, super cryptic looking function that does unexpected thing… Yeah, probably use something that can be understood right away or at least leave a comment about what it does.

4. Modularize to death
Especially in ruby (but any other language as well) I found many people building modules around simple functions, meta programming things to bits and doing stuff they found in years old posts somewhere.
Those techniques are all good and useful at times but not every function is predestined to be reused in another project, so why not declare it a helper function?

In short:
1. Write code that can be read with by an average coder, not just by the “Super-Programmer”. Projects or companies dev teams seldom have an even knowledge distribution. (And in most cases you don’t even want that.)
2. Documentation!
3. Comments!
4. Put your ego aside. I rarely think stuff like “Oh my, he/she came up with a fancy solution”, mostly it is along the line of “WTF! Why didn’t he use the obvious solution?” So if there is a reason for doing it differently go back to point 2 or 3.

Ruby Shortcuts

I sometimes stumble upon little snippets of ruby code that can replace longer loops. Like this one:

array.reject!(&:empty?)

which eliminates all empty strings from an array of strings (does not work for Fixnum), which is quite handy following a “split” operation.

Another one is this:

array.inject(:+)

which sums up all elements in an array and also works for strings.

Datamapper – Padrino – warden

I took a break from coding, but was still looking for a useful set of tools for developing web applications. And I think I found a solution that fits my needs (small core but extensible, modular, reasonable features, usable documentation or active user groups at least).

The goal was to create a backend that would output json objects that could be processed in an independent frontend.

First step was to generate a project following the guide

padrino g project -d datamapper -a mysql -e none

I set renderer (-e option) to none because I am using rabl for templating the json output.
For authentication I chose warden. So I added these to the Gemfile

gem 'warden'
gem 'rabl'

Then turned to the app/app.rb and added

use Warden::Manager do |manager|
manager.default_strategies :password
manager.failure_app = myApp
end

Warden::Manager.serialize_into_session do |user|
user.id
end

Warden::Manager.serialize_from_session do |id|
User.get(id)
end

For creating the model I used the padrino generator again, since the user model is pretty straight forward (extend as needed)

padrino g model User username:string password:string email:string

After setting up config/database.rb you can create the database by using

padrino rake dm:create

To have some entries in the database to work with I costumize the db/seeds.rb which is mentioned in the padrino blog tutorial

Having done this warden should be in the system but is not working yet, since we have to define at least one strategy:

For now I like to use a common username/password login, which is already defined as default in manager.default_strategies. (You could add others if you wanted to, look at the warden-wiki for details)

Warden::Strategies.add(:password) do
def valid?
... code goes here ...
end
def authenticate!
... code goes here ...
? success!(user) : fail!("Invalid")
end
end

So in valid? you would define the requirements that have to be met to go on with the authentication process. In this case checking params[“username”] && params[“password”] would make sense.
After creating a usable authentication! function request to a controller can be authenticated via adding env[‘warden’].authenticate! before the login controller code.
If authentication was successful you can add env[‘warden’].authenticated? to following controllers and get the user (or what you decided to return for success) by calling env[‘warden’].user.

I tested this with curl, since the frontend is intended to be independent. I put the login process in a post route, so
after starting padrino

curl -d "username=...&password=..." localhost:3000/login

gave me the defined output of a successful login.

One pitfall when testing a subsequent controller with curl is that in contrast to a browser you have to add the cookie information. In order to get it you could call

curl -vvv -d "username=...&password=..." localhost:3000/login

and can extract the rack.session=… …; and call the controller with

curl --cookie "rack.session=... ...;" localhost:3000/subsequent_controller

Sinatra, Datamapper and CouchDB – a trainwreck

Just for purely educational reasons (why not) i decide to combine these three on heroku. The spoiler is already in the title: it didn’t work at all. Datamapper is quite cool and works great with the shared Postgres database, but don’t even bother to get the mongo or couch adapter working. Datamapper seems to gets massively reworked, maybe wait for this to be done and then try again. As for Postgres or MySQL it looks nice.

Sinatra, Mustache and Heroku

I’ve been playing around with Sinatra, in order to see how it would do in the wild I decided to use Heroku as a comfortable hosting solution.

Heroku

Begin creating your Sinatra app. Add a Gemfile, since Heroku runs a bundle install.

Commit to git.

To deploy to heroku install the heroku gem and create an instance for your app by calling “heroku create”. By default, this is enough to get going if you want the application to be run under a subdomain (e.g. http://codebrigade.heroku.com) you can do so by adding the desired name to the create.

If you push your app to &quote;heroku master&quote; it should boot and be running. If it doesn’t look into the log-files by typing &quote;heroku logs&quote; in your Command line.

Mustache

Mustache is a logic-less templating language derived from c-templates. Adding it to Sinatra is quite simple, install the mustache gem and add to your app.rb

require 'mustache/sinatra'
set :public => './public/'
register Mustache::Sinatra
require_relative 'views/layout'
set :mustache, {:views => './views/', :templates => './templates/'}

&quote;public&quote; holds static files like css. It works without explicitly setting it on my local machine but won’t do with Heroku, adding this fixes it.

It is important to include and provide the layout file since the engine looks for it.
The layout file includes the frame for all the views. For example:


<!DOCTYPE html>
<html>
<head>
<title>{{title}}</title>
<link rel="stylesheet" type="text/css" href="layout.css">
</head>
<body>
<div id="header">{{> _header}}</div>
<div id="main">{{{yield}}}</div>
<div id="footer">{{> _footer}}</div>
</body>
</html>

My layout shows a custom Title for each view, header and footer are partials.
You will need a view and a layout for every page. All views extend the layout if they use it:

class Codebrigade
  module Views
    class Index < Layout
       def title
           "Hello there"
       end
    end
  end
end

Next steps are CouchDB and Sinatra integration…

Elastic Mapreduce streaming job with elasticity

Requires elasticity (https://github.com/rslifka/elasticity) and a Registration with Amazon AWS but works like a charm 🙂

This mainly does the following: Make a new bucket for every day the script runs, do the map-reduce job, get the result.

@new_bucket = "run-" + Time.now.strftime("%Y%m%d")
@new_job = "job-" + Time.now.strftime("%Y%m%d")
# Create a new result bucket in results
newdir = connection.directories.create(
  :key    => @new_bucket,
  :public => false
)
puts "Results are thrown into bucket" + newdir.key

emr = Elasticity::EMR.new(@key_id,@secret_key)
jobflow_id = emr.run_job_flow({
    :name => @new_job,
    :instances => {
      :ec2_key_name => "test",
      :hadoop_version => "0.20",
      :instance_count => 2,
      :master_instance_type => "m1.small",
      :placement => {
        :availability_zone => "us-east-1a"
      },
      :slave_instance_type => "m1.small",
    },
    :steps => [
      {
        :action_on_failure => "TERMINATE_JOB_FLOW",
        :hadoop_jar_step => {
          :args => [
            "-input",   "s3n://input/",
            "-output",  "s3n://" + @new_bucket + "/",
            "-mapper",  "s3n:/mapper/mapper1.rb",
            "-reducer", "s3n://reducer/reducer1.rb",
          ],
          :jar => "/home/hadoop/contrib/streaming/hadoop-streaming.jar"
        },
        :name => "mr1"
      }
    ]
  })

puts jobflow_id + " started"

jobflows = emr.describe_jobflows
state = jobflows[0].state
puts jobflows[0].name + " " + state + "nn"

if state == 'COMPLETED'
  result = storage.directories.get(@new_bucket).files.get("part-00000").body
  result.each_line do |line|
    puts line[0]
  end
end

Errata:

The last if-statement make no sense, as long as we don’t add a routine to check for changes in the state of the job…

while(state != 'COMPLETED' && state != 'FAILED')
  jobflows = emr.describe_jobflows
  state = jobflows[0].state
  puts jobflows[0].name + " " + state + " (" + Time.now.strftime("%H:%M:%S") + ")n"
  sleep 300
end

Amazon S3 and ruby with fog

This little script lists all keys of directories (buckets in S3) and files (objects). Just to get a grip with fog (https://github.com/geemus/fog)…

connection = Fog::Storage.new(
  :provider                 => 'AWS',
  :aws_secret_access_key    => "",
  :aws_access_key_id        => ""
)

dirs = connection.directories
dirs.each do |dir|
  puts "+ " + dirname = dir.key
  files = dirs.get(dirname).files
  files.each do |file|
    puts "  - " + file.key
  end
end

ZSH and versioning systems

Since oh-my-zsh didn’t work properly with ruby I had do remove it and all the nifty stuff went with it… So i was looking for a quick fix:

First I wanted to have the directory visible, i wrote this to the left:
PROMPT=”%n@%m:%F{6}%~ %F{11}%# “

Then I loaded vcs_info to get the information from git and put it to the right, that’s all I need:
autoload -Uz vcs_info
setopt PROMPT_SUBST
precmd() { vcs_info }
RPROMPT=’%F{4}${vcs_info_msg_0_} ${vcs_info_msg_1_}’
setopt AUTO_CD

It’s enough for me to work.