conffwk.schema Namespace Reference

Classes
class	Cache

Functions
	decode_range (s)
	str2integer (v, t, max)
	to_int (v)
	to_long (v)
	check_range (v, range, range_re, pytype)
	check_relation (v, rel)
	check_cardinality (v, prop)
	coerce (v, attr)
	map_coercion (class_name, schema)

Variables
dict	oks_types = {}
	range_regexp

Detailed Description

A set of utilities to simplify OKS instrospection.

Function Documentation

check_cardinality()

conffwk.schema.check_cardinality	(		v,
			prop )

Checks the cardinality of a certain attribute or relationship.

Definition at line 125 of file schema.py.

def check_cardinality(v, prop):
    """Checks the cardinality of a certain attribute or relationship."""
 
    # check cardinality
    if prop['multivalue'] and not isinstance(v, list):
        raise ValueError('Multivalued properties must be python lists')
    elif not prop['multivalue'] and isinstance(v, list):
        raise ValueError(
            'Single valued properties cannot be set with python lists')
 
 

check_range()

conffwk.schema.check_range	(		v,
			range,
			range_re,
			pytype )

Checks the range of the value 'v' to make sure it is inside.

Definition at line 87 of file schema.py.

def check_range(v, range, range_re, pytype):
    """Checks the range of the value 'v' to make sure it is inside."""
    if isinstance(v, list):
        for k in v:
            check_range(k, range, range_re, pytype)
        return
 
    in_range = False
    if type(v) == str and range_re is not None:
        if range_re.match(v):
            in_range = True
    else:
        for k in range:
            if isinstance(k, tuple):
                if v >= k[0] and v <= k[1]:
                    in_range = True
            else:
                if v == k:
                    in_range = True
 
    if not in_range:
        raise ValueError('Value %s is not in range %s' % (v, range))
 
 

check_relation()

conffwk.schema.check_relation	(		v,
			rel )

Checks the value v against the relationship parameters in 'rel'.

Definition at line 111 of file schema.py.

def check_relation(v, rel):
    """Checks the value v against the relationship parameters in 'rel'."""
    from conffwk.dal import DalBase
 
    if not isinstance(v, DalBase):
        raise ValueError('Relationships should be DAL objects, but %s is not' %
                         repr(v))
 
    # check type
    if rel['type'] not in v.oksTypes():
        raise ValueError('Object %s is not of type or subtype %s' %
                         (repr(v), rel['type']))
 
 

coerce()

conffwk.schema.coerce	(		v,
			attr )

Coerces the input value 'v' in the way the attribute expects.

Definition at line 136 of file schema.py.

def coerce(v, attr):
    """Coerces the input value 'v' in the way the attribute expects."""
 
    # coerce if necessary
    if type(v) != attr['python_class']:
        # coerce in this case
        if attr['python_class'] in [int, int]:
 
            if isinstance(v, str):
                if len(v) == 0:
                    raise ValueError(
                        'Integer number cannot be assigned an empty string')
                if v[0] == '0':
                    try:
                        return attr['python_class'](v, 8)
                    except ValueError:
                        return attr['python_class'](v, 16)
                else:
                    try:
                        return attr['python_class'](v)
                    except ValueError:
                        return attr['python_class'](v, 16)
            else:
                v = attr['python_class'](v)
 
        elif attr['python_class'] is bool:
            if isinstance(v, str):
                if v in ['0', 'false']:
                    v = False
                else:
                    v = True
            else:
                v = attr['python_class'](v)
 
        else:
            v = attr['python_class'](v)
 
    # check the range of each item, if a range was set
    if attr['range']:
        check_range(v, attr['range'], attr['range_re'], attr['python_class'])
 
    # for special types, do a special check
    if attr['type'] == 'class':
        # class references must exist in the DAL the time I set it
        from .dal import __dal__
        check_range(v, list(__dal__.keys()),
                    attr['range_re'], attr['python_class'])
 
    elif attr['type'] == 'date':
        import time
        try:
            time.strptime(v, '%Y-%m-%d')
        except ValueError as e:
            try:
                time.strptime(v, '%d/%m/%y')
            except ValueError as e:
                try:
                    time.strptime(v, '%Y-%b-%d')
                except ValueError as e:
                    raise ValueError(
                        'Date types should have the format '
                        'dd/mm/yy or yyyy-mm-dd or yyyy-mon-dd: %s' % v)
 
    elif attr['type'] == 'time':
        import time
        try:
            time.strptime(v, '%Y-%m-%d %H:%M:%S')
        except ValueError as e:
            try:
                time.strptime(v, '%d/%m/%y %H:%M:%S')
            except ValueError as e:
                try:
                    time.strptime(v, '%Y-%b-%d %H:%M:%S')
                except ValueError as e:
                    raise ValueError(
                        'Time types should have the format dd/mm/yy HH:MM:SS '
                        'or yyyy-mm-dd HH:MM:SS or yyyy-mon-dd HH:MM:SS:'
                        + str(e))
 
    return v
 
 

