onfirstaccess setattr test: use a tmpdir-independ package name

Author: RonnyPfannschmidt

.hgignore

@@ -0,0 +1,16 @@
+
+# These lines are suggested according to the svn:ignore property
+# Feel free to enable them by uncommenting them
+syntax:glob
+*.pyc
+*.pyo
+*.swp
+*.html
+*.class
+
+.tox
+
+build
+dist
+apipkg.egg-info
+

CHANGELOG

@@ -0,0 +1,39 @@
+1.1
+----------------------------------------
+
+- copy __doc__ and introduce a new argument to initpkg()
+  (thanks Ralf Schmitt)
+
+- don't use a "0" default for __version__
+
+1.0
+----------------------------------------
+
+- make apipkg memorize the absolute path where a package starts
+  importing so that subsequent chdir + imports won't break. 
+
+- allow to alias modules
+
+- allow to use dotted names in alias specifications (thanks Ralf
+  Schmitt).
+
+1.0.0b6
+----------------------------------------
+
+- fix recursive import issue resulting in a superflous KeyError 
+- default to __version__ '0' and not set __loader__ or __path__ at all if it
+  doesn't exist on the underlying init module
+
+1.0.0b5
+----------------------------------------
+
+- fixed MANIFEST.in
+- also transfer __loader__ attribute (thanks Ralf Schmitt) 
+- compat fix for BPython 
+
+1.0.0b3 (compared to 1.0.0b2)
+------------------------------------
+
+- added special __onfirstaccess__ attribute whose value will 
+  be called on the first attribute access of an apimodule. 
+

MANIFEST.in

@@ -0,0 +1,7 @@
+include CHANGELOG
+include README.txt
+include setup.py
+include conftest.py
+include test_apipkg.py
+prune .svn 
+prune .hg 

README.txt

