conffwk.dal Namespace Reference

Classes
class	DalBase
class	DalType

Functions
	__strcmp__ (v1, v2)
	__recmp__ (pat, v)
	prettyprint_cardinality (not_null, multivalue)
	prettyprint_range (attr)
	prettyprint_doc (entry)
	get_classes (m)
	generate (configuration, other_dals=[])
	module (name, schema, other_dals=[], backend='oksconflibs', db=None)

Variables
dict	__dal__ = {}

Detailed Description

Contains the base class for DAL types and auxiliary methods.

This module defines the PyDALBase class that is used as the base type for all
DAL classes. A few utilities are also available.

Function Documentation

__recmp__()

__recmp__	(		pat,
			v )

Definition at line 23 of file dal.py.

def __recmp__(pat, v):
    return pat.match(v) is not None
 
 

__strcmp__()

__strcmp__	(		v1,
			v2 )

Definition at line 19 of file dal.py.

def __strcmp__(v1, v2):
    return v1 == v2
 
 

generate()

generate	(		configuration,
			other_dals = [] )

Generates the DAL python access layer for the configuration passed.

This method will generate the python DAL access layer for all classes
declared through the conffwk.Configuration object passed. If this file
includes other schemas, the classes for those schemas will also be
generated, unless, classes with matching names are passed through the
"other_dals" parameters.

This method will re-use classes generated in other calls to this method,
either directly (in DAL binding to a python module) or while you created
Configuration type objects. So, you can call this as many times as you want
without incurring in much overhead.

Keyword parameters:

configuration -- The conffwk.Configuration object that you want the prepare
the DAL for.

other_dals -- This is a list of classes that contain other DALs that should
be considered for the inheritance structure of the classes that are going
to be generated here. These classes will not be regenerated. This parameter
can be either a list of modules or classes that won't be regenerated, but
re-used by this generation method.

Returns the DAL classes you asked for.

Definition at line 589 of file dal.py.

def generate(configuration, other_dals=[]):
    """Generates the DAL python access layer for the configuration passed.
 
    This method will generate the python DAL access layer for all classes
    declared through the conffwk.Configuration object passed. If this file
    includes other schemas, the classes for those schemas will also be
    generated, unless, classes with matching names are passed through the
    "other_dals" parameters.
 
    This method will re-use classes generated in other calls to this method,
    either directly (in DAL binding to a python module) or while you created
    Configuration type objects. So, you can call this as many times as you want
    without incurring in much overhead.
 
    Keyword parameters:
 
    configuration -- The conffwk.Configuration object that you want the prepare
    the DAL for.
 
    other_dals -- This is a list of classes that contain other DALs that should
    be considered for the inheritance structure of the classes that are going
    to be generated here. These classes will not be regenerated. This parameter
    can be either a list of modules or classes that won't be regenerated, but
    re-used by this generation method.
 
    Returns the DAL classes you asked for.
    """
    from types import ModuleType as module
 
    klasses = []
 
    other_classes = {}
    for k in other_dals:
        if isinstance(k, module):
            other_classes.update(get_classes(k))
        else:
            other_classes[k.pyclassName()] = k
 
    # we can save a few loops here, we order by number of bases
    to_generate = {}
    for k in configuration.classes():
        if k in other_classes:
            continue
 
        N = len(configuration.superclasses(k))
        if N in to_generate:
            to_generate[N].append(k)
        else:
            to_generate[N] = [k]
 
    ordered = []
    run_order = list(to_generate.keys())
    run_order.sort()
    for k in run_order:
        ordered += to_generate[k]
 
    # generate what we need to
    while ordered:
        next = ordered[0]  # gets the first one, no matter what it is
 
        # if I generated this before, just re-use the class,
        # so python can check the types in the way the user expects
        if next in __dal__:
            klasses.append(__dal__[next])
            other_classes[next] = __dal__[next]
 
        # else, I need to generate a brand new class here and
        # add it to my __dal__
        else:
            bases = configuration.superclasses(next)
            bases = [other_classes.get(k, None) for k in bases]
            bases.append(DalBase)
            if None in bases:  # cannot yet generate for this one, rotate
                ordered.append(next)
            else:  # we can generate this one now
                klasses.append(DalType(next, tuple(bases),
                                       {'__schema__':
                                        configuration.__schema__[next]}))
                # so we can use this next time
                other_classes[next] = klasses[-1]
                klasses[-1].__doc__ = prettyprint_doc(
                    configuration.__schema__[next])
                __dal__[next] = klasses[-1]
 
        del ordered[0]
 
    return klasses
 
 

get_classes()

get_classes

(

m

)

Returns a map with classes in a module, the key is the class name.

Definition at line 577 of file dal.py.

def get_classes(m):
    """Returns a map with classes in a module, the key is the class name."""
 
    # assesses all classes from other modules, correlate with names
    map = {}
    for k in dir(m):
        if k.find('__') == 0:
            continue
        map[k] = getattr(m, k)
    return map
 
 

module()

module	(		name,
			schema,
			other_dals = [],
			backend = 'oksconflibs',
			db = None )

Creates a new python module with the OKS schema files passed as
parameter.

This method creates a new module for the user, using the schema files
passed as parameter. Classes from other DALs are not re-created, but just
re-used. This is an example usage:

import conffwk.dal
dal = conffwk.dal.module('dal', 'dal/schema/core.schema.xml')
DFdal = conffwk.dal.module('DFdal', 'DFConfiguration/schema/df.schema.xml',
                          [dal])

This will generate two python dals in the current context. One that binds
everything available in the first schema file and a second one that binds
everything else defined in the DF OKS schema file.

