RedHatTraining/pyramid.git

Michael Merickel

2018-10-15 3670c2cdb732d378ba6d38e72e7cd875ff726aa9

commit \| author \| age
7f1e1e	1	import unittest
56df90	2	import os
bc37a5	3	from pyramid.compat import PY2
56df90	4
CM	5	here = os.path.abspath(os.path.dirname(__file__))
7f1e1e	6
CM	7	class TestCallerPath(unittest.TestCase):
d9a76e	8	def tearDown(self):
b60bdb	9	from pyramid.tests import test_path
cba2e1	10	if hasattr(test_path, '__abspath__'):
CM	11	del test_path.__abspath__
d9a76e	12
CM	13	def _callFUT(self, path, level=2):
b60bdb	14	from pyramid.path import caller_path
d9a76e	15	return caller_path(path, level)
7f1e1e	16
CM	17	def test_isabs(self):
d9a76e	18	result = self._callFUT('/a/b/c')
CM	19	self.assertEqual(result, '/a/b/c')
7f1e1e	20
CM	21	def test_pkgrelative(self):
	22	import os
d9a76e	23	result = self._callFUT('a/b/c')
CM	24	self.assertEqual(result, os.path.join(here, 'a/b/c'))
7f1e1e	25
cba2e1	26	def test_memoization_has_abspath(self):
7f1e1e	27	import os
b60bdb	28	from pyramid.tests import test_path
cba2e1	29	test_path.__abspath__ = '/foo/bar'
d9a76e	30	result = self._callFUT('a/b/c')
CM	31	self.assertEqual(result, os.path.join('/foo/bar', 'a/b/c'))
7f1e1e	32
CM	33	def test_memoization_success(self):
	34	import os
b60bdb	35	from pyramid.tests import test_path
d9a76e	36	result = self._callFUT('a/b/c')
CM	37	self.assertEqual(result, os.path.join(here, 'a/b/c'))
cba2e1	38	self.assertEqual(test_path.__abspath__, here)
d9a76e	39
CM	40	class TestCallerModule(unittest.TestCase):
a56564	41	def _callFUT(self, arg, *kw):
b60bdb	42	from pyramid.path import caller_module
a56564	43	return caller_module(arg, *kw)
d9a76e	44
CM	45	def test_it_level_1(self):
b60bdb	46	from pyramid.tests import test_path
d9a76e	47	result = self._callFUT(1)
CM	48	self.assertEqual(result, test_path)
	49
	50	def test_it_level_2(self):
b60bdb	51	from pyramid.tests import test_path
d9a76e	52	result = self._callFUT(2)
CM	53	self.assertEqual(result, test_path)
	54
	55	def test_it_level_3(self):
b60bdb	56	from pyramid.tests import test_path
d9a76e	57	result = self._callFUT(3)
a1d395	58	self.assertNotEqual(result, test_path)
5f4b80	59
a56564	60	def test_it_no___name__(self):
CM	61	class DummyFrame(object):
	62	f_globals = {}
	63	class DummySys(object):
	64	def _getframe(self, level):
	65	return DummyFrame()
	66	modules = {'__main__':'main'}
	67	dummy_sys = DummySys()
	68	result = self._callFUT(3, sys=dummy_sys)
	69	self.assertEqual(result, 'main')
	70
	71
5f4b80	72	class TestCallerPackage(unittest.TestCase):
CM	73	def _callFUT(self, arg, *kw):
b60bdb	74	from pyramid.path import caller_package
5f4b80	75	return caller_package(arg, *kw)
CM	76
	77	def test_it_level_1(self):
b60bdb	78	from pyramid import tests
5f4b80	79	result = self._callFUT(1)
CM	80	self.assertEqual(result, tests)
	81
	82	def test_it_level_2(self):
b60bdb	83	from pyramid import tests
5f4b80	84	result = self._callFUT(2)
CM	85	self.assertEqual(result, tests)
	86
	87	def test_it_level_3(self):
	88	import unittest
	89	result = self._callFUT(3)
	90	self.assertEqual(result, unittest)
	91
	92	def test_it_package(self):
b60bdb	93	import pyramid.tests
5f4b80	94	def dummy_caller_module(*arg):
b60bdb	95	return pyramid.tests
5f4b80	96	result = self._callFUT(1, caller_module=dummy_caller_module)
b60bdb	97	self.assertEqual(result, pyramid.tests)
d9a76e	98
CM	99	class TestPackagePath(unittest.TestCase):
	100	def _callFUT(self, package):
