zodman blog

In [1]: a = ["a","b","c"]

In [2]: b = iter(a)

In [3]: b.next()
Out[3]: 'a'

In [4]: b.next()
Out[4]: 'b'

In [5]: b.next()
Out[5]: 'c'

In [6]: b.next()
---------------------------------------------------------------------------
StopIteration                             Traceback (most recent call last)

/home/zodman/<ipython console> in <module>()

StopIteration:

#!/usr/bin/env python
import urllib2
from poster.encode import multipart_encode
from poster.streaminghttp import register_openers

API_URL = 'http://www.imageshack.us/index.php'

def yesno(x):
    if x:
        return 'yes'
    else:
        return 'no'

def upload_file(filename, optsize=None,
                user_cookie=None,
                remove_bar=True,
                tags=None,
                public=True,
                ):
    register_openers()
    data = {'fileupload' :open(filename),
            'xml':yesno(True)
            }
    datagen, headers = multipart_encode(data)

    # Some optional parameters
    if optsize:
        data['optsize'] = optsize
    if user_cookie:
        data['cookie'] = user_cookie
    if tags:
        data['tags'] = tags

    req = urllib2.Request(API_URL, datagen,headers)
    u = urllib2.urlopen(req)
    return u.read()

if __name__ == "__main__":
    import sys
    print upload_file(sys.argv[1])

[zodman@cosmogirl conary-lib]$ conary q iftop
iftop was not found
[zodman@cosmogirl conary-lib]$ sudo python conarypk.py
Update Success of iftop=/zodyrepo.rpath.org@rpl:devel/0.17-3-1
[zodman@cosmogirl conary-lib]$ conary q iftop --labels
iftop=zodyrepo.rpath.org@rpl:devel/0.17-3-1

def update(self, name, installLabel= None):
        cli = self.cli
        #get a trove
        troves = self.request_query(name, installLabel)
        for trove in troves:
            trovespec =  self.trove_to_spec( trove )
        try:
            # create a Job
            job = cli.newUpdateJob()
            # Add Update task to Job
            cli.prepareUpdateJob(job, cmdline.parseChangeList(trovespec))
            # Apply the Job
            cli.applyUpdateJob(job)
            # im rulz
            return "Update Success of %s" %  trovespec
        except NoNewTrovesError:
            return "no new Troves Found by %s " % trovespec

    def trove_to_spec(self, trove ):
        return cmdline.toTroveSpec( trove[0], str(trove[1]), None)

    conary = ConaryPk()
    print conary.update("iftop","zodyrepo.rpath.org@rpl:devel")

from pyExcelerator import *

w = Workbook()
ws = w.add_sheet('Hey, Dude')

ws.write(0, 0, 1)
ws.write(1, 0, 1.23)
ws.write(2, 0, 12345678)
ws.write(3, 0, 123456.78)

ws.write(0, 1, -1)
ws.write(1, 1, -1.23)
ws.write(2, 1, -12345678)
ws.write(3, 1, -123456.78)

ws.write(0, 2, -17867868678687.0)
ws.write(1, 2, -1.23e-5)
ws.write(2, 2, -12345678.90780980)
ws.write(3, 2, -123456.78)

w.save('numbers.xls')

 set(
     project = 'awesome-app',
     fab_hosts = ['n1.cluster.com', 'n2.cluster.com'],
  )
 def deploy():
    "Build the project and deploy it to a specified environment."
     local('mvn package')
     put('target/$(project).war', '$(project).war')
     put('install-script.sh', 'install-script.sh')
     sudo('install-script.sh')

# filename twitter.py
from django.template import Library
import urllib
import simplejson

register = Library()

@register.simple_tag
def twitter_status( username ):
    url = "http://twitter.com/statuses/user_timeline/%s.json?count=1" % username
    file  = urllib.urlopen(url)
    json_responce = file.read()
    twit = simplejson.loads(json_responce)
    return "%s" % twit[0]["text"]

   {%load cache %}
       {% cache 18000 twitter %}
       {% load twitter %}
    <div class="twitter">
        <img src="/static/images/twitter.gif">
        @zodman: {% twitter_status "zodman" %}
    </div>
  {% endcache %}

