Mark internals in driver.py with underscore (#1181)

Rename undocumented internals to have a leading `_`
* `GraphDatabase`
  * `.bolt_driver`
  *`.neo4j_driver`
* `BoltDriver` and `Neo4jDriver`
  * `.open`
  * `.parse_target`
  * `.default_host`
  * `.default_port`
  * `.default_target`

Signed-off-by: Rouven Bauer <rouven.bauer@neo4j.com>
Co-authored-by: Steve Cathcart <stephen.cathcart@neotechnology.com>

Author: robsdedude

CHANGELOG.md

@@ -91,6 +91,15 @@ See also https://github.com/neo4j/neo4j-python-driver/wiki for a full changelog.
     - `ERROR_REWRITE_MAP`
     - `client_errors`
     - `transient_errors`
+  - `GraphDatabase`
+      - `.bolt_driver`
+      - `.neo4j_driver`
+  - `BoltDriver` and `Neo4jDriver`
+      - `.open`
+      - `.parse_target`
+      - `.default_host`
+      - `.default_port`
+      - `.default_target`
 - 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/_async/driver.py

@@ -51,7 +51,6 @@
 )
 from .._debug import ENABLED as DEBUG_ENABLED
 from .._warnings import (
-    deprecation_warn,
     preview_warn,
     unclosed_resource_warn,
 )
@@ -284,10 +283,10 @@ def driver(
                         "supported by direct drivers "
                         f'("bolt[+s[sc]]://" scheme). Given URI: {uri!r}.'
                     )
-                return cls.bolt_driver(parsed.netloc, **config)
+                return cls._bolt_driver(parsed.netloc, **config)
             # else driver_type == DRIVER_NEO4J
             routing_context = parse_routing_context(parsed.query)
-            return cls.neo4j_driver(
+            return cls._neo4j_driver(
                 parsed.netloc, routing_context=routing_context, **config
             )
 
@@ -376,7 +375,7 @@ def bookmark_manager(
         )
 
     @classmethod
-    def bolt_driver(cls, target, **config):
+    def _bolt_driver(cls, target, **config):
         """
         Create a direct driver.
 
@@ -389,36 +388,28 @@ def bolt_driver(cls, target, **config):
         )
 
         try:
-            return AsyncBoltDriver.open(target, **config)
+            return AsyncBoltDriver._open(target, **config)
         except (BoltHandshakeError, BoltSecurityError) as error:
             from ..exceptions import ServiceUnavailable
 
             raise ServiceUnavailable(str(error)) from error
 
     @classmethod
-    def neo4j_driver(cls, *targets, routing_context=None, **config):
+    def _neo4j_driver(cls, target, routing_context=None, **config):
         """
         Create a routing driver.
 
         Create a driver for routing-capable Neo4j service access
         that uses socket I/O and thread-based concurrency.
         """
-        # TODO: 6.0 - adjust signature to only take one target
-        if len(targets) > 1:
-            deprecation_warn(
-                "Creating a routing driver with multiple targets is "
-                "deprecated. The driver only uses the first target anyway. "
-                "The method signature will change in a future release.",
-            )
-
         from .._exceptions import (
             BoltHandshakeError,
             BoltSecurityError,
         )
 
         try:
-            return AsyncNeo4jDriver.open(
-                *targets, routing_context=routing_context, **config
+            return AsyncNeo4jDriver._open(
+                target, routing_context=routing_context, **config
             )
         except (BoltHandshakeError, BoltSecurityError) as error:
             from ..exceptions import ServiceUnavailable
@@ -427,10 +418,9 @@ def neo4j_driver(cls, *targets, routing_context=None, **config):
 
 
 class _Direct:
-    # TODO: 6.0 - those attributes should be private
-    default_host = "localhost"
-    default_port = 7687
-    default_target = ":"
+    _default_host = "localhost"
+    _default_port = 7687
+    _default_target = ":"
 
     def __init__(self, address):
         self._address = address
@@ -440,22 +430,21 @@ def address(self):
         return self._address
 
     @classmethod
-    def parse_target(cls, target):
+    def _parse_target(cls, target):
         """Parse a target string to produce an address."""
         if not target:
-            target = cls.default_target
+            target = cls._default_target
         return Address.parse(
             target,
-            default_host=cls.default_host,
-            default_port=cls.default_port,
+            default_host=cls._default_host,
+            default_port=cls._default_port,
         )
 
 
 class _Routing:
-    # TODO: 6.0 - those attributes should be private
-    default_host = "localhost"
-    default_port = 7687
-    default_targets = ": :17601 :17687"
+    _default_host = "localhost"
+    _default_port = 7687
+    _default_targets = ": :17601 :17687"
 
     def __init__(self, initial_addresses):
         self._initial_addresses = initial_addresses
@@ -465,15 +454,15 @@ def initial_addresses(self):
         return self._initial_addresses
 
     @classmethod
-    def parse_targets(cls, *targets):
+    def _parse_targets(cls, *targets):
         """Parse a sequence of target strings to produce an address list."""
         targets = " ".join(targets)
         if not targets:
-            targets = cls.default_targets
+            targets = cls._default_targets
         return Address.parse_list(
             targets,
-            default_host=cls.default_host,
-            default_port=cls.default_port,
+            default_host=cls._default_host,
+            default_port=cls._default_port,
         )
 
 
@@ -1308,10 +1297,10 @@ class AsyncBoltDriver(_Direct, AsyncDriver):
     """
 
     @classmethod
-    def open(cls, target, **config):
+    def _open(cls, target, **config):
         from .io import AsyncBoltPool
 
-        address = cls.parse_target(target)
+        address = cls._parse_target(target)
         pool_config, default_workspace_config = Config.consume_chain(
             config, AsyncPoolConfig, WorkspaceConfig
         )
@@ -1342,10 +1331,10 @@ class AsyncNeo4jDriver(_Routing, AsyncDriver):
     """
 
     @classmethod
-    def open(cls, *targets, routing_context=None, **config):
+    def _open(cls, *targets, routing_context=None, **config):
         from .io import AsyncNeo4jPool
 
-        addresses = cls.parse_targets(*targets)
+        addresses = cls._parse_targets(*targets)
         pool_config, default_workspace_config = Config.consume_chain(
             config, AsyncPoolConfig, WorkspaceConfig
         )

src/neo4j/_sync/driver.py

@@ -44,14 +44,14 @@ def __init__(self, uri, token):
 def test_example(uri, mocker):
     # Currently, there is no way of running the test against a server with SSO
     # setup.
-    mocker.patch("neo4j.GraphDatabase.bolt_driver")
-    mocker.patch("neo4j.GraphDatabase.neo4j_driver")
+    mocker.patch("neo4j.GraphDatabase._bolt_driver")
+    mocker.patch("neo4j.GraphDatabase._neo4j_driver")
 
     token = "myToken"
     BearerAuthExample(uri, token)
     calls = (
-        neo4j.GraphDatabase.bolt_driver.call_args_list
-        + neo4j.GraphDatabase.neo4j_driver.call_args_list
+        neo4j.GraphDatabase._bolt_driver.call_args_list
+        + neo4j.GraphDatabase._neo4j_driver.call_args_list
     )
     assert len(calls) == 1
     _args, kwargs = calls[0]