b60bdb	101	from pyramid.path import package_path
d9a76e	102	return package_path(package)
CM	103
	104	def test_it_package(self):
b60bdb	105	from pyramid import tests
d9a76e	106	package = DummyPackageOrModule(tests)
CM	107	result = self._callFUT(package)
	108	self.assertEqual(result, package.package_path)
	109
	110	def test_it_module(self):
b60bdb	111	from pyramid.tests import test_path
d9a76e	112	module = DummyPackageOrModule(test_path)
CM	113	result = self._callFUT(module)
	114	self.assertEqual(result, module.package_path)
	115
	116	def test_memoization_success(self):
b60bdb	117	from pyramid.tests import test_path
d9a76e	118	module = DummyPackageOrModule(test_path)
9a038d	119	self._callFUT(module)
cba2e1	120	self.assertEqual(module.__abspath__, module.package_path)
7f1e1e	121
CM	122	def test_memoization_fail(self):
b60bdb	123	from pyramid.tests import test_path
d9a76e	124	module = DummyPackageOrModule(test_path, raise_exc=TypeError)
CM	125	result = self._callFUT(module)
a1d395	126	self.assertFalse(hasattr(module, '__abspath__'))
d9a76e	127	self.assertEqual(result, module.package_path)
6efd81	128
39480c	129	class TestPackageOf(unittest.TestCase):
CM	130	def _callFUT(self, package):
b60bdb	131	from pyramid.path import package_of
39480c	132	return package_of(package)
CM	133
	134	def test_it_package(self):
b60bdb	135	from pyramid import tests
39480c	136	package = DummyPackageOrModule(tests)
CM	137	result = self._callFUT(package)
	138	self.assertEqual(result, tests)
	139
	140	def test_it_module(self):
94a6f3	141	import pyramid.tests.test_path
b60bdb	142	from pyramid import tests
94a6f3	143	package = DummyPackageOrModule(pyramid.tests.test_path)
39480c	144	result = self._callFUT(package)
CM	145	self.assertEqual(result, tests)
	146
6efd81	147	class TestPackageName(unittest.TestCase):
CM	148	def _callFUT(self, package):
b60bdb	149	from pyramid.path import package_name
6efd81	150	return package_name(package)
CM	151
	152	def test_it_package(self):
b60bdb	153	from pyramid import tests
6efd81	154	package = DummyPackageOrModule(tests)
CM	155	result = self._callFUT(package)
b60bdb	156	self.assertEqual(result, 'pyramid.tests')
c062d5	157
DH	158	def test_it_namespace_package(self):
	159	from pyramid import tests
	160	package = DummyNamespacePackage(tests)
	161	result = self._callFUT(package)
	162	self.assertEqual(result, 'pyramid.tests')
6efd81	163
CM	164	def test_it_module(self):
b60bdb	165	from pyramid.tests import test_path
6efd81	166	module = DummyPackageOrModule(test_path)
CM	167	result = self._callFUT(module)
b60bdb	168	self.assertEqual(result, 'pyramid.tests')
45d08c	169
CM	170	def test_it_None(self):
	171	result = self._callFUT(None)
	172	self.assertEqual(result, '__main__')
d79d13	173
MM	174	def test_it_main(self):
	175	import __main__
	176	result = self._callFUT(__main__)
	177	self.assertEqual(result, '__main__')
56df90	178
078859	179	class TestResolver(unittest.TestCase):
CM	180	def _getTargetClass(self):
	181	from pyramid.path import Resolver
	182	return Resolver
	183
	184	def _makeOne(self, package):
	185	return self._getTargetClass()(package)
	186
	187	def test_get_package_caller_package(self):
	188	import pyramid.tests
	189	from pyramid.path import CALLER_PACKAGE
	190	self.assertEqual(self._makeOne(CALLER_PACKAGE).get_package(),
	191	pyramid.tests)
	192
	193	def test_get_package_name_caller_package(self):
	194	from pyramid.path import CALLER_PACKAGE
	195	self.assertEqual(self._makeOne(CALLER_PACKAGE).get_package_name(),
	196	'pyramid.tests')
	197
	198	def test_get_package_string(self):
	199	import pyramid.tests
	200	self.assertEqual(self._makeOne('pyramid.tests').get_package(),
	201	pyramid.tests)
	202
	203	def test_get_package_name_string(self):
	204	self.assertEqual(self._makeOne('pyramid.tests').get_package_name(),
	205	'pyramid.tests')
	206