decode_range()

conffwk.schema.decode_range

(

s

)

Decodes a range string representation, returns a tuple with 2 values.

This is the supported format in regexp representation:
'([-0x]*\\d+)\\D+-?\\d+'

Definition at line 29 of file schema.py.

def decode_range(s):
    """Decodes a range string representation, returns a tuple with 2 values.
 
    This is the supported format in regexp representation:
    '([-0x]*\\d+)\\D+-?\\d+'
    """
    if s.find('..') != -1:
        # print 'range: %s => %s' % (s, s.split('..'))
        return s.split('..')
    k = range_regexp.match(s)
    if k:
        # print 'range: %s => %s' % (s, (k.group('s1'), k.group('s2')))
        return (k.group('s1'), k.group('s2'))
    # print 'value: %s' % s
    return s
 
 

map_coercion()

conffwk.schema.map_coercion	(		class_name,
			schema )

Given a schema of a class, maps coercion functions from libpyconffwk.

Definition at line 218 of file schema.py.

def map_coercion(class_name, schema):
    """Given a schema of a class, maps coercion functions from libpyconffwk."""
 
    cls = ConfigObject.ConfigObject
 
    schema['mapping'] = {}
 
    for k, v in list(schema['attribute'].items()):
        typename = v['type']
        getname = v['type']
        if getname in oks_types['string']:
            getname = 'string'
        if v['multivalue']:
            typename += '_vec'
            getname += '_vec'
            v['co_get_method'] = getattr(cls, 'get_' + getname)
            v['co_set_method'] = getattr(cls, 'set_' + typename)
 
        else:
            v['co_get_method'] = getattr(cls, 'get_' + getname)
            v['co_set_method'] = getattr(cls, 'set_' + typename)
 
        if v['type'] in oks_types['string']:
            v['python_class'] = str
        elif v['type'] in oks_types['bool']:
            v['python_class'] = bool
        elif v['type'] in oks_types['integer']:
            v['python_class'] = to_int
        elif v['type'] in oks_types['long']:
            v['python_class'] = to_long
        elif v['type'] in oks_types['float']:
            v['python_class'] = float
 
        # split and coerce ranges
        v['range_re'] = None
        if v['range']:
            if v['type'] == 'string':
                v['range_re'] = re.compile(v['range'])
            else:
                v['range'] = [decode_range(j) for j in v['range'].split(',')]
                for j in range(len(v['range'])):
                    if isinstance(v['range'][j], str):
                        v['range'][j] = v['python_class'](v['range'][j])
                    elif len(v['range'][j]) == 1:
                        v['range'][j] = v['python_class'](v['range'][j][0])
                    else:  # len(v['range'][j]) == 2 (the only other case)
                        v['range'][j] = (v['python_class'](v['range'][j][0]),
                                         v['python_class'](v['range'][j][1]))
 
        # integer numbers have implicit ranges and it is better to check
        elif v['type'] in oks_types['int-number']:
            if v['type'] == 's8':
                v['range'] = [(-2**7, (2**7)-1)]
            if v['type'] == 'u8':
                v['range'] = [(0, (2**8)-1)]
            if v['type'] == 's16':
                v['range'] = [(-2**15, (2**15)-1)]
            if v['type'] == 'u16':
                v['range'] = [(0, (2**16)-1)]
            if v['type'] == 's32':
                v['range'] = [(-2**31, (2**31)-1)]
            if v['type'] == 'u32':
                v['range'] = [(0, (2**32)-1)]
            if v['type'] == 's64':
                v['range'] = [(-2**63, (2**63)-1)]
            if v['type'] == 'u64':
                v['range'] = [(0, (2**64)-1)]
 
        # coerce initial values
        if v['init-value']:
            try:
                if v['type'] in oks_types['string']:
                    pass
                elif v['multivalue']:
                    v['init-value'] = [coerce(j, v)
                                       for j in v['init-value'].split(',')]
                else:
                    v['init-value'] = coerce(v['init-value'], v)
            except ValueError as e:
                logging.warning('Initial value of "%s.%s" could not be '
                                'coerced: %s' %
                                (class_name, k, e))
 
        # if the type is a date or time type, and there is not default,
        # set "now"
        if not v['init-value'] and v['type'] == 'date':
            import datetime
            v['init-value'] == datetime.date.today().isoformat()
 
        # if the type is a date or time type, and there is not default,
        # set "now"
        if not v['init-value'] and v['type'] == 'time':
            import datetime
            now = datetime.datetime.today()
            now.replace(microsecond=0)
            v['init-value'] == now.isoformat(sep=' ')
 
    for v in list(schema['relation'].values()):
        if v['multivalue']:
            v['co_get_method'] = getattr(cls, 'get_objs')
            v['co_set_method'] = getattr(cls, 'set_objs')
 
        else:
            v['co_get_method'] = getattr(cls, 'get_obj')
            v['co_set_method'] = getattr(cls, 'set_obj')
 
    return schema
 
 

