def fromfile(path): #{{{ pypath = absmodpath(path) if not pypath: raise TypeError("Not a valid python file: %s" %path) mod, isdir = None, op.isdir rootdir, osj, j = pkgdir(path), op.join, '.'.join path_isdir = isdir(path) pypath_list = pypath.split('.') maxlen = len(pypath_list) if path_isdir: path = osj(path, hasinit(path)) elif op.basename(path) in ('__init__.py%s' %s for s in ('', 'c', 'o')): path_isdir = True sysmod = sys.modules mod = sysmod.get(pypath) if mod and mod.__file__ == path: return mod for ind in xrange(1, maxlen+1): cur = pypath_list[:ind] ospath, name = osj(rootdir, *cur), j(cur) filename = path if ind == maxlen else osj(ospath, hasinit(ospath)) mod = sysmod.get(name) if mod and mod.__file__ == filename: continue mod = module(name) mod.__file__ = filename execfile(filename, mod.__dict__) sysmod[name] = mod if ind < maxlen or path_isdir: mod.__path__ = [ospath] return mod
def makeGrammar(self, rules): """ Produce a class from a collection of rules. @param rules: A mapping of names to rule bodies. """ lines = list(itertools.chain(*[self._function( "def rule_%s(self):" % (name,), ["_locals = {'self': self}", "self.locals[%r] = _locals" % (name,)] + list(body)) + ['\n\n'] for (name, body) in rules])) source = '\n'.join(self._suite( "class %s(%s):" %(self.name, self.superclass.__name__), lines)) modname = "pymeta_grammar__"+self.name filename = "/pymeta_generated_code/"+modname+".py" mod = module(modname) mod.__dict__.update(self.globals) mod.__name__ = modname mod.__dict__[self.superclass.__name__] = self.superclass mod.__loader__ = GeneratedCodeLoader(source) code = compile(source, filename, "exec") eval(code, mod.__dict__) mod.__dict__[self.name].globals = self.globals sys.modules[modname] = mod linecache.getlines(filename, mod.__dict__) return mod.__dict__[self.name]
def moduleFromGrammar(source, className, modname, filename): mod = module(modname) mod.__name__ = modname mod.__loader__ = GeneratedCodeLoader(source) code = compile(source, filename, "exec") eval(code, mod.__dict__) sys.modules[modname] = mod linecache.getlines(filename, mod.__dict__) return mod
def modulize(klass): if not isinstance(klass, type): raise TypeError('Only types can be modulized') result = module(klass.__name__) for name in type.__dir__(klass): if name in DO_NOT_MODULIZE_NAMES: continue value = type.__getattribute__(klass, name) if type(value) in DO_NOT_MODULIZE_TYPES: continue module.__setattr__(result, name, value) return result
def eval(source, scope=jacklegScope, origin="__main"): name = uuid.uuid4().hex + '.py' mod = module(name) mod.__name__ = name mod._m_outerScope = scope pysrc, _, lastline = ecompile(source, scope, origin).rpartition('\n') pysrc = '\n'.join(["from monte import runtime as _monte", pysrc, "_m_evalResult = " + lastline]) mod.__loader__ = GeneratedCodeLoader(pysrc) code = compile(pysrc, name, "exec") pyeval(code, mod.__dict__) sys.modules[name] = mod linecache.getlines(name, mod.__dict__) return mod._m_evalResult
def datatype(cls): """ usage: @datatype class List(metaclass=TypeMeta): Nil : ( ) Cons : ("hd","tl") # then we get a module ,the module name is 'm_' + class <name>, # class List ,then module name is m_List, module has Nil,Cons,List """ mod = module("m_" + cls.__name__, cls.__doc__) mod.__dict__.update(cls.__annotations__) mod.__dict__.update({cls.__name__: cls}) sys.modules["m_" + cls.__name__] = mod return mod
def eval(source, scope=jacklegScope, origin="__main"): name = uuid.uuid4().hex + '.py' mod = module(name) mod.__name__ = name mod._m_outerScope = scope pysrc, _, lastline = ecompile(source, scope, origin).rpartition('\n') pysrc = '\n'.join([ "from monte import runtime as _monte", pysrc, "_m_evalResult = " + lastline ]) mod.__loader__ = GeneratedCodeLoader(pysrc) code = compile(pysrc, name, "exec") pyeval(code, mod.__dict__) sys.modules[name] = mod linecache.getlines(name, mod.__dict__) return mod._m_evalResult
def moduleFromGrammar(tree, className, superclass, globalsDict): source = writePython(tree) modname = "pyometa_grammar__" + className filename = "/pyometa_generated_code/" + modname + ".py" mod = module(modname) mod.__dict__.update(globalsDict) mod.__name__ = modname mod.__dict__[superclass.__name__] = superclass mod.__dict__["GrammarBase"] = superclass mod.__loader__ = GeneratedCodeLoader(source) code = compile(source, filename, "exec") eval(code, mod.__dict__) mod.__dict__[className].globals = globalsDict sys.modules[modname] = mod linecache.getlines(filename, mod.__dict__) return mod.__dict__[className]
def moduleFromGrammar(tree, className, superclass, globalsDict): source = writePython(tree) modname = "pymeta_grammar__" + className filename = "/pymeta_generated_code/" + modname + ".py" mod = module(modname) mod.__dict__.update(globalsDict) mod.__name__ = modname mod.__dict__[superclass.__name__] = superclass mod.__dict__["GrammarBase"] = superclass mod.__loader__ = GeneratedCodeLoader(source) code = compile(source, filename, "exec") eval(code, mod.__dict__) mod.__dict__[className].globals = globalsDict sys.modules[modname] = mod linecache.getlines(filename, mod.__dict__) cls = mod.__dict__[className] cls.source = source return cls
def _create_module_and_parents(name): """ 创建一个moduls, 并且把所有的parents modules添加到sys.modulues @param name: Module name, such as 'lib.'. """ parts = name.split(".") # first create the top-level module parent = _create_module(parts[0]) created_parts = [parts[0]] parts.pop(0) # now, create any remaining child modules while parts: child_name = parts.pop(0) module = types.module(child_name) setattr(parent, child_name, module) created_parts.append(child_name) sys.modules[".".join(created_parts)] = module parent = module
def moduleFromSource(source, className, superclass=None, globalsDict=None, registerModule=True): modname = "pymeta_grammar__" + className + "__" + str(next(next_filename)) filename = "/pymeta_generated_code/" + modname + ".py" mod = module(modname) if globalsDict: mod.__dict__.update(globalsDict) mod.__name__ = modname if superclass: mod.__dict__[superclass.__name__] = superclass mod.__dict__["GrammarBase"] = superclass mod.__loader__ = GeneratedCodeLoader(source) code = compile(source, filename, "exec") eval(code, mod.__dict__) fullGlobals = dict(getattr(mod.__dict__[className], "globals", None) or {}) fullGlobals.update(globalsDict) mod.__dict__[className].globals = fullGlobals if registerModule: sys.modules[modname] = mod linecache.getlines(filename, mod.__dict__) return mod.__dict__[className]
def eval(source, scope=None, origin="__main"): name = origin.encode('ascii') mod = module(name) mod.__name__ = name mod._m_outerScope = scope if source in COMPILE_CACHE: pysrc = COMPILE_CACHE[source].encode('ascii') else: pysrc, _, lastline = ecompile(source, scope, origin).rpartition('\n') pysrc = '\n'.join(["from monte.runtime import compiler_helpers as _monte", pysrc.encode('utf-8'), "_m_evalResult = " + lastline.encode('utf-8')]) mod.__loader__ = GeneratedCodeLoader(pysrc) COMPILE_CACHE[source] = pysrc code = compile(pysrc, name, "exec") import __builtin__ __builtin__.eval(code, mod.__dict__) sys.modules[name] = mod linecache.getlines(name, mod.__dict__) return mod._m_evalResult
from zope.security.checker import InterfaceChecker, CheckerPublic from zope.security.metaconfigure import ClassDirective from zope.browsermenu.menu import BrowserMenu, BrowserMenuItem, BrowserSubMenuItem from zope.browsermenu.interfaces import IBrowserMenu, IMenuItemType from zope.browsermenu.interfaces import IBrowserMenuItem, IBrowserSubMenuItem from zope.browsermenu.interfaces import AddMenu # Create special modules that contain all menu item types from types import ModuleType as module import sys try: import zope.app except ImportError: # we doesn't always have zope.app now sys.modules['zope.app'] = module('app') menus = module('menus') sys.modules['zope.app.menus'] = menus _order_counter = {} def menuDirective(_context, id=None, class_=BrowserMenu, interface=None, title=u'', description=u''): """Registers a new browser menu.""" if id is None and interface is None: raise ConfigurationError( "You must specify the 'id' or 'interface' attribute.") if interface is None:
from zope.app import zapi from zope.app.component.metaconfigure import handler # referred to through ZCML from zope.app.publisher.browser.resourcemeta import resource from zope.app.publisher.browser.resourcemeta import resourceDirectory from zope.app.publisher.browser.i18nresourcemeta import I18nResource from zope.app.publisher.browser.viewmeta import view from zope.app.component.interface import provideInterface # Create special modules that contain all layers and skins from types import ModuleType as module import sys import zope.app zope.app.layers = module("layers") sys.modules["zope.app.layers"] = zope.app.layers zope.app.skins = module("skins") sys.modules["zope.app.skins"] = zope.app.skins def layer(_context, name=None, interface=None, base=IBrowserRequest): """Provides a new layer. >>> class Context(object): ... info = u'doc' ... def __init__(self): self.actions = [] ... def action(self, **kw): self.actions.append(kw) Possibility 1: The Old Way
from zope.app.publisher.browser.menu import BrowserMenuItem, BrowserSubMenuItem from zope.app.publisher.interfaces.browser import IBrowserMenu from zope.app.publisher.interfaces.browser import IBrowserMenuItem from zope.app.publisher.interfaces.browser import IMenuItemType from zope.publisher.interfaces.browser import IBrowserRequest from zope.app.container.interfaces import IAdding from zope.app.component.contentdirective import ContentDirective from zope.app.publisher.interfaces.browser import AddMenu # Create special modules that contain all menu item types from types import ModuleType as module import sys menus = module("menus") sys.modules["zope.app.menus"] = menus _order_counter = {} def menuDirective(_context, id=None, class_=BrowserMenu, interface=None, title=u"", description=u""): """Registers a new browser menu.""" if id is None and interface is None: raise ConfigurationError("You must specify the 'id' or 'interface' attribute.") if interface is None: interface = InterfaceClass(id, (), __doc__="Menu Item Type: %s" % id, __module__="zope.app.menus") # Add the menu item type to the `menus` module. # Note: We have to do this immediately, so that directives using the
del foo.__dict__ except TypeError: pass else: raise TestFailed, "del foo.__dict__" try: foo.__dict__ = {} except TypeError: pass else: raise TestFailed, "foo.__dict__ = {}" verify(foo.__dict__ is None) # Regularly initialized module, no docstring foo = module("foo") vereq(foo.__name__, "foo") vereq(foo.__doc__, None) vereq(foo.__dict__, {"__name__": "foo", "__doc__": None}) # ASCII docstring foo = module("foo", "foodoc") vereq(foo.__name__, "foo") vereq(foo.__doc__, "foodoc") vereq(foo.__dict__, {"__name__": "foo", "__doc__": "foodoc"}) # Unicode docstring foo = module("foo", u"foodoc\u1234") vereq(foo.__name__, "foo") vereq(foo.__doc__, u"foodoc\u1234") vereq(foo.__dict__, {"__name__": "foo", "__doc__": u"foodoc\u1234"})
@zope.interface.implementer(IConnection) def connectionOfPersistent(ob): """An adapter which gets a ZODB connection of a persistent object. We are assuming the object has a parent if it has been created in this transaction. Raises ValueError if it is impossible to get a connection. """ cur = ob while not getattr(cur, '_p_jar', None): cur = getattr(cur, '__parent__', None) if cur is None: return None return cur._p_jar # BBB: If zope.app.keyreference is not installed, we still want # old key references to be available. So fake a module to make # them unpickleable. try: import zope.app.keyreference except ImportError: import sys from types import ModuleType as module z_a_k = module('zope.app.keyreference') sys.modules['zope.app.keyreference'] = z_a_k z_a_k_p = module('zope.app.keyreference.persistent') z_a_k_p.KeyReferenceToPersistent = KeyReferenceToPersistent sys.modules['zope.app.keyreference.persistent'] = z_a_k_p
def connectionOfPersistent(ob): """An adapter which gets a ZODB connection of a persistent object. We are assuming the object has a parent if it has been created in this transaction. Raises ValueError if it is impossible to get a connection. """ cur = ob while not getattr(cur, "_p_jar", None): cur = getattr(cur, "__parent__", None) if cur is None: return None return cur._p_jar # BBB: If zope.app.keyreference is not installed, we still want # old key references to be available. So fake a module to make # them unpickleable. try: import zope.app.keyreference except ImportError: import sys from types import ModuleType as module z_a_k = module("zope.app.keyreference") sys.modules["zope.app.keyreference"] = z_a_k z_a_k_p = module("zope.app.keyreference.persistent") z_a_k_p.KeyReferenceToPersistent = KeyReferenceToPersistent sys.modules["zope.app.keyreference.persistent"] = z_a_k_p
def testNonFileModule(self): # {{{ """Non-file module returns False""" mod = module("testmod") self.assertFalse(isfilemodule(mod))
from zope.security.checker import InterfaceChecker, CheckerPublic from zope.security.metaconfigure import ClassDirective from zope.browsermenu.menu import BrowserMenu, BrowserMenuItem, BrowserSubMenuItem from zope.browsermenu.interfaces import IBrowserMenu, IMenuItemType from zope.browsermenu.interfaces import IBrowserMenuItem, IBrowserSubMenuItem from zope.browsermenu.interfaces import AddMenu from ._compat import _u # Create special modules that contain all menu item types from types import ModuleType as module import sys try: import zope.app except ImportError: # we doesn't always have zope.app now sys.modules['zope.app'] = module('app') menus = module('menus') sys.modules['zope.app.menus'] = menus _order_counter = {} def menuDirective(_context, id=None, class_=BrowserMenu, interface=None, title=_u(''), description=_u('')): """Registers a new browser menu.""" if id is None and interface is None: raise ConfigurationError(
del foo.__dict__ except TypeError: pass else: raise TestFailed, "del foo.__dict__" try: foo.__dict__ = {} except TypeError: pass else: raise TestFailed, "foo.__dict__ = {}" verify(foo.__dict__ is None) # Regularly initialized module, no docstring foo = module("foo") vereq(foo.__name__, "foo") vereq(foo.__doc__, None) vereq(foo.__dict__, {"__name__": "foo", "__package__": None, "__doc__": None}) # ASCII docstring foo = module("foo", "foodoc") vereq(foo.__name__, "foo") vereq(foo.__doc__, "foodoc") vereq(foo.__dict__, { "__name__": "foo", "__package__": None, "__doc__": "foodoc" }) # Unicode docstring
from zope.app.component.contentdirective import ClassDirective from zope.app.pagetemplate.engine import Engine from zope.app.container.interfaces import IAdding from zope.app.publisher.browser.menu import BrowserMenu from zope.app.publisher.browser.menu import BrowserMenuItem, BrowserSubMenuItem from zope.app.publisher.interfaces.browser import IBrowserMenu from zope.app.publisher.interfaces.browser import IBrowserMenuItem from zope.app.publisher.interfaces.browser import IBrowserSubMenuItem from zope.app.publisher.interfaces.browser import IMenuItemType from zope.app.publisher.interfaces.browser import AddMenu # Create special modules that contain all menu item types from types import ModuleType as module import sys menus = module('menus') sys.modules['zope.app.menus'] = menus _order_counter = {} def menuDirective(_context, id=None, class_=BrowserMenu, interface=None, title=u'', description=u''): """Registers a new browser menu.""" if id is None and interface is None: raise ConfigurationError( "You must specify the 'id' or 'interface' attribute.") if interface is None: if id in dir(menus):