:parser UTs in processing

b3j0f/conf/model/base.py

@@ -107,7 +107,7 @@ def __repr__(self):
         return result
 
 
-class CompositeModelElement(ModelElement):
+class CompositeModelElement(ModelElement, dict):
     """Model element composed of model elements."""
 
     __contenttype__ = ModelElement  #: content type.
@@ -160,6 +160,10 @@ def __getattr__(self, key):
 
         return result
 
+    def __deepcopy__(self, memo):
+
+        return self
+
     def __contains__(self, key):
 
         if isinstance(key, ModelElement):

b3j0f/conf/model/conf.py

@@ -42,10 +42,6 @@ class Configuration(CompositeModelElement):
 
     __slots__ = CompositeModelElement.__slots__
 
-    ERRORS = ':ERRORS'  #: category name which contains errors.
-    VALUES = ':VALUES'  #: category name which contains local param values.
-    FOREIGNS = ':FOREIGN'  #: category name which contains foreign params vals.
-
     def resolve(
             self, configurable=None, scope=None, safe=True
     ):
@@ -67,12 +63,11 @@ def resolve(
                     scope=scope, safe=safe
                 )
 
-    def pvalue(self, pname, cname=None, history=0):
-        """Get final parameter value, from the category "VALUES" or
-        from a calculated.
+    def param(self, pname, cname=None, history=0):
+        """Get parameter from a category and history.
 
         :param str pname: parameter name.
-        :param str cname: category name.
+        :param str cname: category name. Default is the last registered.
         :param int history: historical param value from specific category or
             final parameter value if cname is not given. For example, if history
             equals 1 and cname is None, result is the value defined just before
@@ -91,7 +86,7 @@ def pvalue(self, pname, cname=None, history=0):
             if pname in cat:
                 categories.append(cat)
 
-                if cname in (None, category.name):
+                if cname in (None, cat.name):
                     category = cat
 
                     if cname is not None:
@@ -100,12 +95,9 @@ def pvalue(self, pname, cname=None, history=0):
         if category is None:
             raise NameError('Category {0} does not exist.'.format(cname))
 
-        elif history != 0:
-            category = categories[-history]
-
-        param = category[pname]
+        category = categories[- (history + 1)]
 
-        result = param.value
+        result = category[pname]
 
         return result
 

b3j0f/conf/model/param.py

@@ -28,7 +28,7 @@
 
 from __future__ import absolute_import
 
-__all__ = ['Parameter', 'PType']
+__all__ = ['Parameter', 'VType']
 
 from .base import ModelElement
 from ..parser.core import parse, serialize
@@ -44,7 +44,7 @@
 from copy import deepcopy
 
 
-class PType(object):
+class VType(object):
     """Dedicated to embed a specific type such as a parameter type in order to
     instanciate easily this embedded type from a parameter serialized value.
 
@@ -60,19 +60,19 @@ class PType(object):
 
     def __init__(self, _type, *args, **kwargs):
 
-        super(PType, self).__init__(*args, **kwargs)
+        super(VType, self).__init__(*args, **kwargs)
 
         self._type = _type
 
     def __instancecheck__(self, instance):
         """Check instance such as this instance or self _type instance."""
 
-        return isinstance(instance, (PType, self._type))
+        return isinstance(instance, (VType, self._type))
 
     def __subclasscheck__(self, subclass):
         """Check subclass such as this subclass or self _type subclass."""
 
-        return issubclass(subclass, (PType, self._type))
+        return issubclass(subclass, (VType, self._type))
 
     def __call__(self, svalue):
         """Instantiate a new instance of this _type related to input value.
