linse/frappy
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

several improvements and bugfixes

Browse Source 
+ rework GUI
  - include a combobox for selection of visibility
  - include a checkbox wether validation should be done in the client
  - remove unused lineEdit
+ improve datatypes
+ improve tests for new descriptive data
+ metaclasse: fix overlooked read_* or write_* func's
+ improve polling
+ Introduce new ErrorClasses
+ dispatcher: use new features of datatypes + PARAMS
+ improve lib
+ autopep8
+ first working version of MLZ_entangle integration
+ split specific stuff into it's own package (MLZ,demo,ess)

Change-Id: I8ac3ce871b28f44afecbba6332ca741095426712
This commit is contained in:
Enrico Faulhaber
2017-07-09 22:18:01 +02:00
committed by Alexander Lenz
parent 8a63a6c63f
commit 29ee07c5b3
25 changed files with 1830 additions and 220 deletions
Download Patch File Download Diff File Expand all files Collapse all files

208
secop/datatypes.py
View File

@ -22,12 +22,21 @@
"""Define validated data types."""
from .errors import ProgrammingError
from collections import OrderedDict
# Only export these classes for 'from secop.datatypes import *'
__all__ = [
"DataType",
"FloatRange", "IntRange",
"BoolType", "EnumType",
"BLOBType", "StringType",
"TupleOf", "ArrayOf", "StructOf",
]
# base class for all DataTypes
class DataType(object):
as_json = ['undefined']
@ -39,6 +48,11 @@ class DataType(object):
"""returns a python object fit for external serialisation or logging"""
raise NotImplemented
def from_string(self, text):
"""interprets a given string and returns a validated (internal) value"""
# to evaluate values from configfiles, etc...
raise NotImplemented
# goodie: if called, validate
def __call__(self, value):
return self.validate(value)
@ -52,7 +66,7 @@ class FloatRange(DataType):
self.max = None if max is None else float(max)
# note: as we may compare to Inf all comparisons would be false
if (self.min or float('-inf')) <= (self.max or float('+inf')):
if min == None and max == None:
if min is None and max is None:
self.as_json = ['double']
else:
self.as_json = ['double', min, max]
@ -65,9 +79,11 @@ class FloatRange(DataType):
except:
raise ValueError('Can not validate %r to float' % value)
if self.min is not None and value < self.min:
raise ValueError('%r should not be less then %s' % (value, self.min))
raise ValueError('%r should not be less then %s' %
(value, self.min))
if self.max is not None and value > self.max:
raise ValueError('%r should not be greater than %s' % (value, self.max))
raise ValueError('%r should not be greater than %s' %
(value, self.max))
if None in (self.min, self.max):
return value
if self.min <= value <= self.max:
@ -76,9 +92,10 @@ class FloatRange(DataType):
(value, self.min, self.max))
def __repr__(self):
if self.max != None:
return "FloatRange(%r, %r)" % (float('-inf') if self.min is None else self.min, self.max)
if self.min != None:
if self.max is not None:
return "FloatRange(%r, %r)" % (
float('-inf') if self.min is None else self.min, self.max)
if self.min is not None:
return "FloatRange(%r)" % self.min
return "FloatRange()"
@ -86,15 +103,20 @@ class FloatRange(DataType):
"""returns a python object fit for serialisation"""
return float(value)
def from_string(self, text):
value = float(text)
return self.validate(value)
class IntRange(DataType):
"""Restricted int type"""
def __init__(self, min=None, max=None):
self.min = int(min) if min is not None else min
self.max = int(max) if max is not None else max
if self.min is not None and self.max is not None and self.min > self.max:
raise ValueError('Max must be larger then min!')
if self.min == None and self.max == None:
if self.min is None and self.max is None:
self.as_json = ['int']
else:
self.as_json = ['int', self.min, self.max]
@ -104,10 +126,10 @@ class IntRange(DataType):
value = int(value)
if self.min is not None and value < self.min:
raise ValueError('%r should be an int between %d and %d' %
(value, self.min, self.max or 0))
(value, self.min, self.max or 0))
if self.max is not None and value > self.max:
raise ValueError('%r should be an int between %d and %d' %
(value, self.min or 0, self.max))
(value, self.min or 0, self.max))
return value
except:
raise ValueError('Can not validate %r to int' % value)
@ -123,15 +145,20 @@ class IntRange(DataType):
"""returns a python object fit for serialisation"""
return int(value)
def from_string(self, text):
value = int(text)
return self.validate(value)
class EnumType(DataType):
as_json = ['enum']
def __init__(self, *args, **kwds):
# enum keys are ints! check
self.entries = {}
num = 0
for arg in args:
if type(arg) != str:
if not isinstance(arg, str):
print arg, type(arg)
raise ValueError('EnumType entries MUST be strings!')
self.entries[num] = arg
@ -139,19 +166,24 @@ class EnumType(DataType):
for k, v in kwds.items():
v = int(v)
if v in self.entries:
raise ValueError('keyword argument %r=%d is already assigned %r', k, v, self.entries[v])
raise ValueError(
'keyword argument %r=%d is already assigned %r',
k,
v,
self.entries[v])
self.entries[v] = k
if len(self.entries) == 0:
raise ValueError('Empty enums ae not allowed!')
self.reversed = {}
for k,v in self.entries.items():
for k, v in self.entries.items():
if v in self.reversed:
raise ValueError('Mapping for %r=%r is not Unique!', v, k)
self.reversed[v] = k
self.as_json = ['enum', self.reversed.copy()]
def __repr__(self):
return "EnumType(%s)" % ', '.join(['%s=%d' % (v,k) for k,v in self.entries.items()])
return "EnumType(%s)" % ', '.join(
['%s=%d' % (v, k) for k, v in self.entries.items()])
def export(self, value):
"""returns a python object fit for serialisation"""
@ -159,7 +191,8 @@ class EnumType(DataType):
return self.reversed[value]
if int(value) in self.entries:
return int(value)
raise ValueError('%r is not one of %s', str(value), ', '.join(self.reversed.keys()))
raise ValueError('%r is not one of %s', str(
value), ', '.join(self.reversed.keys()))
def validate(self, value):
"""return the validated (internal) value or raise"""
@ -167,10 +200,16 @@ class EnumType(DataType):
return value
if int(value) in self.entries:
return self.entries[int(value)]
raise ValueError('%r is not one of %s', str(value), ', '.join(map(str,self.entries.keys())))
raise ValueError('%r is not one of %s', str(value),
', '.join(map(str, self.entries.keys())))
def from_string(self, text):
value = text
return self.validate(value)
class BLOBType(DataType):
def __init__(self, minsize=0, maxsize=None):
self.minsize = minsize
self.maxsize = maxsize
@ -194,19 +233,26 @@ class BLOBType(DataType):
raise ValueError('%r has the wrong type!', value)
size = len(value)
if size < self.minsize:
raise ValueError('%r must be at least %d bytes long!', value, self.minsize)
raise ValueError(
'%r must be at least %d bytes long!', value, self.minsize)
if self.maxsize is not None:
if size > self.maxsize:
raise ValueError('%r must be at most %d bytes long!', value, self.maxsize)
raise ValueError(
'%r must be at most %d bytes long!', value, self.maxsize)
return value
def export(self, value):
"""returns a python object fit for serialisation"""
return b'%s' % value
def from_string(self, text):
value = text
return self.validate(value)
class StringType(DataType):
as_json = ['string']
def __init__(self, minsize=0, maxsize=None):
self.minsize = minsize
self.maxsize = maxsize
@ -219,7 +265,8 @@ class StringType(DataType):
def __repr__(self):
if self.maxsize:
return 'StringType(%s, %s)' % (str(self.minsize), str(self.maxsize))
return 'StringType(%s, %s)' % (
str(self.minsize), str(self.maxsize))
if self.minsize:
return 'StringType(%d)' % str(self.minsize)
return 'StringType()'
@ -230,22 +277,31 @@ class StringType(DataType):
raise ValueError('%r has the wrong type!', value)
size = len(value)
if size < self.minsize:
raise ValueError('%r must be at least %d bytes long!', value, self.minsize)
raise ValueError(
'%r must be at least %d bytes long!', value, self.minsize)
if self.maxsize is not None:
if size > self.maxsize:
raise ValueError('%r must be at most %d bytes long!', value, self.maxsize)
raise ValueError(
'%r must be at most %d bytes long!', value, self.maxsize)
if '\0' in value:
raise ValueError('Strings are not allowed to embed a \\0! Use a Blob instead!')
raise ValueError(
'Strings are not allowed to embed a \\0! Use a Blob instead!')
return value
def export(self, value):
"""returns a python object fit for serialisation"""
return '%s' % value
def from_string(self, text):
value = text
return self.validate(value)
# Bool is a special enum
class BoolType(DataType):
as_json = ['bool']
def __repr__(self):
return 'BoolType()'
@ -261,23 +317,31 @@ class BoolType(DataType):
"""returns a python object fit for serialisation"""
return True if self.validate(value) else False
def from_string(self, text):
value = text
return self.validate(value)
#
# nested types
#
class ArrayOf(DataType):
def __init__(self, subtype, minsize_or_size=None, maxsize=None):
if maxsize is None:
maxsize = minsize_or_size
self.minsize = minsize_or_size
self.maxsize = maxsize
if self.minsize is not None and self.maxsize is not None and \
self.minsize > self.maxsize:
raise ValueError('minsize must be less than or equal to maxsize!')
self.minsize > self.maxsize:
raise ValueError('minsize must be less than or equal to maxsize!')
if not isinstance(subtype, DataType):
raise ValueError('ArrayOf only works with DataType objs as first argument!')
raise ValueError(
'ArrayOf only works with DataType objs as first argument!')
self.subtype = subtype
self.as_json = ['array', self.subtype.as_json, self.minsize, self.maxsize]
self.as_json = ['array', self.subtype.as_json,
self.minsize, self.maxsize]
if self.minsize is not None and self.minsize < 0:
raise ValueError('Minimum size must be >= 0!')
if self.maxsize is not None and self.maxsize < 1:
@ -286,32 +350,43 @@ class ArrayOf(DataType):
raise ValueError('Maximum size must be >= Minimum size')
def __repr__(self):
return 'ArrayOf(%s, %s, %s)' % (repr(self.subtype), self.minsize, self.maxsize)
return 'ArrayOf(%s, %s, %s)' % (
repr(self.subtype), self.minsize, self.maxsize)
def validate(self, value):
"""validate a external representation to an internal one"""
if isinstance(value, (tuple, list)):
# check number of elements
if self.minsize is not None and len(value) < self.minsize:
raise ValueError('Array too small, needs at least %d elements!', self.minsize)
raise ValueError(
'Array too small, needs at least %d elements!',
self.minsize)
if self.maxsize is not None and len(value) > self.maxsize:
raise ValueError('Array too big, holds at most %d elements!', self.minsize)
raise ValueError(
'Array too big, holds at most %d elements!', self.minsize)
# apply subtype valiation to all elements and return as list
return [self.subtype.validate(elem) for elem in value]
raise ValueError('Can not convert %s to ArrayOf DataType!', repr(value))
raise ValueError(
'Can not convert %s to ArrayOf DataType!', repr(value))
def export(self, value):
"""returns a python object fit for serialisation"""
return [self.subtype.export(elem) for elem in value]
def from_string(self, text):
value = eval(text) # XXX: !!!
return self.validate(value)
class TupleOf(DataType):
def __init__(self, *subtypes):
if not subtypes:
raise ValueError('Empty tuples are not allowed!')
for subtype in subtypes:
if not isinstance(subtype, DataType):
raise ValueError('TupleOf only works with DataType objs as arguments!')
raise ValueError(
'TupleOf only works with DataType objs as arguments!')
self.subtypes = subtypes
self.as_json = ['tuple', [subtype.as_json for subtype in subtypes]]
@ -323,65 +398,84 @@ class TupleOf(DataType):
# keep the ordering!
try:
if len(value) != len(self.subtypes):
raise ValueError('Illegal number of Arguments! Need %d arguments.', len(self.subtypes))
raise ValueError(
'Illegal number of Arguments! Need %d arguments.', len(
self.subtypes))
# validate elements and return as list
return [sub.validate(elem) for sub,elem in zip(self.subtypes, value)]
return [sub.validate(elem)
for sub, elem in zip(self.subtypes, value)]
except Exception as exc:
raise ValueError('Can not validate:', str(exc))
def export(self, value):
"""returns a python object fit for serialisation"""
return [sub.export(elem) for sub,elem in zip(self.subtypes, value)]
return [sub.export(elem) for sub, elem in zip(self.subtypes, value)]
def from_string(self, text):
value = eval(text) # XXX: !!!
return self.validate(tuple(value))
class StructOf(DataType):
def __init__(self, **named_subtypes):
if not named_subtypes:
raise ValueError('Empty structs are not allowed!')
for name, subtype in named_subtypes.items():
if not isinstance(subtype, DataType):
raise ProgrammingError('StructOf only works with named DataType objs as keyworded arguments!')
raise ProgrammingError(
'StructOf only works with named DataType objs as keyworded arguments!')
if not isinstance(name, (str, unicode)):
raise ProgrammingError('StructOf only works with named DataType objs as keyworded arguments!')
raise ProgrammingError(
'StructOf only works with named DataType objs as keyworded arguments!')
self.named_subtypes = named_subtypes
self.as_json = ['struct', dict((n,s.as_json) for n,s in named_subtypes.items())]
self.as_json = ['struct', dict((n, s.as_json)
for n, s in named_subtypes.items())]
def __repr__(self):
return 'StructOf(%s)' % ', '.join(['%s=%s'%(n,repr(st)) for n,st in self.named_subtypes.iteritems()])
return 'StructOf(%s)' % ', '.join(
['%s=%s' % (n, repr(st)) for n, st in self.named_subtypes.iteritems()])
def validate(self, value):
"""return the validated value or raise"""
try:
if len(value.keys()) != len(self.named_subtypes.keys()):
raise ValueError('Illegal number of Arguments! Need %d arguments.', len(self.namd_subtypes.keys()))
raise ValueError(
'Illegal number of Arguments! Need %d arguments.', len(
self.namd_subtypes.keys()))
# validate elements and return as dict
return dict((str(k), self.named_subtypes[k].validate(v))
for k,v in value.items())
for k, v in value.items())
except Exception as exc:
raise ValueError('Can not validate %s: %s', repr(value),str(exc))
raise ValueError('Can not validate %s: %s', repr(value), str(exc))
def export(self, value):
"""returns a python object fit for serialisation"""
if len(value.keys()) != len(self.named_subtypes.keys()):
raise ValueError('Illegal number of Arguments! Need %d arguments.', len(self.namd_subtypes.keys()))
return dict((str(k),self.named_subtypes[k].export(v))
for k,v in value.items())
raise ValueError(
'Illegal number of Arguments! Need %d arguments.', len(
self.namd_subtypes.keys()))
return dict((str(k), self.named_subtypes[k].export(v))
for k, v in value.items())
def from_string(self, text):
value = eval(text) # XXX: !!!
return self.validate(dict(value))
# XXX: derive from above classes automagically!
DATATYPES = dict(
bool = lambda : BoolType(),
int = lambda _min=None, _max=None: IntRange(_min, _max),
double = lambda _min=None, _max=None: FloatRange(_min, _max),
blob = lambda _min=None, _max=None: BLOBType(_min, _max),
string = lambda _min=None, _max=None: StringType(_min, _max),
array = lambda subtype, _min=None, _max=None: ArrayOf(get_datatype(subtype), _min, _max),
tuple = lambda subtypes: TupleOf(*map(get_datatype,subtypes)),
enum = lambda kwds: EnumType(**kwds),
struct = lambda named_subtypes: StructOf(**dict((n,get_datatype(t)) for n,t in named_subtypes.items())),
bool=lambda: BoolType(),
int=lambda _min=None, _max=None: IntRange(_min, _max),
double=lambda _min=None, _max=None: FloatRange(_min, _max),
blob=lambda _min=None, _max=None: BLOBType(_min, _max),
string=lambda _min=None, _max=None: StringType(_min, _max),
array=lambda subtype, _min=None, _max=None: ArrayOf(
get_datatype(subtype), _min, _max),
tuple=lambda subtypes: TupleOf(*map(get_datatype, subtypes)),
enum=lambda kwds: EnumType(**kwds),
struct=lambda named_subtypes: StructOf(
**dict((n, get_datatype(t)) for n, t in named_subtypes.items())),
)
@ -392,12 +486,14 @@ def export_datatype(datatype):
return datatype.as_json
# important for getting the right datatype from formerly jsonified descr.
def get_datatype(json):
if json is None:
return json
if not isinstance(json, list):
raise ValueError('Argument must be a properly formatted list!')
if len(json)<1:
if len(json) < 1:
raise ValueError('can not validate %r', json)
base = json[0]
if base in DATATYPES: