appypod-rattail/__init__.py

113 lines
5 KiB
Python

'''Appy allows you to create easily complete applications in Python.'''
# ------------------------------------------------------------------------------
import os.path
# ------------------------------------------------------------------------------
def getPath(): return os.path.dirname(__file__)
def versionIsGreaterThanOrEquals(version):
'''This method returns True if the current Appy version is greater than or
equals p_version. p_version must have a format like "0.5.0".'''
import appy.version
if appy.version.short == 'dev':
# We suppose that a developer knows what he is doing, so we return True.
return True
else:
paramVersion = [int(i) for i in version.split('.')]
currentVersion = [int(i) for i in appy.version.short.split('.')]
return currentVersion >= paramVersion
# ------------------------------------------------------------------------------
class Object:
'''At every place we need an object, but without any requirement on its
class (methods, attributes,...) we will use this minimalist class.'''
def __init__(self, **fields):
for k, v in fields.iteritems():
setattr(self, k, v)
def __repr__(self):
res = u'<Object '
for attrName, attrValue in self.__dict__.iteritems():
v = attrValue
if hasattr(v, '__repr__'):
v = v.__repr__()
try:
res += u'%s=%s ' % (attrName, v)
except UnicodeDecodeError:
res += u'%s=<encoding problem> ' % attrName
res = res.strip() + '>'
return res.encode('utf-8')
def __nonzero__(self): return bool(self.__dict__)
def get(self, name, default=None): return getattr(self, name, default)
def __getitem__(self, k): return getattr(self, k)
def update(self, other):
'''Includes information from p_other into p_self.'''
for k, v in other.__dict__.iteritems():
setattr(self, k, v)
# ------------------------------------------------------------------------------
class Hack:
'''This class proposes methods for patching some existing code with
alternative methods.'''
@staticmethod
def patch(method, replacement, klass=None):
'''This method replaces m_method with a p_replacement method, but
keeps p_method on its class under name
"_base_<initial_method_name>_". In the patched method, one may use
Hack.base to call the base method. If p_method is static, you must
specify its class in p_klass.'''
# Get the class on which the surgery will take place.
isStatic = klass
klass = klass or method.im_class
# On this class, store m_method under its "base" name.
name = isStatic and method.func_name or method.im_func.__name__
baseName = '_base_%s_' % name
setattr(klass, baseName, method)
# Store the replacement method on klass. When doing so, even when
# m_method is static, it is wrapped in a method. This is why, in
# m_base below, when the method is static, we return method.im_func to
# retrieve the original static method.
setattr(klass, name, replacement)
@staticmethod
def base(method, klass=None):
'''Allows to call the base (replaced) method. If p_method is static,
you must specify its p_klass.'''
isStatic = klass
klass = klass or method.im_class
name = isStatic and method.func_name or method.im_func.__name__
res = getattr(klass, '_base_%s_' % name)
if isStatic: res = res.im_func
return res
@staticmethod
def inject(patchClass, klass, verbose=False):
'''Injects any method or attribute from p_patchClass into klass.'''
patched = []
added = []
for name, attr in patchClass.__dict__.iteritems():
if name.startswith('__'): continue # Ignore special methods
# Is this name already defined on p_klass ?
if hasattr(klass, name):
hasAttr = True
klassAttr = getattr(klass, name)
else:
hasAttr = False
klassAttr = None
if hasAttr and callable(attr) and callable(klassAttr):
# Patch this method via Hack.patch
Hack.patch(klassAttr, attr)
patched.append(name)
else:
# Simply replace the static attr or add the new static
# attribute or method.
setattr(klass, name, attr)
added.append(name)
if verbose:
pName = patchClass.__name__
cName = klass.__name__
print '%d method(s) patched from %s to %s (%s)' % \
(len(patched), pName, cName, str(patched))
print '%d method(s) and/or attribute(s) added from %s to %s (%s)'%\
(len(added), pName, cName, str(added))
# ------------------------------------------------------------------------------