always use a _PathPart object for all split paths

Author: ashafer01

README.md

@@ -27,5 +27,5 @@ _In development_: public API is not stable, support available solely at develope
   * An `InvalidIterationError` will be raised if these iterable path parts are passed to functions other than
     `iterate()`.
 * A `ValidationError` will be raised if the data structure does not match types of all path parts:
-  * Strings keys outside of square brackets MUST correspond to an object that subclasses `dict`
-  * Numerical indicies within square brackets MUST correspond to an object that subclasses `list`
+  * Strings keys (outside of square brackets) MUST correspond to an object that subclasses `dict`
+  * Numerical indicies (within square brackets) MUST correspond to an object that subclasses `list`

datapath/_base.py

@@ -15,11 +15,11 @@
     NO_DEFAULT,
     DatapathError,
     ValidationError,
-    TypeValidationError,
-    TypeMismatchValidationError,
     InvalidIterationError,
     PathLookupError,
-    _IterationPoint,
+    _PathPart,
+    _IndexPart,
+    _KeyPart,
     _ListIterationPoint,
     _StarIterationPoint,
     _RangeIterationPoint,
@@ -58,7 +58,7 @@ def is_path(path: str, iterable: bool = True) -> bool:
     if iterable:
         return True
     try:
-        _split_match(match, iterable=False)
+        _split_path_from_match(match, iterable=False)
         return True
     except ValidationError:
         return False
@@ -74,33 +74,42 @@ def validate_path(path: str, iterable: bool = True) -> None:
         return
     match = _match_validate(path)
     if not iterable:
-        _split_match(match, iterable=False)
+        _split_path_from_match(match, iterable=False)
 
 
 def split(path: str, iterable: bool = False) -> SplitPath:
     """inverse of join() -- split the path string to it's component keys/indexes in order"""
     if path == '':
         return ()
     match = _match_validate(path)
-    return _split_match(match, iterable)
+    return _split_path_from_match(match, iterable)
 
 
-def _split_match(match: re.Match, iterable: bool) -> SplitPath:
+def _split_path_from_match(match: re.Match, iterable: bool) -> SplitPath:
+    return _split_path_from_iterable(match.captures('part'), iterable)
+
+
+def _split_path_from_iterable(parts: Iterable[Key|_PathPart], iterable: bool) -> SplitPath:
     split_path: list[Key] = []
-    for part in match.captures('part'):
-        if part[0] == '[' and part[-1] == ']':
-            index = part[1:-1]
-            if ':' in index:
+    for part in parts:
+        if isinstance(part, _PathPart):
+            path_part = part
+        elif isinstance(part, int):
+            path_part = _IndexPart(f'[{part}]')
+        elif not isinstance(part, str):
+            raise ValidationError('path parts must be str or int')
+        elif part[0] == '[' and part[-1] == ']':
+            if ':' in part:
                 path_part = _RangeIterationPoint(part)
-            elif index:
-                path_part = int(index)
-            else:
+            elif part == '[]':
                 path_part = _ListIterationPoint(part)
+            else:
+                path_part = _IndexPart(part)
         elif '*' in part:
             path_part = _StarIterationPoint(part)
         else:
-            path_part = part
-        if not iterable and isinstance(path_part, _IterationPoint):
+            path_part = _KeyPart(part)
+        if not iterable and path_part.iterable:
             raise InvalidIterationError(f'iterable {path_part.name} {path_part} not allowed here')
         split_path.append(path_part)
     return tuple(split_path)
