Intermediate changes

commit_hash:ac53b6445d4c78c7724d2cedae353982d0fb8332

Author: robot-piglet

contrib/python/ydb/py3/.dist-info/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ydb
-Version: 3.21.1
+Version: 3.21.2
 Summary: YDB Python SDK
 Home-page: http://github.com/ydb-platform/ydb-python-sdk
 Author: Yandex LLC
@@ -65,3 +65,7 @@ Install YDB python sdk:
 ```sh
 $ python -m pip install ydb
 ```
+
+## Development
+
+Instructions on `ydb-python-sdk` development are located in [BUILD.md](BUILD.md).

contrib/python/ydb/py3/README.md

@@ -42,3 +42,7 @@ Install YDB python sdk:
 ```sh
 $ python -m pip install ydb
 ```
+
+## Development
+
+Instructions on `ydb-python-sdk` development are located in [BUILD.md](BUILD.md).

contrib/python/ydb/py3/ya.make

@@ -2,7 +2,7 @@
 
 PY3_LIBRARY()
 
-VERSION(3.21.1)
+VERSION(3.21.2)
 
 LICENSE(Apache-2.0)
 

contrib/python/ydb/py3/ydb/aio/pool.py

@@ -199,12 +199,27 @@ def __init__(self, driver_config):
         self._store = ConnectionsCache(driver_config.use_all_nodes)
         self._grpc_init = Connection(self._driver_config.endpoint, self._driver_config)
         self._stopped = False
-        self._discovery = Discovery(self._store, self._driver_config)
 
-        self._discovery_task = asyncio.get_event_loop().create_task(self._discovery.run())
+        if driver_config.disable_discovery:
+            # If discovery is disabled, just add the initial endpoint to the store
+            async def init_connection():
+                ready_connection = Connection(self._driver_config.endpoint, self._driver_config)
+                await ready_connection.connection_ready(
+                    ready_timeout=getattr(self._driver_config, "discovery_request_timeout", 10)
+                )
+                self._store.add(ready_connection)
+
+            # Create and schedule the task to initialize the connection
+            self._discovery = None
+            self._discovery_task = asyncio.get_event_loop().create_task(init_connection())
+        else:
+            # Start discovery as usual
+            self._discovery = Discovery(self._store, self._driver_config)
+            self._discovery_task = asyncio.get_event_loop().create_task(self._discovery.run())
 
     async def stop(self, timeout=10):
-        self._discovery.stop()
+        if self._discovery:
+            self._discovery.stop()
         await self._grpc_init.close()
         try:
             await asyncio.wait_for(self._discovery_task, timeout=timeout)
@@ -215,15 +230,18 @@ async def stop(self, timeout=10):
     def _on_disconnected(self, connection):
         async def __wrapper__():
             await connection.close()
-            self._discovery.notify_disconnected()
+            if self._discovery:
+                self._discovery.notify_disconnected()
 
         return __wrapper__
 
     async def wait(self, timeout=7, fail_fast=False):
         await self._store.get(fast_fail=fail_fast, wait_timeout=timeout)
 
     def discovery_debug_details(self):
-        return self._discovery.discovery_debug_details()
+        if self._discovery:
+            return self._discovery.discovery_debug_details()
+        return "Discovery is disabled, using only the initial endpoint"
 
     async def __aenter__(self):
         return self
@@ -248,7 +266,8 @@ async def __call__(
         try:
             connection = await self._store.get(preferred_endpoint, fast_fail=fast_fail, wait_timeout=wait_timeout)
         except BaseException:
-            self._discovery.notify_disconnected()
+            if self._discovery:
+                self._discovery.notify_disconnected()
             raise
 
         return await connection(

contrib/python/ydb/py3/ydb/driver.py

@@ -96,6 +96,7 @@ class DriverConfig(object):
         "grpc_lb_policy_name",
         "discovery_request_timeout",
         "compression",
+        "disable_discovery",
     )
 
     def __init__(
@@ -120,6 +121,7 @@ def __init__(
         grpc_lb_policy_name="round_robin",
         discovery_request_timeout=10,
         compression=None,
+        disable_discovery=False,
     ):
         """
         A driver config to initialize a driver instance
@@ -140,6 +142,7 @@ def __init__(
         If tracing aio ScopeManager must be ContextVarsScopeManager
         :param grpc_lb_policy_name: A load balancing policy to be used for discovery channel construction. Default value is `round_round`
         :param discovery_request_timeout: A default timeout to complete the discovery. The default value is 10 seconds.
+        :param disable_discovery: If True, endpoint discovery is disabled and only the start endpoint is used for all requests.
 
         """
         self.endpoint = endpoint
@@ -167,6 +170,7 @@ def __init__(
         self.grpc_lb_policy_name = grpc_lb_policy_name
         self.discovery_request_timeout = discovery_request_timeout
         self.compression = compression
+        self.disable_discovery = disable_discovery
 
     def set_database(self, database):
         self.database = database

contrib/python/ydb/py3/ydb/pool.py

@@ -350,8 +350,21 @@ def __init__(self, driver_config):
         self._store = ConnectionsCache(driver_config.use_all_nodes, driver_config.tracer)
         self.tracer = driver_config.tracer
         self._grpc_init = connection_impl.Connection(self._driver_config.endpoint, self._driver_config)
-        self._discovery_thread = Discovery(self._store, self._driver_config)
-        self._discovery_thread.start()
+
+        if driver_config.disable_discovery:
+            # If discovery is disabled, just add the initial endpoint to the store
+            ready_connection = connection_impl.Connection.ready_factory(
+                self._driver_config.endpoint,
+                self._driver_config,
+                ready_timeout=getattr(self._driver_config, "discovery_request_timeout", 10),
+            )
+            self._store.add(ready_connection)
+            self._discovery_thread = None
+        else:
+            # Start discovery thread as usual
+            self._discovery_thread = Discovery(self._store, self._driver_config)
+            self._discovery_thread.start()
+
         self._stopped = False
         self._stop_guard = threading.Lock()
 
@@ -367,9 +380,11 @@ def stop(self, timeout=10):
                 return
 
             self._stopped = True
-            self._discovery_thread.stop()
+            if self._discovery_thread:
+                self._discovery_thread.stop()
         self._grpc_init.close()
-        self._discovery_thread.join(timeout)
+        if self._discovery_thread:
+            self._discovery_thread.join(timeout)
 
     def async_wait(self, fail_fast=False):
         """
@@ -404,7 +419,13 @@ def _on_disconnected(self, connection):
         self._discovery_thread.notify_disconnected()
 
     def discovery_debug_details(self):
-        return self._discovery_thread.discovery_debug_details()
+        """
+        Returns debug string about last errors
+        :return: str
+        """
+        if self._discovery_thread:
+            return self._discovery_thread.discovery_debug_details()
+        return "Discovery is disabled, using only the initial endpoint"
 
     @tracing.with_trace()
     def __call__(

contrib/python/ydb/py3/ydb/ydb_version.py

@@ -1 +1 @@
-VERSION = "3.21.1"
+VERSION = "3.21.2"