Keyword parameters:

name -- The name of the python module to create. It should match the name
of the variable you are attributing to, but it is not strictly required by
the python interpreter, just a good practice.

schema -- This is a list of OKS schema files that should be considered. You
can also pass OKS datafiles to this one, which actually includes the schema
files you want to have a DAL for. It will just work.

other_dals -- This is a list of other DAL modules that I'll not regenerate,
and which classes will *not* make part of the returned module. In fact,
this parameter is only used to restrict the amount of output classes since
once class is generated internally, it is not regenerated a second time.
In other words creating twice the same DAL implies in almost no overhead.

backend -- This is the OKS backend to use when retrieving the schemas. By
default it is set to 'oksconflibs', which is what we

Definition at line 678 of file dal.py.

def module(name, schema, other_dals=[], backend='oksconflibs', db=None):
    """Creates a new python module with the OKS schema files passed as
    parameter.
 
    This method creates a new module for the user, using the schema files
    passed as parameter. Classes from other DALs are not re-created, but just
    re-used. This is an example usage:
 
    import conffwk.dal
    dal = conffwk.dal.module('dal', 'dal/schema/core.schema.xml')
    DFdal = conffwk.dal.module('DFdal', 'DFConfiguration/schema/df.schema.xml',
                              [dal])
 
    This will generate two python dals in the current context. One that binds
    everything available in the first schema file and a second one that binds
    everything else defined in the DF OKS schema file.
 
    Keyword parameters:
 
    name -- The name of the python module to create. It should match the name
    of the variable you are attributing to, but it is not strictly required by
    the python interpreter, just a good practice.
 
    schema -- This is a list of OKS schema files that should be considered. You
    can also pass OKS datafiles to this one, which actually includes the schema
    files you want to have a DAL for. It will just work.
 
    other_dals -- This is a list of other DAL modules that I'll not regenerate,
    and which classes will *not* make part of the returned module. In fact,
    this parameter is only used to restrict the amount of output classes since
    once class is generated internally, it is not regenerated a second time.
    In other words creating twice the same DAL implies in almost no overhead.
 
    backend -- This is the OKS backend to use when retrieving the schemas. By
    default it is set to 'oksconflibs', which is what we
    """
    import types
    from .Configuration import Configuration
 
    retval = types.ModuleType(name)
    if isinstance(schema, str):
        schema = [schema]
    for s in schema:
        if db is None:
            db = Configuration(backend + ':' + s)
        else:
            db.load(s)
            db.__core_init__()
 
        for k in generate(db, other_dals):
            retval.__dict__[k.pyclassName()] = k
    return retval

prettyprint_cardinality()

prettyprint_cardinality	(		not_null,
			multivalue )

Returns a nice string representation for an object cardinality

Definition at line 27 of file dal.py.

def prettyprint_cardinality(not_null, multivalue):
    """Returns a nice string representation for an object cardinality"""
    if not_null:
        if multivalue:
            return '1..*'
        else:
            return '1..1'
 
    else:
        if multivalue:
            return '0..*'
        else:
            return '0..1'
 
 

prettyprint_doc()

prettyprint_doc

(

entry

)

Pretty prints a schema Cache entry, to be used by __doc__ strings

Definition at line 51 of file dal.py.

def prettyprint_doc(entry):
    """Pretty prints a schema Cache entry, to be used by __doc__ strings"""
    from .schema import oks_types
 
    akeys = list(entry['attribute'].keys())
    akeys.sort()
    retval = '    Attributes:'
    if len(akeys) == 0:
        retval += ' None'
    retval += '\n'
    for k in akeys:
        retval += '      - "' + k + '": ' + \
            entry['attribute'][k]['description'].strip() + '\n'
        retval += '          oks-type: ' + entry['attribute'][k]['type'] + '\n'
        retval += '          cardinality: ' + \
            prettyprint_cardinality(entry['attribute'][k]['not-null'],
                                    entry['attribute'][k]['multivalue']) + '\n'
        if entry['attribute'][k]['range']:
            retval += '          range: ' + \
                prettyprint_range(entry['attribute'][k]) + '\n'
        if entry['attribute'][k]['init-value']:
            retval += '          initial value: ' + \
                str(entry['attribute'][k]['init-value']) + '\n'
 
    rkeys = list(entry['relation'].keys())
    rkeys.sort()
    retval += '\n    Relationships:'
    if len(rkeys) == 0:
        retval += ' None'
    retval += '\n'
    for k in rkeys:
        retval += '      - "' + k + '": ' + \
            entry['relation'][k]['description'].strip() + '\n'
        retval += '          oks-class: ' + entry['relation'][k]['type'] + '\n'
        retval += '          cardinality: ' + \
            prettyprint_cardinality(entry['relation'][k]['not-null'],
                                    entry['relation'][k]['multivalue']) + '\n'
        retval += '          aggregated: ' + \
            str(entry['relation'][k]['aggregation']) + '\n'
    return retval[:-1]
 
 

prettyprint_range()

prettyprint_range

(

attr

)

Prints the range of an attribute in a nice way

Definition at line 42 of file dal.py.

def prettyprint_range(attr):
    """Prints the range of an attribute in a nice way"""
    to_print = list(attr['range'])  # copy
    for k in range(len(to_print)):
        if isinstance(to_print[k], tuple):
            to_print[k] = '..'.join([str(i) for i in to_print[k]])
    return ', '.join([str(i) for i in to_print])
 
 

Variable Documentation

__dal__

dict conffwk.dal.__dal__ = {}

private

Definition at line 14 of file dal.py.