Frozen paths

pathable/accessors.py

@@ -32,6 +32,11 @@ class NodeAccessor(Generic[N, K, V]):
     def __init__(self, node: N):
         self.node = node
 
+    def __eq__(self, other: object) -> Any:
+        if not isinstance(other, NodeAccessor):
+            return NotImplemented
+        return self.node == other.node
+
     def stat(self, parts: Sequence[K]) -> dict[str, Any]:
         raise NotImplementedError
 

pathable/paths.py

@@ -2,18 +2,19 @@
 import warnings
 from collections.abc import Hashable
 from collections.abc import Iterator
-from collections.abc import Mapping
 from contextlib import contextmanager
+from dataclasses import dataclass
+from functools import cached_property
 from typing import Any
 from typing import Generic
+from typing import Optional
 from typing import Sequence
 from typing import Type
 from typing import TypeVar
 from typing import Union
 
 from pathable.accessors import NodeAccessor
 from pathable.accessors import LookupAccessor
-from pathable.dataclasses import BasePathData
 from pathable.parsers import SEPARATOR
 from pathable.parsers import parse_args
 from pathable.types import LookupNode
@@ -24,40 +25,35 @@
 TLookupPath = TypeVar("TLookupPath", bound="LookupPath")
 
 
-class BasePath(BasePathData):
+@dataclass(frozen=True, init=False)
+class BasePath:
     """Base path."""
+    parts: tuple[Hashable, ...]
+    separator: str = SEPARATOR
 
-    def __init__(self, *args: Any, **kwargs: Any):
+    def __init__(self, *args: Any, separator: Optional[str] = None):
         parts = parse_args(list(args))
-        separator = kwargs.pop("separator", SEPARATOR)
-        super().__init__(parts, separator=separator)
-
-        self._cparts_cached: Union[tuple[str, ...], None] = None
+        object.__setattr__(self, 'parts', parts)
+        object.__setattr__(self, 'separator', separator or self.separator)
 
     @classmethod
     def _from_parts(
-        cls: Type[TBasePath], args: Sequence[Any], separator: str = SEPARATOR
+        cls: Type[TBasePath], args: Sequence[Any], separator: Optional[str] = None
     ) -> TBasePath:
-        self = cls(separator=separator)
-        self.parts = parse_args(args)
-        return self
+        return cls(*args, separator=separator)
 
     @classmethod
     def _from_parsed_parts(
-        cls: Type[TBasePath], parts: tuple[Hashable, ...], separator: str = SEPARATOR
-    ) -> TBasePath:
-        self = cls(separator=separator)
-        self.parts = parts
-        return self
-
-    @property
+        cls: Type[TBasePath], parts: tuple[Hashable, ...], separator: Optional[str] = None,
+    ) -> "TBasePath":
+        instance = cls.__new__(cls)
+        object.__setattr__(instance, 'parts', parts)
+        object.__setattr__(instance, 'separator', separator or instance.separator)
+        return instance
+
+    @cached_property
     def _cparts(self) -> tuple[str, ...]:
         # Cached casefolded parts, for hashing and comparison
-        if self._cparts_cached is None:
-            self._cparts_cached = self._get_cparts()
-        return self._cparts_cached
-
-    def _get_cparts(self) -> tuple[str, ...]:
         return tuple(str(p) for p in self.parts)
 
     def _make_child(self: TBasePath, args: list[Any]) -> TBasePath:
@@ -124,37 +120,26 @@ def __ge__(self, other: Any) -> bool:
 
 class AccessorPath(BasePath, Generic[TNodeAccessor]):
     """Path for object that can be read by accessor."""
-    node_accessor_cls: type[TNodeAccessor] = NotImplemented
+    accessor: TNodeAccessor
 
-    def __init__(self, accessor: TNodeAccessor, *args: Any, **kwargs: Any):
-        separator = kwargs.pop("separator", SEPARATOR)
+    def __init__(self, accessor: TNodeAccessor, *args: Any, separator: Optional[str] = None):
+        object.__setattr__(self, 'accessor', accessor)
         super().__init__(*args, separator=separator)