str2integer()

conffwk.schema.str2integer	(		v,
			t,
			max )

Converts a value v to integer, irrespectively of its formatting.

If the number starts with a '0', we convert it using an octal
representation. Else, we try a decimal conversion. If any of these fail,
we try an hexa conversion before throwing a ValueError.

Keyword arguments:

v -- the value to be converted
t -- the python type (int or float) to use in the conversion

Definition at line 46 of file schema.py.

def str2integer(v, t, max):
    """Converts a value v to integer, irrespectively of its formatting.
 
    If the number starts with a '0', we convert it using an octal
    representation. Else, we try a decimal conversion. If any of these fail,
    we try an hexa conversion before throwing a ValueError.
 
    Keyword arguments:
 
    v -- the value to be converted
    t -- the python type (int or float) to use in the conversion
    """
    if isinstance(v, t):
        return v
    if not v:
        return v
    if isinstance(v, tuple) or isinstance(v, list):
        return [str2integer(k, t) for k in v]
    if isinstance(v, str):
        if v[0] == '*':
            return max
        elif v[0] == '0':
            try:
                return t(v, 8)
            except ValueError:
                return t(v, 16)
        else:
            try:
                return t(v)
            except ValueError:
                return t(v, 16)
    else:
        return t(v)
 
 

to_int()

conffwk.schema.to_int

(

v

)

Definition at line 81 of file schema.py.

def to_int(v): return str2integer(v, int, sys.maxsize)
 
 

to_long()

conffwk.schema.to_long

(

v

)

Definition at line 84 of file schema.py.

def to_long(v): return str2integer(v, int, 0xffffffffffffffff)
 
 

Variable Documentation

oks_types

dict conffwk.schema.oks_types = {}

Definition at line 14 of file schema.py.

range_regexp

conffwk.schema.range_regexp

Initial value:

=  re.compile(
    r'(?P<s1>-?0?x?[\da-fA-F]+(\.\d+)?)-(?P<s2>-?0?x?[\da-fA-F]+(\.\d+)?)')

Definition at line 25 of file schema.py.