56df90	207	class TestAssetResolver(unittest.TestCase):
CM	208	def _getTargetClass(self):
	209	from pyramid.path import AssetResolver
	210	return AssetResolver
	211
	212	def _makeOne(self, package='pyramid.tests'):
	213	return self._getTargetClass()(package)
	214
	215	def test_ctor_as_package(self):
	216	import sys
	217	tests = sys.modules['pyramid.tests']
	218	inst = self._makeOne(tests)
	219	self.assertEqual(inst.package, tests)
	220
	221	def test_ctor_as_str(self):
	222	import sys
	223	tests = sys.modules['pyramid.tests']
	224	inst = self._makeOne('pyramid.tests')
	225	self.assertEqual(inst.package, tests)
	226
	227	def test_resolve_abspath(self):
	228	from pyramid.path import FSAssetDescriptor
	229	inst = self._makeOne(None)
	230	r = inst.resolve(os.path.join(here, 'test_asset.py'))
	231	self.assertEqual(r.__class__, FSAssetDescriptor)
660225	232	self.assertTrue(r.exists())
56df90	233
CM	234	def test_resolve_absspec(self):
	235	from pyramid.path import PkgResourcesAssetDescriptor
	236	inst = self._makeOne(None)
	237	r = inst.resolve('pyramid.tests:test_asset.py')
	238	self.assertEqual(r.__class__, PkgResourcesAssetDescriptor)
660225	239	self.assertTrue(r.exists())
56df90	240
CM	241	def test_resolve_relspec_with_pkg(self):
	242	from pyramid.path import PkgResourcesAssetDescriptor
	243	inst = self._makeOne('pyramid.tests')
	244	r = inst.resolve('test_asset.py')
	245	self.assertEqual(r.__class__, PkgResourcesAssetDescriptor)
660225	246	self.assertTrue(r.exists())
56df90	247
CM	248	def test_resolve_relspec_no_package(self):
	249	inst = self._makeOne(None)
	250	self.assertRaises(ValueError, inst.resolve, 'test_asset.py')
078859	251
CM	252	def test_resolve_relspec_caller_package(self):
	253	from pyramid.path import PkgResourcesAssetDescriptor
	254	from pyramid.path import CALLER_PACKAGE
	255	inst = self._makeOne(CALLER_PACKAGE)
	256	r = inst.resolve('test_asset.py')
	257	self.assertEqual(r.__class__, PkgResourcesAssetDescriptor)
660225	258	self.assertTrue(r.exists())
56df90	259
CM	260	class TestPkgResourcesAssetDescriptor(unittest.TestCase):
	261	def _getTargetClass(self):
	262	from pyramid.path import PkgResourcesAssetDescriptor
	263	return PkgResourcesAssetDescriptor
	264
	265	def _makeOne(self, pkg='pyramid.tests', path='test_asset.py'):
	266	return self._getTargetClass()(pkg, path)
	267
02ce7d	268	def test_class_conforms_to_IAssetDescriptor(self):
56df90	269	from pyramid.interfaces import IAssetDescriptor
CM	270	from zope.interface.verify import verifyClass
02ce7d	271	verifyClass(IAssetDescriptor, self._getTargetClass())
56df90	272
02ce7d	273	def test_instance_conforms_to_IAssetDescriptor(self):
56df90	274	from pyramid.interfaces import IAssetDescriptor
CM	275	from zope.interface.verify import verifyObject
02ce7d	276	verifyObject(IAssetDescriptor, self._makeOne())
56df90	277
CM	278	def test_absspec(self):
	279	inst = self._makeOne()
	280	self.assertEqual(inst.absspec(), 'pyramid.tests:test_asset.py')
	281
	282	def test_abspath(self):
	283	inst = self._makeOne()
	284	self.assertEqual(inst.abspath(), os.path.join(here, 'test_asset.py'))
	285
	286	def test_stream(self):
	287	inst = self._makeOne()
	288	inst.pkg_resources = DummyPkgResource()
	289	inst.pkg_resources.resource_stream = lambda x, y: '%s:%s' % (x, y)
