@@ 0,0 1,6 @@ 
+repo: 1f712da4b8a6d6a40aa8db53c48c02f3dd1fdb39
+node: 3e563174f4df61f33660c2327861bf03ed5b0913
+branch: default
+latesttag: null
+latesttagdistance: 14
+changessincelatesttag: 14

          

@@ 0,0 1,24 @@ 
+syntax: glob
+
+.sconsign.dblite
+.settings
+*.egg-info
+*.pyc
+*.blend1
+*.blend2
+*.avi
+*.glc
+*.mp4
+*.p3d
+debug.txt
+__pycache__
+*.orig
+*.bgeconf
+.project
+.pydevproject
+
+syntax: regexp
+
+^build
+^dist
+

          

@@ 0,0 1,26 @@ 
+
+Except when otherwise stated (look for LICENSE files in directories or
+information at the beginning of each file) all software and
+documentation is licensed as follows: 
+
+    The MIT License
+
+    Permission is hereby granted, free of charge, to any person 
+    obtaining a copy of this software and associated documentation 
+    files (the "Software"), to deal in the Software without 
+    restriction, including without limitation the rights to use, 
+    copy, modify, merge, publish, distribute, sublicense, and/or 
+    sell copies of the Software, and to permit persons to whom the 
+    Software is furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included 
+    in all copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 
+    OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
+    THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 
+    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 
+    DEALINGS IN THE SOFTWARE.
+

          

@@ 0,0 1,1 @@ 
+Set of utility classes to help with writing Python-CFFI bindings for C classes. Acts as development/build-time dependency only.

          

@@ 0,0 1,489 @@ 
+
+from __future__ import (print_function, division, absolute_import)
+
+# code generator
+
+import os
+import sys
+from tempfile import mktemp
+from subprocess import PIPE, Popen
+
+import re
+import traceback
+from cffi import FFI, CDefError, verifier
+from StringIO import StringIO
+from fnmatch import fnmatch
+
+IS_WIN32 = sys.platform == 'win32'
+
+# on windows, mingw\bin must be in path
+CPP_PATH = "cpp"
+
+################################################################################
+
+_TEMPLATE = """
+# this file is auto-generated. do not edit.
+from __future__ import (print_function, division, absolute_import)
+
+from cffi import FFI
+
+UNMANGLED_EXPORTS = [
+{all_unmangled}
+]
+
+EXPORTS = [
+{all}
+]
+
+INTERNAL_EXPORTS = [
+'_ffi',
+'EXPORTS',
+'UNMANGLED_EXPORTS',
+]
+
+__all__ = EXPORTS + UNMANGLED_EXPORTS + INTERNAL_EXPORTS
+
+from .internal import *
+
+_LIB = load_lib(\"""
+{cdefs}
+\""")
+
+{imports}
+{post_template}
+"""
+
+_IMPORT_FUNC_TEMPLATE = "{module_name} = lookup('{name}')\n"
+
+_IMPORT_SAFE_FUNC_TEMPLATE = "{module_name} = guard(lookup('{name}'))\n"
+
+################################################################################
+
+class AutoBind(object):
+    def __init__(self, options):
+        """
+        options to pass (as dict):
+        
+        CDEF_PATH: path string to the folder where all cdef files are located
+        CDEF_FILES: a list of include files to parse, in correct order
+        FFI_INCLUDE: a list of ffi objects to include using FFI.include()
+        DEFINES_BLACKLIST: a list of defined symbols that should not be exported
+        DEFINES: a list of defines that help to resolve #ifdef blocks
+        PRIVATE_SYMBOLS: a list of functions that should be prepended with an underscore
+        AUTOCHECK_BLACKLIST: a list of functions that should not be wrapped with guard()
+        REPLACES: a list of tuples (A, B) to be applied for string replacement
+        PRE_REPLACES: a list of tuples (A, B) to be pre-applied for string replacement
+        LIBNAME: name of library that contains the symbols (e.g. "SDL2", "GL", ...)
+        VERIFY_SOURCE: source code containing includes necessary to verify cdefs
+        VERIFY_OPTIONS: dictionary of arguments to pass to verify (optional override)
+        AUTOMANGLE: if True, prefix an underscore to all functions dealing with pointers
+        PYPREDEFS: path to pypredefs to generate for editors such as Aptana Studio
+        OUTMODULE: path to python module that should be generated
+        GENPOSTFIX: string to append to generated module (optional)
+        STRIP: remove comments (default: true)
+        PREPROCESS: preprocess source (default: false)
+        PREPROCESS_OPTIONS: options for preprocessor, if PREPROCESS is True
+        DEBUGOUT: write debug.txt containing intermediate defs
+        FINDERROR: remove statements until problem is gone
+        AUXCACHEDIR: auxiliarly cache dir to be cleaned on build
+        """
+        self.options = options
+    
+    def build_cdefs(self):
+        options = self.options
+        
+        re_ifdef = re.compile(r'^\#\S+\s+(\S+)')
+        re_define = re.compile(r'^\#define\s+(\S+)(\s+\S+)?')
+        re_hex = re.compile(r'(.*)(0x[0-9A-Fa-f]+)([^0-9A-Fa-f]*.*)')
+        
+        CDEF_PATH = options['CDEF_PATH']
+        PREPROCESS = options.get('PREPROCESS', False)
+        CDEF_FILES = options.get('CDEF_FILES', [])
+        _DEFINES_BLACKLIST = set(options.get('DEFINES_BLACKLIST', []))
+        _DEFINES = set(options.get('DEFINES', []))
+        _PRIVATE_SYMBOLS = set(options.get('PRIVATE_SYMBOLS', []))
+        _AUTOCHECK_BLACKLIST = set(options.get('AUTOCHECK_BLACKLIST', []))
+        REPLACES = options.get('REPLACES', [])
+        REPLACES.sort(key=(lambda k: k[0]), reverse=True)
+        PRE_REPLACES = options.get('PRE_REPLACES', [])
+        PRE_REPLACES.sort(key=(lambda k: k[0]), reverse=True)
+    
+        assert os.path.isdir(CDEF_PATH) 
+        
+        cdefs = StringIO()
+        hdefs = StringIO()
+        
+        for cdef_path in CDEF_FILES:
+            local_defines = set(_DEFINES)
+            
+            cdef_path = os.path.join(CDEF_PATH, cdef_path)
+            with open(cdef_path,'r') as cdef_file:
+                cdef_header = cdef_file.read()
+            
+            for a,b in PRE_REPLACES:
+                cdef_header = cdef_header.replace(a, b)
+                
+            if PREPROCESS:
+                cdef_header = self.preprocess_cdefs(cdef_header)
+    
+            clean_cdefs = ''
+            hdefs.write(cdef_header + '\n')
+            
+            blockdesc = []
+            blockdef = []
+            
+            def active_block_desc():
+                return blockdesc[-1]
+            def is_blocked():
+                return blockdef and (blockdef[-1] == False)
+            def is_meta_blocked():
+                return (len(blockdef) > 1) and (blockdef[-2] == False)
+            def block_push(value,line):
+                blockdesc.append(line)
+                blockdef.append(value)
+            def block_pop():
+                blockdesc.pop()
+                blockdef.pop()
+            def block_flip():
+                blockdef[-1] = not blockdef[-1] 
+            
+            eat_next = False
+            for line in cdef_header.splitlines():
+                line = line.strip()
+                # fix OCD preprocessor statements 
+                if line.startswith('#'):
+                    line = '#' + line[1:].strip()
+                if 0:
+                    while '0x' in line:
+                        # convert hexadecimal numbers to decimal ones
+                        m = re_hex.search(line)
+                        line = m.group(1) + str(int(m.group(2),16)) + m.group(3)
+                if eat_next:
+                    if not line.endswith('\\'):
+                        eat_next = False
+                elif line.startswith('#endif'):
+                    block_pop()
+                elif line.startswith('#ifndef '):
+                    if is_blocked():
+                        block_push(False, line)
+                    else:
+                        m = re_ifdef.match(line)
+                        block_push(not (m.group(1) in local_defines), line)
+                elif line.startswith('#ifdef '):
+                    if is_blocked():
+                        block_push(False, line)
+                    else:
+                        m = re_ifdef.match(line)
+                        block_push(m.group(1) in local_defines, line)
+                elif line.startswith('#if '):
+                    print('excluding',line)               
+                    block_push(False, line)
+                elif line.startswith('#elif'):
+                    print('excluding',line)
+                elif line.startswith('#else'):
+                    if is_meta_blocked():
+                        pass
+                    else:
+                        block_flip()
+                        #block_push(not is_blocked(), line)
+                elif is_blocked():
+                    clean_cdefs += '//' + line + ' | excluded by: %s\n' % (active_block_desc(),)
+                elif line.startswith('#include'):
+                    continue
+                elif line.startswith('#pragma'):
+                    continue
+                elif line.startswith('#error'):
+                    continue
+                elif line.startswith('#undef'):
+                    continue
+                elif line.startswith('#define'):
+                    m = re_define.match(line)
+                    define = m.group(1)
+                    var = m.group(2)
+                    if line.endswith('\\'):
+                        eat_next = True
+                    if '(' in define:
+                        # skip function macros
+                        continue
+                    local_defines.add(define)
+                    if not var:
+                        print('+',define)
+                    elif not (define in _DEFINES_BLACKLIST) and not define.startswith('_'):
+                        var = var.strip()                   
+                        clean_cdefs += '#define ' + define + ' ... // ' + var + '\n'
+                elif line:
+                    clean_cdefs += line + '\n'
+            
+            # remove superfluous macros
+            for a,b in REPLACES:
+                clean_cdefs = clean_cdefs.replace(a, b)
+            
+            cdefs.write(clean_cdefs + '\n')
+            
+        return cdefs.getvalue(), hdefs.getvalue()
+
+    def preprocess_cdefs(self, cdefs):
+        options = self.options
+        CDEF_PATH = options['CDEF_PATH']
+        PREPROCESS_OPTIONS = options.get('PREPROCESS_OPTIONS', [])
+        
+        tmppath = mktemp(suffix='.h')
+        file(tmppath, 'w').write(cdefs)
+        cmdline = ' '.join([
+            CPP_PATH,
+            '-I',CDEF_PATH,
+        ] + PREPROCESS_OPTIONS + [
+            '-P','-dD',
+            '-E',tmppath
+        ])
+        print(cmdline)
+        pipe = Popen(cmdline, shell=True, stdout=PIPE, universal_newlines=True)
+        text = pipe.communicate()[0]
+        outtext = ''
+        for line in text.splitlines():
+            line = line.strip()
+            if not line:
+                continue
+            outtext += line + '\n'
+        print(outtext)
+        return outtext
+
+    def remove_comments(self, cdefs):
+        """List cdefs in the current folder sorted by include order"""
+        tmppath = mktemp(suffix='.h')
+        file(tmppath, 'w').write(cdefs)
+        cmdline = CPP_PATH + ' -P -fpreprocessed -dD -E ' + tmppath
+        pipe = Popen(cmdline, shell=True, stdout=PIPE, universal_newlines=True)
+        text = pipe.communicate()[0]
+        outtext = ''
+        for line in text.splitlines():
+            line = line.strip()
+            if not line:
+                continue
+            outtext += line + '\n'
+        return outtext
+
+    def test_cdefs(self,cdefs,hdefs):
+        options = self.options
+        LIBNAME = options.get('LIBNAME',None)
+        DEF_VERIFY_OPTIONS = dict(
+        )
+        
+        if LIBNAME:
+            DEF_VERIFY_OPTIONS['libraries'] = [LIBNAME]
+
+        VERIFY_SOURCE = options.get('VERIFY_SOURCE', hdefs)
+        VERIFY_OPTIONS = options.get('VERIFY_OPTIONS', DEF_VERIFY_OPTIONS)
+        FFI_INCLUDE = options.get('FFI_INCLUDE', [])
+        AUXCACHEDIR = options.get('AUXCACHEDIR',None)
+        
+        verifier.cleanup_tmpdir()
+        if AUXCACHEDIR is not None and AUXCACHEDIR.endswith('__pycache__'):
+            verifier.cleanup_tmpdir(tmpdir=AUXCACHEDIR)
+        
+        ffi = FFI()
+        for sub_ffi in FFI_INCLUDE:
+            ffi.include(sub_ffi) 
+        ffi.cdef(cdefs)
+        print(VERIFY_OPTIONS)
+        capi = ffi.verify(VERIFY_SOURCE, 
+            **VERIFY_OPTIONS)
+        # crosscheck
+        outcapi = {}
+        if LIBNAME:
+            dlffi = FFI()
+            for sub_ffi in FFI_INCLUDE:
+                dlffi.include(sub_ffi) 
+            dlffi.cdef(cdefs)
+            dlcapi = dlffi.dlopen(LIBNAME)
+        else:
+            dlffi = ffi
+            dlcapi = capi
+        for name,value in capi.__dict__.items():
+            if name.startswith('__'):
+                print("skipping",name)
+                continue
+            if callable(value):
+                dlvalue = getattr(dlcapi, name)
+                outcapi[name] = dlvalue
+            elif isinstance(value, (int,float,long)):
+                outcapi[name] = value
+            else:
+                print("ignoring",name,value)
+        return dlffi, outcapi
+
+    def write_pypredef(self,CAPI):
+        PYPREDEFS = self.options['PYPREDEFS']
+        
+        dirpath = os.path.dirname(PYPREDEFS)
+        if not os.path.isdir(dirpath):
+            os.makedirs(dirpath)
+        
+        filepath = PYPREDEFS
+        
+        print("writing",filepath)
+        with file(filepath, 'w') as f:
+            for name,value in CAPI.items():
+                if name.startswith('__'):
+                    continue
+                if callable(value):
+                    f.write('def {name}(*argv):\n    """{name}"""\n\n'.format(
+                        name=name))
+                if isinstance(value, (int,float,long)):
+                    f.write('{name} = {typeid}\n'.format(name=name,typeid=type(value).__name__))
+
+    def safeguard_blacklisted(self,name):
+        _AUTOCHECK_BLACKLIST = set(self.options.get('AUTOCHECK_BLACKLIST',[]))
+        if name in _AUTOCHECK_BLACKLIST:
+            return True
+        for entry in _AUTOCHECK_BLACKLIST:
+            if fnmatch(name, entry):
+                return True
+        return False
+
+    def write_module(self,cdefs,hdefs,ffi,CAPI):
+        options = self.options
+        _PRIVATE_SYMBOLS = set(options.get('PRIVATE_SYMBOLS',[]))
+        AUTOMANGLE = options.get('AUTOMANGLE',False)
+        OUTMODULE = options['OUTMODULE']
+        
+        f = StringIO()
+        
+        imports = ''
+        exports = {
+            'all' : '',
+            'all_unmangled' : '',
+        }
+        
+        def get_signature(value):
+            #resultsig = ffi.typeof(value).result
+            sig = ffi.typeof(value).args
+            return sig
+        
+        def is_strptr_type(ctype):
+            return "'unsigned char *'" in repr(arg)
+        
+        def is_ptr_type(ctype):
+            cname = ctype.cname 
+            if ctype.cname == 'char *':
+                return False
+            return " *" in ctype.cname
+    
+        for name in sorted(CAPI):
+            value = CAPI[name]
+            module_name = name        
+            export_target = 'all'
+    
+            if callable(value):
+                func_template = "lookup('{name}')"
+                
+                mangle = False            
+                if name in _PRIVATE_SYMBOLS:
+                    mangle = True
+                elif AUTOMANGLE:
+                    sig = get_signature(value)
+                    for i,arg in enumerate(sig):
+                        if is_ptr_type(arg):
+                            print(name,"needs mangling")
+                            mangle = True
+                            break
+                    
+                if mangle:
+                    module_name = '_' + module_name
+                    export_target = 'all_unmangled'
+                    
+                if not self.safeguard_blacklisted(name):
+                    func_template = "guard({func_template})".format(**locals())
+                    
+                func_template = func_template.format(**locals())
+                imports += "{module_name} = {func_template}\n".format(**locals())
+                    
+            elif isinstance(value, (int,float,long)):
+                imports += '{module_name} = {value}\n'.format(**locals())
+    
+            exports[export_target] +=  '"{module_name}",\n'.format(**locals())
+    
+        all = exports['all']
+        all_unmangled = exports['all_unmangled']
+    
+        post_template = options.get('GENPOSTFIX','')
+    
+        f.write(_TEMPLATE.format(**locals()))
+        
+        filepath = OUTMODULE
+        print("writing",filepath)
+        with open(filepath, 'w') as outfile:
+            outfile.write(f.getvalue())
+
+    def find_error(self,cdefs):
+        lines = cdefs.splitlines()
+
+        FFI_INCLUDE = self.options.get('FFI_INCLUDE', [])
+        
+        print("backtracking for broken part...")
+        upper = len(lines)
+        for step in (256,128,64,32,16,1):
+            last_parser_error = 0
+            offset = upper
+            while offset > 0:
+                print(upper, offset)
+                source = '\n'.join(lines[:offset])
+                try:
+                    test_ffi = FFI()
+                    for sub_ffi in FFI_INCLUDE:
+                        test_ffi.include(sub_ffi) 
+                    test_ffi.cdef(source)
+                    break
+                except CDefError:
+                    last_parser_error = offset
+                    offset += 1
+                except:
+                    print(lines[offset-1])
+                    #traceback.print_exc()
+                    upper = offset
+                    offset -= step
+                    if offset == last_parser_error:
+                        break
+            
+        with file('debug.txt','w') as f:
+            print("writing to debug.txt...")
+            part_a = '\n'.join(lines[:offset])
+            part_b = '\n'.join(lines[offset:])
+            f.write(part_a)
+            f.write('\n <<<<<< BROKEN PART AROUND HERE >>>>>> \n')
+            f.write(part_b)
+            return
+
+    def build(self):
+        cdefs,hdefs = self.build_cdefs()
+        if self.options.get('STRIP',True):
+            cdefs = self.remove_comments(cdefs)
+        if self.options.get('DEBUGOUT',False):
+            print("writing debug.txt...")
+            with open('debug.txt','w') as f:
+                f.write(cdefs)
+        try:    
+            ffi, CAPI = self.test_cdefs(cdefs,hdefs)
+        except:
+            traceback.print_exc()
+            if self.options.get('FINDERROR', False):
+                self.find_error(cdefs)
+            raise SystemExit, 255
+        self.write_module(cdefs, hdefs, ffi, CAPI)
+        if self.options.get('PYPREDEFS',None):
+            self.write_pypredef(CAPI)
+
+################################################################################
+
+def preprocess_c_header(text, cpp_options=[], cpp_path='mcpp'):
+    cmdline = ' '.join([
+        cpp_path,
+    ] + cpp_options + [
+        '-DSOIL_CDEF',
+        '-P',
+    ])
+    pipe = Popen(cmdline, shell=True, 
+            stdin=PIPE, stdout=PIPE, universal_newlines=True)
+    result = pipe.communicate(input=text)[0]    
+    assert pipe.returncode == 0
+    return result

          

