partis-pyproj 0.1.4__py3-none-any.whl → 0.1.6__py3-none-any.whl

{partis_pyproj-0.1.4.data → partis_pyproj-0.1.6.data}/purelib/partis/pyproj/validate.py

@@ -1,25 +1,23 @@
+from __future__ import annotations
 import sys
-import os.path as osp
-import io
 import warnings
-import stat
-import re
-import pathlib
+from functools import partial
 import inspect
 import types
 from copy import copy
+from abc import ABCMeta
 from collections.abc import (
   Mapping,
   Sequence,
   Iterable )
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 # NOTE: Filtering works by changing the traceback linked-list, which means
 # writing to the 'tb_next' attrbute to the next frame not to be skipped.
 # However, 'tb_next' was a read-only attribute until Python 3.7
 FILTER_VALIDATING_FRAMES = sys.version_info >= (3,7)
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 def filter_traceback(traceback, ignore):
   # NOTE: always keep the first frame in the trace-back (even if it would be filtered)
   cur_tb = traceback
@@ -44,18 +42,18 @@ def filter_traceback(traceback, ignore):
     else:
       prev_kept_tb = cur_tb
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 def ignore_validating(frame, lineno):
   if frame.f_code.co_filename == __file__:
     return True
 
   return False
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 class ValidationWarning( RuntimeWarning ):
   pass
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 class ValidationError( ValueError ):
   """General validation error
 
@@ -130,27 +128,27 @@ class ValidationError( ValueError ):
         filename = self.doc_file,
         path = self.doc_path ))
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 class RequiredValueError( ValidationError ):
   pass
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 class ValidDefinitionError( ValidationError ):
   pass
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 class ValidPathError(ValidationError):
   """File is not valid
   """
   pass
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 class FileOutsideRootError(ValidPathError):
   """File path is outside a desired root directory
   """
   pass
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 class validating:
   """Context manager to append information to a ValidationError as it propagates
 
@@ -200,7 +198,7 @@ class validating:
 
       else:
         raise ValidationError(
-          f"Error while validating",
+          "Error while validating",
           doc_root = self.root,
           doc_file = self.file,
           doc_path = None if self.key is None else [self.key] ) from value
@@ -208,15 +206,11 @@ class validating:
     # do not handle any exceptions here
     return False
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 class Special:
-  #-----------------------------------------------------------------------------
-  def __str__(self):
-    return type(self).__name__
-
   #-----------------------------------------------------------------------------
   def __repr__(self):
-    return str(self)
+    return type(self).__name__
 
   #-----------------------------------------------------------------------------
   def __eq__(self, other):
@@ -230,25 +224,25 @@ class Special:
   def __hash__(self):
     return hash(str(self))
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 class Optional(Special):
   """Optional value
   """
   pass
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 class OptionalNone(Special):
   """Optional value, but is set to None if not initially set
   """
   pass
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 class Required(Special):
   """Required value
   """
   pass
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 class NotSet(Special):
   """Special value indicating a value is not set
   """
@@ -259,7 +253,7 @@ OPTIONAL_NONE = OptionalNone()
 REQUIRED = Required()
 NOTSET = NotSet()
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 def validate(val, default, validators):
   """Internal method to apply default value and validators
   """
@@ -274,7 +268,7 @@ def validate(val, default, validators):
       return None if default == OPTIONAL_NONE else val
 
     elif default == REQUIRED:
-      raise RequiredValueError(f"Value is required")
+      raise RequiredValueError("Value is required")
 
     else:
       val = default
@@ -318,7 +312,7 @@ def validate(val, default, validators):
 
   return val
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 def fmt_validator(v):
 
   if isinstance(v, Validator):
@@ -360,10 +354,12 @@ def fmt_validator(v):
 
   return f"<{name}>"
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 class Validator:
   """Validates a value
   """
+  __slots__ = ('default', 'validators')
+
   #-----------------------------------------------------------------------------
   def __init__(self, *args, default = NOTSET):
 
@@ -400,7 +396,7 @@ class Validator:
           except Exception as e:
             # the type cannot be instantiated without arguments
             raise ValidDefinitionError(
-              f"Default value must be specified, or explicitly set as optional or required") from e
+              "Default value must be specified, or explicitly set as optional or required") from e
 
         else:
           # cannot be used as default, put back to use as validator