@@ -0,0 +1,84 @@
+Welcome to apipkg!
+------------------------
+
+With apipkg you can control the exported namespace of a
+python package and greatly reduce the number of imports for your users.
+It is a `small pure python module`_ that works on virtually all Python
+versions, including CPython2.3 to Python3.1, Jython and PyPy.  It co-operates
+well with Python's ``help()`` system, custom importers (PEP302) and common 
+command line completion tools.  
+
+Usage is very simple: you can require 'apipkg' as a dependency or you
+can copy paste the <100 Lines of code into your project.
+
+Tutorial example
+-------------------
+
+Here is a simple ``mypkg`` package that specifies one namespace
+and exports two objects imported from different modules::
+
+    # mypkg/__init__.py
+    import apipkg
+    apipkg.initpkg(__name__, {
+        'path': {
+            'Class1': "_mypkg.somemodule:Class1",
+            'clsattr': "_mypkg.othermodule:Class2.attr",
+        }
+    }
+
+The package is initialized with a dictionary as namespace. 
+
+You need to create a ``_mypkg`` package with a ``somemodule.py`` 
+and ``othermodule.py`` containing the respective classes.
+The ``_mypkg`` is not special - it's a completely 
+regular python package. 
+
+Namespace dictionaries contain ``name: value`` mappings 
+where the value may be another namespace dictionary or
+a string specifying an import location.  On accessing
+an namespace attribute an import will be performed::
+
+    >>> import mypkg
+    >>> mypkg.path
+    <ApiModule 'mypkg.path'>
+    >>> mypkg.path.Class1   # '_mypkg.somemodule' gets imported now
+    <class _mypkg.somemodule.Class1 at 0xb7d428fc>
+    >>> mypkg.path.clsattr  # '_mypkg.othermodule' gets imported now
+    4 # the value of _mypkg.othermodule.Class2.attr
+
+The ``mypkg.path`` namespace and its two entries are
+loaded when they are accessed.   This means:
+
+* lazy loading - only what is actually needed is ever loaded
+
+* only the root "mypkg" ever needs to be imported to get
+  access to the complete functionality.
+
+* the underlying modules are also accessible, for example::
+
+    from mypkg.sub import Class1
+
+
+Including apipkg in your package
+--------------------------------------
+
+If you don't want to add an ``apipkg`` dependency to your package you 
+can copy the `apipkg.py`_ file somewhere to your own package, 
+for example ``_mypkg/apipkg.py`` in the above example.  You
+then import the ``initpkg`` function from that new place and
+are good to go. 
+
+.. _`small pure python module`:
+.. _`apipkg.py`: http://bitbucket.org/hpk42/apipkg/src/tip/apipkg.py
+
+Feedback? 
+-----------------------
+
+If you have questions you are welcome to 
+
+* join the #pylib channel on irc.freenode.net 
+* subscribe to the http://codespeak.net/mailman/listinfo/py-dev list. 
+* create an issue on http://bitbucket.org/hpk42/apipkg/issues
+
+have fun, 
+holger krekel

apipkg.py

@@ -0,0 +1,120 @@
+"""
+apipkg: control the exported namespace of a python package.
+
+see http://pypi.python.org/pypi/apipkg
+
+(c) holger krekel, 2009 - MIT license
+"""
+import os
+import sys
+from types import ModuleType
+
+__version__ = "1.1"
+
+def initpkg(pkgname, exportdefs, attr=dict()):
+    """ initialize given package from the export definitions. """
+    oldmod = sys.modules[pkgname]
+    d = {}
+    f = getattr(oldmod, '__file__', None)
+    if f:
+        f = os.path.abspath(f)
+    d['__file__'] = f
+    if hasattr(oldmod, '__version__'):
+        d['__version__'] = oldmod.__version__
+    if hasattr(oldmod, '__loader__'):
+        d['__loader__'] = oldmod.__loader__
+    if hasattr(oldmod, '__path__'):
+        d['__path__'] = [os.path.abspath(p) for p in oldmod.__path__]
+    if hasattr(oldmod, '__doc__'):
+        d['__doc__'] = oldmod.__doc__
+    d.update(attr)
+    oldmod.__dict__.update(d)
+    mod = ApiModule(pkgname, exportdefs, implprefix=pkgname, attr=d)
+    sys.modules[pkgname]  = mod
+
+def importobj(modpath, attrname):
+    module = __import__(modpath, None, None, ['__doc__'])
+    if not attrname:
+        return module
+
+    retval = module
+    names = attrname.split(".")
+    for x in names:
+        retval = getattr(retval, x)
+    return retval
+
+class ApiModule(ModuleType):
+    def __init__(self, name, importspec, implprefix=None, attr=None):
+        self.__name__ = name
+        self.__all__ = [x for x in importspec if x != '__onfirstaccess__']
+        self.__map__ = {}
+        self.__implprefix__ = implprefix or name
+        if attr:
+            for name, val in attr.items():
+                #print "setting", self.__name__, name, val
+                setattr(self, name, val)
+        for name, importspec in importspec.items():
+            if isinstance(importspec, dict):
+                subname = '%s.%s'%(self.__name__, name)
+                apimod = ApiModule(subname, importspec, implprefix)
+                sys.modules[subname] = apimod
+                setattr(self, name, apimod)
+            else:
+                parts = importspec.split(':')
+                modpath = parts.pop(0)
+                attrname = parts and parts[0] or ""
+                if modpath[0] == '.':
+                    modpath = implprefix + modpath
+                if name == '__doc__':
+                    self.__doc__ = importobj(modpath, attrname)
+                else:
+                    self.__map__[name] = (modpath, attrname)
+
+    def __repr__(self):
+        l = []
+        if hasattr(self, '__version__'):
+            l.append("version=" + repr(self.__version__))
+        if hasattr(self, '__file__'):
+            l.append('from ' + repr(self.__file__))
+        if l:
+            return '<ApiModule %r %s>' % (self.__name__, " ".join(l))
+        return '<ApiModule %r>' % (self.__name__,)
+
+    def __makeattr(self, name):
+        """lazily compute value for name or raise AttributeError if unknown."""
+        #print "makeattr", self.__name__, name
+        target = None
+        if '__onfirstaccess__' in self.__map__:
+            target = self.__map__.pop('__onfirstaccess__')
+            importobj(*target)()
+        try:
+            modpath, attrname = self.__map__[name]
+        except KeyError:
+            if target is not None and name != '__onfirstaccess__':
+                # retry, onfirstaccess might have set attrs
+                return getattr(self, name)
+            raise AttributeError(name)
+        else:
+            result = importobj(modpath, attrname)
+            setattr(self, name, result)
+            try:
+                del self.__map__[name]
+            except KeyError:
+                pass # in a recursive-import situation a double-del can happen
+            return result
+
+    __getattr__ = __makeattr
+
+    def __dict__(self):
+        # force all the content of the module to be loaded when __dict__ is read
+        dictdescr = ModuleType.__dict__['__dict__']
+        dict = dictdescr.__get__(self)
+        if dict is not None:
+            hasattr(self, 'some')
+            for name in self.__all__:
+                try:
+                    self.__makeattr(name)
+                except AttributeError:
+                    pass
+        return dict
+    __dict__ = property(__dict__)

conftest.py

@@ -0,0 +1,9 @@
+
+def pytest_generate_tests(metafunc):
+    multi = getattr(metafunc.function, 'multi', None)
+    if multi is None:
+        return
+    assert len(multi.kwargs) == 1
+    for name, l in multi.kwargs.items():
+        for val in l:
+            metafunc.addcall(funcargs={name: val})

example/_mypkg/__init__.py

@@ -0,0 +1,3 @@
+
+class OtherClass:
+    pass

example/_mypkg/othermodule.py

@@ -0,0 +1,5 @@
+
+from _mypkg.othermodule import OtherClass
+
+class SomeClass:
+    pass

example/_mypkg/somemodule.py

@@ -0,0 +1,9 @@
+# mypkg/__init__.py
+
+import apipkg
+apipkg.initpkg(__name__, {
+    'SomeClass': '_mypkg.somemodule:SomeClass',
+    'sub': {
+        'OtherClass': '_mypkg.somemodule:OtherClass',
+    }
+})