117 lines
5 KiB
Python
117 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)
|
|
def clone(self):
|
|
res = Object()
|
|
res.update(self)
|
|
return res
|
|
|
|
# ------------------------------------------------------------------------------
|
|
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))
|
|
# ------------------------------------------------------------------------------
|