neo4j.graph remove indirectly exposed items from imports

Author: robsdedude

CHANGELOG.md

@@ -74,7 +74,7 @@ See also https://github.com/neo4j/neo4j-python-driver/wiki for a full changelog.
   - Remove `ExperimentalWarning` and turn the few left instances of it into `PreviewWarning`.
   - Deprecate importing `PreviewWarning` from `neo4j`.  
     Import it from `neo4j.warnings` instead.
-- Make undocumented internal constants and helper functions private:
+- Make undocumented internal constants, helper functions, and other items private:
   - `neo4j.api`
     - `DRIVER_BOLT`
     - `DRIVER_NEO4J`
@@ -104,6 +104,8 @@ See also https://github.com/neo4j/neo4j-python-driver/wiki for a full changelog.
     - `.default_host`
     - `.default_port`
     - `.default_target`
+  - `neo4j.graph`
+    - indirectly exposed items from imports (e.g. `collections.abc.Mapping` as `neo4j.graph.Mapping`).
 - Raise `ConfigurationError` instead of ignoring the routing context (URI query parameters) when creating a direct
   driver ("bolt[+s[sc]]://" scheme).
 - Change behavior of closed drivers:

src/neo4j/graph/__init__.py

@@ -16,16 +16,16 @@
 
 """Graph data types as returned by the DBMS."""
 
-from __future__ import annotations
+from __future__ import annotations as _
 
-import typing as t
-from collections.abc import Mapping
+import typing as _t
+from collections.abc import Mapping as _Mapping
 
 
-if t.TYPE_CHECKING:
-    from typing_extensions import deprecated
+if _t.TYPE_CHECKING:
+    from typing_extensions import deprecated as _deprecated
 else:
-    from .._warnings import deprecated
+    from .._warnings import deprecated as _deprecated
 
 
 __all__ = [
@@ -36,7 +36,7 @@
 ]
 
 
-_T = t.TypeVar("_T")
+_T = _t.TypeVar("_T")
 
 
 class Graph:
@@ -71,7 +71,7 @@ def relationship_type(self, name: str) -> type[Relationship]:
         try:
             cls = self._relationship_types[name]
         except KeyError:
-            cls = self._relationship_types[name] = t.cast(
+            cls = self._relationship_types[name] = _t.cast(
                 type[Relationship], type(str(name), (Relationship,), {})
             )
         return cls
@@ -92,7 +92,7 @@ def _restore(relationship_types: tuple[str, ...]) -> Graph:
         return graph
 
 
-class Entity(t.Mapping[str, t.Any]):
+class Entity(_t.Mapping[str, _t.Any]):
     """
     Graph entity base.
 
@@ -106,7 +106,7 @@ def __init__(
         graph: Graph,
         element_id: str,
         id_: int,
-        properties: dict[str, t.Any] | None,
+        properties: dict[str, _t.Any] | None,
     ) -> None:
         self._graph = graph
         self._element_id = element_id
@@ -115,7 +115,7 @@ def __init__(
             k: v for k, v in (properties or {}).items() if v is not None
         }
 
-    def __eq__(self, other: t.Any) -> bool:
+    def __eq__(self, other: _t.Any) -> bool:
         # TODO: 6.0 - return NotImplemented on type mismatch instead of False
         try:
             return (
@@ -135,13 +135,13 @@ def __hash__(self):
     def __len__(self) -> int:
         return len(self._properties)
 
-    def __getitem__(self, name: str) -> t.Any:
+    def __getitem__(self, name: str) -> _t.Any:
         return self._properties.get(name)
 
     def __contains__(self, name: object) -> bool:
         return name in self._properties
 
-    def __iter__(self) -> t.Iterator[str]:
+    def __iter__(self) -> _t.Iterator[str]:
         return iter(self._properties)
 
     @property
@@ -150,7 +150,7 @@ def graph(self) -> Graph:
         return self._graph
 
     @property  # type: ignore
-    @deprecated("`id` is deprecated, use `element_id` instead")
+    @_deprecated("`id` is deprecated, use `element_id` instead")
     def id(self) -> int:
         """
         The legacy identity of this entity in its container :class:`.Graph`.
@@ -182,24 +182,24 @@ def element_id(self) -> str:
         """
         return self._element_id
 
-    def get(self, name: str, default: object = None) -> t.Any:
+    def get(self, name: str, default: object = None) -> _t.Any:
         """Get a property value by name, optionally with a default."""
         return self._properties.get(name, default)
 
-    def keys(self) -> t.KeysView[str]:
+    def keys(self) -> _t.KeysView[str]:
         """Return an iterable of all property names."""
         return self._properties.keys()
 
-    def values(self) -> t.ValuesView[t.Any]:
+    def values(self) -> _t.ValuesView[_t.Any]:
         """Return an iterable of all property values."""
         return self._properties.values()
 
-    def items(self) -> t.ItemsView[str, t.Any]:
+    def items(self) -> _t.ItemsView[str, _t.Any]:
         """Return an iterable of all property name-value pairs."""
         return self._properties.items()
 
 
-class EntitySetView(Mapping, t.Generic[_T]):
+class EntitySetView(_Mapping, _t.Generic[_T]):
     """View of a set of :class:`.Entity` instances within a :class:`.Graph`."""
 
     def __init__(
@@ -214,7 +214,7 @@ def __getitem__(self, e_id: str) -> _T:
     def __len__(self) -> int:
         return len(self._entity_dict)
 
-    def __iter__(self) -> t.Iterator[_T]:
+    def __iter__(self) -> _t.Iterator[_T]:
         return iter(self._entity_dict.values())
 
 
@@ -226,8 +226,8 @@ def __init__(
         graph: Graph,
         element_id: str,
         id_: int,
-        n_labels: t.Iterable[str] | None = None,
-        properties: dict[str, t.Any] | None = None,
+        n_labels: _t.Iterable[str] | None = None,
+        properties: dict[str, _t.Any] | None = None,
     ) -> None:
         Entity.__init__(self, graph, element_id, id_, properties)
         self._labels = frozenset(n_labels or ())
@@ -252,7 +252,7 @@ def __init__(
         graph: Graph,
         element_id: str,
         id_: int,
-        properties: dict[str, t.Any],
+        properties: dict[str, _t.Any],
     ) -> None:
         Entity.__init__(self, graph, element_id, id_, properties)
         self._start_node: Node | None = None
@@ -307,9 +307,9 @@ def __init__(self, start_node: Node, *relationships: Relationship) -> None:
         for i, relationship in enumerate(relationships, start=1):
             assert isinstance(relationship, Relationship)
             if relationship.start_node == nodes[-1]:
-                nodes.append(t.cast(Node, relationship.end_node))
+                nodes.append(_t.cast(Node, relationship.end_node))
             elif relationship.end_node == nodes[-1]:
-                nodes.append(t.cast(Node, relationship.start_node))
+                nodes.append(_t.cast(Node, relationship.start_node))
             else:
                 raise ValueError(
                     f"Relationship {i} does not connect to the last node"
@@ -323,7 +323,7 @@ def __repr__(self) -> str:
             f"size={len(self)}>"
         )
 
-    def __eq__(self, other: t.Any) -> bool:
+    def __eq__(self, other: _t.Any) -> bool:
         # TODO: 6.0 - return NotImplemented on type mismatch instead of False
         try:
             return (
@@ -345,7 +345,7 @@ def __hash__(self):
     def __len__(self) -> int:
         return len(self._relationships)
 
-    def __iter__(self) -> t.Iterator[Relationship]:
+    def __iter__(self) -> _t.Iterator[Relationship]:
         return iter(self._relationships)
 
     @property