fee381	290	s = inst.stream()
CM	291	self.assertEqual(s,
56df90	292	'%s:%s' % ('pyramid.tests', 'test_asset.py'))
CM	293
	294	def test_isdir(self):
	295	inst = self._makeOne()
	296	inst.pkg_resources = DummyPkgResource()
	297	inst.pkg_resources.resource_isdir = lambda x, y: '%s:%s' % (x, y)
	298	self.assertEqual(inst.isdir(),
	299	'%s:%s' % ('pyramid.tests', 'test_asset.py'))
	300
	301	def test_listdir(self):
	302	inst = self._makeOne()
	303	inst.pkg_resources = DummyPkgResource()
	304	inst.pkg_resources.resource_listdir = lambda x, y: '%s:%s' % (x, y)
	305	self.assertEqual(inst.listdir(),
	306	'%s:%s' % ('pyramid.tests', 'test_asset.py'))
	307
	308	def test_exists(self):
	309	inst = self._makeOne()
	310	inst.pkg_resources = DummyPkgResource()
	311	inst.pkg_resources.resource_exists = lambda x, y: '%s:%s' % (x, y)
	312	self.assertEqual(inst.exists(),
	313	'%s:%s' % ('pyramid.tests', 'test_asset.py'))
	314
	315	class TestFSAssetDescriptor(unittest.TestCase):
	316	def _getTargetClass(self):
	317	from pyramid.path import FSAssetDescriptor
	318	return FSAssetDescriptor
	319
	320	def _makeOne(self, path=os.path.join(here, 'test_asset.py')):
	321	return self._getTargetClass()(path)
	322
02ce7d	323	def test_class_conforms_to_IAssetDescriptor(self):
56df90	324	from pyramid.interfaces import IAssetDescriptor
CM	325	from zope.interface.verify import verifyClass
02ce7d	326	verifyClass(IAssetDescriptor, self._getTargetClass())
56df90	327
02ce7d	328	def test_instance_conforms_to_IAssetDescriptor(self):
56df90	329	from pyramid.interfaces import IAssetDescriptor
CM	330	from zope.interface.verify import verifyObject
02ce7d	331	verifyObject(IAssetDescriptor, self._makeOne())
56df90	332
CM	333	def test_absspec(self):
	334	inst = self._makeOne()
	335	self.assertRaises(NotImplementedError, inst.absspec)
	336
	337	def test_abspath(self):
	338	inst = self._makeOne()
	339	self.assertEqual(inst.abspath(), os.path.join(here, 'test_asset.py'))
	340
	341	def test_stream(self):
	342	inst = self._makeOne()
fee381	343	s = inst.stream()
CM	344	val = s.read()
	345	s.close()
56df90	346	self.assertTrue(b'asset' in val)
CM	347
	348	def test_isdir_False(self):
	349	inst = self._makeOne()
	350	self.assertFalse(inst.isdir())
	351
	352	def test_isdir_True(self):
	353	inst = self._makeOne(here)
	354	self.assertTrue(inst.isdir())
	355
	356	def test_listdir(self):
	357	inst = self._makeOne(here)
	358	self.assertTrue(inst.listdir())
	359
	360	def test_exists(self):
	361	inst = self._makeOne()
	362	self.assertTrue(inst.exists())
	363
	364	class TestDottedNameResolver(unittest.TestCase):
	365	def _makeOne(self, package=None):
	366	from pyramid.path import DottedNameResolver
	367	return DottedNameResolver(package)
	368
	369	def config_exc(self, func, arg, *kw):
	370	try:
	371	func(arg, *kw)
	372	except ValueError as e:
	373	return e
	374	else:
	375	raise AssertionError('Invalid not raised') # pragma: no cover
	376
	377	def test_zope_dottedname_style_resolve_builtin(self):
	378	typ = self._makeOne()
bc37a5	379	if PY2:
078859	380	result = typ._zope_dottedname_style('__builtin__.str', None)
bc37a5	381	else:
MM	382	result = typ._zope_dottedname_style('builtins.str', None)
56df90	383	self.assertEqual(result, str)
CM	384
	385	def test_zope_dottedname_style_resolve_absolute(self):
	386	typ = self._makeOne()
	387	result = typ._zope_dottedname_style(
078859	388	'pyramid.tests.test_path.TestDottedNameResolver', None)
56df90	389	self.assertEqual(result, self.__class__)
CM	390
	391	def test_zope_dottedname_style_irrresolveable_absolute(self):
	392	typ = self._makeOne()
	393	self.assertRaises(ImportError, typ._zope_dottedname_style,
078859	394	'pyramid.test_path.nonexisting_name', None)
56df90	395
CM	396	def test__zope_dottedname_style_resolve_relative(self):
	397	import pyramid.tests