-        self.accessor = accessor
-
-        self._content_cached: Any = None
-
-    @classmethod
-    def _from_node(
-        cls: Type[TAccessorPath],
-        node: Any,
-        *args: Any,
-        **kwargs: Any,
-    ) -> TAccessorPath:
-        accessor = cls.node_accessor_cls(node)
-        return cls(accessor, *args, **kwargs)
 
     @classmethod
     def _from_parsed_parts(
         cls: Type[TAccessorPath],
         parts: tuple[Hashable, ...],
-        separator: str = SEPARATOR,
+        separator: Optional[str] = None,
         accessor: Union[TNodeAccessor, None] = None,
     ) -> TAccessorPath:
         if accessor is None:
             raise ValueError("accessor must be provided")
-        self = cls(accessor, separator=separator)
-        self.parts = parts
-        return self
+        instance = cls.__new__(cls)
+        object.__setattr__(instance, 'parts', parts)
+        object.__setattr__(instance, 'separator', separator or instance.separator)
+        object.__setattr__(instance, 'accessor', accessor)
+        return instance
 
     def _make_child(self: TAccessorPath, args: list[Any]) -> TAccessorPath:
         parts = parse_args(args, self.separator)
@@ -260,7 +245,6 @@ def read_value(self) -> Any:
 
 class LookupPath(AccessorPath[LookupAccessor]):
     """Path for object that supports __getitem__ lookups."""
-    node_accessor_cls = LookupAccessor
 
     @classmethod
     def _from_lookup(

tests/unit/test_paths.py

@@ -17,6 +17,7 @@ class MockAccessor(NodeAccessor[Union[Mapping[Hashable, Any], Any], Hashable, An
     """Mock accessor."""
 
     def __init__(self, *children_keys: str, content: Any = None, exists: bool = False):
+        super().__init__(None)
         self._children_keys = children_keys
         self._content = content
         self._exists = exists
@@ -31,6 +32,19 @@ def read(self, parts: list[Hashable]) -> Union[Mapping[Hashable, Any], Any]:
         return self._content
 
 
+class MockPart(str):
+    """Mock resource for testing purposes."""
+
+    def __init__(self, s: str):
+        self.s = s
+
+        self.str_counter = 0
+
+    def __str__(self) -> str:
+        self.str_counter += 1
+        return self.s
+
+
 class MockResource(dict):
     """Mock resource for testing purposes."""
 
@@ -138,12 +152,15 @@ def test_separator(self):
         assert str(p) == separator.join(args)
 
     def test_cparts_cached(self):
-        args = ["part1", "part2"]
+        part = MockPart("part1")
+        args = [part, ]
         separator = ","
         p = BasePath(*args, separator=separator)
-        p._cparts_cached = p._get_cparts()
 
         assert str(p) == separator.join(args)
+        assert part.str_counter == 1
+        assert str(p) == separator.join(args)
+        assert part.str_counter == 1
 
 
 class TestBasePathRepr:
@@ -199,12 +216,16 @@ def test_separator(self):
         assert hash(p) == hash(tuple(p._cparts))
 
     def test_cparts_cached(self):
-        args = ["part1", "part2"]
+        part = MockPart("part1")
+        args = [part, ]
         separator = ","
         p = BasePath(*args, separator=separator)
-        p._cparts_cached = p._get_cparts()
 
         assert hash(p) == hash(tuple(p._cparts))
+        assert part.str_counter == 1
+        assert hash(p) == hash(tuple(p._cparts))
+        assert part.str_counter == 1
+
 
 
 class TestBasePathMakeChild:
@@ -719,8 +740,8 @@ def test_list(self):
         assert type(result) == GeneratorType
         result_list = list(result)
         assert result_list == [
-            LookupPath._from_lookup(resource, "test1/test2/0"),
-            LookupPath._from_lookup(resource, "test1/test2/1"),
+            LookupPath._from_lookup(resource, "test1/test2", 0),
+            LookupPath._from_lookup(resource, "test1/test2", 1),
         ]