python.PyAthena Namespace Reference

Classes
class	ModuleFacade

Functions
	_get_native_libname (libname)
	helpers
	load_library (libname)
	find_library (libname)
	reload_module (modname)
	py_reload (*args)

Variables
str	__doc__ = """Module containing a set of Python base classes for PyAthena"""
str	__author__ = "Sebastien Binet <binet@cern.ch>"
list	__all__ = []
	data
list	__pseudo_all__
	modname = arg.im_self.__class__.__module__
	print (" ==> moduletype")
	module = reload (sys.modules[modname])
	obj = arg.im_self
	klass = getattr (module, obj.__class__.__name__)
	fct_name = arg.im_func.__name__
	new_fct = getattr (klass, fct_name)
	cfg_methods = dir(Configurable)
tuple	d
	v = getattr (klass, k)

Function Documentation

_get_native_libname()

python.PyAthena._get_native_libname ( libname )

protected

helpers

return the OS-native name from an OS-indenpendent one 

Definition at line 23 of file PyAthena.py.

def _get_native_libname(libname):
    """ return the OS-native name from an OS-indenpendent one """
    import sys
    plat = sys.platform
    if plat.count('linux')>0:
        lib_prefix,lib_suffix = 'lib', '.so'
    elif plat == 'win32':
        lib_prefix,lib_suffix = '', '.dll'
    elif plat == 'darwin':
        lib_prefix,lib_suffix = 'lib','.dylib'
    else:
        raise RuntimeError ("sorry platform [%s] is not (yet?) supported"%plat)
    _sys_libname = libname
    if not _sys_libname.startswith (lib_prefix):
        _sys_libname = ''.join([lib_prefix,_sys_libname])
    if not _sys_libname.endswith (lib_suffix):
        _sys_libname = ''.join([_sys_libname, lib_suffix])
    return _sys_libname
 

find_library()

python.PyAthena.find_library

(

libname

)

Helper function to find the (full)path to a library given its natural name.
 @return None on failure
 
usage:
 >>> find_library('AthenaServices')
 '/afs/cern.ch/.../AtlasCore/[release]/InstallArea/.../libAthenaServices.so

Definition at line 60 of file PyAthena.py.

def find_library(libname):
    """
    Helper function to find the (full)path to a library given its natural name.
     @return None on failure
     
    usage:
     >>> find_library('AthenaServices')
     '/afs/cern.ch/.../AtlasCore/[release]/InstallArea/.../libAthenaServices.so
    """
    import os
    
    _sys_libname = _get_native_libname(libname)
    # FIXME: REALLY not portable...
    if os.name != 'posix':
        raise RuntimeError('sorry OS [%s] is not supported' % os.name)
    
    if 'LD_LIBRARY_PATH' in os.environ:
        for d in os.environ['LD_LIBRARY_PATH'].split(os.pathsep):
            lib = os.path.join(d, _sys_libname)
            if os.path.exists(lib):
                return lib
    return
    

load_library()

python.PyAthena.load_library

(

libname

)

Helper method to load a library by its natural name, not the OS-native name.
But if the OS-native name is given, it is safely handled too. Note that there's
a problem on MacOSX, for which the OS-native name ends with .dylib, but for
which ATLAS builds .so libraries. Override the OS-native name (which should probably
be replaced by two attempts; one with the .dylib and the other with .so)
usage:
 >>> load_library ('AthenaServices')
 >>> load_library ('AthenaServicesDict')

Definition at line 42 of file PyAthena.py.

def load_library (libname):
    """
    Helper method to load a library by its natural name, not the OS-native name.
    But if the OS-native name is given, it is safely handled too. Note that there's
    a problem on MacOSX, for which the OS-native name ends with .dylib, but for
    which ATLAS builds .so libraries. Override the OS-native name (which should probably
    be replaced by two attempts; one with the .dylib and the other with .so)
    usage:
     >>> load_library ('AthenaServices')
     >>> load_library ('AthenaServicesDict')
    """
    _sys_libname = _get_native_libname(libname)
    from sys import platform
    if platform == 'darwin':
        _sys_libname = _sys_libname.replace('.dylib', '.so')
    import ctypes
    return ctypes.cdll.LoadLibrary (_sys_libname)
 

py_reload()

