# HG changeset patch # User ymh # Date 1263987673 -3600 # Node ID b77683731f252261337be90561e22e5f22c6ebda # Parent 526ebd3988b029054d7919877c5c4d2834d0205b# Parent c00932a80c14d8341813b2cd24a83136f8083b77 branch merge diff -r c00932a80c14 -r b77683731f25 .hgignore --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/.hgignore Wed Jan 20 12:41:13 2010 +0100 @@ -0,0 +1,7 @@ +syntax: glob +*.pyc + +syntax: regexp +^web/.htaccess$ +^web/blinkster/.htaccess$ +^web/blinkster/config.py$ diff -r c00932a80c14 -r b77683731f25 web/blinkster/.htaccess.tmpl --- a/web/blinkster/.htaccess.tmpl Wed Jan 20 10:58:18 2010 +0100 +++ b/web/blinkster/.htaccess.tmpl Wed Jan 20 12:41:13 2010 +0100 @@ -1,11 +1,11 @@ SetHandler python-program PythonHandler django.core.handlers.modpython -SetEnv DJANGO_SETTINGS_MODULE pocketfilms.settings +SetEnv DJANGO_SETTINGS_MODULE blinkster.settings SetEnv PY_USE_XMLPLUS true -PythonInterpreter pocketfilms -PythonOption django.root /~ymh/pocketfilms/pocketfilms +PythonInterpreter blinkster +PythonOption django.root /~ymh/blinkster/blinkster PythonDebug on -PythonPath "['/Users/ymh/Sites/pocketfilms'] + sys.path" +PythonPath "['/Users/ymh/Sites/blinkster', '/Users/ymh/Sites/blinkster/lib'] + sys.path" Header set Pragma "no-cache" Header set Cache-Control "no-cache" Header set Expires "-1" diff -r c00932a80c14 -r b77683731f25 web/blinkster/ldt/__init__.py --- a/web/blinkster/ldt/__init__.py Wed Jan 20 10:58:18 2010 +0100 +++ b/web/blinkster/ldt/__init__.py Wed Jan 20 12:41:13 2010 +0100 @@ -1,10 +1,10 @@ import lucene -import pocketfilms.settings +from django.conf import settings #import fileimport lucene.initVM(lucene.CLASSPATH) -STORE = lucene.FSDirectory.getDirectory(pocketfilms.settings.INDEX_PATH, False) +STORE = lucene.FSDirectory.getDirectory(settings.INDEX_PATH, False) ANALYZER = lucene.PerFieldAnalyzerWrapper(lucene.StandardAnalyzer()) ANALYZER.addAnalyzer("tags",lucene.FrenchAnalyzer()) ANALYZER.addAnalyzer("title",lucene.FrenchAnalyzer()) diff -r c00932a80c14 -r b77683731f25 web/blinkster/ldt/contentindexer.py --- a/web/blinkster/ldt/contentindexer.py Wed Jan 20 10:58:18 2010 +0100 +++ b/web/blinkster/ldt/contentindexer.py Wed Jan 20 12:41:13 2010 +0100 @@ -2,11 +2,11 @@ import os import os.path import shutil -from pocketfilms.utils import zipfileext -import pocketfilms.utils.log -import pocketfilms.utils.xml -from pocketfilms import settings -from pocketfilms.ldt.models import Content +from blinkster.utils import zipfileext +import blinkster.utils.log +import blinkster.utils.xml +from blinkster import settings +from blinkster.ldt.models import Content import xml import xml.dom import xml.dom.minidom @@ -16,8 +16,8 @@ import uuid import shutil import lucene -from pocketfilms.ldt import STORE -from pocketfilms.ldt import ANALYZER +from blinkster.ldt import STORE +from blinkster.ldt import ANALYZER def Property(func): return property(**func()) @@ -53,7 +53,7 @@ def index_content(self, content): - pocketfilms.utils.log.debug("Indexing content : "+str(content.iri_id)) + blinkster.utils.log.debug("Indexing content : "+str(content.iri_id)) filepath = content.iri_file_path() doc = xml.dom.minidom.parse(filepath) @@ -66,7 +66,7 @@ ensembleId = ensemble.getAttribute("id") for decoupageNode in ensemble.childNodes: - pocketfilms.utils.log.debug("Indexing content decoupage : "+ repr(decoupageNode.nodeType) + " in " + repr(self.decoupage_blacklist)) + blinkster.utils.log.debug("Indexing content decoupage : "+ repr(decoupageNode.nodeType) + " in " + repr(self.decoupage_blacklist)) if decoupageNode.nodeType != xml.dom.Node.ELEMENT_NODE or decoupageNode.tagName != "decoupage" or decoupageNode.getAttribute("id") in self.decoupage_blacklist: continue @@ -144,7 +144,7 @@ def index_project(self, project): - pocketfilms.utils.log.debug("Indexing project : "+str(project.iri_id)) + blinkster.utils.log.debug("Indexing project : "+str(project.iri_id)) doc = xml.dom.minidom.parseString(project.ldt) self.__writer.deleteDocuments(lucene.Term("iri_id", project.iri_id)) @@ -158,7 +158,7 @@ ensembleId = "ens_perso" for decoupageNode in content.childNodes: - pocketfilms.utils.log.debug("Indexing content decoupage : "+ repr(decoupageNode.nodeType) + " in " + repr(self.decoupage_blacklist)) + blinkster.utils.log.debug("Indexing content decoupage : "+ repr(decoupageNode.nodeType) + " in " + repr(self.decoupage_blacklist)) if decoupageNode.nodeType != xml.dom.Node.ELEMENT_NODE or decoupageNode.tagName != "decoupage" or decoupageNode.getAttribute("id") in self.decoupage_blacklist: continue @@ -204,4 +204,4 @@ self.__writer.addDocument(doc) - self.__writer.flush() \ No newline at end of file + self.__writer.flush() diff -r c00932a80c14 -r b77683731f25 web/blinkster/ldt/fileimport.py --- a/web/blinkster/ldt/fileimport.py Wed Jan 20 10:58:18 2010 +0100 +++ b/web/blinkster/ldt/fileimport.py Wed Jan 20 12:41:13 2010 +0100 @@ -2,11 +2,11 @@ import os import os.path import shutil -from pocketfilms.utils import zipfileext -import pocketfilms.utils.log -import pocketfilms.utils.xml -from pocketfilms import settings -from pocketfilms.ldt.models import Content, LdtProject +from blinkster.utils import zipfileext +import blinkster.utils.log +import blinkster.utils.xml +from blinkster import settings +from blinkster.ldt.models import Content, LdtProject import xml import xml.dom import xml.dom.minidom @@ -17,9 +17,9 @@ import shutil import lucene import uuid -from pocketfilms.ldt import STORE -from pocketfilms.ldt import ANALYZER -from pocketfilms.ldt.contentindexer import ContentIndexer +from blinkster.ldt import STORE +from blinkster.ldt import ANALYZER +from blinkster.ldt.contentindexer import ContentIndexer def Property(func): return property(**func()) @@ -111,7 +111,7 @@ f.close() - destPath = os.path.join(os.path.join(os.path.join(pocketfilms.settings.MEDIA_ROOT, "media"), "ldt"), self.id); + destPath = os.path.join(os.path.join(os.path.join(blinkster.settings.MEDIA_ROOT, "media"), "ldt"), self.id); if not os.path.exists(destPath): os.makedirs(destPath) shutil.move(os.path.join(self.basepath, self.src), os.path.join(destPath, os.path.basename(self.src))) @@ -119,7 +119,7 @@ def saveContent(self): - pocketfilms.utils.log.debug("ID of object to create : "+str(self.id)) + blinkster.utils.log.debug("ID of object to create : "+str(self.id)) content, self.created = Content.objects.get_or_create(iri_id=self.id, defaults = { 'iri' : self.id + u"/" + os.path.basename(self.src), 'title':self.title, 'description':self.desc, })#'decoupage_id': self.decoupageId, 'ensemble_id': self.ensembleId}); if not self.created: content.iri = self.id + u"/" + os.path.basename(self.src) @@ -242,7 +242,7 @@ for i, medianode in enumerate(result): id = medianode.attributes['id'].value - pocketfilms.utils.log.debug("FIRST ID : " + str(id)) + blinkster.utils.log.debug("FIRST ID : " + str(id)) if self.checkExistingMedia: try: Content.objects.get(iri_id=id) @@ -253,16 +253,16 @@ do_pass = False if not do_pass: if not (contents.has_key(id)): - pocketfilms.utils.log.debug("CREATE IRI INFO ID : " + str(id)) + blinkster.utils.log.debug("CREATE IRI INFO ID : " + str(id)) contents[id] = IriInfo(id, os.path.dirname(ldtpath), i, "") contents[id].src = medianode.attributes['src'].value result = xml.xpath.Evaluate("/iri/annotations/content", context=con) - pocketfilms.utils.log.debug("content xpath result : " + str(len(result))) + blinkster.utils.log.debug("content xpath result : " + str(len(result))) for contentnode in result: id = contentnode.attributes['id'].value - pocketfilms.utils.log.debug("ID : " + str(id)) + blinkster.utils.log.debug("ID : " + str(id)) if contents.has_key(id): if self.author: contentnode.setAttribute("author", unicode(self.author)) @@ -290,21 +290,21 @@ zipfile = zipfileext.ZipFileExt(self.filepath) zipfile.unzip_into_dir(self.__tempdir) #load ldt - pocketfilms.utils.log.debug("Processing files : ") - pocketfilms.utils.log.debug(os.listdir(self.__tempdir)) + blinkster.utils.log.debug("Processing files : ") + blinkster.utils.log.debug(os.listdir(self.__tempdir)) foldersToProcess = [self.__tempdir] while len(foldersToProcess): - pocketfilms.utils.log.debug("folder stack length : "+ str(len(foldersToProcess))) + blinkster.utils.log.debug("folder stack length : "+ str(len(foldersToProcess))) currentFolder = foldersToProcess.pop() for entry in os.listdir(currentFolder): if entry in settings.ZIP_BLACKLIST: continue entryPath = os.path.join(currentFolder, entry) if(os.path.isdir(entryPath)): - pocketfilms.utils.log.debug("Push folder : " + entryPath) + blinkster.utils.log.debug("Push folder : " + entryPath) foldersToProcess.append(entryPath) elif fnmatch.fnmatch(entry, "*.ldt"): - pocketfilms.utils.log.debug("Process file : " + entryPath) + blinkster.utils.log.debug("Process file : " + entryPath) ldtid = self.processLdt(entryPath) processedids.append(ldtid) elif fnmatch.fnmatch(entry, "*.flv"): @@ -341,7 +341,7 @@ for i, medianode in enumerate(result): id = medianode.attributes['id'].value - pocketfilms.utils.log.debug("FIRST ID : " + str(id)) + blinkster.utils.log.debug("FIRST ID : " + str(id)) content = Content.objects.get(iri_id = id) self.contents.append(content) @@ -360,7 +360,7 @@ ldtproject = LdtProject(ldt_id = ldt_id, ldt=ldt) ldtproject.save() idldt = ldtproject.id - pocketfilms.utils.log.debug("ProjectFileImport.processFile ID : " + str(idldt)) + blinkster.utils.log.debug("ProjectFileImport.processFile ID : " + str(idldt)) for author in authors: ldtproject.authors.add(author) for content in contents: @@ -381,9 +381,9 @@ fi = ProjectFileImport(ldtPath, self.author) FileImport.processLdt(self, ldtPath) idproject = fi.processFile() - pocketfilms.utils.log.debug("ZipProjectFileImport.processLdt ID : " + str(idproject)) + blinkster.utils.log.debug("ZipProjectFileImport.processLdt ID : " + str(idproject)) fi.close() return idproject - \ No newline at end of file + diff -r c00932a80c14 -r b77683731f25 web/blinkster/ldt/forms.py --- a/web/blinkster/ldt/forms.py Wed Jan 20 10:58:18 2010 +0100 +++ b/web/blinkster/ldt/forms.py Wed Jan 20 12:41:13 2010 +0100 @@ -1,6 +1,6 @@ # -*- coding: utf-8 -*- from django import forms -from pocketfilms.ldt.models import * +from blinkster.ldt.models import * class LdtImportForm(forms.Form): importFile = forms.FileField() diff -r c00932a80c14 -r b77683731f25 web/blinkster/ldt/models.py --- a/web/blinkster/ldt/models.py Wed Jan 20 10:58:18 2010 +0100 +++ b/web/blinkster/ldt/models.py Wed Jan 20 12:41:13 2010 +0100 @@ -3,9 +3,9 @@ from django.db import models from django.contrib import admin import lucene -from pocketfilms.ldt import STORE -from pocketfilms.ldt import ANALYZER -from pocketfilms import settings +from blinkster.ldt import STORE +from blinkster.ldt import ANALYZER +from blinkster import settings class Author(models.Model): diff -r c00932a80c14 -r b77683731f25 web/blinkster/ldt/utils.py --- a/web/blinkster/ldt/utils.py Wed Jan 20 10:58:18 2010 +0100 +++ b/web/blinkster/ldt/utils.py Wed Jan 20 12:41:13 2010 +0100 @@ -1,9 +1,9 @@ import lucene -from pocketfilms.ldt import STORE -from pocketfilms.ldt import ANALYZER +from blinkster.ldt import STORE +from blinkster.ldt import ANALYZER import uuid import django.core.urlresolvers -import pocketfilms.settings +import blinkster.settings from Ft.Xml import MarkupWriter import xml.dom import xml.dom.minidom @@ -43,7 +43,7 @@ writer.simpleElement(u"project", attributes={u"id":unicode(str(uuid.uuid1())), u"title":unicode(title) , u"user":author, u"abstract":u""}) writer.startElement(u"medias") for content in contentList: - writer.simpleElement(u"media", attributes={u"id":content.iri_id,u"src":content.iri_url(web_url),u"video":unicode(media_url)+unicode(pocketfilms.settings.STREAM_URL),u"pict":u"",u"extra":u""}) + writer.simpleElement(u"media", attributes={u"id":content.iri_id,u"src":content.iri_url(web_url),u"video":unicode(media_url)+unicode(blinkster.settings.STREAM_URL),u"pict":u"",u"extra":u""}) writer.endElement(u"medias") writer.simpleElement(u"annotations") writer.startElement(u"displays") @@ -80,14 +80,14 @@ elementfile = doc.createElement('file') - elementfile.setAttribute('src',pocketfilms.settings.WEB_URL + django.core.urlresolvers.reverse(method, args=url)) + elementfile.setAttribute('src',blinkster.settings.WEB_URL + django.core.urlresolvers.reverse(method, args=url)) elementfile.setAttribute('display', '1') if(search): - elementfile.setAttribute("segsel",pocketfilms.settings.WEB_URL + django.core.urlresolvers.reverse(search, args=url)) + elementfile.setAttribute("segsel",blinkster.settings.WEB_URL + django.core.urlresolvers.reverse(search, args=url)) #/*chemin video : tant que le serveur de media n'est pas up, */ - elementfile.setAttribute('video', pocketfilms.settings.STREAM_URL) + elementfile.setAttribute('video', blinkster.settings.STREAM_URL) elementfile.setAttribute('pict', "") elementfile.setAttribute('extra', "") diff -r c00932a80c14 -r b77683731f25 web/blinkster/ldt/views.py --- a/web/blinkster/ldt/views.py Wed Jan 20 10:58:18 2010 +0100 +++ b/web/blinkster/ldt/views.py Wed Jan 20 12:41:13 2010 +0100 @@ -2,39 +2,39 @@ from django.http import HttpResponse from django.shortcuts import render_to_response from django.template import RequestContext -from pocketfilms import settings -from pocketfilms import version -from pocketfilms.ldt.forms import LdtImportForm -from pocketfilms.ldt.forms import LdtProjectImportForm -from pocketfilms.ldt.forms import SearchForm, LdtForm, reindexForm -from pocketfilms.ldt.fileimport import * -from pocketfilms.ldt.models import Author, LdtProject, Content -from pocketfilms.ldt.utils import * +from blinkster import settings +from blinkster import version +from blinkster.ldt.forms import LdtImportForm +from blinkster.ldt.forms import LdtProjectImportForm +from blinkster.ldt.forms import SearchForm, LdtForm, reindexForm +from blinkster.ldt.fileimport import * +from blinkster.ldt.models import Author, LdtProject, Content +from blinkster.ldt.utils import * import django.core.urlresolvers import django.utils.http -import pocketfilms.ldt.models -import pocketfilms.utils.zipfileext -import pocketfilms.utils.log +import blinkster.ldt.models +import blinkster.utils.zipfileext +import blinkster.utils.log import xml.dom.minidom import xml.dom.ext import urllib import base64 import cgi -from pocketfilms.ldt import STORE -from pocketfilms.ldt import ANALYZER +from blinkster.ldt import STORE +from blinkster.ldt import ANALYZER from string import Template from Ft.Xml import MarkupWriter def index(request, url): - urlStr = settings.WEB_URL + django.core.urlresolvers.reverse("pocketfilms.ldt.views.init", args=['ldt', url]) + urlStr = settings.WEB_URL + django.core.urlresolvers.reverse("blinkster.ldt.views.init", args=['ldt', url]) language_code = request.LANGUAGE_CODE[:2] return render_to_response('ldt/init_ldt.html', {'MEDIA_URL': settings.MEDIA_URL, 'colorurl': settings.MEDIA_URL+'swf/ldt/pkg/color.xml', 'i18nurl': settings.MEDIA_URL+'swf/ldt/pkg/i18n', 'language': language_code, 'baseurl': settings.MEDIA_URL+'swf/ldt/', 'url': urlStr}, context_instance=RequestContext(request)) def indexProject(request, id): - urlStr = settings.WEB_URL + django.core.urlresolvers.reverse("pocketfilms.ldt.views.init", args=['ldtProject', id]) + urlStr = settings.WEB_URL + django.core.urlresolvers.reverse("blinkster.ldt.views.init", args=['ldtProject', id]) language_code = request.LANGUAGE_CODE[:2] return render_to_response('ldt/init_ldt.html', {'MEDIA_URL': settings.MEDIA_URL, 'colorurl': settings.MEDIA_URL+'swf/ldt/pkg/color.xml', 'i18nurl': settings.MEDIA_URL+'swf/ldt/pkg/i18n', 'language': language_code, 'baseurl': settings.MEDIA_URL+'swf/ldt/', 'url': urlStr}, context_instance=RequestContext(request)) @@ -49,24 +49,24 @@ queryStr = base64.urlsafe_b64encode(request.POST["search"].encode('utf8')) field = request.POST["field"] language_code = request.LANGUAGE_CODE[:2] - #pocketfilms.utils.log.debug(str(form)) - #pocketfilms.utils.log.debug(str(sform.cleaned_data)) + #blinkster.utils.log.debug(str(form)) + #blinkster.utils.log.debug(str(sform.cleaned_data)) #queryStr = django.utils.http.urlquote_plus(form.search) - url = settings.WEB_URL + django.core.urlresolvers.reverse("pocketfilms.ldt.views.searchInit", args=[field, queryStr]) + url = settings.WEB_URL + django.core.urlresolvers.reverse("blinkster.ldt.views.searchInit", args=[field, queryStr]) return render_to_response('ldt/init_ldt.html', {'MEDIA_URL': settings.MEDIA_URL, 'colorurl': settings.MEDIA_URL+'swf/ldt/pkg/color.xml', 'i18nurl': settings.MEDIA_URL+'swf/ldt/pkg/i18n', 'language': language_code, 'baseurl': settings.MEDIA_URL+'swf/ldt/', 'url': url}, context_instance=RequestContext(request)) def searchIndexGet(request, field, query): language_code = request.LANGUAGE_CODE[:2] - url = settings.WEB_URL + django.core.urlresolvers.reverse("pocketfilms.ldt.views.searchInit", args=[field, query]) + url = settings.WEB_URL + django.core.urlresolvers.reverse("blinkster.ldt.views.searchInit", args=[field, query]) return render_to_response('ldt/init_ldt.html', {'MEDIA_URL': settings.MEDIA_URL, 'colorurl': settings.MEDIA_URL+'swf/ldt/pkg/color.xml', 'i18nurl': settings.MEDIA_URL+'swf/ldt/pkg/i18n', 'language': language_code, 'baseurl': settings.MEDIA_URL+'swf/ldt/', 'url': url}, context_instance=RequestContext(request)) def searchInit(request, field, query): - ldtgen = pocketfilms.ldt.utils.LdtUtils() + ldtgen = blinkster.ldt.utils.LdtUtils() - doc = ldtgen.generateInit([field,query], 'pocketfilms.ldt.views.searchLdt', 'pocketfilms.ldt.views.searchSegments') + doc = ldtgen.generateInit([field,query], 'blinkster.ldt.views.searchLdt', 'blinkster.ldt.views.searchSegments') resp = HttpResponse(mimetype="text/xml") xml.dom.ext.PrettyPrint(doc, resp) @@ -75,9 +75,9 @@ def init(request, method, url): - ldtgen = pocketfilms.ldt.utils.LdtUtils() + ldtgen = blinkster.ldt.utils.LdtUtils() - doc = ldtgen.generateInit([url], 'pocketfilms.ldt.views.'+method, None) + doc = ldtgen.generateInit([url], 'blinkster.ldt.views.'+method, None) resp = HttpResponse(mimetype="text/xml") xml.dom.ext.PrettyPrint(doc, resp) @@ -92,9 +92,9 @@ resp = HttpResponse(mimetype="text/xml") - contentList = pocketfilms.ldt.models.Content.objects.filter(iri_id=url) + contentList = blinkster.ldt.models.Content.objects.filter(iri_id=url) - ldtgen = pocketfilms.ldt.utils.LdtUtils() + ldtgen = blinkster.ldt.utils.LdtUtils() ldtgen.generateLdt(contentList, file=resp, title = contentList[0].title) return resp @@ -102,7 +102,7 @@ def ldtProject(request, id): resp = HttpResponse(mimetype="text/xml") - project = pocketfilms.ldt.models.LdtProject.objects.get(id=id) + project = blinkster.ldt.models.LdtProject.objects.get(id=id) template = Template(project.ldt) resp.write(template.safe_substitute({'web_url':settings.WEB_URL,'media_url':settings.MEDIA_URL, 'stream_url': settings.STREAM_URL})) @@ -127,8 +127,8 @@ def uploadFile(request): importform = LdtImportForm(request.POST, request.FILES) if importform.is_valid(): - pocketfilms.utils.log.debug(request.FILES) - pocketfilms.utils.log.debug(importform.cleaned_data['author']) + blinkster.utils.log.debug(request.FILES) + blinkster.utils.log.debug(importform.cleaned_data['author']) fi = FileImport(request.FILES['importFile'], importform.cleaned_data['author']) fi.processFile() fi.close() @@ -140,8 +140,8 @@ importForm = LdtProjectImportForm(request.POST, request.FILES) args = {} if importForm.is_valid(): - pocketfilms.utils.log.debug(request.FILES) - pocketfilms.utils.log.debug(importForm.cleaned_data['author']) + blinkster.utils.log.debug(request.FILES) + blinkster.utils.log.debug(importForm.cleaned_data['author']) filetoprocess = request.FILES['importFile'] fi = None @@ -178,7 +178,7 @@ if query and len(query)>0: queryStr = base64.urlsafe_b64decode(query.encode("ascii")).decode("utf8") #queryStr = base64.urlsafe_b64decode(query.trim("=")) - searcher = pocketfilms.ldt.utils.LdtSearch() + searcher = blinkster.ldt.utils.LdtSearch() ids = {} for result in searcher.query(field, queryStr): @@ -190,10 +190,10 @@ ids_editions = map(lambda t:t[0], filter(lambda id: id[0] is not None, Speak.objects.filter(session__day__edition=edition).order_by("session__start_ts", "order").values_list("content__iri_id"))) id_list = filter(lambda id: id in id_list, ids_editions) - contentList = pocketfilms.ldt.models.Content.objects.filter(iri_id__in=id_list) + contentList = blinkster.ldt.models.Content.objects.filter(iri_id__in=id_list) - ldtgen = pocketfilms.ldt.utils.LdtUtils() + ldtgen = blinkster.ldt.utils.LdtUtils() ldtgen.generateLdt(contentList, file=resp, title = u"Recherche : " + queryStr) return resp @@ -202,7 +202,7 @@ def searchSegments(request, field, query, edition=None): if query and len(query)>0: - searcher = pocketfilms.ldt.utils.LdtSearch() + searcher = blinkster.ldt.utils.LdtSearch() queryStr = base64.urlsafe_b64decode(query.encode("ascii")).decode("utf8") res = searcher.query(field, queryStr) @@ -243,7 +243,7 @@ rawContentList = Content.objects.in_bulk(ids) contentList = map(lambda id: rawContentList[id], ids) - ldtgen = pocketfilms.ldt.utils.LdtUtils() + ldtgen = blinkster.ldt.utils.LdtUtils() ldtgen.generateLdt(contentList, file=resp, author=user, title = "ENMI %s" % edition, web_url=settings.WEB_URL, media_url=settings.MEDIA_BASE_URL) return resp @@ -289,7 +289,7 @@ writer.startElement(u"projects") for project in projects: - writer.startElement(u"project", attributes={"id":unicode(project.id), "url":unicode(settings.WEB_URL + django.core.urlresolvers.reverse('pocketfilms.ldt.views.indexProject',args=[project.id]))}) + writer.startElement(u"project", attributes={"id":unicode(project.id), "url":unicode(settings.WEB_URL + django.core.urlresolvers.reverse('blinkster.ldt.views.indexProject',args=[project.id]))}) writer.startElement(u"authors") for author in project.authors.all(): writer.startElement(u"author") diff -r c00932a80c14 -r b77683731f25 web/blinkster/settings.py --- a/web/blinkster/settings.py Wed Jan 20 10:58:18 2010 +0100 +++ b/web/blinkster/settings.py Wed Jan 20 12:41:13 2010 +0100 @@ -51,7 +51,7 @@ ADMIN_MEDIA_PREFIX = '/media/' # Make this unique, and don't share it with anybody. -SECRET_KEY = '-)1l)+v@raqnw8-olez3qtr_cwy37+ok@#$ppcu4ip@)i1v5s-' +SECRET_KEY = '8cj2-b_tt4h0j9!n%75-n=#ng#^37euw45)v)uvva2-sb0$xx6' # List of callables that know how to import templates from various sources. TEMPLATE_LOADERS = ( @@ -77,6 +77,7 @@ ) INSTALLED_APPS = ( + 'django_extensions', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', diff -r c00932a80c14 -r b77683731f25 web/blinkster/utils/context_processors.py --- a/web/blinkster/utils/context_processors.py Wed Jan 20 10:58:18 2010 +0100 +++ b/web/blinkster/utils/context_processors.py Wed Jan 20 12:41:13 2010 +0100 @@ -1,11 +1,11 @@ -import pocketfilms.settings; -import pocketfilms.version; +import blinkster.settings; +import blinkster.version; def version(request): - return {'VERSION': pocketfilms.version.VERSION } + return {'VERSION': blinkster.version.VERSION } def base(request): - return {'BASE_URL': pocketfilms.settings.BASE_URL } + return {'BASE_URL': blinkster.settings.BASE_URL } def web(request): return {'WEB_URL': enmi.settings.WEB_URL } diff -r c00932a80c14 -r b77683731f25 web/lib/django_extensions/__init__.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/web/lib/django_extensions/__init__.py Wed Jan 20 12:41:13 2010 +0100 @@ -0,0 +1,10 @@ + +VERSION = (0, "4.1") + +# Dynamically calculate the version based on VERSION tuple +if len(VERSION)>2 and VERSION[2] is not None: + str_version = "%s.%s_%s" % VERSION[:3] +else: + str_version = "%s.%s" % VERSION[:2] + +__version__ = str_version diff -r c00932a80c14 -r b77683731f25 web/lib/django_extensions/admin/__init__.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/web/lib/django_extensions/admin/__init__.py Wed Jan 20 12:41:13 2010 +0100 @@ -0,0 +1,125 @@ +# +# Autocomplete feature for admin panel +# +# Most of the code has been written by Jannis Leidel and was updated a bit +# for django_extensions. +# http://jannisleidel.com/2008/11/autocomplete-form-widget-foreignkey-model-fields/ +# +# to_string_function, Satchmo adaptation and some comments added by emes +# (Michal Salaban) +# +import operator +from django.http import HttpResponse, HttpResponseNotFound +from django.contrib import admin +from django.db import models +from django.db.models.query import QuerySet +from django.utils.encoding import smart_str +from django.utils.translation import ugettext as _ +from django.utils.text import get_text_list + +from django_extensions.admin.widgets import ForeignKeySearchInput + +class ForeignKeyAutocompleteAdmin(admin.ModelAdmin): + """Admin class for models using the autocomplete feature. + + There are two additional fields: + - related_search_fields: defines fields of managed model that + have to be represented by autocomplete input, together with + a list of target model fields that are searched for + input string, e.g.: + + related_search_fields = { + 'author': ('first_name', 'email'), + } + + - related_string_functions: contains optional functions which + take target model instance as only argument and return string + representation. By default __unicode__() method of target + object is used. + """ + + related_search_fields = {} + related_string_functions = {} + + def __call__(self, request, url): + if url is None: + pass + elif url == 'foreignkey_autocomplete': + return self.foreignkey_autocomplete(request) + return super(ForeignKeyAutocompleteAdmin, self).__call__(request, url) + + def foreignkey_autocomplete(self, request): + """ + Searches in the fields of the given related model and returns the + result as a simple string to be used by the jQuery Autocomplete plugin + """ + query = request.GET.get('q', None) + app_label = request.GET.get('app_label', None) + model_name = request.GET.get('model_name', None) + search_fields = request.GET.get('search_fields', None) + object_pk = request.GET.get('object_pk', None) + try: + to_string_function = self.related_string_functions[model_name] + except KeyError: + to_string_function = lambda x: x.__unicode__() + if search_fields and app_label and model_name and (query or object_pk): + def construct_search(field_name): + # use different lookup methods depending on the notation + if field_name.startswith('^'): + return "%s__istartswith" % field_name[1:] + elif field_name.startswith('='): + return "%s__iexact" % field_name[1:] + elif field_name.startswith('@'): + return "%s__search" % field_name[1:] + else: + return "%s__icontains" % field_name + model = models.get_model(app_label, model_name) + queryset = model._default_manager.all() + data = '' + if query: + for bit in query.split(): + or_queries = [models.Q(**{construct_search( + smart_str(field_name)): smart_str(bit)}) + for field_name in search_fields.split(',')] + other_qs = QuerySet(model) + other_qs.dup_select_related(queryset) + other_qs = other_qs.filter(reduce(operator.or_, or_queries)) + queryset = queryset & other_qs + data = ''.join([u'%s|%s\n' % ( + to_string_function(f), f.pk) for f in queryset]) + elif object_pk: + try: + obj = queryset.get(pk=object_pk) + except: + pass + else: + data = to_string_function(obj) + return HttpResponse(data) + return HttpResponseNotFound() + + def get_help_text(self, field_name, model_name): + searchable_fields = self.related_search_fields.get(field_name, None) + if searchable_fields: + help_kwargs = { + 'model_name': model_name, + 'field_list': get_text_list(searchable_fields, _('and')), + } + return _('Use the left field to do %(model_name)s lookups in the fields %(field_list)s.') % help_kwargs + return '' + + def formfield_for_dbfield(self, db_field, **kwargs): + """ + Overrides the default widget for Foreignkey fields if they are + specified in the related_search_fields class attribute. + """ + if (isinstance(db_field, models.ForeignKey) and + db_field.name in self.related_search_fields): + model_name = db_field.rel.to._meta.object_name + help_text = self.get_help_text(db_field.name, model_name) + if kwargs.get('help_text'): + help_text = u'%s %s' % (kwargs['help_text'], help_text) + kwargs['widget'] = ForeignKeySearchInput(db_field.rel, + self.related_search_fields[db_field.name]) + kwargs['help_text'] = help_text + return super(ForeignKeyAutocompleteAdmin, + self).formfield_for_dbfield(db_field, **kwargs) diff -r c00932a80c14 -r b77683731f25 web/lib/django_extensions/admin/widgets.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/web/lib/django_extensions/admin/widgets.py Wed Jan 20 12:41:13 2010 +0100 @@ -0,0 +1,76 @@ +from django import forms +from django.conf import settings +from django.utils.safestring import mark_safe +from django.utils.text import truncate_words +from django.template.loader import render_to_string +from django.contrib.admin.widgets import ForeignKeyRawIdWidget + +class ForeignKeySearchInput(ForeignKeyRawIdWidget): + """ + A Widget for displaying ForeignKeys in an autocomplete search input + instead in a " ] || + + !tags.indexOf("", "" ] || + + tags.match(/^<(thead|tbody|tfoot|colg|cap)/) && + [ 1, "", "
" ] || + + !tags.indexOf("", "" ] || + + // matched above + (!tags.indexOf("", "" ] || + + !tags.indexOf("", "" ] || + + // IE can't serialize and \ No newline at end of file diff -r c00932a80c14 -r b77683731f25 web/lib/django_extensions/templatetags/__init__.py diff -r c00932a80c14 -r b77683731f25 web/lib/django_extensions/templatetags/syntax_color.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/web/lib/django_extensions/templatetags/syntax_color.py Wed Jan 20 12:41:13 2010 +0100 @@ -0,0 +1,77 @@ +r""" +Template filter for rendering a string with syntax highlighting. +It relies on Pygments to accomplish this. + +Some standard usage examples (from within Django templates). +Coloring a string with the Python lexer: + + {% load syntax_color %} + {{ code_string|colorize:"python" }} + +You may use any lexer in Pygments. The complete list of which +can be found [on the Pygments website][1]. + +[1]: http://pygments.org/docs/lexers/ + +You may also have Pygments attempt to guess the correct lexer for +a particular string. However, if may not be able to choose a lexer, +in which case it will simply return the string unmodified. This is +less efficient compared to specifying the lexer to use. + + {{ code_string|colorize }} + +You may also render the syntax highlighed text with line numbers. + + {% load syntax_color %} + {{ some_code|colorize_table:"html+django" }} + {{ let_pygments_pick_for_this_code|colorize_table }} + +Please note that before you can load the ``syntax_color`` template filters +you will need to add the ``django_extensions.utils`` application to the +``INSTALLED_APPS``setting in your project's ``settings.py`` file. +""" + +__author__ = 'Will Larson ' + + +from django import template +from django.template.defaultfilters import stringfilter +from django.utils.safestring import mark_safe +from pygments import highlight +from pygments.formatters import HtmlFormatter +from pygments.lexers import get_lexer_by_name,guess_lexer,ClassNotFound + +register = template.Library() + +def generate_pygments_css(path=None): + if path is None: + import os + path = os.path.join(os.getcwd(),'pygments.css') + f = open(path,'w') + f.write(HtmlFormatter().get_style_defs('.highlight')) + f.close() + + +def get_lexer(value,arg): + if arg is None: + return guess_lexer(value) + return get_lexer_by_name(arg) + +@register.filter(name='colorize') +@stringfilter +def colorize(value, arg=None): + try: + return mark_safe(highlight(value,get_lexer(value,arg),HtmlFormatter())) + except ClassNotFound: + return value + + +@register.filter(name='colorize_table') +@stringfilter +def colorize_table(value,arg=None): + try: + return mark_safe(highlight(value,get_lexer(value,arg),HtmlFormatter(linenos='table'))) + except ClassNotFound: + return value + + diff -r c00932a80c14 -r b77683731f25 web/lib/django_extensions/templatetags/truncate_letters.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/web/lib/django_extensions/templatetags/truncate_letters.py Wed Jan 20 12:41:13 2010 +0100 @@ -0,0 +1,21 @@ +from django import template +from django.template.defaultfilters import stringfilter + +register = template.Library() + +def truncateletters(value, arg): + """ + Truncates a string after a certain number of letters + + Argument: Number of letters to truncate after + """ + from django_extensions.utils.text import truncate_letters + try: + length = int(arg) + except ValueError: # invalid literal for int() + return value # Fail silently + return truncate_letters(value, length) + +truncateletters.is_safe = True +truncateletters = stringfilter(truncateletters) +register.filter(truncateletters) diff -r c00932a80c14 -r b77683731f25 web/lib/django_extensions/utils/__init__.py diff -r c00932a80c14 -r b77683731f25 web/lib/django_extensions/utils/text.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/web/lib/django_extensions/utils/text.py Wed Jan 20 12:41:13 2010 +0100 @@ -0,0 +1,13 @@ +from django.utils.encoding import force_unicode +from django.utils.functional import allow_lazy + +def truncate_letters(s, num): + """ truncates a string to a number of letters, similar to truncate_words """ + s = force_unicode(s) + length = int(num) + if len(s)>length: + s = s[:length] + if not s.endswith('...'): + s += '...' + return s +truncate_letters = allow_lazy(truncate_letters, unicode) diff -r c00932a80c14 -r b77683731f25 web/lib/django_extensions/utils/uuid.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/web/lib/django_extensions/utils/uuid.py Wed Jan 20 12:41:13 2010 +0100 @@ -0,0 +1,541 @@ +r"""UUID objects (universally unique identifiers) according to RFC 4122. + +This module provides immutable UUID objects (class UUID) and the functions +uuid1(), uuid3(), uuid4(), uuid5() for generating version 1, 3, 4, and 5 +UUIDs as specified in RFC 4122. + +If all you want is a unique ID, you should probably call uuid1() or uuid4(). +Note that uuid1() may compromise privacy since it creates a UUID containing +the computer's network address. uuid4() creates a random UUID. + +Typical usage: + + >>> import uuid + + # make a UUID based on the host ID and current time + >>> uuid.uuid1() + UUID('a8098c1a-f86e-11da-bd1a-00112444be1e') + + # make a UUID using an MD5 hash of a namespace UUID and a name + >>> uuid.uuid3(uuid.NAMESPACE_DNS, 'python.org') + UUID('6fa459ea-ee8a-3ca4-894e-db77e160355e') + + # make a random UUID + >>> uuid.uuid4() + UUID('16fd2706-8baf-433b-82eb-8c7fada847da') + + # make a UUID using a SHA-1 hash of a namespace UUID and a name + >>> uuid.uuid5(uuid.NAMESPACE_DNS, 'python.org') + UUID('886313e1-3b8a-5372-9b90-0c9aee199e5d') + + # make a UUID from a string of hex digits (braces and hyphens ignored) + >>> x = uuid.UUID('{00010203-0405-0607-0809-0a0b0c0d0e0f}') + + # convert a UUID to a string of hex digits in standard form + >>> str(x) + '00010203-0405-0607-0809-0a0b0c0d0e0f' + + # get the raw 16 bytes of the UUID + >>> x.bytes + '\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f' + + # make a UUID from a 16-byte string + >>> uuid.UUID(bytes=x.bytes) + UUID('00010203-0405-0607-0809-0a0b0c0d0e0f') +""" + +__author__ = 'Ka-Ping Yee ' + +RESERVED_NCS, RFC_4122, RESERVED_MICROSOFT, RESERVED_FUTURE = [ + 'reserved for NCS compatibility', 'specified in RFC 4122', + 'reserved for Microsoft compatibility', 'reserved for future definition'] + +class UUID(object): + """Instances of the UUID class represent UUIDs as specified in RFC 4122. + UUID objects are immutable, hashable, and usable as dictionary keys. + Converting a UUID to a string with str() yields something in the form + '12345678-1234-1234-1234-123456789abc'. The UUID constructor accepts + five possible forms: a similar string of hexadecimal digits, or a tuple + of six integer fields (with 32-bit, 16-bit, 16-bit, 8-bit, 8-bit, and + 48-bit values respectively) as an argument named 'fields', or a string + of 16 bytes (with all the integer fields in big-endian order) as an + argument named 'bytes', or a string of 16 bytes (with the first three + fields in little-endian order) as an argument named 'bytes_le', or a + single 128-bit integer as an argument named 'int'. + + UUIDs have these read-only attributes: + + bytes the UUID as a 16-byte string (containing the six + integer fields in big-endian byte order) + + bytes_le the UUID as a 16-byte string (with time_low, time_mid, + and time_hi_version in little-endian byte order) + + fields a tuple of the six integer fields of the UUID, + which are also available as six individual attributes + and two derived attributes: + + time_low the first 32 bits of the UUID + time_mid the next 16 bits of the UUID + time_hi_version the next 16 bits of the UUID + clock_seq_hi_variant the next 8 bits of the UUID + clock_seq_low the next 8 bits of the UUID + node the last 48 bits of the UUID + + time the 60-bit timestamp + clock_seq the 14-bit sequence number + + hex the UUID as a 32-character hexadecimal string + + int the UUID as a 128-bit integer + + urn the UUID as a URN as specified in RFC 4122 + + variant the UUID variant (one of the constants RESERVED_NCS, + RFC_4122, RESERVED_MICROSOFT, or RESERVED_FUTURE) + + version the UUID version number (1 through 5, meaningful only + when the variant is RFC_4122) + """ + + def __init__(self, hex=None, bytes=None, bytes_le=None, fields=None, + int=None, version=None): + r"""Create a UUID from either a string of 32 hexadecimal digits, + a string of 16 bytes as the 'bytes' argument, a string of 16 bytes + in little-endian order as the 'bytes_le' argument, a tuple of six + integers (32-bit time_low, 16-bit time_mid, 16-bit time_hi_version, + 8-bit clock_seq_hi_variant, 8-bit clock_seq_low, 48-bit node) as + the 'fields' argument, or a single 128-bit integer as the 'int' + argument. When a string of hex digits is given, curly braces, + hyphens, and a URN prefix are all optional. For example, these + expressions all yield the same UUID: + + UUID('{12345678-1234-5678-1234-567812345678}') + UUID('12345678123456781234567812345678') + UUID('urn:uuid:12345678-1234-5678-1234-567812345678') + UUID(bytes='\x12\x34\x56\x78'*4) + UUID(bytes_le='\x78\x56\x34\x12\x34\x12\x78\x56' + + '\x12\x34\x56\x78\x12\x34\x56\x78') + UUID(fields=(0x12345678, 0x1234, 0x5678, 0x12, 0x34, 0x567812345678)) + UUID(int=0x12345678123456781234567812345678) + + Exactly one of 'hex', 'bytes', 'bytes_le', 'fields', or 'int' must + be given. The 'version' argument is optional; if given, the resulting + UUID will have its variant and version set according to RFC 4122, + overriding the given 'hex', 'bytes', 'bytes_le', 'fields', or 'int'. + """ + + if [hex, bytes, bytes_le, fields, int].count(None) != 4: + raise TypeError('need one of hex, bytes, bytes_le, fields, or int') + if hex is not None: + hex = hex.replace('urn:', '').replace('uuid:', '') + hex = hex.strip('{}').replace('-', '') + if len(hex) != 32: + raise ValueError('badly formed hexadecimal UUID string') + int = long(hex, 16) + if bytes_le is not None: + if len(bytes_le) != 16: + raise ValueError('bytes_le is not a 16-char string') + bytes = (bytes_le[3] + bytes_le[2] + bytes_le[1] + bytes_le[0] + + bytes_le[5] + bytes_le[4] + bytes_le[7] + bytes_le[6] + + bytes_le[8:]) + if bytes is not None: + if len(bytes) != 16: + raise ValueError('bytes is not a 16-char string') + int = long(('%02x'*16) % tuple(map(ord, bytes)), 16) + if fields is not None: + if len(fields) != 6: + raise ValueError('fields is not a 6-tuple') + (time_low, time_mid, time_hi_version, + clock_seq_hi_variant, clock_seq_low, node) = fields + if not 0 <= time_low < 1<<32L: + raise ValueError('field 1 out of range (need a 32-bit value)') + if not 0 <= time_mid < 1<<16L: + raise ValueError('field 2 out of range (need a 16-bit value)') + if not 0 <= time_hi_version < 1<<16L: + raise ValueError('field 3 out of range (need a 16-bit value)') + if not 0 <= clock_seq_hi_variant < 1<<8L: + raise ValueError('field 4 out of range (need an 8-bit value)') + if not 0 <= clock_seq_low < 1<<8L: + raise ValueError('field 5 out of range (need an 8-bit value)') + if not 0 <= node < 1<<48L: + raise ValueError('field 6 out of range (need a 48-bit value)') + clock_seq = (clock_seq_hi_variant << 8L) | clock_seq_low + int = ((time_low << 96L) | (time_mid << 80L) | + (time_hi_version << 64L) | (clock_seq << 48L) | node) + if int is not None: + if not 0 <= int < 1<<128L: + raise ValueError('int is out of range (need a 128-bit value)') + if version is not None: + if not 1 <= version <= 5: + raise ValueError('illegal version number') + # Set the variant to RFC 4122. + int &= ~(0xc000 << 48L) + int |= 0x8000 << 48L + # Set the version number. + int &= ~(0xf000 << 64L) + int |= version << 76L + self.__dict__['int'] = int + + def __cmp__(self, other): + if isinstance(other, UUID): + return cmp(self.int, other.int) + return NotImplemented + + def __hash__(self): + return hash(self.int) + + def __int__(self): + return self.int + + def __repr__(self): + return 'UUID(%r)' % str(self) + + def __setattr__(self, name, value): + raise TypeError('UUID objects are immutable') + + def __str__(self): + hex = '%032x' % self.int + return '%s-%s-%s-%s-%s' % ( + hex[:8], hex[8:12], hex[12:16], hex[16:20], hex[20:]) + + def get_bytes(self): + bytes = '' + for shift in range(0, 128, 8): + bytes = chr((self.int >> shift) & 0xff) + bytes + return bytes + + bytes = property(get_bytes) + + def get_bytes_le(self): + bytes = self.bytes + return (bytes[3] + bytes[2] + bytes[1] + bytes[0] + + bytes[5] + bytes[4] + bytes[7] + bytes[6] + bytes[8:]) + + bytes_le = property(get_bytes_le) + + def get_fields(self): + return (self.time_low, self.time_mid, self.time_hi_version, + self.clock_seq_hi_variant, self.clock_seq_low, self.node) + + fields = property(get_fields) + + def get_time_low(self): + return self.int >> 96L + + time_low = property(get_time_low) + + def get_time_mid(self): + return (self.int >> 80L) & 0xffff + + time_mid = property(get_time_mid) + + def get_time_hi_version(self): + return (self.int >> 64L) & 0xffff + + time_hi_version = property(get_time_hi_version) + + def get_clock_seq_hi_variant(self): + return (self.int >> 56L) & 0xff + + clock_seq_hi_variant = property(get_clock_seq_hi_variant) + + def get_clock_seq_low(self): + return (self.int >> 48L) & 0xff + + clock_seq_low = property(get_clock_seq_low) + + def get_time(self): + return (((self.time_hi_version & 0x0fffL) << 48L) | + (self.time_mid << 32L) | self.time_low) + + time = property(get_time) + + def get_clock_seq(self): + return (((self.clock_seq_hi_variant & 0x3fL) << 8L) | + self.clock_seq_low) + + clock_seq = property(get_clock_seq) + + def get_node(self): + return self.int & 0xffffffffffff + + node = property(get_node) + + def get_hex(self): + return '%032x' % self.int + + hex = property(get_hex) + + def get_urn(self): + return 'urn:uuid:' + str(self) + + urn = property(get_urn) + + def get_variant(self): + if not self.int & (0x8000 << 48L): + return RESERVED_NCS + elif not self.int & (0x4000 << 48L): + return RFC_4122 + elif not self.int & (0x2000 << 48L): + return RESERVED_MICROSOFT + else: + return RESERVED_FUTURE + + variant = property(get_variant) + + def get_version(self): + # The version bits are only meaningful for RFC 4122 UUIDs. + if self.variant == RFC_4122: + return int((self.int >> 76L) & 0xf) + + version = property(get_version) + +def _find_mac(command, args, hw_identifiers, get_index): + import os + for dir in ['', '/sbin/', '/usr/sbin']: + executable = os.path.join(dir, command) + if not os.path.exists(executable): + continue + + try: + # LC_ALL to get English output, 2>/dev/null to + # prevent output on stderr + cmd = 'LC_ALL=C %s %s 2>/dev/null' % (executable, args) + pipe = os.popen(cmd) + except IOError: + continue + + for line in pipe: + words = line.lower().split() + for i in range(len(words)): + if words[i] in hw_identifiers: + return int(words[get_index(i)].replace(':', ''), 16) + return None + +def _ifconfig_getnode(): + """Get the hardware address on Unix by running ifconfig.""" + + # This works on Linux ('' or '-a'), Tru64 ('-av'), but not all Unixes. + for args in ('', '-a', '-av'): + mac = _find_mac('ifconfig', args, ['hwaddr', 'ether'], lambda i: i+1) + if mac: + return mac + + import socket + ip_addr = socket.gethostbyname(socket.gethostname()) + + # Try getting the MAC addr from arp based on our IP address (Solaris). + mac = _find_mac('arp', '-an', [ip_addr], lambda i: -1) + if mac: + return mac + + # This might work on HP-UX. + mac = _find_mac('lanscan', '-ai', ['lan0'], lambda i: 0) + if mac: + return mac + + return None + +def _ipconfig_getnode(): + """Get the hardware address on Windows by running ipconfig.exe.""" + import os, re + dirs = ['', r'c:\windows\system32', r'c:\winnt\system32'] + try: + import ctypes + buffer = ctypes.create_string_buffer(300) + ctypes.windll.kernel32.GetSystemDirectoryA(buffer, 300) + dirs.insert(0, buffer.value.decode('mbcs')) + except: + pass + for dir in dirs: + try: + pipe = os.popen(os.path.join(dir, 'ipconfig') + ' /all') + except IOError: + continue + for line in pipe: + value = line.split(':')[-1].strip().lower() + if re.match('([0-9a-f][0-9a-f]-){5}[0-9a-f][0-9a-f]', value): + return int(value.replace('-', ''), 16) + +def _netbios_getnode(): + """Get the hardware address on Windows using NetBIOS calls. + See http://support.microsoft.com/kb/118623 for details.""" + import win32wnet, netbios + ncb = netbios.NCB() + ncb.Command = netbios.NCBENUM + ncb.Buffer = adapters = netbios.LANA_ENUM() + adapters._pack() + if win32wnet.Netbios(ncb) != 0: + return + adapters._unpack() + for i in range(adapters.length): + ncb.Reset() + ncb.Command = netbios.NCBRESET + ncb.Lana_num = ord(adapters.lana[i]) + if win32wnet.Netbios(ncb) != 0: + continue + ncb.Reset() + ncb.Command = netbios.NCBASTAT + ncb.Lana_num = ord(adapters.lana[i]) + ncb.Callname = '*'.ljust(16) + ncb.Buffer = status = netbios.ADAPTER_STATUS() + if win32wnet.Netbios(ncb) != 0: + continue + status._unpack() + bytes = map(ord, status.adapter_address) + return ((bytes[0]<<40L) + (bytes[1]<<32L) + (bytes[2]<<24L) + + (bytes[3]<<16L) + (bytes[4]<<8L) + bytes[5]) + +# Thanks to Thomas Heller for ctypes and for his help with its use here. + +# If ctypes is available, use it to find system routines for UUID generation. +_uuid_generate_random = _uuid_generate_time = _UuidCreate = None +try: + import ctypes, ctypes.util + _buffer = ctypes.create_string_buffer(16) + + # The uuid_generate_* routines are provided by libuuid on at least + # Linux and FreeBSD, and provided by libc on Mac OS X. + for libname in ['uuid', 'c']: + try: + lib = ctypes.CDLL(ctypes.util.find_library(libname)) + except: + continue + if hasattr(lib, 'uuid_generate_random'): + _uuid_generate_random = lib.uuid_generate_random + if hasattr(lib, 'uuid_generate_time'): + _uuid_generate_time = lib.uuid_generate_time + + # On Windows prior to 2000, UuidCreate gives a UUID containing the + # hardware address. On Windows 2000 and later, UuidCreate makes a + # random UUID and UuidCreateSequential gives a UUID containing the + # hardware address. These routines are provided by the RPC runtime. + # NOTE: at least on Tim's WinXP Pro SP2 desktop box, while the last + # 6 bytes returned by UuidCreateSequential are fixed, they don't appear + # to bear any relationship to the MAC address of any network device + # on the box. + try: + lib = ctypes.windll.rpcrt4 + except: + lib = None + _UuidCreate = getattr(lib, 'UuidCreateSequential', + getattr(lib, 'UuidCreate', None)) +except: + pass + +def _unixdll_getnode(): + """Get the hardware address on Unix using ctypes.""" + _uuid_generate_time(_buffer) + return UUID(bytes=_buffer.raw).node + +def _windll_getnode(): + """Get the hardware address on Windows using ctypes.""" + if _UuidCreate(_buffer) == 0: + return UUID(bytes=_buffer.raw).node + +def _random_getnode(): + """Get a random node ID, with eighth bit set as suggested by RFC 4122.""" + import random + return random.randrange(0, 1<<48L) | 0x010000000000L + +_node = None + +def getnode(): + """Get the hardware address as a 48-bit positive integer. + + The first time this runs, it may launch a separate program, which could + be quite slow. If all attempts to obtain the hardware address fail, we + choose a random 48-bit number with its eighth bit set to 1 as recommended + in RFC 4122. + """ + + global _node + if _node is not None: + return _node + + import sys + if sys.platform == 'win32': + getters = [_windll_getnode, _netbios_getnode, _ipconfig_getnode] + else: + getters = [_unixdll_getnode, _ifconfig_getnode] + + for getter in getters + [_random_getnode]: + try: + _node = getter() + except: + continue + if _node is not None: + return _node + +_last_timestamp = None + +def uuid1(node=None, clock_seq=None): + """Generate a UUID from a host ID, sequence number, and the current time. + If 'node' is not given, getnode() is used to obtain the hardware + address. If 'clock_seq' is given, it is used as the sequence number; + otherwise a random 14-bit sequence number is chosen.""" + + # When the system provides a version-1 UUID generator, use it (but don't + # use UuidCreate here because its UUIDs don't conform to RFC 4122). + if _uuid_generate_time and node is clock_seq is None: + _uuid_generate_time(_buffer) + return UUID(bytes=_buffer.raw) + + global _last_timestamp + import time + nanoseconds = int(time.time() * 1e9) + # 0x01b21dd213814000 is the number of 100-ns intervals between the + # UUID epoch 1582-10-15 00:00:00 and the Unix epoch 1970-01-01 00:00:00. + timestamp = int(nanoseconds/100) + 0x01b21dd213814000L + if timestamp <= _last_timestamp: + timestamp = _last_timestamp + 1 + _last_timestamp = timestamp + if clock_seq is None: + import random + clock_seq = random.randrange(1<<14L) # instead of stable storage + time_low = timestamp & 0xffffffffL + time_mid = (timestamp >> 32L) & 0xffffL + time_hi_version = (timestamp >> 48L) & 0x0fffL + clock_seq_low = clock_seq & 0xffL + clock_seq_hi_variant = (clock_seq >> 8L) & 0x3fL + if node is None: + node = getnode() + return UUID(fields=(time_low, time_mid, time_hi_version, + clock_seq_hi_variant, clock_seq_low, node), version=1) + +def uuid3(namespace, name): + """Generate a UUID from the MD5 hash of a namespace UUID and a name.""" + import md5 + hash = md5.md5(namespace.bytes + name).digest() + return UUID(bytes=hash[:16], version=3) + +def uuid4(): + """Generate a random UUID.""" + + # When the system provides a version-4 UUID generator, use it. + if _uuid_generate_random: + _uuid_generate_random(_buffer) + return UUID(bytes=_buffer.raw) + + # Otherwise, get randomness from urandom or the 'random' module. + try: + import os + return UUID(bytes=os.urandom(16), version=4) + except: + import random + bytes = [chr(random.randrange(256)) for i in range(16)] + return UUID(bytes=bytes, version=4) + +def uuid5(namespace, name): + """Generate a UUID from the SHA-1 hash of a namespace UUID and a name.""" + import sha + hash = sha.sha(namespace.bytes + name).digest() + return UUID(bytes=hash[:16], version=5) + +# The following standard UUIDs are for use with uuid3() or uuid5(). + +NAMESPACE_DNS = UUID('6ba7b810-9dad-11d1-80b4-00c04fd430c8') +NAMESPACE_URL = UUID('6ba7b811-9dad-11d1-80b4-00c04fd430c8') +NAMESPACE_OID = UUID('6ba7b812-9dad-11d1-80b4-00c04fd430c8') +NAMESPACE_X500 = UUID('6ba7b814-9dad-11d1-80b4-00c04fd430c8')