@@ -126,8 +126,8 @@ class Parameter(ModelElement):
     """
 
     __slots__ = (
-        '_name', 'ptype', 'parser', '_svalue', '_value', '_error', 'conf',
-        'local', 'scope', 'configurable', 'serializer', 'besteffort'
+        '_name', 'vtype', 'parser', '_svalue', '_value', '_error', 'conf',
+        'local', 'scope', 'configurable', 'serializer', 'besteffort', 'safe'
     ) + ModelElement.__slots__
 
     class Error(Exception):
@@ -140,14 +140,14 @@ class Error(Exception):
     _PARAM_NAME_COMPILER_MATCHER = re_compile(PARAM_NAME_REGEX).match
 
     DEFAULT_NAME = re_compile('.*')
-    DEFAULT_VTYPE = object  #: default ptype.
+    DEFAULT_VTYPE = object  #: default vtype.
     DEFAULT_LOCAL = True  #: default local value.
     DEFAULT_BESTEFFORT = False  #: default best effort.
     DEFAULT_SAFE = True  #: default safe
     DEFAULT_SCOPE = None  #: default scope
 
     def __init__(
-            self, name=DEFAULT_NAME, ptype=DEFAULT_VTYPE, value=None,
+            self, name=DEFAULT_NAME, vtype=DEFAULT_VTYPE, value=None,
             parser=parse, serializer=serialize, svalue=None,
             conf=None, configurable=None,
             local=DEFAULT_LOCAL, scope=DEFAULT_SCOPE, safe=DEFAULT_SAFE,
@@ -161,7 +161,7 @@ def __init__(
                 common properties (parser, value, conf, etc.).
 
             Default is the regex ``.*``.
-        :param type ptype: parameter value type.
+        :param type vtype: parameter value type.
         :param callable parser: param value deserializer which takes in param a
             str. Default is the expression parser.
         :param callable serializer: param serializer which takes in param an
@@ -189,7 +189,7 @@ def __init__(
         # init public attributes
         self.parser = parser
         self.serializer = serializer
-        self.ptype = ptype
+        self.vtype = vtype
         self.conf = conf
         self.configurable = configurable
         self.local = local
@@ -236,12 +236,12 @@ def __hash__(self):
         return hash(self.name) + hash(Parameter)
 
     def __repr__(self):
-        """Display self name, value, svalue, ptype and error.
+        """Display self name, value, svalue, vtype and error.
 
         :rtype: str"""
 
         return 'Parameter({0}, {1}, {2}, {3}, {4})'.format(
-            self.name, self._value, self._svalue, self.ptype, self.error
+            self.name, self._value, self._svalue, self.vtype, self.error
         )
 
     @property