@@ 0,0 1,24 @@ 
+
+import os
+from setuptools import setup
+
+def read(fname):
+    return open(os.path.join(os.path.dirname(__file__), fname)).read()
+
+setup(
+    name = "autobind-cffi",
+    version = "0.1",
+    author = "Leonard Ritter",
+    author_email = "contact@leonard-ritter.com",
+    description = ("Set of utility classes to help with writing Python-CFFI "
+        "bindings for C classes. Acts as development/build-time dependency only."),
+    license = "MIT",
+    keywords = "cffi pypy bindings",
+    url = "https://bitbucket.org/duangle/autobind-cffi",
+    packages=['autobind'],
+    long_description=read('README'),
+    classifiers=[
+        "Development Status :: 3 - Alpha",
+        "License :: OSI Approved :: MIT License",
+    ],
+)
  No newline at end of file

          

@@ 0,0 1,6 @@ 
+repo: 60193f992356f6a6471e5ce769378b97ee892a1d
+node: 6e73417591f358b67f8f90f2ac81199bc1343237
+branch: default
+latesttag: release-0.5.1
+latesttagdistance: 31
+changessincelatesttag: 31

          

@@ 0,0 1,14 @@ 
+syntax: glob
+
+*.pyc
+__pycache__
+*.orig
+*.egg-info
+.project
+.pydevproject
+
+syntax: regexp
+
+^build
+^dist
+

          

@@ 0,0 1,2 @@ 
+b5e9614dbabbcad87f5d1ab25e506f102878b836 release-0.5
+0486868d6710e250ebd8a9f8ff7dc63a81cb77f0 release-0.5.1

          

@@ 0,0 1,26 @@ 
+
+Except when otherwise stated (look for LICENSE files in directories or
+information at the beginning of each file) all software and
+documentation is licensed as follows: 
+
+    The MIT License
+
+    Permission is hereby granted, free of charge, to any person 
+    obtaining a copy of this software and associated documentation 
+    files (the "Software"), to deal in the Software without 
+    restriction, including without limitation the rights to use, 
+    copy, modify, merge, publish, distribute, sublicense, and/or 
+    sell copies of the Software, and to permit persons to whom the 
+    Software is furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included 
+    in all copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 
+    OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
+    THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 
+    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 
+    DEALINGS IN THE SOFTWARE.
+

          

@@ 0,0 1,209 @@ 
+glue.py is a single lightweight utility module expanding Python with new 
+powerful idioms for accessors, callsets, weak methods, enums, singletons and 
+observable primitives that can easily be integrated with existing projects. It
+is particularly useful for writing model/view oriented applications.
+
+Installation
+============
+
+You'll require Python 2.7, Python 3+ or PyPy 1.9 to use glue.py. Earlier
+versions are not supported.
+
+glue.py can easily be installed from the Python package repository using
+distutils or pip:
+
+    pip install glue.py
+
+If you plan to make amendments to the codebase, or you're interested in the 
+latest development release, it is best to check out the source tree and
+install glue.py in development mode:
+
+    python setup.py develop
+
+Usage
+=====
+
+glue.py provides a larger set of interoperating utility classes and functions,
+of which only the most important ones will be described here in detail. It's
+not a bad idea to just browse through the source and look what else is there
+besides what's covered in this introduction.
+
+Generated Accessors
+-------------------
+
+While Python supports accessors through properties, providing regulated access
+to class variables has been traditionally cumbersome and repetitive, even though
+the syntax has somewhat improved with recent versions. Consider this classical
+approach to property access:
+
+    from types import NoneType
+
+    class Sponge(object):
+        pass
+
+    class Pineapple(object):
+        on_owner_changed = None
+        
+        def __init__(self):
+            self.__owner = None
+            
+        def get_owner(self):
+            return self.__owner
+        def set_owner(self, value):
+            if value == self.__owner:
+                return
+            assert isinstance(value, (Sponge, NoneType))
+            self.__owner = value
+            if self.on_owner_changed:
+                self.on_owner_changed(self)
+        owner = property(get_owner, set_owner, 
+            doc = "the owner of this Pineapple")
+
+apart from preventing a rewrite, the setter also provides an optional hook that
+can be triggered when the value changes. Notice how many times the word "owner"
+has to be repeated in one form or the other in order to expose this relatively
+simple attribute. Until Python 2.7, most people adapted this handy recipe to
+cut down on repetition:
+
+         def owner():
+            doc = """the owner of this pineapple"""
+            def fget(self):
+                return self.__owner
+            def fset(self, value):
+                if value == self.__owner:
+                    return
+                assert isinstance(value, (Sponge, NoneType))
+                self.__owner = value
+                if self.on_owner_changed:
+                    self.on_owner_changed(self)
+            return property(**locals())
+        owner = owner()
+
+That's slightly better, but not perfect, and also a little convoluted. These
+days, this approach is the status quo:
+
+        @property
+        def owner(self):
+            """The owner of this pineapple"""
+            return self.__owner
+        @owner.setter
+        def owner(self, value):
+            if value == self.__owner:
+                return
+            assert isinstance(value, (Sponge, NoneType))
+            self.__owner = value
+            if self.on_owner_changed:
+                self.on_owner_changed(self)
+
+it seems like we're mostly shuffling details around... all three solutions
+vary around 12 lines, and with a bunch of these, classes may seem a lot larger
+than they are. This is how glue.py does it:
+
+    from glue import (lazydecls, defproperty, autoinit, callset)
+    from types import NoneType
+
+    class Sponge(object):
+        pass
+
+    @lazydecls
+    class Pineapple(object):
+        on_owner_changed = callset()
+        
+        owner = defproperty(
+            default = None, types=(Sponge, NoneType), hook = on_owner_changed, 
+            doc = "The owner of this pineapple")
+        
+        def __init__(self):
+            autoinit()
+
+...case closed. For more information, try `help(glue.defproperty)`. 
+
+Callable Sets
+-------------
+
+You may have noticed that the `Pineapple` class exposes the `on_owner_changed`
+callback as a `callset`, which is just a short way of instantiating a
+`CallableSet`. Callable sets are a fast way to create observables:
+
+    from glue import callset
+        
+    def func1(value): 
+        print("func1 called with value",value)
+        return value+10
+
+    def func2(value): 
+        print("func2 called with value",value)
+        return value+20
+
+    def func3(value): 
+        print("func3 called with value",value)
+        return value+30
+
+Trying this on the command line:
+
+    >>> funcs = callset([func1,func2,func3])
+    >>> print(max(funcs(10)))
+    func1 called with value 10
+    func2 called with value 10
+    func3 called with value 10
+    40
+
+In the pineapple example, this is how a view would typically subscribe to
+events sent by the `Pineapple` class:
+
+    @lazydecls
+    class Squid(object):
+        neighbor_house = defproperty()
+        annoying_coworkers = defproperty(default = set)
+        
+        def __init__(self, **kwargs):
+            # auto-assign matching keyword args
+            autoinit(**kwargs)
+            # track if the owner of the neighbor house changes by registering
+            # Squid's callback. The callback will be weakly proxied, and
+            # automatically unregisters when this Squid instance is no longer
+            # referenced. 
+            self.neighbor_house.on_owner_changed.addweak(self.someone_moved_in)
+            
+        def someone_moved_in(self, event):
+            # since the on_owner_changed callset is global to Pineapple, Squid
+            # would be notified of any owner changes in Pineapples, so filter
+            # for the right one.
+            if not (event.instance is self.neighbor_house):
+                return
+            # check if the new tenant is one of our annoying coworkers
+            if event.value in self.annoying_coworkers:
+                # state opinion on the situation
+                print("Meh.")
+    
+
+Trying this on the command line:
+
+    >>> house = Pineapple()
+    >>> bob = Sponge()
+    >>> squidward = Squid(neighbor_house = house)
+    >>> squidward.annoying_coworkers.add(bob)
+    >>> house.owner = bob
+    Meh.
+
+And that's the gist of it.
+
+Weak Callable Proxies
+---------------------
+
+TODO
+
+Observable Dicts, Lists and Sets
+--------------------------------
+
+TODO
+
+Enums
+-----
+
+TODO
+
+Singletons
+----------
+
+TODO

          