$ woof yucatux_fmat3.png 
Now serving on http://192.168.254.4:8080/
192.168.254.4 - - [28/Aug/2008 13:33:23] "GET /yucatux_fmat3.png HTTP/1.1" 200 -

$ droopy  -m "Hellowwwwwwww" -p yucatux_fmat3.png 
HTTP server running... Check it out at http://localhost:8000
localhost.localdomain - - [28/Aug/2008 13:15:10] "GET / HTTP/1.1" 200 -
localhost.localdomain - - [28/Aug/2008 13:15:10] "GET /yucatux_fmat3.png HTTP/1.1" 200 -
localhost.localdomain - - [28/Aug/2008 13:15:22] "POST / HTTP/1.1" - -
localhost.localdomain - - [28/Aug/2008 13:15:22] *Received: coas.bmp*

from django.db import models
from django.contrib import databrowse
from zodyblog.tumble.models import Item
from django.db.models import signals
from django.contrib.contenttypes.models import ContentType
import  django.dispatch

class PownceNote(models.Model):
    pownce_id = models.PositiveIntegerField()
    body = models.TextField()
    permalink = models.URLField()
    date= models.DateTimeField()
    def get_type(self):
        pownce_type="Message"
        if self.powncelink_set.all().count() > 0:
            pownce_type= "Link"
        if self.pownceevent_set.all().count() > 0:
            pownce_type="Event"
        if self.powncefile_set.all().count() > 0:
            pownce_type= "File"
        return pownce_type

    def __unicode__(self):
        return "[%s] %s" %(self.get_type(),self.body)

class PownceLink(models.Model):
    url = models.URLField()
    pownce_note = models.ForeignKey(PownceNote,unique=True)
    def __unicode__(self):
        return self.url

class PownceFile(models.Model):
    name = models.CharField(max_length=200)
    type = models.CharField(max_length=100)
    pownce_note = models.ForeignKey(PownceNote,unique=True)
    def __unicode__(self):
        return self.name

class PownceEvent(models.Model):
    name  = models.CharField(max_length=200)
    ical  = models.URLField()
    location = models.CharField(max_length=200)
    date = models.DateTimeField()
    pownce_note = models.ForeignKey(PownceNote,unique=True)
    def __unicode__(self):
        return self.name

def create_item(sender,instance, **kwargs):
    ctype = ContentType.objects.get_for_model(instance)
    if ctype.name == "entrada":
        pub_date = instance.fecha
    else:
        pub_date = instance.date
    if "created" in kwargs:
        if kwargs["created"]:
            si,created = Item.objects.get_or_create(content_type=ctype, object_id=instance.id, pub_date=pub_date)
        else:
            si = Item.objects.get(content_type=ctype,object_id=instance.pk)
            si.pub_date=pub_date
            si.save()

signals.post_save.connect(create_item, sender=PownceNote)

import logging as log
log.basicConfig(level=log.DEBUG)
import urllib
import simplejson
import datetime
import sys

mypath="/home/zodman/lab/dev/zodyblog/"
sys.path.append(mypath)

from django.core.management import setup_environ
from django.utils.dateformat import DateFormat
import settings

setup_environ(settings)
from zodyblog.zodynetwork.models import PownceLink, PownceNote, PownceEvent, PownceFile

def link( entry, note ):
    link = PownceLink(url=entry["link"]["url"])
    link.pownce_note = note
    link.save()

def event( entry, note ):
    event = PownceEvent(
        name=entry["event"]["name"],
        ical=entry["event"]["ical"],
        location=entry["event"]["location"],
        date=entry["event"]["date"],
        pownce_note= note
        )
    event.save()

def file( entry, note ):
    file = PownceFile(name=entry["file"]["name"],type=entry["file"]["content_type"],pownce_note=note)
    file.save()
def message():
    pass

URL = "http://api.pownce.com/2.0/"
user ="zodman"

