e6data-python-connector 2.3.10rc2__tar.gz → 2.3.10rc3__tar.gz

{e6data_python_connector-2.3.10rc2/e6data_python_connector.egg-info → e6data_python_connector-2.3.10rc3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: e6data-python-connector
-Version: 2.3.10rc2
+Version: 2.3.10rc3
 Summary: Client for the e6data distributed SQL Engine.
 Home-page: https://github.com/e6x-labs/e6data-python-connector
 Author: e6data, Inc.
@@ -38,7 +38,7 @@ Dynamic: summary
 
 # e6data Python Connector
 
-![version](https://img.shields.io/badge/version-2.3.10,rc2-blue.svg)
+![version](https://img.shields.io/badge/version-2.3.10,rc3-blue.svg)
 
 ## Introduction
 

{e6data_python_connector-2.3.10rc2 → e6data_python_connector-2.3.10rc3}/README.md

@@ -1,6 +1,6 @@
 # e6data Python Connector
 
-![version](https://img.shields.io/badge/version-2.3.10,rc2-blue.svg)
+![version](https://img.shields.io/badge/version-2.3.10,rc3-blue.svg)
 
 ## Introduction
 

{e6data_python_connector-2.3.10rc2 → e6data_python_connector-2.3.10rc3}/e6data_python_connector/e6data_grpc.py

@@ -243,7 +243,7 @@ def _invalidate_all_sessions():
     shared_strategy['session_invalidated'] = True
 
 
-def _register_query_strategy(query_id, strategy):
+def _register_query_strategy(query_id, strategy, session_id=None):
     """Register the strategy used for a specific query."""
     if not query_id or not strategy:
         return
@@ -257,7 +257,8 @@ def _register_query_strategy(query_id, strategy):
         query_map = shared_strategy.get('query_strategy_map', {})
         query_map[query_id] = normalized_strategy
         shared_strategy['query_strategy_map'] = query_map
-        _strategy_debug_log(f"Query {query_id} registered with strategy: {normalized_strategy}")
+        session_info = f", session: {session_id}" if session_id else ""
+        _strategy_debug_log(f"Query {query_id} registered with strategy: {normalized_strategy}{session_info}")
 
 
 def _get_query_strategy(query_id):
@@ -271,7 +272,7 @@ def _get_query_strategy(query_id):
         return query_map.get(query_id, current_active_strategy)
 
 
-def _cleanup_query_strategy(query_id):
+def _cleanup_query_strategy(query_id, session_id=None):
     """Remove the strategy mapping for a completed query."""
     if not query_id:
         return
@@ -283,7 +284,8 @@ def _cleanup_query_strategy(query_id):
             del query_map[query_id]
             shared_strategy['query_strategy_map'] = query_map
             remaining_queries = len(query_map)
-            _strategy_debug_log(f"Query {query_id} completed (was using {strategy}). Remaining active queries: {remaining_queries}")
+            session_info = f", session: {session_id}" if session_id else ""
+            _strategy_debug_log(f"Query {query_id} completed (was using {strategy}{session_info}). Remaining active queries: {remaining_queries}")
 
 
 def _get_strategy_debug_info():
@@ -518,9 +520,11 @@ class Connection(object):
         # Check if session strategy matches current active strategy
         elif self._session_id and self._session_strategy and self._session_strategy != _get_active_strategy():
             # Session was created with different strategy, need to re-authenticate
-            _strategy_debug_log(f"Session strategy mismatch: session created with {self._session_strategy}, current active is {_get_active_strategy()}")
+            _strategy_debug_log(f"Session strategy mismatch: session {self._session_id} created with {self._session_strategy}, current active is {_get_active_strategy()}")
+            old_session_id = self._session_id
             self._session_id = None
             self._session_strategy = None
+            _strategy_debug_log(f"Invalidating session {old_session_id} due to strategy mismatch")
             self.close()
             self._create_client()
 
@@ -538,7 +542,7 @@ class Connection(object):
 
                 if active_strategy and not pending_strategy:
                     # Use cached strategy only if there's no pending strategy
-                    _strategy_debug_log(f"Authenticating with cached strategy: {active_strategy}")
+                    _strategy_debug_log(f"Authenticating with cached strategy: {active_strategy} (session: {self._session_id})")
                     try:
                         authenticate_response = self._client.authenticate(
                             authenticate_request,
@@ -549,21 +553,25 @@ class Connection(object):
                             raise ValueError("Invalid credentials.")
                         # Track which strategy was used for this session
                         self._session_strategy = active_strategy
+                        _strategy_debug_log(f"Authentication successful with strategy: {active_strategy}, session: {self._session_id}")
                         # Check for new strategy in authenticate response
                         if hasattr(authenticate_response, 'new_strategy') and authenticate_response.new_strategy:
                             new_strategy = authenticate_response.new_strategy.lower()
                             if new_strategy != active_strategy:
+                                _strategy_debug_log(f"Strategy changed from {active_strategy} to {new_strategy} in authenticate response, session: {self._session_id}")
                                 _set_pending_strategy(new_strategy)
                                 _apply_pending_strategy()
+                                old_session_id = self._session_id
                                 self._session_id = None
                                 self._session_strategy = None
+                                _strategy_debug_log(f"Resetting session {old_session_id} due to new strategy: {new_strategy}")
                                 self.close()
                                 self._create_client()
                                 return self.get_session_id
                     except _InactiveRpcError as e:
                         if e.code() == grpc.StatusCode.UNKNOWN and 'status: 456' in e.details():
                             # Strategy changed, clear cache and retry
-                            _strategy_debug_log(f"Got 456 error with strategy {active_strategy}, clearing cache and retrying")
+                            _strategy_debug_log(f"Got 456 error with strategy {active_strategy}, session: {self._session_id}, clearing cache and retrying")
                             _clear_strategy_cache()
                             active_strategy = None
                         else:
@@ -585,7 +593,7 @@ class Connection(object):
                         _strategy_debug_log(f"No cached strategy, will try strategies in order: {strategies}")
                     last_error = None
                     for strategy in strategies:
-                        _strategy_debug_log(f"Attempting authentication with strategy: {strategy}")
+                        _strategy_debug_log(f"Attempting authentication with strategy: {strategy} (no session yet)")
                         try:
                             authenticate_response = self._client.authenticate(
                                 authenticate_request,
@@ -594,7 +602,7 @@ class Connection(object):
                             self._session_id = authenticate_response.sessionId
                             if self._session_id:
                                 # Success! Cache this strategy
-                                _strategy_debug_log(f"Authentication successful with strategy: {strategy}")
+                                _strategy_debug_log(f"Authentication successful with strategy: {strategy}, session: {self._session_id}")
                                 _set_active_strategy(strategy)
                                 # Track which strategy was used for this session
                                 self._session_strategy = strategy
@@ -603,9 +611,12 @@ class Connection(object):
                                 if hasattr(authenticate_response, 'new_strategy') and authenticate_response.new_strategy:
                                     new_strategy = authenticate_response.new_strategy.lower()
                                     if new_strategy != strategy:
+                                        _strategy_debug_log(f"Strategy changed from {strategy} to {new_strategy} in authenticate response, session: {self._session_id}")
                                         _set_pending_strategy(new_strategy)
                                         _apply_pending_strategy()
+                                        old_session_id = self._session_id
                                         self.close()
+                                        _strategy_debug_log(f"Resetting session {old_session_id} due to new strategy: {new_strategy}")
                                         self._create_client()
                                         self._session_id = None
                                         self._session_strategy = None
@@ -614,7 +625,7 @@ class Connection(object):
                         except _InactiveRpcError as e:
                             if e.code() == grpc.StatusCode.UNKNOWN and 'status: 456' in e.details():
                                 # Wrong strategy, try the next one
-                                _strategy_debug_log(f"Strategy {strategy} failed with 456 error, trying next")
+                                _strategy_debug_log(f"Strategy {strategy} failed with 456 error (session attempt failed), trying next")
                                 last_error = e
                                 continue
                             else:
@@ -682,6 +693,7 @@ class Connection(object):
 
         This method ensures that the gRPC channel is properly closed and the session ID is reset to None.
         """
+        old_session = self._session_id
         if self._channel is not None:
             self._channel.close()
             self._channel = None
@@ -691,7 +703,8 @@ class Connection(object):
         # Remove from debug connections if debug was enabled
         if self._debug:
             _debug_connections.discard(id(self))
-            _strategy_debug_log(f"Debug mode disabled for connection {id(self)}")
+            session_info = f", session was: {old_session}" if old_session else ""
+            _strategy_debug_log(f"Debug mode disabled for connection {id(self)}{session_info}")
 
     def check_connection(self):
         """
@@ -1136,7 +1149,7 @@ class Cursor(DBAPICursor):
 
         # Clean up query strategy mapping
         if query_id:
-            _cleanup_query_strategy(query_id)
+            _cleanup_query_strategy(query_id, self.connection.get_session_id)
 
         # Check if this was the last query and we have a pending strategy
         shared_strategy = _get_shared_strategy()
@@ -1144,7 +1157,7 @@ class Cursor(DBAPICursor):
         query_map = shared_strategy.get('query_strategy_map', {})
 
         if pending_strategy and len(query_map) == 0:
-            _strategy_debug_log(f"Last query cleared, triggering pending strategy transition")
+            _strategy_debug_log(f"Last query cleared for session {self.connection.get_session_id}, triggering pending strategy transition from {_get_active_strategy()} to {pending_strategy}")
             _apply_pending_strategy()
 
         return clear_response
@@ -1160,7 +1173,7 @@ class Cursor(DBAPICursor):
         self.connection.query_cancel(engine_ip=self._engine_ip, query_id=query_id)
 
         if query_id:
-            _cleanup_query_strategy(query_id)
+            _cleanup_query_strategy(query_id, self.connection.get_session_id)
 
         # Check if this was the last query and we have a pending strategy
         shared_strategy = _get_shared_strategy()
@@ -1168,7 +1181,7 @@ class Cursor(DBAPICursor):
         query_map = shared_strategy.get('query_strategy_map', {})
 
         if pending_strategy and len(query_map) == 0:
-            _strategy_debug_log(f"Last query cleared, triggering pending strategy transition")
+            _strategy_debug_log(f"Last query cleared for session {self.connection.get_session_id}, triggering pending strategy transition from {_get_active_strategy()} to {pending_strategy}")
             _apply_pending_strategy()
 
     def status(self, query_id):
@@ -1242,7 +1255,7 @@ class Cursor(DBAPICursor):
             # Register this query with the current strategy
             current_strategy = _get_active_strategy()
             if current_strategy:
-                _register_query_strategy(self._query_id, current_strategy)
+                _register_query_strategy(self._query_id, current_strategy, self.connection.get_session_id)
 
             execute_statement_request = e6x_engine_pb2.ExecuteStatementRequest(
                 engineIP=self._engine_ip,
@@ -1289,7 +1302,7 @@ class Cursor(DBAPICursor):
             current_strategy = _get_active_strategy()
 
             if current_strategy:
-                _register_query_strategy(self._query_id, current_strategy)
+                _register_query_strategy(self._query_id, current_strategy, self.connection.get_session_id)
 
             execute_statement_request = e6x_engine_pb2.ExecuteStatementV2Request(
                 engineIP=self._engine_ip,

{e6data_python_connector-2.3.10rc2 → e6data_python_connector-2.3.10rc3/e6data_python_connector.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: e6data-python-connector
-Version: 2.3.10rc2
+Version: 2.3.10rc3
 Summary: Client for the e6data distributed SQL Engine.
 Home-page: https://github.com/e6x-labs/e6data-python-connector
 Author: e6data, Inc.
@@ -38,7 +38,7 @@ Dynamic: summary
 
 # e6data Python Connector
 
-![version](https://img.shields.io/badge/version-2.3.10,rc2-blue.svg)
+![version](https://img.shields.io/badge/version-2.3.10,rc3-blue.svg)
 
 ## Introduction
 

{e6data_python_connector-2.3.10rc2 → e6data_python_connector-2.3.10rc3}/setup.py

@@ -12,7 +12,7 @@
 
 import setuptools
 
-VERSION = (2, 3, 10, 'rc2')
+VERSION = (2, 3, 10, 'rc3')
 
 
 def get_long_desc():