@@ 0,0 1,1539 @@ 
+# glue.py - agnostic model/view toolshed for Python 2.7, 3.x and PyPy
+# Copyright (c) 2013 Leonard Ritter <contact@leonard-ritter.com>
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+"""
+glue.py is a single lightweight utility module expanding Python with
+powerful idioms for accessors, callsets, weak methods, enums, singletons and
+observable primitives that can be easily integrated with existing projects.
+"""
+
+from __future__ import (print_function, division, absolute_import)
+
+import collections
+import functools
+import gc
+import imp
+import inspect
+import sys
+import traceback
+import types
+import weakref
+import threading
+
+__all__ = [
+    'Undefined', 'enum', 'FunctionProxy', 'MethodProxy', 'callproxy',
+    'OrderedSet', 'StopCallableIteration', 'CallableSet', 'callset',
+    'SetPropertyEvent', 'genproperty', 'defproperty', 'autoinit', 'safecall',
+    'Dict', 'List', 'iterprops', 'Property', 'CallableQueue', 'callqueue',
+    'classproperty', 'ClassProperty', 'expect_empty', 'singleton',
+    'Singleton', 'History', 'deep_reload', 'Graph',
+    'clamp', 'mix', 'Named', 'Managed', 'main'
+]
+
+################################################################################
+
+# True if running in Python 3.0+
+ispython3 = sys.version_info >= (3, 0)
+
+# to be used for defaults where None is ambiguous
+if ispython3:
+    Undefined = type('Undefined', (), dict(
+        __bool__ = lambda self: False
+    ))()
+else:
+    Undefined = type('Undefined', (), dict(
+        __nonzero__ = lambda self: False
+    ))()
+
+################################################################################
+
+def enum(*sequential, **named):
+    """creates a new enum type of sequential or named enums and enhances it
+    with a reverse lookup method.
+    
+    enum can also be used as a class decorator.
+    """
+    if not named and len(sequential) == 1 and inspect.isclass(sequential[0]):
+        class_ = sequential[0]
+        keys = [k for k in class_.__dict__.keys() 
+            if not k.startswith('_') and not callable(getattr(class_,k))]
+        enums = dict((k,getattr(class_,k)) for k in keys)
+        reverse = dict((value, key) for key, value in enums.iteritems())
+        class_.keys = set(keys)
+        class_.reverse_dict = reverse
+        class_.count = len(reverse) 
+        return class_
+    
+    enums = dict(zip(sequential, range(len(sequential))), **named)
+    reverse = dict((value, key) for key, value in enums.iteritems())
+    enums['reverse_dict'] = reverse
+    enums['count'] = len(reverse)
+    return type('Enum', (), enums)
+
+def expect_empty(args):
+    """Simple tool function to complain about excess arguments or keyword
+    arguments passed, after all required elements have been popped.
+    
+    It is advisable to only make use of this check in baseclasses, where excess
+    keywords are not going to be processed by further baseclass constructors."""
+    if args:
+        if isinstance(args, dict):
+            msg = "Unexpected keyword(s): {}".format(args.keys())
+        else:
+            msg = "Unexpected argument(s): {}".format(args)
+        raise ValueError(msg)
+    
+def _make_safecall(func, default = Undefined):
+    @functools.wraps(func)
+    def wrapper(*args, **kargs):
+        try:
+            return func(*args, **kargs)
+        except:
+            traceback.print_exc()
+        return default
+    return wrapper
+
+def safecall(*args, **kwargs):
+    """
+    A decorator that wraps function func with an exception catcher. If an 
+    exception is raised, the traceback is printed and the function returns
+    a default value.     
+    
+    You can use the decorator with and without arguments. If the optional 
+    keyword argument "default" is omitted, the function will return Undefined.
+    """
+    if args:
+        return _make_safecall(*args, **kwargs)
+    else:
+        return functools.partial(_make_safecall, **kwargs)
+
+def main(func):
+    """
+    A decorator that calls function func if it's defined in the main module.
+    This can be used to easily designate a function as the main function:
+    
+    @main
+    def test():
+        print("main.")
+       
+    or
+    
+    def test():
+        print("main.")    
+    main(test)
+        
+    is equivalent to
+    
+    if __name__ == '__main__':
+        print("main.")
+    """
+    if func.__module__ == '__main__':
+        func()
+    
+################################################################################
+
+class FunctionProxy(object):
+    """a weak hashable and comparable function proxy."""
+
+    __slots__ = [
+        '_func',
+        '_hash',
+        '__weakref__',
+        '__call__'
+    ]
+    
+    def __init__(self, func, callback = None):
+        self._hash = hash(func)
+        self._func = weakref.ref(func, 
+            lambda r: callback(self) if callback else None)
+            
+    def __repr__(self):
+        return 'FunctionProxy({!r})'.format(self._func())
+            
+    def alive(self):
+        return True if self._func() else False
+            
+    if ispython3:
+        def __bool__(self):
+            return self.alive()
+    else:
+        def __nonzero__(self):
+            return self.alive()
+            
+    def __eq__(self, other):
+        return hash(self) == hash(other)
+    
+    def __ne__(self, other):
+        return hash(self) != hash(other)
+            
+    def get(self):
+        return self._func()
+            
+    def __hash__(self):
+        return self._hash
+        
+    def __call__(self, *args, **kwds):
+        func = self._func()
+        if not func:
+            return
+        return func(*args, **kwds)
+
+class MethodProxy(FunctionProxy):
+    """a weak hashable and comparable method proxy."""
+
+    __slots__ = [
+        '_self',
+    ]
+    
+    def __init__(self, func, callback = None):
+        FunctionProxy.__init__(self, func.__func__)
+        self._hash = hash(func)
+        self._self = weakref.ref(func.__self__, 
+            lambda r: callback(self) if callback else None)
+            
+    def __repr__(self):
+        return 'MethodProxy({!r}.{!r})'.format(self._self(),self._func())
+            
+    def alive(self):
+        return True if self._self() else False
+        
+    def __call__(self, *args, **kwds):
+        self_ = self._self()
+        if not self_:
+            return
+        FunctionProxy.__call__(self, self_, *args, **kwds)
+
+def callproxy(callable_, callback = None):
+    """turns any callable into a weak proxy. If the object associated with
+    the callable disappears, calling the proxy turns into a non-op.
+    
+    As with weakref.ref, callback will be invoked when the callable disappears.
+    """
+    assert callable(callable_), 'argument must be callable'
+    if inspect.ismethod(callable_):
+        return MethodProxy(callable_, callback)
+    else:
+        return FunctionProxy(callable_, callback)
+
+################################################################################
+
+def format_bytesize(num):
+    for x in ['bytes','KB','MB','GB']:
+        if num < 1024.0 and num > -1024.0:
+            return "%3.1f%s" % (num, x)
+        num /= 1024.0
+    return "%3.1f%s" % (num, 'TB')
+
+################################################################################
+
+class OrderedSet(collections.OrderedDict, collections.MutableSet):
+    """An ordered set where all write operations can be hooked."""
+    
+    hook = None
+    
+    class Event(object):
+        def __init__(self, set_, method, args, kwargs):
+            self.set = set_
+            self.method = method
+            self.args = args
+            self.kwargs = kwargs
+            
+        def __repr__(self):
+            return 'Event({!r},{!r},{!r},{!r})'.format(
+                self.set, self.method, self.args, self.kwargs)
+    
+    def _wrap(method): #@NoSelf
+        def wrapper(self, *args, **kwargs):
+            if self.hook:
+                self.hook(OrderedSet.Event(self, method, args, kwargs))
+            return method(self, *args, **kwargs)
+        return wrapper
+    
+    def __init__(self, *args, **kwargs):
+        super(OrderedSet, self).__init__(self)
+        self.update(*args, **kwargs)
+    
+    @_wrap
+    def update(self, *args, **kwargs):
+        if kwargs:
+            raise TypeError("update() takes no keyword arguments")
+        for s in args:
+            for e in s:
+                self.add(e)
+
+    @_wrap
+    def add(self, elem):
+        self[elem] = None
+
+    @_wrap
+    def discard(self, elem):
+        self.pop(elem, None)
+
+    def __hash__(self):
+        return object.__hash__(self)
+
+    def __le__(self, other):
+        return all(e in other for e in self)
+
+    def __lt__(self, other):
+        return self <= other and self != other
+
+    def __ge__(self, other):
+        return all(e in self for e in other)
+
+    def __gt__(self, other):
+        return self >= other and self != other
+
+    def __repr__(self):
+        return 'OrderedSet([%s])' % (', '.join(map(repr, self.keys())))
+
+    def __str__(self):
+        return '{%s}' % (', '.join(map(repr, self.keys())))
+    
+    def discard_weakrefs(self):
+        for e in self.keys():
+            if isinstance(e, weakref.ref) and (e() is None):
+                self.discard(e)
+            if isinstance(e, FunctionProxy) and not e.alive():
+                self.discard(e)
+
+    __ior__ = _wrap(collections.MutableSet.__ior__)
+    __isub__ = _wrap(collections.MutableSet.__isub__)
+    __iand__ = _wrap(collections.MutableSet.__iand__)
+    __ixor__ = _wrap(collections.MutableSet.__ixor__)
+
+    difference = property(lambda self: self.__sub__)
+    difference_update = property(lambda self: self.__isub__)
+    intersection = property(lambda self: self.__and__)
+    intersection_update = property(lambda self: self.__iand__)
+    issubset = property(lambda self: self.__le__)
+    issuperset = property(lambda self: self.__ge__)
+    symmetric_difference = property(lambda self: self.__xor__)
+    symmetric_difference_update = property(lambda self: self.__ixor__)
+    union = property(lambda self: self.__or__)
+
+################################################################################
+
+class StopCallableIteration(Exception):
+    """Aborts a callset iteration if raised while being called by a callset."""
+    pass
+
+class CallableSet(OrderedSet):
+    """A set of callables. Implements what is known as 'observable' pattern.
+    Enables decoupling of components by allowing to multiplex a call into many
+    calls. Can also be understood as a function pointer that points to many
+    functions, or a virtual method that is configured from the outside.
+    
+    When adding an observer's method to the set, use addweak() to wrap the
+    method in a callproxy to prevent the callable set from keeping your object
+    alive. When the object dies, the proxy will be removed from the set.  
+    """
+    
+    def __repr__(self):
+        return 'CallableSet([%s])' % (', '.join(map(repr, self.keys())))
+    
+    def addweak(self, callable_):
+        if callable_ in self:
+            return
+        self.add(callproxy(callable_, self.remove))
+    
+    def __call__(self, *args, **kargs):
+        try:
+            for callable_ in self:
+                callable_(*args,**kargs)
+        except StopCallableIteration:
+            pass
+        
+    def call_list(self, *args, **kargs):
+        try:
+            return [callable_(*args,**kargs) for callable_ in self]
+        except StopCallableIteration:
+            pass
+        
+    def call_parallel(self, *args, **kargs):
+        threads = []
+        for callable_ in self:
+            threads.append(threading.Thread(
+                target = callable_, args = args, kwargs = kargs))
+        for thread in threads:
+            thread.start()
+        for thread in threads:
+            thread.join()
+
+def callset(*args, **kargs):
+    """A shortcut for instantiating a CallableSet"""
+    return CallableSet(*args, **kargs)
+
+################################################################################
+
+class CallableSetBag(object):
+    """A collection (or so-called bag) of callable sets that can be accessed by
+    key or by attribute. The bag also contains an 'all' callset that allows to
+    subscribe to all callsets at once.
+    
+    Use callable set bags where you need to expose a range of observables
+    in your class, e.g. events in models that views can subscribe to.
+    """
+    
+    def __init__(self, *names):
+        self.__names = tuple(names)
+        all_events = callset()
+        events = dict(
+            all = all_events
+        )
+        for name in self.__names:
+            observers = callset()
+            observers.add(all_events)
+            events[name] = observers
+        self.__dict__.update(events)
+        
+    def __iter__(self):
+        return ((name,self.__dict__[name]) for name in self.__names)
+    
+    def __repr__(self):
+        return 'CallableSetBag{!r}'.format(self.__names) 
+    
+    def __getitem__(self, key):
+        return self.__dict__[key]
+
+def callsetbag(*names):
+    """A shortcut for instantiating a CallableSetBag"""
+    return CallableSetBag(*names)
+
+################################################################################
+
+def lazydecls(cls):
+    """A class decorator that searches a class for attributes carrying a
+    special '__lazydecl__' factory and uses it to instantiate the
+    attribute. This way, descriptors exposing a __lazydecl__ factory can
+    learn the class attribute they have been assigned to.
+    
+    The lazydecls() functionality is used to enable properties generated
+    with defproperty() to function."""
+    
+    items = dict(cls.__dict__).items()
+    for key, value in items:
+        if hasattr(value, '__lazydecl__'):
+            setattr(cls, key, value.__lazydecl__(cls, key))
+    return cls
+
+class LazyDecl(object):
+    """Descriptor implementing the __lazydecl__ operator."""
+    
+    def __get__(self, *args):
+        raise ValueError('class needs @lazydecls decorator')
+
+    def __set__(self, *args):
+        raise ValueError('class needs @lazydecls decorator')
+
+    def __delete__(self, *args):
+        raise ValueError('class needs @lazydecls decorator')
+
+    def __lazydecl__(self, cls, name):
+        # implement this function
+        pass
+        
+################################################################################
+
+class classproperty(property):
+    """A method decorator that allows to turn a classmethod into a class
+    property."""
+    
+    def __get__(self, cls, owner):
+        return classmethod(self.fget).__get__(None, owner)()
+
+################################################################################
+
+class SetPropertyEvent(object):
+    """An event sent by properties generated with defproperty() on change."""
+    
+    def __init__(self, instance, name, value):
+        self.instance = instance
+        self.name = name
+        self.value = value
+        
+    def __repr__(self):
+        return 'Event({!r},{!r},{!r})'.format(
+            self.instance, self.name, self.value)
+
+class Property(property):
+    """The descriptor of properties generated with defproperty()""" 
+    
+    def __repr__(self):
+        return 'Property({!r})'.format(self.name)
+    
+    def init(self, instance):
+        default = getattr(self, 'default', Undefined)
+        if default is Undefined:
+            return
+        if not callable(default):
+            return
+        setattr(instance, self.private, default())
+
+class ClassProperty(classproperty):
+    """An alternative descriptor for defproperty() that allows to generate
+    class properties."""
+    
+    def __repr__(self):
+        return 'ClassProperty({!r})'.format(self.name)
+        
+################################################################################
+
+if ispython3:
+    def _exec(s, globs):
+        exec(s, globs)
+else:
+    exec("""
+def _exec(s, globs):
+    exec s in globs
+""") 
+
+################################################################################
+
+_next_order = 0
+def genproperty(name, private, **options):
+    """A versatile and powerful property generator that generates code for
+    accessors typically needed in Python classes.
+    
+    This is the explicit function, which is rarely required. For more
+    documentation, see defproperty()."""
+    
+    global _next_order
+    privname = private    
+    readonly = options.pop('readonly', False)
+    default = options.pop('default', Undefined)
+    propcls = options.pop('class_', Property)
+    weak = options.pop('weak', False)
+    doc = options.pop('doc', None)
+    order = _next_order
+    _next_order += 1 
+
+    attribs = dict(
+        name = name,
+        private = privname,
+        readonly = readonly,
+        order = order
+    )
+    
+    if not (default is Undefined):
+        attribs.update(default=default)
+
+    s = 'def fget(self):\n'
+    if (default is Undefined) or callable(default):
+        s += '    value = getattr(self, privname)\n'
+    else:
+        s += '    value = getattr(self, privname, default)\n'
+    if weak:
+        attribs.update(weak=weak)
+        s += '    value = (value or None) and value()\n'
+    s += '    return value\n'
+    
+    globs = dict(globals())
+    globs.update(locals())
+    _exec(s, globs)
+    fget = globs['fget']
+    
+    ref = weakref.ref
+    
+    if not readonly:
+        rewrite = options.pop('rewrite', False)
+        types = options.pop('types', None)
+        validate = options.pop('validate', None)
+        sanitize = options.pop('sanitize', None)
+        hook = options.pop('hook',None)
+        if hook is None:
+            hook = options.pop('changing', None)
+        
+        s = 'def fset(self, value):\n'
+        
+        if not (sanitize is None):
+            attribs.update(sanitize = sanitize)
+            s += '    value = sanitize(value)\n'
+            
+        if not rewrite:
+            attribs.update(rewrite = rewrite)
+            s += '    if value == getattr(self, name, default):\n'
+            s += '        return\n'
+            
+        if not (types is None):
+            attribs.update(types = types)
+            s += '    if not isinstance(value, types):\n'
+            s += '        raise TypeError("type(s) {} expected, got {}".format(types, type(value)))\n'
+            
+        if not (validate is None):
+            attribs.update(validate = validate)
+            s += '    if not validate(value):\n'
+            s += '        raise ValueError("validation failed")\n'
+            
+        if not (hook is None):
+            attribs.update(hook = hook)
+            s += '    hook(SetPropertyEvent(self, name, value))\n'
+            
+        if weak:
+            s += '    value = None if value is None else ref(value)\n'
+            
+        s += '    setattr(self, privname, value)\n'
+
+        
+        globs = dict(globals())
+        globs.update(locals())        
+        _exec(s, globs)
+        fset = globs['fset']
+        
+        def fdel(self):
+            delattr(self, privname)
+    else:
+        fset = None
+        fdel = None
+        
+    if options:
+        raise ValueError('Unexpected keyword(s): {}'.format(options.keys()))
+
+    prop = propcls(fget=fget, fset=fset, fdel=fdel, doc=doc)
+    prop.__doc__ = doc
+    for name, value in attribs.items():
+        setattr(prop, name, value)
+        
+    return prop
+
+def defproperty(**options):
+    """Defines a versatile and powerful property and generates code for
+    accessors as needed. Classes using defproperty() require the @lazydecls
+    decorator and should call autoinit() during initialization.
+    
+    While properties are stored in classes independent of order of declaration,
+    properties generated with defproperty() expose an integer 'order' attribute
+    which can be used as key by inspectors to sort enumerated properties.
+      
+    In addition, following creation options are available, with the default
+    setting in brackets:
+    
+    * readonly (False): if True, the property is read-only / protected and
+    can not be set. This setting can be read from the properties 'readonly'
+    attribute.
+    
+    * default (Undefined): the default value for the property. If the value
+    is mutable or should be instantiated per class, a factory function can
+    be specified instead which will be used to initialize the instance
+    value. If you use a default factory, you must call autoinit() in
+    the classes __init__ method. If set, the setting can be read from the
+    properties 'default' attribute.
+    
+    * private (__<attribute name>): The name of the attribute in which
+    the property instance's value will be stored. This defaults to a private
+    attribute which can only be accessed from within the declared class. 
+    The private name can be read from the properties 'private' attribute.
+    
+    * hook (None): [only when readonly = False] A callable (which includes
+    callsets) that will be called right before the property is changed, with
+    an event of type SetPropertyEvent as only argument. Views can use hooks to
+    be notified when a models attribute changes, and refresh accordingly. 
+    If set, this setting can be read from the properties 'hook' attribute. 
+    'changing' is an alias for this option.
+    
+    * sanitize (None): [only when readonly = False] A function of the format
+    sanitize(value) -> value. If specified, will be called before rewrite, 
+    type and validate check. You can use types like int or float here. A
+    sanitizer does not raise errors, but attempts to turn a value into as
+    useful as possible before it is assigned, and equips a property with
+    "overload" capability. Typical use cases are type conversions and
+    clamping numerical values. If set, this setting can be read from the
+    properties 'sanitize' attribute.
+    
+    * types (None): [only when readonly = False] A single type or a tuple of
+    types that a value should be checked against. If the value does not match
+    any type, the setter will raise a TypeError. If set, this setting can be
+    read from the properties 'types' attribute.
+    
+    * validate (None): [only when readonly = False] A function of the format
+    validate(value) -> bool. If specified, will be called after the optional
+    type check, but before it is ultimately assigned. If validate returns
+    False, the setter will raise a ValueError. If set, this setting can be read
+    from the properties 'validate' attribute.
+    
+    * rewrite (False): [only when readonly = False] By default, the generated
+    setter will check if the new value equals the old one. If rewrite is True,
+    this check will be skipped. If set, this setting can be read from the
+    properties 'rewrite' attribute.
+    
+    * doc (None): The docstring for this property.
+    
+    * weak (False): if True, the stored value is transparently weakly
+    referenced. Useful for pointers that the class instance should not own.
+    Will not work with callables. If the referenced object dies, accessing
+    the attribute will return None. If set, the setting can be read from the
+    properties 'weak' attribute.
+    
+    * class_ (Property): the class used to instantiate the property. Rarely
+    required. Use ClassProperty if you want a class attribute.
+    """
+    
+    class LazyPropertyDecl(LazyDecl):
+        def __lazydecl__(self, class_, name): #@NoSelf
+            opts = dict(options)
+            private = opts.pop('private', Undefined)
+            if private is Undefined:
+                private = '__' + name
+                
+            if private.startswith('__'):
+                private = '_' + class_.__name__ + private
+            
+            return genproperty(name, private, **opts)
+    
+    return LazyPropertyDecl()
+
+def autoinit(cls = None, self = None, **kwargs):
+    """To be called in __init__ constructors of classes that make use of
+    defproperty(). Initializes (only) the properties within this class.
+    
+    The function may be called explicitly or implicitly, similar to super():
+    
+    autoinit(MyClass, self)
+    
+    If self is omitted, autoinit() will try to infer the 'self' attribute from
+    the callers local scope. If class is omitted, autoinit() infers the
+    function containing the code, assumes that it is a constructor and checks
+    which of self's classes contains it.
+    
+    For generic constructors that accept variable keyword arguments, the
+    dict can be passed on to autoinit, which pops all values from it for which
+    properties declared with defproperty() exist:
+    
+    @lazydecls
+    class O(object):
+        name = defproperty()
+    
+        def __init__(self, **kwargs):
+            expect_empty(autoinit(**kwargs))
+    
+    # will assign name, but complain about spam
+    o = O(name = 'test', spam = True)
+    
+    (Note: While it is convenient to use autoinit() without arguments, the
+    implementation may not work in all implementations of Python, as it
+    depends on interpreter internals. It has been tested with CPython 2.7,
+    3.2 and PyPy 1.9.)
+    """
+    
+    if (self and cls) is None:
+        callframe = inspect.currentframe().f_back
+        if self is None:
+            self = callframe.f_locals['self']
+        if cls is None:
+            code = callframe.f_code
+            for subcls in inspect.getmro(self.__class__):
+                method = subcls.__dict__.get('__init__', None)
+                if not method:
+                    continue
+                if method.__code__ == code:
+                    cls = subcls
+                    break
+            assert not (cls is None), 'could not find class for constructor'
+        
+    assert isinstance(self, cls)    
+    for name, prop in cls.__dict__.items():
+        if not isinstance(prop, Property):
+            continue
+        value = kwargs.pop(name, Undefined)
+        if value is Undefined:
+            prop.init(self)
+        else:
+            setattr(self, name, value)
+    
+    return kwargs
+
+def iterprops(obj):
+    """Iterate all properties defined by defproperty() in an object."""  
+    for name, prop in inspect.getmembers(obj.__class__): #@UnusedVariable
+        if not isinstance(prop, Property):
+            continue
+        yield prop
+
+################################################################################
+
+class Dict(dict):
+    """An observable drop-in replacement for Python dicts"""
+    
+    class Event(object):
+        def __init__(self, dict_, method, args, kwargs):
+            self.dict = dict_
+            self.method = method
+            self.args = args
+            self.kwargs = kwargs
+            
+        def __repr__(self):
+            return 'Event({!r},{!r},{!r},{!r})'.format(
+                self.dict, self.method, self.args, self.kwargs)
+                
+    hook = None
+    
+    def __init__(self, *args, **kwargs):
+        dict.__init__(self, *args, **kwargs)
+        
+    def _wrap(method): #@NoSelf
+        def wrapper(self, *args, **kwargs):
+            if self.hook:
+                self.hook(Dict.Event(self, method, args, kwargs))
+            return method(self, *args, **kwargs)
+        return wrapper
+    __delitem__ = _wrap(dict.__delitem__)
+    __setitem__ = _wrap(dict.__setitem__)
+    clear = _wrap(dict.clear)
+    pop = _wrap(dict.pop)
+    popitem = _wrap(dict.popitem)
+    setdefault = _wrap(dict.setdefault)
+    update =  _wrap(dict.update)
+    del _wrap
+
+################################################################################
+
+class List(list):
+    """An observable drop-in replacement for Python lists"""
+    
+    class Event(object):
+        def __init__(self, list_, method, args, kwargs):
+            self.list = list_
+            self.method = method
+            self.args = args
+            self.kwargs = kwargs
+            
+        def __repr__(self):
+            return 'Event({!r},{!r},{!r},{!r})'.format(
+                self.list, self.method, self.args, self.kwargs)
+                
+    hook = None
+    
+    def __init__(self, *args, **kwargs):
+        list.__init__(self, *args, **kwargs)
+        
+    def _wrap(method): #@NoSelf
+        def wrapper(self, *args, **kwargs):
+            if self.hook:
+                self.hook(List.Event(self, method, args, kwargs))
+            return method(self, *args, **kwargs)
+        return wrapper
+    __delitem__ = _wrap(list.__delitem__)
+    __setitem__ = _wrap(list.__setitem__)
+    if hasattr(list, '__delslice__'):
+        __delslice__ = _wrap(list.__delslice__)
+    if hasattr(list, '__setslice__'):
+        __setslice__ = _wrap(list.__setslice__)
+    pop = _wrap(list.pop)
+    append = _wrap(list.append)
+    insert = _wrap(list.insert)
+    __iadd__ = _wrap(list.__iadd__)
+    __imul__ = _wrap(list.__imul__)
+    remove = _wrap(list.remove)
+    sort = _wrap(list.sort)
+    extend = _wrap(list.extend)
+    reverse = _wrap(list.reverse)
+    del _wrap
+
+################################################################################
+
+class CallableQueue(object):
+    """a simple message queue that allows for callables to be propagated later"""
+    
+    def __init__(self):
+        self.clear()
+        
+    def clear(self):
+        self._todo = []
+        
+    def iterate(self):
+        while self._todo:
+            func,args,kwargs = self._todo.pop(0)
+            func(*args,**kwargs)
+            
+    def post(self, func, *args, **kwargs):
+        self._todo.append((func, args, kwargs))
+    
+def callqueue():
+    return CallableQueue()
+
+################################################################################
+
+def singleton(factory, **kwargs):
+    """
+    Can be used as decorator on a factory function. Should not be used as
+    class decorator, as you hide the class type reference.
+    
+    turns callable factory (usually the class) into a weak singleton 
+    provider. On first call, the generated function will call the factory
+    to produce a new singleton instance. Unless all references to the instance
+    are cleared, this function will always return the same object."""
+    
+    __instance = [None]
+    weak = kwargs.pop('weak', True)
+    if weak:
+        callback = kwargs.pop('callback', None)
+        def on_delete(ref):
+            __instance[0] = None
+            if callback:
+                callback(ref)
+        def instance():
+            if not __instance[0]:
+                instance = factory()
+                __instance[0] = weakref.ref(instance, on_delete)
+            return __instance[0]()
+    else:
+        def instance():
+            if not __instance[0]:
+                __instance[0] = factory()
+            return __instance[0]
+    expect_empty(kwargs)
+    return instance
+    
+def get_last_descendant(cls):
+    """return the last declared descendant"""
+    while cls.__subclasses__():
+        cls = cls.__subclasses__()[-1]
+    return cls    
+    
+class Singleton(type):
+    """
+    Singleton implemented as a metaclass to support inheritance. Use it like 
+    this:
+    
+    # Python 2.7
+    class MyClass(object):
+        __metaclass__ = Singleton
+    
+    # Python 3.x
+    class MyClass(metaclass=Singleton):
+        pass
+        
+    The singleton will make sure calls to baseclasses will also resolve to
+    inheriting classes. When the class has already been inherited and the
+    base class is instantiated, it will instantiate the last declared
+    descending class instead. Therefore, avoid inheritance trees, as you
+    will most likely end up with unintended results.
+    
+    Also, make sure all inheriting classes are declared before you instantiate
+    the singleton for the first time, or it will be re-instantiated.
+    """
+    
+    _instances = {}
+    
+    def __call__(cls, *args, **kwargs): #@NoSelf
+        # always take the last declared descendant
+        cls = get_last_descendant(cls)
+        result = cls._instances.get(cls, None)
+        if result:
+            return result
+        result = super(Singleton, cls).__call__(
+            *args, **kwargs)
+        cls._instances[cls] = result
+        return result
+    
+    def del_singleton(cls): #@NoSelf
+        cls = get_last_descendant(cls)
+        del cls._instances[cls]
+
+################################################################################
+
+@lazydecls
+class History(object):
+    """Converts event driven notifications to polling, e.g. for interfacing
+    with web clients which can not keep a standing connection or deferral
+    for delayed processing. If you wish to subscribe to a lot of callsets owned
+    by a single model class, consider grouping all callsets with a callsetbag,
+    then just pass the bags' 'all' callset to the History constructor.
+    """
+    
+    entries = defproperty(default = list)
+    
+    def __init__(self, *callablesets):
+        autoinit()
+        
+        for observers in callablesets:
+            observers.addweak(self.log_event)
+       
+    def pop_entries(self):
+        entries = list(self.entries)
+        self.entries = []
+        return entries
+    
+    def log_event(self, event):
+        self.entries.append(event)
+
+################################################################################
+
+def swap_classes(classmap):
+    """
+    Swaps classes using a old class -> new class dictionary passed as classmap. 
+    The function uses the gc module to enumerate all currently tracked 
+    instances of the old class, and exchanges their class attribute to the
+    new class. A list of objects that have been updated will be returned.
+    
+    This function is part of the deep reload functionality. 
+    """
+    classkeys = tuple(classmap.keys())
+
+    descendants = []
+    updated = []
+
+    for obj in gc.get_objects():
+        if inspect.isclass(obj):
+            if issubclass(obj, classkeys):
+                #if inspect.getmodule(obj) is module_:
+                #    continue
+                for cls in classkeys:
+                    if cls in obj.__bases__:
+                        descendants.append((obj, cls))
+        elif isinstance(obj, classkeys):
+            cls = obj.__class__
+            if cls in classkeys:
+                try:
+                    obj.__class__ = classmap[cls]
+                    updated.append(obj)
+                except TypeError:
+                    traceback.print_exc()
+    
+    if descendants:
+        # TODO: update inheriting classes
+        pass
+
+    return updated
+
+def iter_module_content(module_):
+    """
+    iterate the contents of a module for the purpose of tracking nested classes.
+    
+    This function is part of the deep reload functionality.
+    """
+    assert inspect.getmodule(module_) is module_
+    predicate = lambda x: inspect.getmodule(x) is module_
+    stack = [((),module_)]
+    walked = set()
+    while stack:
+        basename,namespace = stack.pop()
+        objid = id(namespace)
+        if objid in walked:
+            continue
+        walked.add(objid)
+        for name, obj in inspect.getmembers(namespace, predicate):
+            if inspect.isclass(obj) or inspect.isfunction(obj):
+                fullname = basename + (name,)
+                yield fullname, obj
+
+def resolve_namespace(module_, path):
+    """
+    Resolve a list of key names from module until the object is retrieved.
+    
+    This function is part of the deep reload functionality.
+    """
+    obj = module_
+    for name in path:
+        obj = getattr(obj, name)
+    return obj
+
+def deep_reload(module_):
+    """
+    Reloads module and updates all objects using classes from this module as
+    far as possible to match updated methods. It returns a list of objects
+    that have been updated.
+    """
+    content = list(iter_module_content(module_))
+    try:
+        imp.reload(module_)
+    except:
+        traceback.print_exc()
+        return
+    
+    classes = {}
+    for path, obj in content:
+        if inspect.isclass(obj):
+            newobj = resolve_namespace(module_, path)
+            if newobj is None:
+                continue
+            if obj is newobj:
+                print("object is same after reload?",obj,newobj)
+                continue
+            classes[obj] = newobj
+    
+    return swap_classes(classes)
+                
+################################################################################
+
+class Named(object):
+    """Many systems require objects to be distinguishable during debugging.
+    Countless objects therefore carry some kind of a name or id. This base class
+    facilitates this service and also supports assigning names by @lazydecl.
+    
+    If a class is decorated with lazydecl and has unnamed Named objects declared
+    at class level, the objects will be named after the attribute they have
+    been assigned to."""
+    
+    attributes = [
+        '_name',
+    ]
+    
+    def __init__(self):
+        self._name = ""
+        
+    def __repr__(self):
+        return '{0}({1})'.format(self.__class__.__name__, self._name or '?')
+
+    # auto-name from property if class is annotated with @lazydecls
+    def __lazydecl__(self, class_, name):
+        if self._name: return
+        self._name = name
+        return self 
+
+    @property
+    def name(self):
+        return self._name
+    @name.setter
+    def name(self, value):
+        self._name = value
+
+################################################################################
+
+class Managed(object):
+    """This class provides a simple wrapper for objects wrapping a C pointer
+    that needs to be freed when the object is collected. It also provides
+    a resolve function that allows to retrieve an existing wrapper for any
+    pointer.
+    
+    To use this class, inherit from it and assign _destroy_ptr(ptr) at class
+    level. _destroy_ptr should be a C function. You also need to assign _ffi
+    to the cffi instance you would like to be used to tag the weak reference.
+    """ 
+    
+    attributes = [
+        '_ptr',
+    ]
+    
+    # default implementation does nothing
+    _destroy_ptr = lambda ptr: None
+    
+    _ffi = None
+    _users = weakref.WeakValueDictionary()
+    
+    def __init__(self, ptr):
+        assert ptr
+        self._ptr = self._ffi.gc(ptr, self.__class__._destroy_ptr)
+        self._users[self._ptr] = self
+        
+    def destroy(self):
+        self._ptr = None
+        
+    @classmethod
+    def resolve(cls, ptr):
+        if not ptr: return None
+        return cls._users[ptr]
+    
+    @classmethod
+    def wrap(cls, ptr):
+        obj = cls._users.get(ptr, None)
+        if obj: return obj
+        obj = cls.__new__(cls)
+        obj._ptr = ptr
+        cls._users[obj._ptr] = obj
+        return obj
+                
+################################################################################
+                
+class Graph(object):
+    def __init__(self):
+        self.clear()
+        
+    def clear(self):
+        self._sorted = False
+        self._order = []
+        self.edges = {}
+        self.priorities = {}
+        
+    def invalidate(self):
+        self._sorted = False
+
+    def priority(self, node, prio):
+        """node with higher priority is first in order"""
+        self.priorities[node] = prio
+        self.invalidate()
+
+    def depends(self, target, *sources): 
+        """target depends on sources"""
+        sourceset = self.edges.setdefault(target, OrderedSet())        
+        for source in sources:
+            sourceset.add(source)
+        self.invalidate()
+            
+    def clear_sources(self, target):
+        self.edges.pop(target, None)
+        self.invalidate() 
+            
+    def sources(self, target):
+        return list(self.edges.get(target, []))
+
+    def targets(self, source):
+        result = OrderedSet()
+        for target,sources in self.edges.items():
+            if source in sources:
+                result.add(target)
+        return result
+
+    def calculate_order(self):
+        """traverses the graph and returns an ordered list of nodes"""
+        # find root nodes
+        roots = OrderedSet(self.edges.keys())
+        for target, sources in self.edges.iteritems():
+            roots.difference_update(sources)
+        if not roots:
+            return [] # cyclic dependency
+        
+        visited = OrderedSet()
+        order = OrderedSet()
+        stack = list(roots)
+        stack.sort(key=lambda k: self.priorities.get(k, 0))
+        
+        while stack:
+            node = stack[-1]
+            if node in visited:
+                order.add(node)
+                stack.pop()
+            else:
+                visited.add(node)
+                sources = list(self.edges.get(node, []))
+                sources.sort(key=lambda k: self.priorities.get(k, 0))
+                for source in sources:
+                    if source in visited:
+                        continue
+                    stack.append(source)
+        return list(order)
+    
+    def ensure_sorted(self):
+        if self._sorted:
+            return
+        self._order = self.calculate_order()
+        self._sorted = True
+
+    @property
+    def order(self):
+        self.ensure_sorted()
+        return self._order
+
+################################################################################
+
+def clamp(x, mn, mx):
+    if x != x: # nan
+        return mn
+    return min(max(x, mn), mx)
+
+def mix(a, b, x):
+    return a*(1-x) + b*x
+
+################################################################################
+
+def test_enums():
+    # enum as decorator
+    @enum
+    class MyEnum:
+        blue = 3
+        yellow = 5
+        green = 10
+        
+        @classmethod
+        def my_classfunc(cls):
+            print("i am a classfunc")
+            
+        def my_other_func(self):
+            pass
+        
+    assert 'blue' in MyEnum.keys
+    assert MyEnum.reverse_dict[5] == 'yellow'
+    assert MyEnum.count == 3
+
+def test_callable_proxy_set():
+    class C(object): 
+        A = []
+        
+        def func1(self):
+            self.A.append(1)
+        
+        def func2(self):
+            self.A.append(2)
+        
+    cset = CallableSet()
+    def scoped():
+        c = C() 
+        def func3():
+            C.A.append(3)
+        
+        assert callproxy(c.func1) == callproxy(c.func1)
+        assert callproxy(func3) == callproxy(func3)
+        assert callproxy(func3) == func3
+        assert callproxy(c.func1) == c.func1
+        assert callproxy(c.func1) != c.func2
+        assert callproxy(c.func1) != callproxy(c.func2)
+        assert callproxy(c.func1) != callproxy(func3)
+        assert callproxy(c.func2) != callproxy(func3)
+
+        assert hash(callproxy(c.func1)) != hash(callproxy(c.func2))
+        assert hash(callproxy(c.func1)) != hash(callproxy(func3))
+        assert hash(callproxy(c.func2)) != hash(callproxy(func3))
+            
+        cset.addweak(c.func1)
+        cset.addweak(c.func2)
+        cset.addweak(func3)
+        # should be ignored
+        cset.addweak(c.func1)
+        # should be ignored
+        cset.update([c.func2, c.func1]) 
+        assert c.func1 in cset
+        assert c.func2 in cset
+        assert func3 in cset
+        assert len(cset) == 3, len(cset)
+        cset()
+        assert c.A == [1,2,3], c.A
+        cset()
+        assert C.A == [1,2,3,1,2,3], C.A
+        
+        proxy = callproxy(func3)
+        assert proxy.alive()
+        assert proxy
+        
+        proxy2 = callproxy(c.func1)
+        assert proxy2.alive()
+        assert proxy2
+        
+        return proxy, proxy2
+    proxy, proxy2 = scoped()
+    gc.collect() # pypy fix    
+    assert not proxy.alive()
+    assert not proxy2.alive()
+    assert not proxy
+    assert not proxy2
+    cset()
+    assert C.A == [1,2,3,1,2,3], C.A
+    assert len(cset) == 0, len(cset)
+    
+def test_threaded_callset():
+    import time
+    cset = callset()
+    
+    things = []
+    cset.add(lambda k: things.append(k))
+    cset.add(lambda k: things.append(k+1))
+    cset.add(lambda k: things.append(k+2))
+    cset.add(time.sleep)
+    t = time.time()
+    cset.call_parallel(2)
+    assert time.time() - t >= 2
+    assert set(things) == set([2,3,4])
+    
+def test_property():
+    # base class
+    @lazydecls
+    class U(object):
+        ignore = defproperty()
+        
+        def __init__(self, **kwargs):
+            expect_empty(autoinit(**kwargs))
+             
+    # base class
+    @lazydecls
+    class B(U):
+        ignore2 = defproperty()
+        
+        def __init__(self, **kwargs):
+            U.__init__(self, **autoinit(**kwargs))
+    
+    # demo class
+    @lazydecls
+    class C(B):
+        # an observable shared by all properties in this class
+        event_changing = callset()
+        
+        # expand C by a property named "test" and autogenerate its accessors.
+        # By default, the internal name of the attribute will be "__test",
+        # but you can change this with the 'private' keyword.
+        # All attributes passed to the property can be read out from C.test
+        # later on by Views of this class to e.g. generate a GUI.
+        test = defproperty( 
+            # optional: if set, will check if values assigned to this property
+            # are instances of these types. Can be a single class or a tuple
+            # of classes.
+            types = str, 
+            # optional: an observer to be called when a new value is assigned
+            # to this property.
+            changing = event_changing,
+            # optional: a santizing function doing its best to translate the
+            # value to a valid form. 
+            sanitize = lambda v: v.upper(),
+            # optional: a validation function returning True if the value meets
+            # constraints. 
+            validate = lambda v: len(v) < 10,
+            # optional: the value this property will return by default.   
+            default = lambda: 'hi')
+        
+        def __init__(self, **kwargs):
+            B.__init__(self, **autoinit(**kwargs))
+            assert self.__test == 'hi'
+    
+    # create an instance of C for playing around
+    c = C(ignore = True, ignore2 = True)
+    assert c.ignore
+    assert c.ignore2
+    
+    assert sorted([p.name for p in iterprops(c)]) == ['ignore','ignore2','test']
+    
+    # an array that will hold all values assigned to monitored properties of c 
+    A = []
+    
+    # a handler function that will be called when properties of C change
+    def func(event):
+        A.append(event.value)
+    
+    # register our handler function with C
+    C.event_changing.add(func)
+    
+    # default value should be as specified
+    assert c.test == 'hi'
+    
+    # assign a new value that will be sanitized to uppercases
+    c.test = "hello"
+    
+    # c.test should now hold our sanitized value
+    assert c.test == "HELLO"
+    
+    # A should contain our santized value as well
+    assert A == ['HELLO']
+
+def test_dict():
+    k = {1:2,3:4}
+    
+    def handler(event):
+        event.method(k, *event.args, **event.kwargs) 
+    
+    d = Dict(k)
+    k[4] = 5
+    d.hook = CallableSet()
+    d.hook.add(handler)
+    del d[1]
+    d["test"] = "test"
+    assert not k is d
+    assert k == {'test':'test', 3:4, 4:5}
+
+def test_list():
+    k = [10]
+    
+    def handler(event):
+        event.method(k, *event.args, **event.kwargs)
+    
+    l = List(k)
+    l.hook = callset()
+    l.hook.add(handler)
+    del l[0]
+    l += [1,2,3]
+    l.append(5)
+    assert k == l, "{} != {}".format(k,l)
+
+def test_classproperty():
+    class classprop(object):
+        _instance = 10
+        
+        @classproperty
+        def instance(cls): #@NoSelf
+            return cls._instance
+    
+    assert classprop.instance is 10
+    classprop._instance = 15
+    assert classprop.instance is 15
+    
+def test_singleton():
+    class A(object):
+        pass
+    
+    @singleton
+    def make_a():
+        return A()
+    
+    a = make_a()
+    b = make_a()
+    c = make_a()
+    s = repr(a)
+    t = repr(b)
+    assert s == t and b is c
+    assert s == repr(make_a())
+    
+    del a
+    del b
+    del c
+    gc.collect()
+    
+    assert s != repr(make_a())
+    
+    class B(object):
+        pass
+    class C(B):
+        __metaclass__ = Singleton
+    class G(C):
+        pass
+    class D(C): # will override G
+        pass
+    class E(D):
+        pass
+    class F(E):
+        pass
+    
+    z = B()
+    a = C()
+    b = F()
+    c = E()
+    s = repr(a)
+    t = repr(b)
+    assert s == t and b is c
+    assert s == repr(C())
+    assert s != repr(B())
+    assert isinstance(a, F)
+    assert isinstance(z, B)
+
+def test_safecall():
+    @safecall
+    def noproblem(x,y):
+        return x/y
+    @safecall(default = 0)
+    def noproblem2(x,y):
+        return x/y
+    @safecall()
+    def noproblem3(x,y):
+        return x/y
+    
+    assert noproblem(1,2) == 0.5
+    assert noproblem(1,0) is Undefined
+    assert noproblem2(4,2) == 2
+    assert noproblem2(1,0) == 0
+    assert noproblem3(1,2) == 0.5
+    assert noproblem3(1,0) is Undefined
+
+if __name__ == '__main__':
+    test_enums()
+    test_callable_proxy_set()
+    test_threaded_callset()
+    test_property()
+    test_dict()
+    test_list()
+    test_classproperty()
+    test_singleton()
+    test_safecall()
+    print("OK.")

          