class TZ(datetime.tzinfo):
    def utcoffset(self,dt):
        return datetime.timedelta(hours=-5)
    def dst(self,dt):
        return self.utcoffset(dt)

# load the pownce posts
p = urllib.urlopen(URL+"note_lists/zodman.json")
json_response =  p.read()
notes = simplejson.loads(json_response)

for i in notes['notes']:
    if 'sender' in i:
        del i['sender']
    if 'app' in i:
        del i['app']

    functions = {
        "link":     lambda i,note: link(i,note),
        "message":  lambda i,note: message(),
        "event":    lambda i,note: event(i,note),
        "file":     lambda i,note: file(i,note)
    }
    dt = datetime.datetime.fromtimestamp(i['timestamp'],TZ())
    df = DateFormat(dt)
    defaults = {"body":i["body"], "permalink":i["permalink"]}
    note, created = PownceNote.objects.get_or_create(pownce_id=i['id'],date=df.format("Y-m-d H:i"),defaults=defaults)
    if created:
        functions[i["type"]](i,note)

{% extends "index.html" %}
{% load markup %}
{% load zodytag %}
{% block contenido %}
{% for j in latest %}
{% ifequal j.content_type.name "entrada"%}
    {%with j.content_object as e %}
    <div class="entrada-all">
        <span class="round-up-left"></span>
        <span class="round-up-right"></span>
        <div class="entrada">
            <div class="x-small float-right" style="width:100px;height:20px">{{e.fecha|date}} </div>
            <h2> {{e.titulo}} </h2>
                {{e.contenido|markdown:"codehilite" }}
            <div class="left x-small categorias">
                {%for i in e.categoria.all %}
                    <a href="{{i.permalink}}"> {{i.nombre}}</a>
                {% endfor %}
            </div>
            <div class="entrada-links">
                <a href="{{e.permalink}}">Direct Link </a> |
                <span class="a" onclick="addComment('{{e.pk}}')"> Comment ({% count_comment e.pk %})  </span>
            </div>
        </div>
    </div>
    {% endwith %}
{%endifequal%}
{% ifequal j.content_type.name "pownce note"%}
    {% with j.content_object as e %}
      <div class="pownce">
        <span class="type"> {{e.get_type}}</span>
          <span class="permalink"> <a href="{{e.permalink}}">permalink</a></span>
            <div class="content">
                {{e.body|truncatewords_html:20|urlize}}

            </div>
                <div class="content-type">
                {% ifequal e.get_type "Link" %}
                    {% for i in e.powncelink_set.all %}
                       <div class="link">
                        <img src="/static/images/link.gif"><a href="{{i.url}}">{{ i.url|urlizetrunc:32 }}</a>
                       </div>
                    {% endfor %}
                {% endifequal %}
                {% ifequal e.get_type "Event" %}
                    {% for i in e.pownceevent_set.all %}
                       <div class="event">
                            <img src="/static/images/event.gif">
                            <a href="{{i.ical}}">
                            {{i.name}}  /
                            {{i.location}} /
                            {{i.date|date:"Y F d"}}
                            </a>
                       </div>
                    {% endfor %}
                {% endifequal %}

                 {% ifequal e.get_type "File" %}
                    {% for i in e.powncefile_set.all %}
                       <div class="file">
                        <img src="/static/images/file.gif">
                        <a href="{{e.permalink}}">
                            {{i.name}}
                        </a>
                       </div>
                    {% endfor %}
                {% endifequal %}
            </div>
      </div>
    {% endwith %}

{%  endifequal  %}
<div style="height:20px;"></div>
{% endfor %}
{% endblock %}

def link():
    print "link"
def message( ):
    print "msg"
def event(  ):
    print "event"
def file( ):
    print "juaz"
functions = {
        "link": link(),
        "message":message(),
        "event":event(),
        "file": file()
}   
dofunc = functions["event"]
dofunc()

switch( var ){
   case "event":
   break;
   default:
   break;
}

$ pydoc <module>

$ sudo pydoc  -p 8001
pydoc server ready at http://localhost:8001/