def save_type(self, obj):
if getattr(new, obj.__name__, None) is obj:
# Types in 'new' module claim their module is '__builtin__' but are not actually there
save_global_byname(self, obj, 'new', obj.__name__)
elif obj.__module__ == '__main__':
# Types in __main__ are saved by value
# Make sure we have a reference to type.__new__
if id(type.__new__) not in self.memo:
self.save_reduce(getattr, (type, '__new__'), obj=type.__new__)
self.write(pickle.POP)
# Copy dictproxy to real dict
d = dict(obj.__dict__)
# Clean up unpickleable descriptors added by Python
d.pop('__dict__', None)
d.pop('__weakref__', None)
args = (type(obj), obj.__name__, obj.__bases__, d)
self.save_reduce(type.__new__, args, obj=obj)
else:
# Fallback to default behavior: save by reference
pickle.Pickler.save_global(self, obj)
python类module()的实例源码
def test_add_invalid(self):
mod = new.module('spam')
self.assertRaises(TypeError, pyamf.add_type, mod)
self.assertRaises(TypeError, pyamf.add_type, {})
self.assertRaises(TypeError, pyamf.add_type, 'spam')
self.assertRaises(TypeError, pyamf.add_type, u'eggs')
self.assertRaises(TypeError, pyamf.add_type, 1)
self.assertRaises(TypeError, pyamf.add_type, 234234L)
self.assertRaises(TypeError, pyamf.add_type, 34.23)
self.assertRaises(TypeError, pyamf.add_type, None)
self.assertRaises(TypeError, pyamf.add_type, object())
class A:
pass
self.assertRaises(TypeError, pyamf.add_type, A())
def setUp(self):
ClassCacheClearingTestCase.setUp(self)
self.module = new.module('foo')
self.module.Classic = self.ClassicType
self.module.New = self.NewType
self.module.s = 'str'
self.module.i = 12323
self.module.f = 345.234
self.module.u = u'unicode'
self.module.l = ['list', 'of', 'junk']
self.module.d = {'foo': 'bar', 'baz': 'gak'}
self.module.obj = object()
self.module.mod = self.module
self.module.lam = lambda _: None
self.NewType.__module__ = 'foo'
self.ClassicType.__module__ = 'foo'
self.spam_module = Spam.__module__
Spam.__module__ = 'foo'
self.names = (self.module.__name__,)
def _normalize_module(module, depth=2):
"""
Return the module specified by `module`. In particular:
- If `module` is a module, then return module.
- If `module` is a string, then import and return the
module with that name.
- If `module` is None, then return the calling module.
The calling module is assumed to be the module of
the stack frame at the given depth in the call stack.
"""
if inspect.ismodule(module):
return module
elif isinstance(module, (str, unicode)):
return __import__(module, globals(), locals(), ["*"])
elif module is None:
return sys.modules[sys._getframe(depth).f_globals['__name__']]
else:
raise TypeError("Expected a module, string, or None")
def _from_module(self, module, object):
"""
Return true if the given object is defined in the given
module.
"""
if module is None:
return True
elif inspect.isfunction(object):
return module.__dict__ is object.func_globals
elif inspect.isclass(object):
# Some jython classes don't set __module__
return module.__name__ == getattr(object, '__module__', None)
elif inspect.getmodule(object) is not None:
return module is inspect.getmodule(object)
elif hasattr(object, '__module__'):
return module.__name__ == object.__module__
elif isinstance(object, property):
return True # [XX] no way not be sure.
else:
raise ValueError("object must be a class or function")
def __init__(self, mod=None, globs=None, verbose=None,
isprivate=None, optionflags=0):
warnings.warn("class Tester is deprecated; "
"use class doctest.DocTestRunner instead",
DeprecationWarning, stacklevel=2)
if mod is None and globs is None:
raise TypeError("Tester.__init__: must specify mod or globs")
if mod is not None and not inspect.ismodule(mod):
raise TypeError("Tester.__init__: mod must be a module; %r" %
(mod,))
if globs is None:
globs = mod.__dict__
self.globs = globs
self.verbose = verbose
self.isprivate = isprivate
self.optionflags = optionflags
self.testfinder = DocTestFinder(_namefilter=isprivate)
self.testrunner = DocTestRunner(verbose=verbose,
optionflags=optionflags)
def _remoteInvocationMobileCode(self, method, flags, *args):
# special trimmed-down version for mobile code methods (no locking etc)
body=pickle.dumps((self.URI.objectID,method,flags,args),Pyro.config.PYRO_PICKLE_FORMAT)
sock_sendmsg(self.conn.sock, self.createMsg(body), self.timeout)
ver,answer,pflags = self.receiveMsg(self.conn,1)
if answer is None:
raise ProtocolError('incorrect answer received')
answer=pickle.loads(answer)
if isinstance(answer,PyroExceptionCapsule):
if isinstance(answer.excObj,_InternalNoModuleError):
# server couldn't load module, supply it
return self.processMissingModuleError(answer.excObj, method, flags, args)
else:
# we have an encapsulated exception, raise it again.
answer.raiseEx()
return answer
def _normalize_module(module, depth=2):
"""
Return the module specified by `module`. In particular:
- If `module` is a module, then return module.
- If `module` is a string, then import and return the
module with that name.
- If `module` is None, then return the calling module.
The calling module is assumed to be the module of
the stack frame at the given depth in the call stack.
"""
if inspect.ismodule(module):
return module
elif isinstance(module, (str, unicode)):
return __import__(module, globals(), locals(), ["*"])
elif module is None:
return sys.modules[sys._getframe(depth).f_globals['__name__']]
else:
raise TypeError("Expected a module, string, or None")
def _from_module(self, module, object):
"""
Return true if the given object is defined in the given
module.
"""
if module is None:
return True
elif inspect.isfunction(object):
return module.__dict__ is object.func_globals
elif inspect.isclass(object):
# Some jython classes don't set __module__
return module.__name__ == getattr(object, '__module__', None)
elif inspect.getmodule(object) is not None:
return module is inspect.getmodule(object)
elif hasattr(object, '__module__'):
return module.__name__ == object.__module__
elif isinstance(object, property):
return True # [XX] no way not be sure.
else:
raise ValueError("object must be a class or function")
def __init__(self, mod=None, globs=None, verbose=None,
isprivate=None, optionflags=0):
warnings.warn("class Tester is deprecated; "
"use class doctest.DocTestRunner instead",
DeprecationWarning, stacklevel=2)
if mod is None and globs is None:
raise TypeError("Tester.__init__: must specify mod or globs")
if mod is not None and not inspect.ismodule(mod):
raise TypeError("Tester.__init__: mod must be a module; %r" %
(mod,))
if globs is None:
globs = mod.__dict__
self.globs = globs
self.verbose = verbose
self.isprivate = isprivate
self.optionflags = optionflags
self.testfinder = DocTestFinder(_namefilter=isprivate)
self.testrunner = DocTestRunner(verbose=verbose,
optionflags=optionflags)
def _caller(tblist, skip):
string = ""
arr = []
for file, line, name, text in tblist:
if file[-10:] == "TestCmd.py":
break
arr = [(file, line, name, text)] + arr
atfrom = "at"
for file, line, name, text in arr[skip:]:
if name in ("?", "<module>"):
name = ""
else:
name = " (" + name + ")"
string = string + ("%s line %d of %s%s\n" % (atfrom, line, file, name))
atfrom = "\tfrom"
return string
def build(self, key, name, opened, entry):
try:
module = new.module(re_not_word.sub('_',key))
module.__file__ = key
exec opened in module.__dict__
return module
finally:
opened.close()
def build(self, key, name, opened, entry):
try:
module = new.module(re_not_word.sub('_',key))
module.__file__ = key
text = opened.read().replace('\r\n', '\n')
code = compile(text, name, 'exec')
exec code in module.__dict__
return module
finally:
opened.close()
def getETreeModule(ElementTreeImplementation):
name = "_" + ElementTreeImplementation.__name__+"builder"
if name in moduleCache:
return moduleCache[name]
else:
mod = ModuleType("_" + ElementTreeImplementation.__name__+"builder")
objs = getETreeBuilder(ElementTreeImplementation)
mod.__dict__.update(objs)
moduleCache[name] = mod
return mod
def getETreeModule(ElementTreeImplementation, fullTree=False):
name = "_" + ElementTreeImplementation.__name__+"builder"
if name in moduleCache:
return moduleCache[name]
else:
mod = ModuleType("_" + ElementTreeImplementation.__name__+"builder")
objs = getETreeBuilder(ElementTreeImplementation, fullTree)
mod.__dict__.update(objs)
moduleCache[name] = mod
return mod
def getDomModule(DomImplementation):
name = "_" + DomImplementation.__name__+"builder"
if name in moduleCache:
return moduleCache[name]
else:
mod = ModuleType(name)
objs = getDomBuilder(DomImplementation)
mod.__dict__.update(objs)
moduleCache[name] = mod
return mod
def tearDown(self):
ClassCacheClearingTestCase.tearDown(self)
Spam.__module__ = self.spam_module
self.module.__name__ = self.names
def test_module(self):
r = pyamf.register_package(self.module, 'com.example')
self.check_module(r, 'com.example.')
def test_all(self):
self.module.Spam = Spam
self.module.__all__ = ['Classic', 'New']
r = pyamf.register_package(self.module, 'com.example')
self.check_module(r, 'com.example.')
def test_separator(self):
r = pyamf.register_package(self.module, 'com.example', separator='/')
self.ClassicType.__module__ = 'com.example'
self.NewType.__module__ = 'com.example'
self.check_module(r, 'com.example/')
def test_name(self):
self.module.__name__ = 'spam.eggs'
self.ClassicType.__module__ = 'spam.eggs'
self.NewType.__module__ = 'spam.eggs'
r = pyamf.register_package(self.module)
self.check_module(r, 'spam.eggs.')
def test_strict(self):
self.module.Spam = Spam
Spam.__module__ = self.spam_module
r = pyamf.register_package(self.module, 'com.example', strict=True)
self.check_module(r, 'com.example.')
def test_not_strict(self):
self.module.Spam = Spam
Spam.__module__ = self.spam_module
r = pyamf.register_package(self.module, 'com.example', strict=False)
self.assertEqual(len(r), 3)
for c in [self.NewType, self.ClassicType, Spam]:
alias = r[c]
self.assertTrue(isinstance(alias, pyamf.ClassAlias))
self.assertEqual(alias.klass, c)
self.assertEqual(alias.alias, 'com.example.' + c.__name__)
def setUp(self):
BaseTestCase.setUp(self)
import new
self.mod_name = '%s.%s' % (__name__, 'settings')
self.settings = sys.modules[self.mod_name] = new.module(self.mod_name)
self.old_env = os.environ.get('DJANGO_SETTINGS_MODULE', None)
os.environ['DJANGO_SETTINGS_MODULE'] = self.mod_name
self.settings.SECRET_KEY = 'unittest'
def getcurrent(clazz):
assert type(clazz) == types.ClassType, 'must be a class...'
module = namedModule(clazz.__module__)
currclass = getattr(module, clazz.__name__, None)
if currclass is None:
return clazz
return currclass
def namedModule(name):
"""Return a module given its name."""
topLevel = __import__(name)
packages = name.split(".")[1:]
m = topLevel
for p in packages:
m = getattr(m, p)
return m
def namedObject(name):
"""Get a fully named module-global object.
"""
classSplit = string.split(name, '.')
module = namedModule(string.join(classSplit[:-1], '.'))
return getattr(module, classSplit[-1])
def namedAny(name):
"""Get a fully named package, module, module-global object, or attribute.
"""
names = name.split('.')
topLevelPackage = None
moduleNames = names[:]
while not topLevelPackage:
try:
trialname = '.'.join(moduleNames)
topLevelPackage = __import__(trialname)
except ImportError:
# if the ImportError happened in the module being imported,
# this is a failure that should be handed to our caller.
# count stack frames to tell the difference.
exc_info = sys.exc_info()
if len(traceback.extract_tb(exc_info[2])) > 1:
try:
# Clean up garbage left in sys.modules.
del sys.modules[trialname]
except KeyError:
# Python 2.4 has fixed this. Yay!
pass
raise exc_info[0], exc_info[1], exc_info[2]
moduleNames.pop()
obj = topLevelPackage
for n in names[1:]:
obj = getattr(obj, n)
return obj
def macro(name, filename, source, **identifiers):
"""macro(name, source, **identifiers)
This allows you to create macro-like behaviors in python. See
twisted.python.hook for an example of its usage.
"""
if not identifiers.has_key('name'):
identifiers['name'] = name
source = source % identifiers
codeplace = "<%s (macro)>" % filename
code = compile(source, codeplace, 'exec')
# shield your eyes!
sm = sys.modules
tprm = "twisted.python.reflect.macros"
if not sm.has_key(tprm):
macros = new.module(tprm)
sm[tprm] = macros
macros.count = 0
macros = sm[tprm]
macros.count += 1
macroname = 'macro_' + str(macros.count)
tprmm = tprm + '.' + macroname
mymod = new.module(tprmm)
sys.modules[tprmm] = mymod
setattr(macros, macroname, mymod)
dict = mymod.__dict__
# Before we go on, I guess I should explain why I just did that. Basically
# it's a gross hack to get epydoc to work right, but the general idea is
# that it will be a useful aid in debugging in _any_ app which expects
# sys.modules to have the same globals as some function. For example, it
# would be useful if you were foolishly trying to pickle a wrapped function
# directly from a class that had been hooked.
exec code in dict, dict
return dict[name]
def testRebuild(self):
"""Rebuilding an unchanged module."""
# This test would actually pass if rebuild was a no-op, but it
# ensures rebuild doesn't break stuff while being a less
# complex test than testFileRebuild.
x = crash_test_dummy.X('a')
rebuild.rebuild(crash_test_dummy, doLog=False)
# Instance rebuilding is triggered by attribute access.
x.do()
self.failUnlessIdentical(x.__class__, crash_test_dummy.X)
self.failUnlessIdentical(f, crash_test_dummy.foo)