@@ 0,0 1,29 @@ 
+
+import os
+from setuptools import setup
+
+def read(fname):
+    return open(os.path.join(os.path.dirname(__file__), fname)).read()
+
+setup(
+    name = "glue.py",
+    version = "0.6",
+    author = "Leonard Ritter",
+    author_email = "contact@leonard-ritter.com",
+    description = ("The agnostic model/view toolshed"),
+    license = "MIT",
+    keywords = "python glue mvc observable idioms lightweight",
+    url = "https://bitbucket.org/duangle/glue.py",
+    py_modules=['glue'],
+    long_description=read('README.text'),
+    classifiers=[
+        "Development Status :: 5 - Production/Stable",
+        "Intended Audience :: Developers",
+        "Programming Language :: Python :: 2.7",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: Implementation :: CPython",
+        "Programming Language :: Python :: Implementation :: PyPy",
+        "Topic :: Software Development :: Libraries",
+        "License :: OSI Approved :: MIT License",
+    ],
+)

          

@@ 0,0 1,6 @@ 
+repo: 123b51019c6e65f82cc6267647cc56fe746419e4
+node: 36e8bfde49b262ac7195fe5e56e94395bb73a654
+branch: default
+latesttag: null
+latesttagdistance: 849
+changessincelatesttag: 852

          