@@ -358,7 +358,7 @@ def resolve(
             self._error = None  # nonify error.
 
             if _type is None:
-                _type = self.ptype
+                _type = self.vtype
 
             if parser is None:  # init parser
                 parser = self.parser
@@ -411,7 +411,7 @@ def value(self):
         calculate the new value from the serialized one.
 
         :return: parameter value.
-        :raises: TypeError if serialized value is not an instance of self ptype
+        :raises: TypeError if serialized value is not an instance of self vtype
             . ParserError if parsing step raised an error.
         """
 
@@ -437,20 +437,20 @@ def value(self, value):
         If an error occured, it is stored in this error attribute.
 
         :param value: new value to use. If input value is not an instance of
-            self.ptype, self error
-        :raises: TypeError if input value is not an instance of self ptype.
+            self.vtype, self error
+        :raises: TypeError if input value is not an instance of self vtype.
         """
 
         if value is None or (
-                self.ptype is not None and isinstance(value, self.ptype)
+                self.vtype is not None and isinstance(value, self.vtype)
         ):
             self._value = value
 
         else:
             # raise wrong type error
             error = TypeError(
                 'Wrong value type of ({0}). {1} expected.'.format(
-                    value, self.ptype
+                    value, self.vtype
                 )
             )
             self._error = error
@@ -466,7 +466,7 @@ def copy(self, cleaned=False, *args, **kwargs):
         """
 
         props = (
-            'name', 'parser', 'local', 'ptype', 'conf', 'scope', 'besteffort'
+            'name', 'parser', 'local', 'vtype', 'conf', 'scope', 'besteffort'
         )
         for prop in props:
             kwargs.setdefault(prop, getattr(self, prop))

b3j0f/conf/model/test/param.py

@@ -35,53 +35,53 @@
 
 from b3j0f.utils.ut import UTCase
 
-from ..param import Parameter, PType
+from ..param import Parameter, VType
 from parser import ParserError
 
 
-class PTypeTest(UTCase):
-    """Test PType."""
+class VTypeTest(UTCase):
+    """Test VType."""
 
     def setUp(self):
 
-        self.ptype = PType(_type=Parameter)
+        self.vtype = VType(_type=Parameter)
 
     def test_isinstance(self):
         """Test if isinstance."""
 
-        self.assertIsInstance(Parameter(''), self.ptype)
+        self.assertIsInstance(Parameter(''), self.vtype)
 
-    def test_PTypeisinstance(self):
+    def test_VTypeisinstance(self):
         """Test isinstance of PTYpe."""
 
-        self.assertIsInstance(self.ptype, self.ptype)
+        self.assertIsInstance(self.vtype, self.vtype)
 
     def test_isnotinstance(self):
         """Test is not instance."""
 
-        self.assertNotIsInstance(None, self.ptype)
+        self.assertNotIsInstance(None, self.vtype)
 
     def test_issubclass(self):
         """Test is subclass."""
 
-        self.assertTrue(issubclass(Parameter, self.ptype))
+        self.assertTrue(issubclass(Parameter, self.vtype))
 
-    def test_PTypeissubclass(self):
-        """Test is subclass of PType."""
+    def test_VTypeissubclass(self):
+        """Test is subclass of VType."""
 
-        self.assertTrue(issubclass(PType, self.ptype))
+        self.assertTrue(issubclass(VType, self.vtype))
 
     def test_notissubclass(self):
         """Test is not subclass."""
 
-        self.assertFalse(issubclass(type(None), self.ptype))
+        self.assertFalse(issubclass(type(None), self.vtype))
 
     def test_instanciate(self):
         """Test to instanciate a parameter."""
 
         value = 'test'
 
-        param = self.ptype(value)
+        param = self.vtype(value)
 
         self.assertIsInstance(param, Parameter)
         self.assertEqual(value, param.name)
@@ -91,7 +91,7 @@ def test_instanciate_kwargs(self):
 
         value = {'name': 'test'}
 
-        param = self.ptype(value)
+        param = self.vtype(value)
 
         self.assertIsInstance(param, Parameter)
         self.assertEqual(value['name'], param.name)
@@ -101,7 +101,7 @@ def test_instanciate_args(self):
 
         value = ['test']
 
-        param = self.ptype(value)
+        param = self.vtype(value)
 
         self.assertIsInstance(param, Parameter)
         self.assertEqual(value[0], param.name)
@@ -111,15 +111,15 @@ def test_instanciate_object(self):
 
         svalue = 1
 
-        value = PType(str)(svalue)
+        value = VType(str)(svalue)
 
         self.assertIsInstance(value, str)
         self.assertEqual(value, str(1))
 
     def test_instanciateerror(self):
         """Test to instanciate with an error."""
 
-        self.assertRaises(ParserError, self.ptype, {'': None})
+        self.assertRaises(ParserError, self.vtype, {'': None})
 
 
 class ParameterTest(UTCase):

b3j0f/conf/parser/__init__.py

@@ -1,8 +1,8 @@
 
 __all__ = [
-	'parse', 'EXPR_PREFIX', 'serialize',
+	'parse', 'serialize',
 	'resolve', 'ExprResolver', 'register', 'names'
 ]
 
-from .core import parse, EXPR_PREFIX, serialize
+from .core import parse, serialize
 from .resolver import resolve, ExprResolver, names, register