python.PyAthena.py_reload

(

*

args

)

simple minded function to reload objects, methods and modules

example of usage:
>>> # edit and modify the execute methods of some PyAthena.Alg
... # class, then load back that definition
>>> PyAthena.py_reload (alg1.execute, alg2.execute)
>>> PyAthena.py_reload (alg1.execute)
>>> alg1.execute() # will use the new definition
>>> theApp.nextEvent() # will also use the new definitions
... # of both alg1 and alg2

Definition at line 106 of file PyAthena.py.

def py_reload (*args):
    """simple minded function to reload objects, methods and modules
 
    example of usage:
    >>> # edit and modify the execute methods of some PyAthena.Alg
    ... # class, then load back that definition
    >>> PyAthena.py_reload (alg1.execute, alg2.execute)
    >>> PyAthena.py_reload (alg1.execute)
    >>> alg1.execute() # will use the new definition
    >>> theApp.nextEvent() # will also use the new definitions
    ... # of both alg1 and alg2
    """
    import types, sys
    from importlib import reload
    for i,arg in enumerate(args):
        if isinstance (arg, types.ModuleType):

reload_module()

python.PyAthena.reload_module

(

modname

)

Helper method to reload a python module by name.
This is useful in the usual following case:
 >>> from Foo import MyAlg
 >>> assert (not 'Foo' in dir())
 >>> reload(Foo) # won't work
 >>> PyAthena.reload_module ('Foo') # will work
 >>> PyAthena.reload_module (Foo)   # will work too

Definition at line 88 of file PyAthena.py.

def reload_module (modname):
    """
    Helper method to reload a python module by name.
    This is useful in the usual following case:
     >>> from Foo import MyAlg
     >>> assert (not 'Foo' in dir())
     >>> reload(Foo) # won't work
     >>> PyAthena.reload_module ('Foo') # will work
     >>> PyAthena.reload_module (Foo)   # will work too
    """
    import sys, types
    from importlib import reload
    if isinstance (modname, types.ModuleType):
        modname = modname.__name__
    if modname in sys.modules:
        return reload (sys.modules[modname])
    raise ValueError('no module [%s] could be found'%modname)
 

Variable Documentation

__all__

list python.PyAthena.__all__ = []

private

data

Definition at line 11 of file PyAthena.py.

__author__

str python.PyAthena.__author__ = "Sebastien Binet <binet@cern.ch>"

private

Definition at line 8 of file PyAthena.py.

__doc__

str python.PyAthena.__doc__ = """Module containing a set of Python base classes for PyAthena"""

private

Definition at line 7 of file PyAthena.py.

__pseudo_all__

list python.PyAthena.__pseudo_all__

private

Initial value:

=  [ 'StatusCode',
                   'Alg',
                   'Svc',
                   'AlgTool',
                   'Aud',
                   'AthFilterAlgorithm',
                   'services',
                   'algs'
                   ]

Definition at line 12 of file PyAthena.py.

cfg_methods

python.PyAthena.cfg_methods = dir(Configurable)

Definition at line 149 of file PyAthena.py.

d

tuple python.PyAthena.d

Initial value:

=  (k for k in dir(klass)
                 if not k.startswith('__') and k not in cfg_methods)

Definition at line 150 of file PyAthena.py.

fct_name

python.PyAthena.fct_name = arg.im_func.__name__

Definition at line 135 of file PyAthena.py.

klass

python.PyAthena.klass = getattr (module, obj.__class__.__name__)

Definition at line 133 of file PyAthena.py.

modname

python.PyAthena.modname = arg.im_self.__class__.__module__

print (" ==> moduletype")

print ("-->fct:",new_fct.im_func)

print (" ==> methodtype") reload module holding the class' definition

print (" ==> classtype") reload module holding the class' definition

Definition at line 130 of file PyAthena.py.

module

python.PyAthena.module = reload (sys.modules[modname])

Definition at line 131 of file PyAthena.py.

new_fct

python.PyAthena.new_fct = getattr (klass, fct_name)

Definition at line 136 of file PyAthena.py.

obj

python.PyAthena.obj = arg.im_self

Definition at line 132 of file PyAthena.py.

v

python.PyAthena.v = getattr (klass, k)

Definition at line 154 of file PyAthena.py.