@@ -415,16 +411,16 @@ class Validator:
       # convenience method to used default value to derive type
       args.append(type(default))
 
-    self._default = default
-    self._validators = args
+    self.default = default
+    self.validators = tuple(args)
 
   #-----------------------------------------------------------------------------
   def __str__(self):
     args = list()
-    for v in self._validators:
+    for v in self.validators:
       args.append(fmt_validator(v))
 
-    args.append(f"default = {fmt_validator(self._default)}")
+    args.append(f"default = {fmt_validator(self.default)}")
     args = ', '.join(args)
     return f"{type(self).__name__}({args})"
 
@@ -434,16 +430,18 @@ class Validator:
 
   #-----------------------------------------------------------------------------
   def __call__(self, val = NOTSET):
-    return validate(val, self._default, self._validators)
+    return validate(val, self.default, self.validators)
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 class Restricted(Validator):
   """Restricts a value to one of listed options
   """
+  __slots__ = ('options',)
+
   #-----------------------------------------------------------------------------
   def __init__(self, *options ):
     if len(options) == 0:
-      raise ValidDefinitionError(f"Must have at least one option")
+      raise ValidDefinitionError("Must have at least one option")
 
     super().__init__(options[0], type(options[0]))
 
@@ -454,19 +452,19 @@ class Restricted(Validator):
         with validating(key = i):
           _options.append(super().__call__(v))
 
-    self._options = set(_options)
+    self.options = set(_options)
 
   #-----------------------------------------------------------------------------
   def __call__(self, val):
     val = super().__call__(val)
 
-    if val not in self._options:
+    if val not in self.options:
       raise ValidationError(
-        f"Must be one of {self._options}: {val}")
+        f"Must be one of {self.options}: {val}")
 
     return val
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 def valid(*validators, default = NOTSET):
   """Casts list of objects to Validator, if needed
   """
@@ -478,19 +476,19 @@ def valid(*validators, default = NOTSET):
 
   return Validator(*validators, default = default)
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 def union(*validators):
   """Value must pass at least one of listed validators
   """
   return Validator([valid(v) for v in validators], default = REQUIRED)
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 def restrict(*options):
   """Restricts a value to one of listed options
   """
   return Restricted(*options)
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 def valid_type(
   obj,
   types ):