@@ 0,0 1,39 @@ 
+syntax: glob
+
+.sconsign.dblite
+.settings
+*.marsh
+*.egg-info
+*.pyc
+*.json
+*.blend1
+*.blend2
+*.blendc
+screenshot*.png
+batchgraph*.png
+*.avi
+*.glc
+*.mp4
+*.p3d
+debug.txt
+debuglog.txt
+__pycache__
+*.orig
+*.pyd
+*.soil
+*.cdef
+*.bgeconf
+*.so
+data.dat
+.project
+.pydevproject
+.liminal*.db
+.sass-cache
+
+syntax: regexp
+
+^build
+^doc/build
+^dist
+^py2exe/build
+^py2exe/dist

          

@@ 0,0 1,26 @@ 
+
+Except when otherwise stated (look for LICENSE files in directories or
+information at the beginning of each file) all software and
+documentation is licensed as follows: 
+
+    The MIT License
+
+    Permission is hereby granted, free of charge, to any person 
+    obtaining a copy of this software and associated documentation 
+    files (the "Software"), to deal in the Software without 
+    restriction, including without limitation the rights to use, 
+    copy, modify, merge, publish, distribute, sublicense, and/or 
+    sell copies of the Software, and to permit persons to whom the 
+    Software is furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included 
+    in all copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 
+    OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
+    THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 
+    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 
+    DEALINGS IN THE SOFTWARE.
+

          