@@ -117,54 +126,22 @@ def join(split_path: Iterable[Key]) -> str:
     ```
     """
     path = ''
-    for i, part in enumerate(split_path):
-        if isinstance(part, str):
-            if path:
-                path = f'{path}.{part}'
-            else:
-                path = part
-        elif isinstance(part, int):
-            if path:
-                path = f'{path}[{part}]'
-            else:
-                path = f'[{part}]'
-        elif isinstance(part, _IterationPoint):
-            path = part.append_path(path)
-        else:
-            raise ValidationError(f'index {i} is invalid, must be str/int or iteration point, '
-                                  f'got {type(part).__name__}')
+    for i, part in enumerate(_split_path_from_iterable(split_path, True)):
+        path = part.append_path(path)
     return path
 
 
-def _validate_key_collection_type(obj: Collection, key: Key) -> None:
-    """
-    validate a collection object and key are valid and corresponding types
-    raise a ValidationError if they are not
-    """
-    if isinstance(key, _IterationPoint):
-        raise TypeError('bug: iteration not supported here')
-    if not isinstance(obj, _collection_types):
-        raise TypeValidationError('object must be list/dict')
-    if not isinstance(key, _key_types):
-        raise TypeValidationError('path parts must all be str or int')
-    if isinstance(key, int) and not isinstance(obj, list):
-        raise TypeMismatchValidationError(f'int key requires list, got {type(obj).__name__}')
-    if isinstance(key, str) and not isinstance(obj, dict):
-        raise TypeMismatchValidationError(f'str key requires dict, got {type(obj).__name__}')
-
-
-def _contextual_validate_key_collection_type(at_path: list[Key],
-                                             obj: Collection,
-                                             key: Key) -> None:
+def _check_collection_for_path_part(at_path: list[_PathPart], path_part: _PathPart, obj: Collection) -> None:
     """
     validate_key_collection_type(), except the path where the error occurred is prepended
     to the exception message
     """
-    at_path.append(key)
+    if path_part.iterable:
+        raise RuntimeError('bug: iteration not supported here')
     try:
-        _validate_key_collection_type(obj, key)
+        path_part.check(obj)
     except ValidationError as e:
-        raise type(e)(f'{join(at_path)}: {e}') from None
+        raise ValidationError(f'{join(at_path)}: {e}') from None
 
 
 def leaf(obj: Collection, path: str) -> CollectionKey:
@@ -174,16 +151,17 @@ def leaf(obj: Collection, path: str) -> CollectionKey:
 
 def _leaf(obj: Collection, split_path: SplitPath) -> CollectionKey:
     """leaf() on an already-split path"""
-    at_path: list[Key] = []
-    for key in split_path[:-1]:
-        _contextual_validate_key_collection_type(at_path, obj, key)
+    at_path: list[_PathPart] = []
+    for path_part in split_path[:-1]:
+        _check_collection_for_path_part(at_path, path_part, obj)
         try:
-            obj = obj[key]
+            obj = obj[path_part.key]
+            at_path.append(path_part)
         except LookupError:
-            raise PathLookupError(f'{join(at_path[:-1])}: could not find key/index {key!r}') from None
-    leaf_key = split_path[-1]
-    _contextual_validate_key_collection_type(at_path, obj, leaf_key)
-    return obj, leaf_key
+            raise PathLookupError(f'{join(at_path)}: could not find key/index {path_part.key!r}') from None
+    leaf_path_part = split_path[-1]
+    _check_collection_for_path_part(at_path, leaf_path_part, obj)
+    return obj, leaf_path_part.key
 
 
 def get(obj: Collection, path: str, default: Any = NO_DEFAULT) -> Any:
@@ -196,7 +174,7 @@ def get(obj: Collection, path: str, default: Any = NO_DEFAULT) -> Any:
     return _get(obj, split(path), default)
 
 
-def _get(obj: Collection, split_path: str, default: Any = NO_DEFAULT) -> Any:
+def _get(obj: Collection, split_path: SplitPath, default: Any = NO_DEFAULT) -> Any:
     """get() on an already-split path"""
     if not split_path:
         return obj
@@ -253,7 +231,7 @@ def _iterate(obj: Collection,
     iter_index = None
     iter_point = None
     for index, part in enumerate(split_path):
-        if isinstance(part, _IterationPoint):
+        if part.iterable:
             iter_index = index
             iter_point = part
             break

datapath/collection.py

@@ -53,7 +53,7 @@ def __getitem__(self, key: Key) -> Any:
             return self.get(key)
         if isinstance(key, int) and isinstance(self.root, list):
             return self.root[key]
-        raise TypeError('unsupported key type')
+        raise ValueError('unsupported key type')
 
     def iterate(self, path: str, default: Any = NO_DEFAULT, wrap: bool = NO_DEFAULT) -> Generator[tuple[str, Any], None, None]:
         """identical to iterate() for the wrapped root object

datapath/folding.py

@@ -14,6 +14,9 @@
     PathDict,
     RootPathDict,
     ValidationError,
+    _IndexPart,
+    _KeyPart,
+    InvalidIterationError,
 )
 
 
@@ -93,22 +96,24 @@ def unfold_path_dict(paths: PathDict,
                 continue
             did_any = True
             parent = join(split_path[:-1])
-            key = split_path[-1]
-            if isinstance(key, int):
+            path_part = split_path[-1]
+            if isinstance(path_part, _IndexPart):
                 default_collection: PartialList = []
-            elif isinstance(key, str):
+            elif isinstance(path_part, _KeyPart):
                 default_collection: Map = {}
+            elif path_part.iterable:
+                raise InvalidIterationError('iteration not supported here')
             else:
                 raise TypeError('bug: unsupported path part type')
             collection: PartialCollection = path_dict.setdefault(parent, default_collection)
             value = path_dict.pop(path)
-            if isinstance(key, int) and isinstance(collection, list):
-                collection.append((key, value))
-            elif isinstance(key, str) and isinstance(collection, dict):
-                collection[key] = value
+            if isinstance(default_collection, list) and isinstance(collection, list):
+                collection.append((path_part.key, value))
+            elif isinstance(default_collection, dict) and isinstance(collection, dict):
+                collection[path_part.key] = value
             else:
                 raise ValidationError(f'unsupported/inconsistent types: parent {parent!r} '
-                                      f'has type {type(collection).__name__} key/index {key!r}')
+                                      f'has type {type(collection).__name__} for key/index {path_part.key!r}')
         if not did_any:
             path_length -= 1
             if complete_intermediates: