def make_dispatch_functions():
ri2ro = singledispatch(_ri2ro)
py2ri = singledispatch(_py2ri)
py2ro = singledispatch(_py2ro)
ri2py = singledispatch(_ri2py)
return (ri2ro, py2ri, py2ro, ri2py)
def make_dispatch_functions():
ri2ro = singledispatch(_ri2ro)
py2ri = singledispatch(_py2ri)
py2ro = singledispatch(_py2ro)
ri2py = singledispatch(_ri2py)
return (ri2ro, py2ri, py2ro, ri2py)
def methdispatch(func):
dispatcher = singledispatch(func)
def wrapper(*args, **kw):
return dispatcher.dispatch(args[1].__class__)(*args, **kw)
wrapper.register = dispatcher.register
update_wrapper(wrapper, func)
return wrapper
def method_dispatch(func):
dispatcher = singledispatch(func)
def wrapper(*args, **kw):
return dispatcher.dispatch(args[1].__class__)(*args, **kw)
wrapper.register = dispatcher.register
update_wrapper(wrapper, func)
return wrapper
def initDefDispatcher(self):
self.generate = singledispatch.singledispatch(self.generate)
self.generate.register(lara_process.LogEntry, self.genLogEntry)
self.generate.register(lara_process.BeginSubProcess,
self.switchDispatcher)
self.generate.register(lara_process.BeginProcess, self.genBeginProcess)
self.generate.register(lara_process.BeginLockedTask,
self.genBeginLockedTask)
self.generate.register(lara_process.EndLockedTask,
self.genEndLockedTask)
self.generate.register(lara_process.BeginLoop, self.genBeginLoop)
self.generate.register(lara_process.EndLoop, self.genEndLoop)
self.generate.register(lara_process.BeginParallel,
self.genBeginParallel)
self.generate.register(lara_process.EndParallel, self.genEndParallel)
self.generate.register(lara_process.BeginThread, self.genBeginThread)
self.generate.register(lara_process.EndThread, self.genEndThread)
self.generate.register(lara_process.Delay, self.genDelay)
self.generate.register(lara_process.ReadBarcode, self.genReadBarcode)
self.generate.register(lara_process.MovePlate, self.genLoadDevice)
self.generate.register(lara_process.AutoLoad, self.genAutoLoadDevice)
self.generate.register(lara_process.Dispense, self.genDispenseCombi)
self.generate.register(lara_process.Shake, self.genShake)
self.generate.register(lara_process.Incubate, self.genIncubate)
self.generate.register(lara_process.RunExternalProtocol,
self.genRunProtocol)
self.generate.register(lara_process.Centrifuge, self.genCentrifuge)
self.generate.register(lara_process.EndProcess, self.genEndProcess)
def dispatchmethod(func):
""" singledispatch for class methods
This provides for a way to use ``functools.singledispatch`` inside of a class.
It has the same basic interface that ``singledispatch`` does.
"""
# This implementation builds on the following gist:
# https://gist.github.com/adamnew123456/9218f99ba35da225ca11
dispatcher = singledispatch(func)
def register(type): # pylint: disable=redefined-builtin
def _register(func):
return dispatcher.register(type)(func)
return _register
def dispatch(type): # pylint: disable=redefined-builtin
return dispatcher.dispatch(type)
def wrapper(inst, *args, **kwargs):
obj = args[0] if len(args) > 0 else inst
cls = obj if isclass(obj) else obj.__class__
impl = dispatch(cls)
return impl(inst, *args, **kwargs)
wrapper.register = register
wrapper.dispatch = dispatch
wrapper.registry = dispatcher.registry
wrapper._clear_cache = dispatcher._clear_cache # pylint: disable=protected-access
update_wrapper(wrapper, func)
return wrapper
def singledispatch(*args, **kwargs):
"""Singledispatch that works with @classmethod and @staticmethod."""
try:
rv = _singledispatch.singledispatch(*args, **kwargs)
except AttributeError:
# Due to imperfection in Python 2, functools.update_wrapper
# may raise an AttributeError exception when applied to
# @classmethod or @staticmethod. If that happened, the best
# we can do is try one more time using a
# functools.update_wrapper from Python 3 where this issue
# does not exist anymore.
_update_wrapper = _singledispatch.update_wrapper
_singledispatch.update_wrapper = update_wrapper
rv = _singledispatch.singledispatch(*args, **kwargs)
_singledispatch.update_wrapper = _update_wrapper
return rv
def generate_dispatches(self):
"""Generate singledispatches
"""
self.add_template_paths = singledispatch(self.add_template_paths)
self.add_template_paths.register(str, self._add_template_paths_str)
self.add_template_paths.register(list, self._add_template_paths_list)
self.add_template_paths.register(tuple, self._add_template_paths_tuple)
def generate_dispatches(self):
"""Generate singledispatches
"""
self.add_template_paths = singledispatch(self.add_template_paths)
self.add_template_paths.register(str, self._add_template_paths_str)
self.add_template_paths.register(list, self._add_template_paths_list)
self.add_template_paths.register(tuple, self._add_template_paths_tuple)
def methoddispatch(func):
# http://stackoverflow.com/questions/24601722/how-can-i-use-functools-singledispatch-with-instance-methods
dispatcher = singledispatch(func)
def wrapper(*args, **kwargs):
return dispatcher.dispatch(args[1].__class__)(*args, **kwargs)
wrapper.register = dispatcher.register
update_wrapper(wrapper, func)
return wrapper
def initDefDispatcher(self):
self.generate = singledispatch.singledispatch(self.generate)
self.generate.register(lara_process.BeginSubProcess,self.switchDispatcher)
self.generate.register(lara_process.EndSubProcess,self.genEndSubProcess)
self.generate.register(lara_process.EndProcess,self.genEndProcess)
self.generate.register(lara_process.MovePlate,self.genPlacePlate)
self.generate.register(lara_process.LoadTips,self.genLoadTips)
self.generate.register(lara_process.Aspirate,self.genAspirate)
self.generate.register(lara_process.Dispense,self.genDispense)
self.generate.register(lara_process.UnloadTips,self.genUnloadTips)
def valuedispatch(func):
_func = singledispatch(func)
@wraps(func)
def wrapper(*args, **kwargs):
return _func.registry.get(args[0], _func)(*args, **kwargs)
wrapper.register = _func.register
wrapper.dispatch = _func.dispatch
wrapper.registry = _func.registry
return wrapper
def valuedispatch(func):
_func = singledispatch(func)
@wraps(func)
def wrapper(*args, **kwargs):
return _func.registry.get(args[0], _func)(*args, **kwargs)
wrapper.register = _func.register
wrapper.dispatch = _func.dispatch
wrapper.registry = _func.registry
return wrapper
def methdispatch(func):
dispatcher = singledispatch(func)
def wrapper(*args, **kw):
try:
return dispatcher.dispatch(args[1].__class__)(*args, **kw)
except IndexError:
return dispatcher.dispatch(args[0].__class__)(*args, **kw)
wrapper.register = dispatcher.register
update_wrapper(wrapper, func)
return wrapper
def initDefDispatcher(self):
self.generate = singledispatch.singledispatch(self.generate)
self.generate.register(lara_process.BeginSubProcess,
self.switchDispatcher)
self.generate.register(lara_process.EndSubProcess,
self.genEndSubProcess)
self.generate.register(lara_process.EndProcess, self.genEndProcess)
self.generate.register(lara_process.MovePlate, self.genPlacePlate)
self.generate.register(lara_process.LoadTips, self.genLoadTips)
self.generate.register(lara_process.Aspirate, self.genAspirate)
self.generate.register(lara_process.Dispense, self.genDispense)
self.generate.register(lara_process.UnloadTips, self.genUnloadTips)
def singledispatchmethod(method):
'''
Enable singledispatch for class methods.
See http://stackoverflow.com/a/24602374/274318
'''
dispatcher = singledispatch(method)
def wrapper(*args, **kw):
return dispatcher.dispatch(args[1].__class__)(*args, **kw)
wrapper.register = dispatcher.register
update_wrapper(wrapper, dispatcher)
return wrapper
class Type(object):
def __init__(self, types_dict):
self.types_dict = types_dict
name = ClassAttr('__name__')
@classmethod
def from_attr(cls, attr, types_dict):
instance = cls(types_dict)
instance.attr = attr
return instance
def as_graphql(self):
raise NotImplementedError
def as_input(self):
return self.as_graphql()
def make_field(self, resolver=None):
return GraphQLField(self.as_graphql())
def _dispatcher(py_type):
return CustomType
_dispatcher = singledispatch(_dispatcher)
def dispatch_attr(cls, attr):
if isinstance(attr, Set):
return EntityConnectionType
return cls.dispatch(attr.py_type)
@classmethod
def dispatch(cls, py_type):
'''
Dispatch to the handler class
'''
return cls._dispatcher.dispatch(py_type)
@classmethod
def register(cls, py_type):
'''
Register class as attribute handler
'''
def decorate(klass):
cls._dispatcher.register(py_type, klass)
return klass
return decorate
def sdmethod(meth):
"""
This is a hack to monkey patch sdproperty to work as expected with instance methods.
"""
sd = singledispatch(meth)
def wrapper(obj, *args, **kwargs):
return sd.dispatch(args[0].__class__)(obj, *args, **kwargs)
wrapper.register = sd.register
wrapper.dispatch = sd.dispatch
wrapper.registry = sd.registry
wrapper._clear_cache = sd._clear_cache
functools.update_wrapper(wrapper, meth)
return wrapper
def sdmethod(meth):
"""
This is a hack to monkey patch sdproperty to work as expected with instance methods.
"""
sd = singledispatch(meth)
def wrapper(obj, *args, **kwargs):
return sd.dispatch(args[0].__class__)(obj, *args, **kwargs)
wrapper.register = sd.register
wrapper.dispatch = sd.dispatch
wrapper.registry = sd.registry
wrapper._clear_cache = sd._clear_cache
functools.update_wrapper(wrapper, meth)
return wrapper
def __init__(self, model):
if '__pypy__' in sys.modules:
# try to use psycopg2ct if we are on PyPy
try:
from psycopg2ct import compat
compat.register()
# monkey patch to dont let Storm crash on register type
import psycopg2
psycopg2._psycopg = object
class _psycopg:
UNICODEARRAY = psycopg2.extensions.UNICODEARRAY
from twisted.python.monkey import MonkeyPatcher
monkey_patcher = MonkeyPatcher(
(psycopg2, '_psycopg', _psycopg))
monkey_patcher.patch()
except ImportError:
raise RuntimeError(
'You are trying to use PostgreSQL with PyPy. Regular '
'psycopg2 module don\'t work with PyPy, you may install '
'psycopg2ct in order to can use psycopg2 with PyPy'
)
self.model = model
self._columns_mapping = {
properties.Bool: 'bool',
properties.UUID: 'uuid',
properties.RawStr: 'bytea',
properties.Pickle: 'bytea',
properties.JSON: 'json',
properties.DateTime: 'timestamp',
properties.Date: 'date',
properties.Time: 'time',
properties.TimeDelta: 'interval',
properties.Enum: 'integer',
properties.Decimal: 'decimal'
}
self.parse = singledispatch(self.parse)
self.parse.register(properties.Int, self._parse_int)
self.parse.register(properties.Unicode, self._parse_unicode)
self.parse.register(properties.Float, self._parse_float)
self.parse.register(properties.List, self._parse_list)
self.parse.register(NativeEnum, self._parse_enum)
def __init__(self, model):
if '__pypy__' in sys.modules:
# try to use psycopg2ct if we are on PyPy
try:
from psycopg2ct import compat
compat.register()
# monkey patch to dont let Storm crash on register type
import psycopg2
psycopg2._psycopg = object
class _psycopg:
UNICODEARRAY = psycopg2.extensions.UNICODEARRAY
from twisted.python.monkey import MonkeyPatcher
monkey_patcher = MonkeyPatcher(
(psycopg2, '_psycopg', _psycopg))
monkey_patcher.patch()
except ImportError:
raise RuntimeError(
'You are trying to use PostgreSQL with PyPy. Regular '
'psycopg2 module don\'t work with PyPy, you may install '
'psycopg2ct in order to can use psycopg2 with PyPy'
)
self.model = model
self._columns_mapping = {
properties.Bool: 'bool',
properties.UUID: 'uuid',
properties.RawStr: 'bytea',
properties.Pickle: 'bytea',
properties.JSON: 'json',
properties.DateTime: 'timestamp',
properties.Date: 'date',
properties.Time: 'time',
properties.TimeDelta: 'interval',
properties.Enum: 'integer',
properties.Decimal: 'decimal'
}
self.parse = singledispatch(self.parse)
self.parse.register(properties.Int, self._parse_int)
self.parse.register(properties.Unicode, self._parse_unicode)
self.parse.register(properties.Float, self._parse_float)
self.parse.register(properties.List, self._parse_list)
self.parse.register(NativeEnum, self._parse_enum)
def classdispatch(func):
"""
Like ``singledispatch``, this allows you to write a generic function that
with implementations that differ on type. However, unlike ``singledispatch``,
this expects a class as the first argument, and dispatches on that class,
rather than expecting an instance of a class, and dispatching on the class
of the instance.
"""
dispatcher = singledispatch(func)
def wrapper(*args, **kw): # pylint: disable=missing-docstring
return dispatcher.dispatch(args[0])(*args, **kw)
wrapper.register = dispatcher.register
update_wrapper(wrapper, func)
return wrapper
def __init__(self):
self.routes = {
'GET': defaultdict(dict),
'POST': defaultdict(dict),
'PUT': defaultdict(dict),
'DELETE': defaultdict(dict),
'OPTIONS': defaultdict(dict),
'PATCH': defaultdict(dict),
'HEAD': defaultdict(dict)
}
self._prepare_response = singledispatch(self._prepare_response)
self._prepare_response.register(str, self._prepare_response_str)
self._prepare_response.register(response.Response,
self._prepare_response_object)
super(Router, self).__init__()
def __init__(self):
self.routes = {
'GET': defaultdict(dict),
'POST': defaultdict(dict),
'PUT': defaultdict(dict),
'DELETE': defaultdict(dict),
'OPTIONS': defaultdict(dict),
'PATCH': defaultdict(dict),
'HEAD': defaultdict(dict)
}
self._prepare_response = singledispatch(self._prepare_response)
self._prepare_response.register(str, self._prepare_response_str)
self._prepare_response.register(
response.Response, self._prepare_response_object)
super(Router, self).__init__()
def AddCapability(cls, capab_dispatcher):
"""Adds a method to this class for doing type-specific things.
Args:
capab_dispatcher: Default function to use for this capability. Raise an
exception if there is no fallback code. The name of the function is
the name of the capability.
Returns:
A singledispatcher registered for this method. Use its .register method to
add type-specific functions.
Example:
@DescriptorSubclass.AddCapability
def SomeCapability(desc, arg):
raise NotImplementedError('No fallback for SomeCapability')
@SomeCapability.register(data_descriptor.NumberDescriptor)
def SomeCapabilityNumber(desc, arg):
assert isinstance(desc, DescriptorSubclass)
# Since desc is a subclass of DescriptorSubclass, and therefore
# Descriptor, use anything it has.
if desc.Validate(6):
return ''
return desc.description
desc = DescriptorSubclass().Doc('doc')
desc.SomeCapability() # raises NotImplementedError
desc.Number()
desc.SomeCapability() == ''
desc.InRange(1, 2)
desc.SomeCapability() == 'doc'
"""
dispatcher = singledispatch.singledispatch(capab_dispatcher)
def wrapper(self, *args, **kwargs):
"""Wrapper to return."""
cls = self.type.__class__ if self.HasType() else object
return dispatcher.dispatch(cls)(self, *args, **kwargs)
setattr(cls, capab_dispatcher.func_name, wrapper)
return dispatcher
def AddCapability(cls, capab_dispatcher):
"""Adds a method to this class for doing type-specific things.
Args:
capab_dispatcher: Default function to use for this capability. Raise an
exception if there is no fallback code. The name of the function is
the name of the capability.
Returns:
A singledispatcher registered for this method. Use its .register method to
add type-specific functions.
Example:
@DescriptorSubclass.AddCapability
def SomeCapability(desc, arg):
raise NotImplementedError('No fallback for SomeCapability')
@SomeCapability.register(data_descriptor.NumberDescriptor)
def SomeCapabilityNumber(desc, arg):
assert isinstance(desc, DescriptorSubclass)
# Since desc is a subclass of DescriptorSubclass, and therefore
# Descriptor, use anything it has.
if desc.Validate(6):
return ''
return desc.description
desc = DescriptorSubclass().Doc('doc')
desc.SomeCapability() # raises NotImplementedError
desc.Number()
desc.SomeCapability() == ''
desc.InRange(1, 2)
desc.SomeCapability() == 'doc'
"""
dispatcher = singledispatch.singledispatch(capab_dispatcher)
def wrapper(self, *args, **kwargs):
"""Wrapper to return."""
cls = self.type.__class__ if self.HasType() else object
return dispatcher.dispatch(cls)(self, *args, **kwargs)
setattr(cls, capab_dispatcher.func_name, wrapper)
return dispatcher
def __init__(self, model):
self.model = model
self._columns_mapping = {
properties.Enum: 'integer',
properties.Bool: 'integer',
properties.Int: 'integer',
properties.RawStr: 'blob',
properties.Pickle: 'blob',
properties.JSON: 'blob',
properties.Float: 'real',
properties.Unicode: 'varchar',
properties.DateVariable: 'varchar',
properties.DateTimeVariable: 'varchar',
properties.TimeVariable: 'varchar',
properties.TimeDeltaVariable: 'varchar',
properties.ListVariable: 'varchar',
NativeEnum: 'varchar'
}
self.parse = singledispatch(self.parse)
def __init__(self, model):
self.model = model
self._columns_mapping = {
properties.Bool: 'tinyint',
properties.UUID: 'blob',
properties.RawStr: 'blob',
properties.Pickle: 'varbinary',
properties.JSON: 'blob',
properties.DateTime: 'datetime',
properties.Date: 'date',
properties.Time: 'time',
properties.Enum: 'integer',
NativeEnum: 'enum'
}
self.parse = singledispatch(self.parse)
self.parse.register(properties.Int, self.parse_int)
self.parse.register(properties.Decimal, self.parse_decimal)
self.parse.register(properties.Unicode, self._parse_unicode)
self.parse.register(properties.Float, self._parse_float)
def __init__(self, model):
self.model = model
self._columns_mapping = {
properties.Bool: 'tinyint',
properties.UUID: 'blob',
properties.RawStr: 'blob',
properties.Pickle: 'varbinary',
properties.JSON: 'blob',
properties.DateTime: 'datetime',
properties.Date: 'date',
properties.Time: 'time',
properties.Enum: 'integer',
NativeEnum: 'enum'
}
self.parse = singledispatch(self.parse)
self.parse.register(properties.Int, self.parse_int)
self.parse.register(properties.Decimal, self.parse_decimal)
self.parse.register(properties.Unicode, self._parse_unicode)
self.parse.register(properties.Float, self._parse_float)
def __init__(self, model):
self.model = model
self._columns_mapping = {
properties.Enum: 'integer',
properties.Bool: 'integer',
properties.Int: 'integer',
properties.RawStr: 'blob',
properties.Pickle: 'blob',
properties.JSON: 'blob',
properties.Float: 'real',
properties.Unicode: 'varchar',
properties.DateVariable: 'varchar',
properties.DateTimeVariable: 'varchar',
properties.TimeVariable: 'varchar',
properties.TimeDeltaVariable: 'varchar',
properties.ListVariable: 'varchar',
NativeEnum: 'varchar'
}
self.parse = singledispatch(self.parse)
def initDefDispatcher(self):
self.generate = singledispatch.singledispatch(self.generate)
self.generate.register(lara_process.LogEntry,self.genLogEntry)
self.generate.register(lara_process.BeginSubProcess,self.switchDispatcher)
self.generate.register(lara_process.BeginProcess,self.genBeginProcess)
self.generate.register(lara_process.BeginLockedTask,self.genBeginLockedTask)
self.generate.register(lara_process.EndLockedTask,self.genEndLockedTask)
self.generate.register(lara_process.BeginLoop,self.genBeginLoop)
self.generate.register(lara_process.EndLoop,self.genEndLoop)
self.generate.register(lara_process.BeginParallel,self.genBeginParallel)
self.generate.register(lara_process.EndParallel,self.genEndParallel)
self.generate.register(lara_process.BeginThread,self.genBeginThread)
self.generate.register(lara_process.EndThread,self.genEndThread)
self.generate.register(lara_process.Delay,self.genDelay)
self.generate.register(lara_process.ReadBarcode,self.genReadBarcode)
self.generate.register(lara_process.MovePlate,self.genLoadDevice)
self.generate.register(lara_process.AutoLoad,self.genAutoLoadDevice)
self.generate.register(lara_process.Dispense,self.genDispenseCombi)
self.generate.register(lara_process.Shake,self.genShake)
self.generate.register(lara_process.Incubate,self.genIncubate)
self.generate.register(lara_process.RunExternalProtocol,self.genRunProtocol)
self.generate.register(lara_process.Centrifuge,self.genCentrifuge)
self.generate.register(lara_process.EndProcess,self.genEndProcess)
def __init__(self, model):
self.model = model
self._columns_mapping = {
properties.Bool: 'bool',
properties.UUID: 'uuid',
properties.RawStr: 'bytea',
properties.Pickle: 'bytea',
properties.JSON: 'json',
properties.DateTime: 'timestamp',
properties.Date: 'date',
properties.Time: 'time',
properties.TimeDelta: 'interval',
properties.Enum: 'integer',
properties.Decimal: 'decimal'
}
self.parse = singledispatch(self.parse)
self.parse.register(properties.Int, self._parse_int)
self.parse.register(properties.Unicode, self._parse_unicode)
self.parse.register(properties.Float, self._parse_float)
self.parse.register(properties.List, self._parse_list)
self.parse.register(NativeEnum, self._parse_enum)
def __init__(self, model):
self.model = model
self._columns_mapping = {
properties.Bool: 'bool',
properties.UUID: 'uuid',
properties.RawStr: 'bytea',
properties.Pickle: 'bytea',
properties.JSON: 'json',
properties.DateTime: 'timestamp',
properties.Date: 'date',
properties.Time: 'time',
properties.TimeDelta: 'interval',
properties.Enum: 'integer',
properties.Decimal: 'decimal'
}
self.parse = singledispatch(self.parse)
self.parse.register(properties.Int, self._parse_int)
self.parse.register(properties.Unicode, self._parse_unicode)
self.parse.register(properties.Float, self._parse_float)
self.parse.register(properties.List, self._parse_list)
self.parse.register(NativeEnum, self._parse_enum)
def __init__(self, template_paths=None, cache_size=50, static_path=None):
TwistedResource.__init__(self)
sep = filepath.os.sep
self._templates = {}
self.cache_size = cache_size
self.template_paths = [
'application/view/templates', '{}/templates/jinja'.format(
filepath.os.path.dirname(__file__).rsplit(sep, 1)[0])
]
self.add_template_paths = singledispatch(self.add_template_paths)
self.add_template_paths.register(str, self._add_template_paths_str)
self.add_template_paths.register(list, self._add_template_paths_list)
self.add_template_paths.register(tuple, self._add_template_paths_tuple)
if template_paths is not None:
self.add_template_paths(template_paths)
self.config = Application()
# set resources managers
self._styles_manager = appstyles.AppStyles()
self._scripts_manager = scripts.Scripts()
# headers and render keys for root_page and index templates
header = headers.Headers()
self.render_keys = {
'doctype': header.get_doctype(),
'header': {
'title': self.config.name,
'content_type': header.content_type,
'generator_content': header.get_generator_content(),
'description_content': header.get_description_content(),
'language_content': header.get_language_content(),
'mamba_content': header.get_mamba_content(),
'media': header.get_favicon_content('assets'),
'styles': self._styles_manager.get_styles().values(),
'scripts': self._scripts_manager.get_scripts().values()
}
}
# containers
self.containers = {
'styles': static.Data('', 'text/css'),
'scripts': static.Data('', 'text/javascript')
}
# register containers
self.putChild('styles', self.containers['styles'])
self.putChild('scripts', self.containers['scripts'])
# insert stylesheets
self.insert_stylesheets()
# insert scripts
self.insert_scripts()
# static accessible data (scripts, css, images, and others)
if static_path is None:
self.putChild('assets',
static.File(filepath.os.getcwd() + '/static'))
else:
self.putChild('assets', static_path)
# template environment
self.environment = templating.Environment(
autoescape=lambda name: (name.rsplit('.', 1)[1] == 'html'
if name is not None else False),
cache_size=self.cache_size,
loader=templating.FileSystemLoader(self.template_paths))
def othersDispatcher(self):
self.generate = singledispatch.singledispatch(self.generate)
def othersDispatcher(self):
self.generate = singledispatch.singledispatch(self.generate)
def make_dispatch_functions():
py2rpy = singledispatch(_py2rpy)
rpy2py = singledispatch(_rpy2py)
return (py2rpy, rpy2py)
def __init__(self):
super(SerializerClass, self).__init__()
self.serialize = singledispatch(self.serialize)
self.serialize.register(datetime, self._datetime)
self.serialize.register(list, self._list)
self.serialize.register(dict, self._dict)
def __init__(self, template_paths=None, cache_size=50, static_path=None):
TwistedResource.__init__(self)
sep = filepath.os.sep
self._templates = {}
self.cache_size = cache_size
self.template_paths = [
'application/view/templates',
'{}/templates/jinja'.format(
filepath.os.path.dirname(__file__).rsplit(sep, 1)[0]
)
]
self.add_template_paths = singledispatch(self.add_template_paths)
self.add_template_paths.register(str, self._add_template_paths_str)
self.add_template_paths.register(list, self._add_template_paths_list)
self.add_template_paths.register(tuple, self._add_template_paths_tuple)
if template_paths is not None:
self.add_template_paths(template_paths)
self.config = Application()
# set resources managers
self._styles_manager = appstyles.AppStyles()
self._scripts_manager = scripts.Scripts()
# headers and render keys for root_page and index templates
header = headers.Headers()
self.render_keys = {
'doctype': header.get_doctype(),
'header': {
'title': self.config.name,
'content_type': header.content_type,
'generator_content': header.get_generator_content(),
'description_content': header.get_description_content(),
'language_content': header.get_language_content(),
'mamba_content': header.get_mamba_content(),
'media': header.get_favicon_content('assets'),
'styles': self._styles_manager.get_styles().values(),
'scripts': self._scripts_manager.get_scripts().values()
}
}
# containers
self.containers = {
'styles': static.Data('', 'text/css'),
'scripts': static.Data('', 'text/javascript')
}
# register containers
self.putChild('styles', self.containers['styles'])
self.putChild('scripts', self.containers['scripts'])
# insert stylesheets
self.insert_stylesheets()
# insert scripts
self.insert_scripts()
# static accessible data (scripts, css, images, and others)
if static_path is None:
self.putChild(
'assets', static.File(filepath.os.getcwd() + '/static')
)
else:
self.putChild('assets', static_path)
# template environment
self.environment = templating.Environment(
autoescape=lambda name: (
name.rsplit('.', 1)[1] == 'html' if name is not None else False
),
cache_size=self.cache_size,
loader=templating.FileSystemLoader(self.template_paths)
)