@@ 0,0 1,33 @@ 
+
+Optimization ideas based on "Porting Source to Linux - Valve's Lessons Learned":
+https://developer.nvidia.com/sites/default/files/akamai/gamedev/docs/Porting%20Source%20to%20Linux.pdf
+
+* Replace VAOs with directly loading the buffers, as it's faster.
+  (see "Vertex Attribs – Alternative #1")
+
+* See if we can get RAD's Telemetry going
+
+* Use index buffers where possible
+
+* avoid binding objects, use EXT_direct_state_access
+
+* control vsync with EXT_swap_interval / EXT_swap_control_tear
+  ( http://www.opengl.org/wiki/Swap_Interval )
+
+* use NVX_gpu_memory_info / GL_ATI_meminfo
+
+* store texture settings with samplers, ARB_sampler_objects
+
+* avoid glGet*, glGetError, GL functions that return a value
+
+* use ARB_vertex_attrib_binding
+
+* use glBindMultiTextureEXT instead of glActiveTexture/glBindTexture
+
+* on-GPU texture compression: https://code.google.com/p/nvidia-texture-tools/
+  (more compression stuff here: http://developer.download.nvidia.com/SDK/10/opengl/samples.html)
+  
+* copy rects: EXT_copy_texture, stretch rects: NV_draw_texture
+
+* stretch rect; MSAA blit scaled: EXT_framebuffer_multisample_blit_scaled
+

          

@@ 0,0 1,153 @@ 
+# Makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line.
+SPHINXOPTS    =
+SPHINXBUILD   = sphinx-build
+PAPER         =
+BUILDDIR      = build
+
+# Internal variables.
+PAPEROPT_a4     = -D latex_paper_size=a4
+PAPEROPT_letter = -D latex_paper_size=letter
+ALLSPHINXOPTS   = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) source
+# the i18n builder cannot share the environment and doctrees with the others
+I18NSPHINXOPTS  = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) source
+
+.PHONY: help clean html dirhtml singlehtml pickle json htmlhelp qthelp devhelp epub latex latexpdf text man changes linkcheck doctest gettext
+
+help:
+	@echo "Please use \`make <target>' where <target> is one of"
+	@echo "  html       to make standalone HTML files"
+	@echo "  dirhtml    to make HTML files named index.html in directories"
+	@echo "  singlehtml to make a single large HTML file"
+	@echo "  pickle     to make pickle files"
+	@echo "  json       to make JSON files"
+	@echo "  htmlhelp   to make HTML files and a HTML help project"
+	@echo "  qthelp     to make HTML files and a qthelp project"
+	@echo "  devhelp    to make HTML files and a Devhelp project"
+	@echo "  epub       to make an epub"
+	@echo "  latex      to make LaTeX files, you can set PAPER=a4 or PAPER=letter"
+	@echo "  latexpdf   to make LaTeX files and run them through pdflatex"
+	@echo "  text       to make text files"
+	@echo "  man        to make manual pages"
+	@echo "  texinfo    to make Texinfo files"
+	@echo "  info       to make Texinfo files and run them through makeinfo"
+	@echo "  gettext    to make PO message catalogs"
+	@echo "  changes    to make an overview of all changed/added/deprecated items"
+	@echo "  linkcheck  to check all external links for integrity"
+	@echo "  doctest    to run all doctests embedded in the documentation (if enabled)"
+
+clean:
+	-rm -rf $(BUILDDIR)/*
+
+html:
+	$(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html
+	@echo
+	@echo "Build finished. The HTML pages are in $(BUILDDIR)/html."
+
+dirhtml:
+	$(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml
+	@echo
+	@echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml."
+
+singlehtml:
+	$(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml
+	@echo
+	@echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml."
+
+pickle:
+	$(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle
+	@echo
+	@echo "Build finished; now you can process the pickle files."
+
+json:
+	$(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json
+	@echo
+	@echo "Build finished; now you can process the JSON files."
+
+htmlhelp:
+	$(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp
+	@echo
+	@echo "Build finished; now you can run HTML Help Workshop with the" \
+	      ".hhp project file in $(BUILDDIR)/htmlhelp."
+
+qthelp:
+	$(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp
+	@echo
+	@echo "Build finished; now you can run "qcollectiongenerator" with the" \
+	      ".qhcp project file in $(BUILDDIR)/qthelp, like this:"
+	@echo "# qcollectiongenerator $(BUILDDIR)/qthelp/Beige.qhcp"
+	@echo "To view the help file:"
+	@echo "# assistant -collectionFile $(BUILDDIR)/qthelp/Beige.qhc"
+
+devhelp:
+	$(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp
+	@echo
+	@echo "Build finished."
+	@echo "To view the help file:"
+	@echo "# mkdir -p $$HOME/.local/share/devhelp/Beige"
+	@echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/Beige"
+	@echo "# devhelp"
+
+epub:
+	$(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub
+	@echo
+	@echo "Build finished. The epub file is in $(BUILDDIR)/epub."
+
+latex:
+	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
+	@echo
+	@echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex."
+	@echo "Run \`make' in that directory to run these through (pdf)latex" \
+	      "(use \`make latexpdf' here to do that automatically)."
+
+latexpdf:
+	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
+	@echo "Running LaTeX files through pdflatex..."
+	$(MAKE) -C $(BUILDDIR)/latex all-pdf
+	@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
+
+text:
+	$(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text
+	@echo
+	@echo "Build finished. The text files are in $(BUILDDIR)/text."
+
+man:
+	$(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man
+	@echo
+	@echo "Build finished. The manual pages are in $(BUILDDIR)/man."
+
+texinfo:
+	$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
+	@echo
+	@echo "Build finished. The Texinfo files are in $(BUILDDIR)/texinfo."
+	@echo "Run \`make' in that directory to run these through makeinfo" \
+	      "(use \`make info' here to do that automatically)."
+
+info:
+	$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
+	@echo "Running Texinfo files through makeinfo..."
+	make -C $(BUILDDIR)/texinfo info
+	@echo "makeinfo finished; the Info files are in $(BUILDDIR)/texinfo."
+
+gettext:
+	$(SPHINXBUILD) -b gettext $(I18NSPHINXOPTS) $(BUILDDIR)/locale
+	@echo
+	@echo "Build finished. The message catalogs are in $(BUILDDIR)/locale."
+
+changes:
+	$(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes
+	@echo
+	@echo "The overview file is in $(BUILDDIR)/changes."
+
+linkcheck:
+	$(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck
+	@echo
+	@echo "Link check complete; look for any errors in the above output " \
+	      "or in $(BUILDDIR)/linkcheck/output.txt."
+
+doctest:
+	$(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest
+	@echo "Testing of doctests in the sources finished, look at the " \
+	      "results in $(BUILDDIR)/doctest/output.txt."

          

@@ 0,0 1,262 @@ 
+
+"""
+
+The Liminal RNode System - Scheduling Renderjobs In A Crazy World
+by Leonard Ritter, Duangle GbR (2014.4.11)
+
+
+
+Structuring rendering in a 3D application to allow for drastical alterations
+    in pipeline ordering isn't easy; you usually end up wanting all kinds of
+    permutations, like "i want _this_ actor with _this_ mesh, but this time into
+    _this_ framebuffer, but with the same camera data; screw that; we need
+    the same data in two different rendertargets, oh and I forgot we need
+    splitscreen, so all this needs to be split into four viewports - except
+    for this object, which needs to be on top of it all."
+
+...and the graphics engine coder works his ass off for two more weeks; usually
+these changes ripple through the entire codebase; starting at providing
+basic support at the engine level, over to the game programmer, who then has
+to make use of the new flags and refactor the rendering setup.
+
+"""
+
+# so here's how to setup scenes in our Liminal engine now;
+# it's a bit like linking generators and effects in a modular sequencer,
+# only that it works on packets (aka renderjobs) instead of streams of
+# audio impulses.
+
+# I haven't seen a game engine which organizes its renderpath like this yet, 
+# so I'm pretty excited to demo this and get everyone's input on what I
+# think is a pretty lean and elegant way to organize 3D rendering in a game.
+
+
+# first, generate a default, uv mapped cube mesh with normals
+mesh = generate_cube_mesh()
+mesh.name = "cube"
+
+# setup a deferred material for the mesh
+material = GMaterial.new()
+material.name = "CubeMaterial"
+material.use_backface_culling = True
+material.use_shadow = True
+material.albedo = vec3(1.0,1.0,1.0)
+material.metallic_factor = 0.0
+material.roughness_factor = 1.0
+material.add_shader_texture('albedo_map', noise1_texture)
+material.add_shader_texture('height_map', noise1_texture)
+material.add_shader_texture('gloss_map', noise1_texture)
+material.add_shader_texture('glow_map', zero_texture())
+
+# create a new actor to give the mesh a location
+# the actor has no conception of anything else; just an orientation in space
+cube2 = Actor()
+cube2.name = 'cube2'
+# give it a physical body for collision testing
+cube2.body = GeomBody.new(ws.world, Box.new(ws.space, vec3(64,64,1)))
+cube2.body.kinematic = True
+# apply position and size
+cube2.position = vec3(0,0,-10)
+cube2.scale = vec3(32.0,32.0,0.5)
+
+# now concatenate our renderjob:
+# we want this mesh with this material at this actor's location,
+# so cube2 now depends on material, which depends on mesh
+cube2 << material << mesh
+
+# the order of assignments is only interesting in relation to the graph,
+# the only requirement is that the mesh is the a source, as meshes are
+# the only nodes that generate renderjobs; other nodes only augment them.
+#
+# this would be equally valid, and a good setup for when many actors
+# share the same material:
+material << cube2 << mesh
+
+# now setup an empty vizgroup which we use to bundle a group of objects,
+# possibly to control visibility later. This would be kind of like a "scene"
+vizgroup = RNode()
+vizgroup.name = 'scene' 
+# make vizgroup depend on cube2
+vizgroup << cube2
+
+# The RNode is the basic building block for the render graph; materials, meshes, 
+# actors, framebuffers, etc. and a lot of other default resources already
+# implement the RNode interface so they can be linked; But it's pretty easy
+# to write your own RNodes, or use a RNode as proxy to re-use another RNode in
+# two different unrelated paths.
+
+# get the singleton for the deferred renderer's resources, which is also
+# an RNode
+grm = GRenderManager()
+
+# link the vizgroup to the framebuffer for the deferred "scene" -
+grm.scene_framebuffer << vizgroup
+
+# now the last thing we need to complete the job is a camera to actually 
+# specify where the scene is in relation to the viewer; 
+camera = DebugCamera(lock_up=True)
+camera.name = 'camera'
+camera.far = 300.0
+camera.fov = 90.0
+# give the camera a collision box
+camera.body = GeomBody.new(ws.world, Box.new(ws.space, vec3(1,1,1)))
+camera.body.kinematic = True
+# and position it
+camera.look_at(vec3(0,-70.0,0), vec3(0,0,0), vec3(0,0,1))
+            
+# all resources the deferred renderer has set up are set, except for the view
+# data, so let's just link the entire grm through it and we're done; the
+# scene is on screen.
+#
+# retrieve render manager singleton
+rm = RenderManager()
+# complete the chain; batch is the root node - now the renderer can 'see'
+# the content.
+rm.batch << camera << grm
+
+# For debugging, I have written a small 90 line function to have graphviz
+# draw a map of the graph, so I can see at any point what the pipeline looks
+# like 
+
+"""
+
+"""
+
+# the declaration for RNodes is only 70 lines, and writing new RNodes is simple;
+# here is an RNode that changes the renderpass of all jobs going through it:
+class Renderpass(RNode):
+    def __init__(self, renderpass):
+        RNode.__init__(self)
+        self.renderpass = renderpass
+        
+    def process(self, batch, jobs):
+        RNode.process(self, batch, jobs)
+        for job in jobs:
+            # we could also insert new orders into the jobs array here
+            # but let's just alter the renderpass
+            job.key.renderpass = self.renderpass
+
+# rnodes are only traversed on graph change, not per frame, and the work can
+# be done in a thread, as the renderer isn't required for processing.
+#
+# this is how the renderbatch then generates all jobs while traversing
+# the graph:
+
+def render_nodes(self):
+    # this could be done in a more conside way in python,
+    # but i wanted to keep the implementation parallel to a possible
+    # future C implementation; this one doesn't need any hash tables
+    # or binary searches, just arrays.
+    
+    # get a new selection id
+    RNode.NODE_ID += 1
+    node_id = RNode.NODE_ID 
+    
+    # array of nodes in topological order
+    nodes = []
+    # how many times each node's content is referenced
+    noderefs = []
+    
+    # recursive visitor function
+    def visit_node(node):
+        # if node has already been seen, skip 
+        if node._node_id == node_id: return
+        # visit children first
+        for n in node.sources:
+            visit_node(n)
+            # increase noderefs for that node
+            noderefs[n._node_index] += 1
+        # assign the node's order index
+        node._node_index = len(nodes)
+        # update the select id to mark the node as visited
+        node._node_id = node_id
+        # append to topologically sorted array
+        nodes.append(node)
+        # and initialize the refcount for this node
+        noderefs.append(0)
+        
+    # start at batch, which is the root
+    visit_node(self)
+    
+    # debug out: print order in which nodes are processed, (which
+    # is not the order in which they are rendered, btw)
+    for i,n in enumerate(nodes):
+        print('#{}: {}'.format(i,n))
+        
+    # array of each node's jobs
+    all_jobs = []
+    # linearly go through node in sorted order
+    for k,node in enumerate(nodes):
+        # list of jobs that this node will receive
+        jobs = []
+        # for all inputs of this node
+        for source in node.sources:
+            # retrieve the jobs that the predecessor has
+            src_index = source._node_index
+            src_jobs = all_jobs[src_index]
+            # make sure we have at least one reference left
+            assert noderefs[src_index] > 0
+            # if this is not the last reference
+            if noderefs[src_index] > 1:
+                # make a copy of the jobs and append
+                for job in src_jobs:
+                    jobs.append(self.copy_job(job))
+            else:
+                # last reference: they terk er jerbs
+                for job in src_jobs:
+                    jobs.append(job)
+                all_jobs[src_index] = None
+            # and decrease reference
+            noderefs[src_index] -= 1
+        
+        # process the jobs
+        try:
+            node.process(self, jobs)
+        except:
+            print(node)
+            raise         
+        # and append to job list       
+        all_jobs.append(jobs)
+        
+    # as jobs are already appended to the renderbatch on create/copy,
+    # we are already done; the batch can now be sorted and is ready
+    # for rendering.
+
+# And, just for completion, this is the basic RNode class declaration:
+
+class RNode(Named):
+    # selection id counter
+    NODE_ID = 0 
+    
+    def __init__(self):
+        Named.__init__(self)
+        # set of input nodes
+        self._sources = set()
+        # variables used during graph traversion
+        self._node_index = 0
+        self._node_id = 0
+        
+    # this function does a number on the jobs; any operation is OK:
+    # alteration, duplication, deletion, etc. Change of order has no effect
+    # on anything.
+    def process(self, batch, jobs):
+        pass
+    
+    @property
+    def sources(self):
+        return self._sources
+        
+    # overloaded << operator to provide linking syntax sugar
+    def __lshift__(self, other):
+        assert self.name, '{} is unnamed'.format(self)
+        if isinstance(other, collections.Iterable):
+            for node in other:
+                assert node.name, '{} is unnamed'.format(other)
+            self.sources.update(other)
+            return other
+        else:
+            assert other.name, '{} is unnamed'.format(other)
+            self.sources.add(other)
+            return other    
+
+# That's it. Thanks for reading :)

          

@@ 0,0 1,146 @@ 
+           An Inversible Split Scheme for Cascading Shadow Maps
+
+                           by Leonard Ritter
+                              Duangle GbR
+                              
+                        First revision: 2013/12/18
+
+
+DISCLAIMER: This is original research and has not been verified by a
+second or third party yet.
+
+
+This is a proposal for a new function for the practical split 
+scheme[1] for shadow map cascades by Zhang et al. The new 
+function can be inverted in a shader to easily project 
+distance z  back to layer index i. An intuitive replacement 
+for the weighing factor sigma is proposed as well.
+
+
+In the original article[1], a split scheme function was suggested to
+find good boundaries for individual shadow map cascades, so that
+given a layer index i, the optimal depth z for that index could
+be derived; given a normal scalar x which is retrieved via
+
+                                         i
+                                x = -----------
+                                    layer_count
+
+and a sigma constant S in the range 0..1, which would allow the
+user interpolate linearly between an equidistant depth distribution
+and an ideal exponential one to bias the resolution distribution,
+the original split scheme equation would be
+
+                          f
+                  z = pow(-, x) n S + ((f - n) x + n) (1 - S) = f(x)
+                          n
+
+n and f designate the distance of the near and far planes respectively.
+
+Unfortunately this function can't be inverted. With this solution,
+it is necessary to precompute and pass the layer boundaries to the 
+pixel shader, which then performs a conditional range check
+for each fragment.
+
+
+The New Split Scheme
+====================
+
+Through experimentation and some guesswork, I found an alternative
+way to bias the distribution, which is purely exponential and
+has no additive polynomial component, so inversion is trivial.
+
+This bias effectively projects the near and far distances to a
+slope further up the exponential curve, which dampens the initial
+slow momentum and causes the function to approach a more linear
+scaling.
+
+The original sigma constant S is squared so that C = sqrt(S),
+and the split scheme function is altered so that 
+
+                 f                     f
+            z = (- + n - f) (pow(-------------, x) - 1.0) + n = f(x)
+                 C               (n - f) C + f
+
+At the original proposed default of S = 0.5, the function starts
+with near identical momentum, but converges marginally sooner
+towards f; across all values of S, the first half of the function
+distributes very similarly, so this function can easily be used 
+as a drop-in replacement.
+
+
+Analysis
+========
+
+http://i.imgur.com/9OeUMBz.png
+
+The above picture shows the distribution for sigma = 0.5; the
+green and yellow curves show the boundaries at sigma 0.0 and 1.0,
+which are the same for both old and new functions.
+The purple curve is the original split scheme, the blue curve
+is the modified one.
+
+
+Shader Usage
+============
+
+In the shader, the layer index can now be retrieved by resolving x from a
+distance z and multiplying it with layer_count to retrieve the interpolated
+index of the layer to be retrieved.
+
+To calculate x from z, we inverse the new split scheme function so that
+
+                (z - far) C + far                  far
+       x = log(--------------------) / log(--------------------) = f(z)
+               (near - far) C + far        (near - far) C + far
+
+For optimization, the inner factors and the second log term can be stored in
+three constant variables U, V, W:
+
+                           d = far * (1.0 - C) + near * C
+
+                                         C
+                                     U = -
+                                         d
+
+                                   far - far * C
+                               V = -------------
+                                         d
+
+                                                                far
+                                 W = layer_count * log(2) / log(---)
+                                                                 d
+
+With these optimizations, the resolve reduces to
+
+                              i = log2(z U + V) W
+
+
+Future Work
+===========
+
+I did not find the original weighing parameter sigma to be particularly
+easy to understand and apply. In practice, I found myself aiming to get
+an optimal balance between resolution and the range of the first cascade
+layer by guessing values for sigma; There was no clear relationship
+between the parameter and its implications.
+
+Ideally, I would prefer a new balancing variable z1 instead of sigma, which
+defines the distance at which the first shadow map layer ends, and is
+used to calculate the bias C.
+
+Unfortunately, I could not find a way to solve the equation towards C,
+so I leave this for further exploration. Until a simpler method can be found,
+bisecting towards C would be the nearest choice; A routine would 
+methodically attempt to solve the split scheme function by adjusting C until
+z = z1 for x = 1 / layer_count.
+
+
+References
+==========
+
+[1] Parallel-Split Shadow Maps on Programmable GPUs
+    http://http.developer.nvidia.com/GPUGems3/gpugems3_ch10.html
+
+
+Thanks to Sean Barrett and Fabian Giesen for help and suggestions.

          

@@ 0,0 1,190 @@ 
+@ECHO OFF
+
+REM Command file for Sphinx documentation
+
+if "%SPHINXBUILD%" == "" (
+	set SPHINXBUILD=sphinx-build
+)
+set BUILDDIR=build
+set ALLSPHINXOPTS=-d %BUILDDIR%/doctrees %SPHINXOPTS% source
+set I18NSPHINXOPTS=%SPHINXOPTS% source
+if NOT "%PAPER%" == "" (
+	set ALLSPHINXOPTS=-D latex_paper_size=%PAPER% %ALLSPHINXOPTS%
+	set I18NSPHINXOPTS=-D latex_paper_size=%PAPER% %I18NSPHINXOPTS%
+)
+
+if "%1" == "" goto help
+
+if "%1" == "help" (
+	:help
+	echo.Please use `make ^<target^>` where ^<target^> is one of
+	echo.  html       to make standalone HTML files
+	echo.  dirhtml    to make HTML files named index.html in directories
+	echo.  singlehtml to make a single large HTML file
+	echo.  pickle     to make pickle files
+	echo.  json       to make JSON files
+	echo.  htmlhelp   to make HTML files and a HTML help project
+	echo.  qthelp     to make HTML files and a qthelp project
+	echo.  devhelp    to make HTML files and a Devhelp project
+	echo.  epub       to make an epub
+	echo.  latex      to make LaTeX files, you can set PAPER=a4 or PAPER=letter
+	echo.  text       to make text files
+	echo.  man        to make manual pages
+	echo.  texinfo    to make Texinfo files
+	echo.  gettext    to make PO message catalogs
+	echo.  changes    to make an overview over all changed/added/deprecated items
+	echo.  linkcheck  to check all external links for integrity
+	echo.  doctest    to run all doctests embedded in the documentation if enabled
+	goto end
+)
+
+if "%1" == "clean" (
+	for /d %%i in (%BUILDDIR%\*) do rmdir /q /s %%i
+	del /q /s %BUILDDIR%\*
+	goto end
+)
+
+if "%1" == "html" (
+	%SPHINXBUILD% -b html %ALLSPHINXOPTS% %BUILDDIR%/html
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished. The HTML pages are in %BUILDDIR%/html.
+	goto end
+)
+
+if "%1" == "dirhtml" (
+	%SPHINXBUILD% -b dirhtml %ALLSPHINXOPTS% %BUILDDIR%/dirhtml
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished. The HTML pages are in %BUILDDIR%/dirhtml.
+	goto end
+)
+
+if "%1" == "singlehtml" (
+	%SPHINXBUILD% -b singlehtml %ALLSPHINXOPTS% %BUILDDIR%/singlehtml
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished. The HTML pages are in %BUILDDIR%/singlehtml.
+	goto end
+)
+
+if "%1" == "pickle" (
+	%SPHINXBUILD% -b pickle %ALLSPHINXOPTS% %BUILDDIR%/pickle
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished; now you can process the pickle files.
+	goto end
+)
+
+if "%1" == "json" (
+	%SPHINXBUILD% -b json %ALLSPHINXOPTS% %BUILDDIR%/json
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished; now you can process the JSON files.
+	goto end
+)
+
+if "%1" == "htmlhelp" (
+	%SPHINXBUILD% -b htmlhelp %ALLSPHINXOPTS% %BUILDDIR%/htmlhelp
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished; now you can run HTML Help Workshop with the ^
+.hhp project file in %BUILDDIR%/htmlhelp.
+	goto end
+)
+
+if "%1" == "qthelp" (
+	%SPHINXBUILD% -b qthelp %ALLSPHINXOPTS% %BUILDDIR%/qthelp
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished; now you can run "qcollectiongenerator" with the ^
+.qhcp project file in %BUILDDIR%/qthelp, like this:
+	echo.^> qcollectiongenerator %BUILDDIR%\qthelp\Beige.qhcp
+	echo.To view the help file:
+	echo.^> assistant -collectionFile %BUILDDIR%\qthelp\Beige.ghc
+	goto end
+)
+
+if "%1" == "devhelp" (
+	%SPHINXBUILD% -b devhelp %ALLSPHINXOPTS% %BUILDDIR%/devhelp
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished.
+	goto end
+)
+
+if "%1" == "epub" (
+	%SPHINXBUILD% -b epub %ALLSPHINXOPTS% %BUILDDIR%/epub
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished. The epub file is in %BUILDDIR%/epub.
+	goto end
+)
+
+if "%1" == "latex" (
+	%SPHINXBUILD% -b latex %ALLSPHINXOPTS% %BUILDDIR%/latex
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished; the LaTeX files are in %BUILDDIR%/latex.
+	goto end
+)
+
+if "%1" == "text" (
+	%SPHINXBUILD% -b text %ALLSPHINXOPTS% %BUILDDIR%/text
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished. The text files are in %BUILDDIR%/text.
+	goto end
+)
+
+if "%1" == "man" (
+	%SPHINXBUILD% -b man %ALLSPHINXOPTS% %BUILDDIR%/man
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished. The manual pages are in %BUILDDIR%/man.
+	goto end
+)
+
+if "%1" == "texinfo" (
+	%SPHINXBUILD% -b texinfo %ALLSPHINXOPTS% %BUILDDIR%/texinfo
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished. The Texinfo files are in %BUILDDIR%/texinfo.
+	goto end
+)
+
+if "%1" == "gettext" (
+	%SPHINXBUILD% -b gettext %I18NSPHINXOPTS% %BUILDDIR%/locale
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished. The message catalogs are in %BUILDDIR%/locale.
+	goto end
+)
+
+if "%1" == "changes" (
+	%SPHINXBUILD% -b changes %ALLSPHINXOPTS% %BUILDDIR%/changes
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.The overview file is in %BUILDDIR%/changes.
+	goto end
+)
+
+if "%1" == "linkcheck" (
+	%SPHINXBUILD% -b linkcheck %ALLSPHINXOPTS% %BUILDDIR%/linkcheck
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Link check complete; look for any errors in the above output ^
+or in %BUILDDIR%/linkcheck/output.txt.
+	goto end
+)
+
+if "%1" == "doctest" (
+	%SPHINXBUILD% -b doctest %ALLSPHINXOPTS% %BUILDDIR%/doctest
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Testing of doctests in the sources finished, look at the ^
+results in %BUILDDIR%/doctest/output.txt.
+	goto end
+)
+
+:end

          

@@ 0,0 1,242 @@ 
+# -*- coding: utf-8 -*-
+#
+# Beige documentation build configuration file, created by
+# sphinx-quickstart on Thu Jan  3 13:01:37 2013.
+#
+# This file is execfile()d with the current directory set to its containing dir.
+#
+# Note that not all possible configuration values are present in this
+# autogenerated file.
+#
+# All configuration values have a default; values that are commented out
+# serve to show the default.
+
+import sys, os
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+sys.path.insert(0, os.path.abspath('..'))
+
+# -- General configuration -----------------------------------------------------
+
+# If your documentation needs a minimal Sphinx version, state it here.
+#needs_sphinx = '1.0'
+
+# Add any Sphinx extension module names here, as strings. They can be extensions
+# coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
+extensions = ['sphinx.ext.autodoc', 'sphinx.ext.todo', 'sphinx.ext.coverage', 'sphinx.ext.pngmath', 'sphinx.ext.ifconfig', 'sphinx.ext.viewcode']
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ['_templates']
+
+# The suffix of source filenames.
+source_suffix = '.txt'
+
+# The encoding of source files.
+#source_encoding = 'utf-8-sig'
+
+# The master toctree document.
+master_doc = 'index'
+
+# General information about the project.
+project = u'Beige'
+copyright = u'2013, Leonard Ritter'
+
+# The version info for the project you're documenting, acts as replacement for
+# |version| and |release|, also used in various other places throughout the
+# built documents.
+#
+# The short X.Y version.
+version = '0.1'
+# The full version, including alpha/beta/rc tags.
+release = '0.1'
+
+# The language for content autogenerated by Sphinx. Refer to documentation
+# for a list of supported languages.
+#language = None
+
+# There are two options for replacing |today|: either, you set today to some
+# non-false value, then it is used:
+#today = ''
+# Else, today_fmt is used as the format for a strftime call.
+#today_fmt = '%B %d, %Y'
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+exclude_patterns = []
+
+# The reST default role (used for this markup: `text`) to use for all documents.
+#default_role = None
+
+# If true, '()' will be appended to :func: etc. cross-reference text.
+#add_function_parentheses = True
+
+# If true, the current module name will be prepended to all description
+# unit titles (such as .. function::).
+#add_module_names = True
+
+# If true, sectionauthor and moduleauthor directives will be shown in the
+# output. They are ignored by default.
+#show_authors = False
+
+# The name of the Pygments (syntax highlighting) style to use.
+pygments_style = 'sphinx'
+
+# A list of ignored prefixes for module index sorting.
+#modindex_common_prefix = []
+
+
+# -- Options for HTML output ---------------------------------------------------
+
+# The theme to use for HTML and HTML Help pages.  See the documentation for
+# a list of builtin themes.
+html_theme = 'default'
+
+# Theme options are theme-specific and customize the look and feel of a theme
+# further.  For a list of options available for each theme, see the
+# documentation.
+#html_theme_options = {}
+
+# Add any paths that contain custom themes here, relative to this directory.
+#html_theme_path = []
+
+# The name for this set of Sphinx documents.  If None, it defaults to
+# "<project> v<release> documentation".
+#html_title = None
+
+# A shorter title for the navigation bar.  Default is the same as html_title.
+#html_short_title = None
+
+# The name of an image file (relative to this directory) to place at the top
+# of the sidebar.
+#html_logo = None
+
+# The name of an image file (within the static path) to use as favicon of the
+# docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
+# pixels large.
+#html_favicon = None
+
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named "default.css" will overwrite the builtin "default.css".
+html_static_path = ['_static']
+
+# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
+# using the given strftime format.
+#html_last_updated_fmt = '%b %d, %Y'
+
+# If true, SmartyPants will be used to convert quotes and dashes to
+# typographically correct entities.
+#html_use_smartypants = True
+
+# Custom sidebar templates, maps document names to template names.
+#html_sidebars = {}
+
+# Additional templates that should be rendered to pages, maps page names to
+# template names.
+#html_additional_pages = {}
+
+# If false, no module index is generated.
+#html_domain_indices = True
+
+# If false, no index is generated.
+#html_use_index = True
+
+# If true, the index is split into individual pages for each letter.
+#html_split_index = False
+
+# If true, links to the reST sources are added to the pages.
+#html_show_sourcelink = True
+
+# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
+#html_show_sphinx = True
+
+# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
+#html_show_copyright = True
+
+# If true, an OpenSearch description file will be output, and all pages will
+# contain a <link> tag referring to it.  The value of this option must be the
+# base URL from which the finished HTML is served.
+#html_use_opensearch = ''
+
+# This is the file name suffix for HTML files (e.g. ".xhtml").
+#html_file_suffix = None
+
+# Output file base name for HTML help builder.
+htmlhelp_basename = 'Beigedoc'
+
+
+# -- Options for LaTeX output --------------------------------------------------
+
+latex_elements = {
+# The paper size ('letterpaper' or 'a4paper').
+#'papersize': 'letterpaper',
+
+# The font size ('10pt', '11pt' or '12pt').
+#'pointsize': '10pt',
+
+# Additional stuff for the LaTeX preamble.
+#'preamble': '',
+}
+
+# Grouping the document tree into LaTeX files. List of tuples
+# (source start file, target name, title, author, documentclass [howto/manual]).
+latex_documents = [
+  ('index', 'Beige.tex', u'Beige Documentation',
+   u'Leonard Ritter', 'manual'),
+]
+
+# The name of an image file (relative to this directory) to place at the top of
+# the title page.
+#latex_logo = None
+
+# For "manual" documents, if this is true, then toplevel headings are parts,
+# not chapters.
+#latex_use_parts = False
+
+# If true, show page references after internal links.
+#latex_show_pagerefs = False
+
+# If true, show URL addresses after external links.
+#latex_show_urls = False
+
+# Documents to append as an appendix to all manuals.
+#latex_appendices = []
+
+# If false, no module index is generated.
+#latex_domain_indices = True
+
+
+# -- Options for manual page output --------------------------------------------
+
+# One entry per manual page. List of tuples
+# (source start file, name, description, authors, manual section).
+man_pages = [
+    ('index', 'liminal', u'Beige Documentation',
+     [u'Leonard Ritter'], 1)
+]
+
+# If true, show URL addresses after external links.
+#man_show_urls = False
+
+
+# -- Options for Texinfo output ------------------------------------------------
+
+# Grouping the document tree into Texinfo files. List of tuples
+# (source start file, target name, title, author,
+#  dir menu entry, description, category)
+texinfo_documents = [
+  ('index', 'Beige', u'Beige Documentation',
+   u'Leonard Ritter', 'Beige', 'One line description of project.',
+   'Miscellaneous'),
+]
+
+# Documents to append as an appendix to all manuals.
+#texinfo_appendices = []
+
+# If false, no module index is generated.
+#texinfo_domain_indices = True
+
+# How to display URL addresses: 'footnote', 'no', or 'inline'.
+#texinfo_show_urls = 'footnote'