078859	398	typ = self._makeOne()
56df90	399	result = typ._zope_dottedname_style(
078859	400	'.test_path.TestDottedNameResolver', pyramid.tests)
56df90	401	self.assertEqual(result, self.__class__)
CM	402
	403	def test__zope_dottedname_style_resolve_relative_leading_dots(self):
94a6f3	404	import pyramid.tests.test_path
078859	405	typ = self._makeOne()
56df90	406	result = typ._zope_dottedname_style(
078859	407	'..tests.test_path.TestDottedNameResolver', pyramid.tests)
56df90	408	self.assertEqual(result, self.__class__)
CM	409
	410	def test__zope_dottedname_style_resolve_relative_is_dot(self):
	411	import pyramid.tests
078859	412	typ = self._makeOne()
CM	413	result = typ._zope_dottedname_style('.', pyramid.tests)
56df90	414	self.assertEqual(result, pyramid.tests)
CM	415
	416	def test__zope_dottedname_style_irresolveable_relative_is_dot(self):
	417	typ = self._makeOne()
078859	418	e = self.config_exc(typ._zope_dottedname_style, '.', None)
56df90	419	self.assertEqual(
CM	420	e.args[0],
	421	"relative name '.' irresolveable without package")
	422
	423	def test_zope_dottedname_style_resolve_relative_nocurrentpackage(self):
	424	typ = self._makeOne()
078859	425	e = self.config_exc(typ._zope_dottedname_style, '.whatever', None)
56df90	426	self.assertEqual(
CM	427	e.args[0],
	428	"relative name '.whatever' irresolveable without package")
	429
	430	def test_zope_dottedname_style_irrresolveable_relative(self):
	431	import pyramid.tests
078859	432	typ = self._makeOne()
56df90	433	self.assertRaises(ImportError, typ._zope_dottedname_style,
078859	434	'.notexisting', pyramid.tests)
56df90	435
CM	436	def test__zope_dottedname_style_resolveable_relative(self):
	437	import pyramid
078859	438	typ = self._makeOne()
CM	439	result = typ._zope_dottedname_style('.tests', pyramid)
56df90	440	from pyramid import tests
CM	441	self.assertEqual(result, tests)
	442
	443	def test__zope_dottedname_style_irresolveable_absolute(self):
	444	typ = self._makeOne()
	445	self.assertRaises(
	446	ImportError,
078859	447	typ._zope_dottedname_style, 'pyramid.fudge.bar', None)
56df90	448
CM	449	def test__zope_dottedname_style_resolveable_absolute(self):
	450	typ = self._makeOne()
	451	result = typ._zope_dottedname_style(
078859	452	'pyramid.tests.test_path.TestDottedNameResolver', None)
56df90	453	self.assertEqual(result, self.__class__)
CM	454
	455	def test__pkg_resources_style_resolve_absolute(self):
	456	typ = self._makeOne()
	457	result = typ._pkg_resources_style(
078859	458	'pyramid.tests.test_path:TestDottedNameResolver', None)
56df90	459	self.assertEqual(result, self.__class__)
CM	460
	461	def test__pkg_resources_style_irrresolveable_absolute(self):
	462	typ = self._makeOne()
	463	self.assertRaises(ImportError, typ._pkg_resources_style,
078859	464	'pyramid.tests:nonexisting', None)
56df90	465
CM	466	def test__pkg_resources_style_resolve_relative(self):
	467	import pyramid.tests
078859	468	typ = self._makeOne()
56df90	469	result = typ._pkg_resources_style(
078859	470	'.test_path:TestDottedNameResolver', pyramid.tests)
56df90	471	self.assertEqual(result, self.__class__)
CM	472
	473	def test__pkg_resources_style_resolve_relative_is_dot(self):
	474	import pyramid.tests
