Gromit hat geschrieben:die Attribute von __builtin__ interessieren die C-Library überhaupt nicht, d.h. fremde Funktionen aus fremden Libs liefern nach wie vor Instanzen von str.
Das ist doch mal eine Aussage, mit dem ich etwas anfangen kann!
Dann könnte ich das so Regeln, das ich leider auf alle neuen C-Lib-Features verzichten muß, die anderen mache ich dann über __features__ und den __builtin__ verfügbar, soweit wie es geht.
Ich möchte halt nicht nur mit Python 2.2.1 programmieren und den Anschluss an die schöne neue Python-Welt verlieren
Was die strip() geschichte anbelangt, könnte ich mir halt eine strip()-Funktion bauen, die entweder auf das vorhandene neue C-Lib-strip zurück greift oder die aktion komplett zu Fuss macht... Diese Funktion pack ich dann immer in die __builtin__, dann kann ich zwar nicht normal s.rstrip("/") schreiben, sondern muß rstrip(s, "/") schreiben. Das könnte ungefähr so aussehen:
Code: Alles auswählen
import __builtin__
def strip(s, chars=None):
try:
return s.strip(chars)
except:
print 'NotImplemented!'
__builtin__.strip = strip
print strip("/jep/", "/")
Da ich nur eine zentral zu startendes Skript habe, (WSGI -> den Handler für CGI und Co.) ist das vorgehen mit dem zentralen __builtin__-Patch auch viel praktischer als das __features__-Ding. Ich könnte einfach zwei Handler erstellen, einer für alte Python und einer für ein aktuelles Python...
Für den features-Import hab ich extra einen Patcher geschrieben:
Code: Alles auswählen
#!/usr/bin/python
# -*- coding: UTF-8 -*-
import os, sys
patch = """
# Automatic inserted import:
from __future__ import generators
"""
class Patcher:
def __init__(self, path):
print "Patch dir: '%s'" % path
self.confirmation()
fileList = self.readDir(path)
for fileName in fileList:
self.patchFile(fileName)
def confirmation(self):
choice = raw_input(
"Press y and ENTER to patch all *.py Files ? "
)
choice = choice.lower()
if choice != "y":
sys.exit()
def readDir(self, path):
result = []
for root, dirs, files in os.walk(path):
for fileName in files:
if not fileName.endswith(".py"):
continue
if fileName == "__init__.py":
continue
result.append(
os.path.join(root, fileName)
)
return result
def patchFile(self, fileName):
print fileName
f = file(fileName, "rU")
content = f.read()
f.close()
lines = content.split("\n")
status = self.checkNecessary(lines)
if status == False:
print "future import not necessary!"
return
lines = self.patchFileContent(lines)
print "Patched!"
f = file(fileName, "w")
f.write(
"\n".join(lines)
)
f.close()
def checkNecessary(self, lines):
for line in lines:
if line.startswith("from __future__") or \
line.startswith("import __future__"):
return False
if "yield" in line:
return True
return False
def patchFileContent(self, lines):
for no, line in enumerate(lines):
if not line.startswith("#"):
break
print no
lines.insert(no, patch)
test = lines[:no+5]
print " -"*30
print "\n".join(test)
print " -"*30
return lines
Patcher(os.getcwd())
Es wird also in den Dateien nur ein
from __future__ import generators eingefügt, wenn irgendwo ein
yield virkommt...
Der unnötige __future__ import bei einer aktuellen Python-Version soll allerdings auch so gut wie keine Zeit kosten. Weiß da jemand was näheres drüber???