@@ -502,7 +500,7 @@ def valid_type(
   raise ValidationError(
     f"Must be of type {types}: {type(obj)}" )
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 def valid_keys(
   obj,
   key_valid = None,
@@ -560,7 +558,7 @@ def valid_keys(
   def copy_once(out):
     if out is obj:
       # copy only if 'out' is still the same object as obj
-      return dict(obj)
+      return copy(obj)
 
     return out
 
@@ -705,110 +703,209 @@ def valid_keys(
 
   return out
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-class validating_block:
-  def __init__(self, obj):
-    self._obj = obj
+#===============================================================================
+class _ValidDictAttr:
+  r"""Descriptor for accessing dictionary keys as attributes
+  """
+  __slots__ = ('name', 'key')
 
-  def __enter__(self):
-    self._obj._validating = True
+  #-----------------------------------------------------------------------------
+  def __init__(self, name: str, key: str):
+    self.name = name
+    self.key = key
 
-  def __exit__(self, type, value, traceback):
-    self._obj._validating = False
+  #-----------------------------------------------------------------------------
+  def __get__(self, obj, owner):
+    if obj is None:
+      return self
 
-    # do not handle any exceptions here
-    return False
+    return obj._data[self.key]
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-def attrs_modifiable( obj ):
-  return (
-    not hasattr( obj, '_p_attrs_modify' )
-    or obj._p_attrs_modify )
+  #-----------------------------------------------------------------------------
+  def __set__(self, obj, value):
+    obj._data[self.key] = value
+    obj._validate()
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-class attrs_modify:
   #-----------------------------------------------------------------------------
-  def __init__( self, obj ):
-    self._obj = obj
+  def __delete__(self, obj):
+    del obj._data[self.key]
+    obj._validate()
 
   #-----------------------------------------------------------------------------
-  def __enter__(self):
-    self._obj._p_attrs_modify = True
+  def __repr__(self):
+    return f"{type(self).__name__}({self.name!r}, {self.key!r})"
 
+#===============================================================================
+class _ValidDictMeta(ABCMeta):
   #-----------------------------------------------------------------------------
-  def __exit__(self, type, value, traceback):
-    self._obj._p_attrs_modify = False
+  def __new__(mcls,
+      name,
+      bases,
+      namespace):
+
+    schema_keys = (
+      'key_valid',
+      'value_valid',
+      'item_valid',
+      'allow_keys',
+      'require_keys',
+      'min_keys',
+      'wedge_keys',
+      'mutex_keys',
+      'deprecate_keys',
+      'forbid_keys',
+      'default',
+      'proxy_keys')
+
+    schema = {}
+
+    for base in bases:
+      # include options from base classes
+      if isinstance(base, _ValidDictMeta):
+        for k in schema_keys:
+          v = base.__dict__.get(k)
+
+          if v is not None:
+            schema[k] = v
+
+    for k in schema_keys:
+      v = namespace.get(k)
+
+      if v is not None:
+        schema[k] = v
+
+    namespace.update(schema)
+
+    validator = schema.get('validator')
+    key_valid = schema.get('key_valid')
+    value_valid = schema.get('value_valid')
+    item_valid = schema.get('item_valid')
+    allow_keys = schema.get('allow_keys')
+    require_keys = schema.get('require_keys')
+    min_keys = schema.get('min_keys')
+    wedge_keys = schema.get('wedge_keys')
+    mutex_keys = schema.get('mutex_keys')
+    deprecate_keys = schema.get('deprecate_keys')
+    forbid_keys = schema.get('forbid_keys')
+    default = schema.get('default')
+    proxy_keys = schema.get('proxy_keys')
+
+    default = {
+      k: valid(v)
+      for k,v in (default or dict()).items()}
+    all_keys = list()
+
+    all_keys.extend(allow_keys or ())
+    all_keys.extend(require_keys or ())
+    all_keys.extend(default.keys())
+
+    if deprecate_keys:
+      all_keys.extend([
+          k_new
+          for k_old, k_new in deprecate_keys
+          if k_new not in [None, OPTIONAL, OPTIONAL_NONE, REQUIRED]])
+
+    if min_keys:
+      for keys in min_keys:
+        all_keys.extend(keys)
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-class valid_dict(Mapping):
+    if wedge_keys:
+      for keys in wedge_keys:
+        all_keys.extend(keys)
+
+    if mutex_keys:
+      for keys in mutex_keys:
+        all_keys.extend(keys)
+
+    all_keys = tuple(all_keys)
+
+    # compose validator with parameterized valid_keys method
+    validator = valid(
+      validator or (lambda v: v),
+      partial(valid_keys,
+        key_valid = key_valid,
+        value_valid = value_valid,
+        item_valid = item_valid,
+        allow_keys = allow_keys,
+        require_keys = require_keys,
+        min_keys = min_keys,
+        wedge_keys = wedge_keys,
+        mutex_keys = mutex_keys,
+        deprecate_keys = deprecate_keys,
+        forbid_keys = forbid_keys,
+        default = default,
+        proxy_keys = proxy_keys))
+
+    namespace['_all_keys'] = all_keys
+    namespace['_validator'] = validator
+    namespace.setdefault('__slots__', ())
+
+    for k in all_keys:
+      # create attributes mapping to dictionary keys
+      name = k.replace('-','_')
+      attr = _ValidDictAttr(name, k)
+      namespace[name] = attr
+
+    cls = super().__new__(mcls, name, bases, namespace)
+
+    return cls
+
+#===============================================================================
+class valid_dict(Mapping, metaclass = _ValidDictMeta):
   """Validated Mapping
 
   Attributes
   ----------
-  _proxy_key: None | str
+  proxy_key: None | str
     If initialized with a value that is not a Mapping, this key is assigned the
     value before performing validation.
-  _key_valid: None | callable
+  key_valid: None | callable
     Validates all keys
-  _value_valid: None | callable
+  value_valid: None | callable
     Validates all values
-  _item_valid: None | callable
+  item_valid: None | callable
     Validates all (key,value) pairs
-  _allow_keys: None | list[str]
+  allow_keys: None | list[str]
     Mapping may not contain keys that are not listed.
-  _require_keys: None | list[str]
+  require_keys: None | list[str]
     Mapping must contain all listed keys.
-  _min_keys: None | list[ list[str] ]
+  min_keys: None | list[ list[str] ]
     Mapping must contain at least one key from each list.
-  _wedge_keys: None | list[ list[str] ]
+  wedge_keys: None | list[ list[str] ]
     Mapping must contain either none or all of the listed keys.
-  _mutex_keys: None | list[ list[str] ]
+  mutex_keys: None | list[ list[str] ]
     Mapping may contain at most one key from each list.
-  _deprecate_keys: None | list[ (str, None | str | Required) ]
+  deprecate_keys: None | list[ (str, None | str | Required) ]
     First key is marked as deprecated and removed from the Mapping.
     If new key is given, the value is remapped to the new key.
     If new key is Required, an error is raised, otherwise a deprecation warning
     is reported.
-  _forbid_keys: None | list[str]
+  forbid_keys: None | list[str]
     Mapping must not contain any of the listed keys.
-  _default: None | Mapping[object, object | type | Validator]
+  default: None | Mapping[object, object | type | Validator]
     Default value or validator for given keys.
-  _validator : None | Validator
+  validator : None | Validator
     General validator for entire Mapping after above constraints are satisfied.
   See Also
   --------
   * :func:`valid_keys`
   """
-
-  _proxy_key = None
-  _proxy_keys = None
-  _key_valid = None
-  _value_valid = None
-  _item_valid = None
-  _allow_keys = None
-  _require_keys = None
-  _min_keys = None
-  _wedge_keys = None
-  _mutex_keys = None
-  _deprecate_keys = None
-  _forbid_keys = None
-  _default = None
-  _validator = None
-
-  # internal
-  _p_all_keys = list()
-
-  #-----------------------------------------------------------------------------
-  def __new__( cls, *args, **kwargs ):
-
-    self = super().__new__( cls )
-    self._p_attrs_modify = False
-
-    with attrs_modify( self ):
-      self._p_dict = dict()
-      self._p_key_attr = dict()
-
-    return self
+  __slots__ = ('_data',)
+
+  proxy_key = None
+  proxy_keys = None
+  key_valid = None
+  value_valid = None
+  item_valid = None
+  allow_keys = None
+  require_keys = None
+  min_keys = None
+  wedge_keys = None
+  mutex_keys = None
+  deprecate_keys = None
+  forbid_keys = None
+  default = None
+  validator = None
 
   #---------------------------------------------------------------------------#
   # pylint: disable-next=E0602
@@ -822,224 +919,132 @@ class valid_dict(Mapping):
 
       v = args[0]
 
-      if v in [None, OPTIONAL, OPTIONAL_NONE]:
+      if v in (None, OPTIONAL, OPTIONAL_NONE):
         args = [dict()]
-      elif cls._proxy_key:
-        args = [{ cls._proxy_key : v }]
-
-    self._p_dict = dict(*args, **kwargs)
-
-    with attrs_modify( self ):
-      self._default = { k: valid(v) for k,v in ( cls._default or dict() ).items() }
-      self._validator = valid(cls._validator or (lambda v: v))
 
-      self._p_all_keys = list()
-      self._validating = False
+      elif cls.proxy_key:
+        args = [{ cls.proxy_key : v }]
 
-    self._p_all_keys.extend( self._allow_keys or [] )
-    self._p_all_keys.extend( self._require_keys or [] )
-    self._p_all_keys.extend( self._default.keys() )
-
-    if self._deprecate_keys:
-      for keys in self._deprecate_keys:
-        self._p_all_keys.extend( [
-            k_new
-            for k_old, k_new in self._deprecate_keys
-            if k_new not in [None, OPTIONAL, OPTIONAL_NONE, REQUIRED] ] )
+    self._data = dict(*args, **kwargs)
+    self._validate()
 
-    if self._min_keys:
-      for keys in self._min_keys:
-        self._p_all_keys.extend(keys)
+  #-----------------------------------------------------------------------------
+  def __eq__(self, other):
+    if isinstance(other, valid_dict):
+      other = other._data
 
-    if self._wedge_keys:
-      for keys in self._wedge_keys:
-        self._p_all_keys.extend(keys)
+    return self._data.__eq__(other)
 
-    if self._mutex_keys:
-      for keys in self._mutex_keys:
-        self._p_all_keys.extend(keys)
+  #-----------------------------------------------------------------------------
+  def __ne__(self, other):
+    if isinstance(other, valid_dict):
+      other = other._data
 
-    self._p_key_attr = { k.replace('-','_') : k for k in self._p_all_keys }
-    self._validate()
+    return self._data.__ne__(other)
 
   #-----------------------------------------------------------------------------
   def __copy__(self):
-    obj = copy(super())
-    obj._p_dict = copy(self._p_dict)
+    cls = type(self)
+    obj = cls.__new__(cls)
+    obj._data = copy(self._data)
     return obj
 
   #-----------------------------------------------------------------------------
   def __str__(self):
-    return str(self._p_dict)
+    return str(self._data)
 
   #-----------------------------------------------------------------------------
   def __repr__(self):
-    return str(self._p_dict)
+    return repr(self._data)
 
   #-----------------------------------------------------------------------------
-  def __len__( self ):
-    return len(self._p_dict)
+  def __len__(self):
+    return len(self._data)
 
   #-----------------------------------------------------------------------------
-  def __iter__( self ):
-    return iter(self._p_dict)
+  def __iter__(self):
+    return iter(self._data)
 
   #-----------------------------------------------------------------------------
-  def keys( self ):
-    return self._p_dict.keys()
+  def __contains__(self, name):
+    return self._data.__contains__(name)
 
   #-----------------------------------------------------------------------------
-  def values( self ):
-    return self._p_dict.values()
+  def keys(self):
+    return self._data.keys()
 
   #-----------------------------------------------------------------------------
-  def items( self ):
-    return self._p_dict.items()
+  def values(self):
+    return self._data.values()
 
   #-----------------------------------------------------------------------------
-  def clear( self ):
-    self._p_dict.clear()
+  def items(self):
+    return self._data.items()
+
+  #-----------------------------------------------------------------------------
+  def clear(self):
+    self._data.clear()
     self._validate()
 
   #---------------------------------------------------------------------------#
   def update(self, *args, **kwargs ):
-    self._p_dict.update(*args, **kwargs)
+    self._data.update(*args, **kwargs)
     self._validate()
 
   #-----------------------------------------------------------------------------
   def setdefault( self, *args, **kwargs ):
-    val = self._p_dict.setdefault(*args, **kwargs)
+    val = self._data.setdefault(*args, **kwargs)
     self._validate()
     return val
 
   #-----------------------------------------------------------------------------
   def get( self, *args, **kwargs ):
-    return self._p_dict.get(*args, **kwargs)
+    return self._data.get(*args, **kwargs)
 
   #-----------------------------------------------------------------------------
   def pop( self, *args, **kwargs ):
-    val = self._p_dict.pop(*args, **kwargs)
+    val = self._data.pop(*args, **kwargs)
+    self._validate()
+    return val
+
+  #-----------------------------------------------------------------------------
+  def popitem( self, *args, **kwargs ):
+    val = self._data.popitem(*args, **kwargs)
     self._validate()
     return val
 
   #-----------------------------------------------------------------------------
   def __getitem__( self, key ):
-    return self._p_dict.__getitem__(key)
+    return self._data.__getitem__(key)
 
   #-----------------------------------------------------------------------------
   def __setitem__( self, key, val ):
-    self._p_dict.__setitem__(key, val)
+    self._data.__setitem__(key, val)
     self._validate()
 
   #-----------------------------------------------------------------------------
   def __delitem__( self, key ):
-    self._p_dict.__delitem__( key )
+    self._data.__delitem__( key )
     self._validate()
 
-  #-----------------------------------------------------------------------------
-  def __setattr__( self, name, val ):
-
-    try:
-
-      if name != '_p_attrs_modify' and not attrs_modifiable( self ):
-        # only set mapping if base object doesn't have the attribute
-        super().__getattribute__(name)
-
-        if name in self._p_key_attr:
-          warnings.warn(f"'{type(self).__name__}' attribute shadows mapping key: {name}")
-
-      object.__setattr__( self, name, val )
-      return
-
-    except AttributeError as e:
-      pass
-
-    if name != '_p_dict' and name != '_p_key_attr':
-      if name in self._p_dict:
-        self._p_dict[ name ] = val
-        self._validate()
-        return
-
-      if name in self._p_key_attr:
-        self._p_dict[ self._p_key_attr[name] ] = val
-        self._validate()
-        return
-
-    raise AttributeError(
-      f"'{type(self).__name__}' object has no key '{name}'."
-      " New keys must be added using a Mapping method;"
-      f" E.G. x['{name}'] = {val}" )
-
-
-  #-----------------------------------------------------------------------------
-  def __getattribute__( self, name ):
-
-    try:
-      val = super().__getattribute__(name)
-
-      if name != '_p_dict' and name != '_p_key_attr' and name in self._p_key_attr:
-        warnings.warn(f"'{type(self).__name__}' attribute shadows mapping key: {name}")
-
-      return val
-
-    except AttributeError as e:
-      pass
-
-    # only get mapping if base object does not have attribute
-    if name != '_p_dict' and name != '_p_key_attr':
-      if name in self._p_dict:
-        return self._p_dict[ name ]
-
-      if name in self._p_key_attr:
-        return self._p_dict[ self._p_key_attr[name] ]
-
-    raise AttributeError(
-      f"'{type(self).__name__}' object has no key '{name}'")
-
-
   #-----------------------------------------------------------------------------
   def _validate(self):
-    if self._validating:
-      return
-
-    with validating_block(self):
-      self.update( **self._validator( valid_keys(
-        self._p_dict,
-        key_valid = self._key_valid,
-        value_valid = self._value_valid,
-        item_valid = self._item_valid,
-        allow_keys = self._allow_keys,
-        require_keys = self._require_keys,
-        min_keys = self._min_keys,
-        wedge_keys = self._wedge_keys,
-        mutex_keys = self._mutex_keys,
-        deprecate_keys = self._deprecate_keys,
-        forbid_keys = self._forbid_keys,
-        default = self._default,
-        proxy_keys = self._proxy_keys ) ) )
-
-  #-----------------------------------------------------------------------------
-  def __str__(self):
-    return str(self._p_dict)
-
-  #-----------------------------------------------------------------------------
-  def __repr__(self):
-    return str(self)
+    self._data = self._validator(self._data)
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 class valid_list(list):
   """Validated list
   """
   _as_list = None
-  _value_valid = None
+  value_valid = None
   _min_len = 0
 
   #---------------------------------------------------------------------------#
   def __init__( self, vals = None ):
     cls = type(self)
     self._as_list = cls._as_list or list
-    self._value_valid = valid(
-      cls._value_valid or (lambda v: v))
+    self.value_valid = valid(
+      cls.value_valid or (lambda v: v))
 
     if vals is None:
       vals = list()
@@ -1049,13 +1054,13 @@ class valid_list(list):
 
     for i,v in enumerate(vals):
       with validating(key = i):
-        vals[i] = self._value_valid(v)
+        vals[i] = self.value_valid(v)
 
     super().__init__(vals)
     self._validate()
 
   #-----------------------------------------------------------------------------
-  def clear( self ):
+  def clear(self):
     super().clear()
     self._validate()
 
@@ -1068,7 +1073,7 @@ class valid_list(list):
   #---------------------------------------------------------------------------#
   def append(self, val ):
     with validating(key = len(self)):
-      val = self._value_valid(val)
+      val = self.value_valid(val)
 
     super().append(val)
 
@@ -1078,14 +1083,14 @@ class valid_list(list):
 
     for i,v in enumerate(vals):
       with validating(key = len(self) + i):
-        vals[i] = self._value_valid(v)
+        vals[i] = self.value_valid(v)
 
     super().extend(vals)
 
   #-----------------------------------------------------------------------------
   def __setitem__( self, key, val ):
     with validating(key = key):
-      val = self._value_valid(val)
+      val = self.value_valid(val)
 
     super().__setitem__(key, val)
 
@@ -1094,7 +1099,7 @@ class valid_list(list):
     if len(self) < self._min_len:
       raise ValidationError(f"Must have length >= {self._min_len}: {len(self)}")
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 def mapget(
   obj,
   path,
@@ -1124,7 +1129,7 @@ def mapget(
 
   return _obj
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 def as_list(obj):
   if isinstance(obj, (str, Mapping)) or not isinstance(obj, Iterable):
     return [obj]