078859	475	typ = self._makeOne()
CM	476	result = typ._pkg_resources_style('.', pyramid.tests)
56df90	477	self.assertEqual(result, pyramid.tests)
CM	478
	479	def test__pkg_resources_style_resolve_relative_nocurrentpackage(self):
	480	typ = self._makeOne()
	481	self.assertRaises(ValueError, typ._pkg_resources_style,
078859	482	'.whatever', None)
56df90	483
CM	484	def test__pkg_resources_style_irrresolveable_relative(self):
	485	import pyramid
078859	486	typ = self._makeOne()
56df90	487	self.assertRaises(ImportError, typ._pkg_resources_style,
078859	488	':notexisting', pyramid)
56df90	489
CM	490	def test_resolve_not_a_string(self):
	491	typ = self._makeOne()
	492	e = self.config_exc(typ.resolve, None)
	493	self.assertEqual(e.args[0], 'None is not a string')
	494
	495	def test_resolve_using_pkgresources_style(self):
	496	typ = self._makeOne()
	497	result = typ.resolve(
	498	'pyramid.tests.test_path:TestDottedNameResolver')
	499	self.assertEqual(result, self.__class__)
	500
	501	def test_resolve_using_zope_dottedname_style(self):
	502	typ = self._makeOne()
	503	result = typ.resolve(
	504	'pyramid.tests.test_path:TestDottedNameResolver')
	505	self.assertEqual(result, self.__class__)
	506
	507	def test_resolve_missing_raises(self):
	508	typ = self._makeOne()
	509	self.assertRaises(ImportError, typ.resolve, 'cant.be.found')
	510
078859	511	def test_resolve_caller_package(self):
CM	512	from pyramid.path import CALLER_PACKAGE
	513	typ = self._makeOne(CALLER_PACKAGE)
	514	self.assertEqual(typ.resolve('.test_path.TestDottedNameResolver'),
	515	self.__class__)
	516
	517	def test_maybe_resolve_caller_package(self):
	518	from pyramid.path import CALLER_PACKAGE
	519	typ = self._makeOne(CALLER_PACKAGE)
	520	self.assertEqual(typ.maybe_resolve('.test_path.TestDottedNameResolver'),
	521	self.__class__)
	522
56df90	523	def test_ctor_string_module_resolveable(self):
CM	524	import pyramid.tests
	525	typ = self._makeOne('pyramid.tests.test_path')
	526	self.assertEqual(typ.package, pyramid.tests)
	527
	528	def test_ctor_string_package_resolveable(self):
	529	import pyramid.tests
	530	typ = self._makeOne('pyramid.tests')
	531	self.assertEqual(typ.package, pyramid.tests)
	532
	533	def test_ctor_string_irresolveable(self):
	534	self.assertRaises(ValueError, self._makeOne, 'cant.be.found')
	535
	536	def test_ctor_module(self):
	537	import pyramid.tests
	538	import pyramid.tests.test_path
	539	typ = self._makeOne(pyramid.tests.test_path)
	540	self.assertEqual(typ.package, pyramid.tests)
	541
	542	def test_ctor_package(self):
	543	import pyramid.tests
	544	typ = self._makeOne(pyramid.tests)
	545	self.assertEqual(typ.package, pyramid.tests)
	546
	547	def test_ctor_None(self):
	548	typ = self._makeOne(None)
	549	self.assertEqual(typ.package, None)
	550
	551	class DummyPkgResource(object):
	552	pass
	553
d9a76e	554	class DummyPackageOrModule:
CM	555	def __init__(self, real_package_or_module, raise_exc=None):
	556	self.__dict__['raise_exc'] = raise_exc
	557	self.__dict__['__name__'] = real_package_or_module.__name__
7f1e1e	558	import os
d9a76e	559	self.__dict__['package_path'] = os.path.dirname(
CM	560	os.path.abspath(real_package_or_module.__file__))
6efd81	561	self.__dict__['__file__'] = real_package_or_module.__file__
d9a76e	562
CM	563	def __setattr__(self, key, val):
	564	if self.raise_exc is not None:
	565	raise self.raise_exc
	566	self.__dict__[key] = val
c062d5	567
DH	568	class DummyNamespacePackage:
	569	"""Has no __file__ attribute.
	570	"""
	571
	572	def __init__(self, real_package_or_module):
	573	self.__name__ = real_package_or_module.__name__
	574	import os
	575	self.package_path = os.path.dirname(
	576	os.path.abspath(real_package_or_module.__file__))