e6data-python-connector 2.3.9rc6__tar.gz → 2.3.9rc8__tar.gz

{e6data_python_connector-2.3.9rc6/e6data_python_connector.egg-info → e6data_python_connector-2.3.9rc8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: e6data-python-connector
-Version: 2.3.9rc6
+Version: 2.3.9rc8
 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.9rc6-blue.svg)
+![version](https://img.shields.io/badge/version-2.3.9.rc8-blue.svg)
 
 ## Introduction
 

{e6data_python_connector-2.3.9rc6 → e6data_python_connector-2.3.9rc8}/README.md

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

{e6data_python_connector-2.3.9rc6 → e6data_python_connector-2.3.9rc8}/e6data_python_connector/e6data_grpc.py

@@ -7,7 +7,6 @@ from __future__ import absolute_import
 from __future__ import unicode_literals
 
 import datetime
-import logging
 import re
 import sys
 import time
@@ -28,9 +27,6 @@ from e6data_python_connector.datainputstream import get_query_columns_info, read
 from e6data_python_connector.server import e6x_engine_pb2_grpc, e6x_engine_pb2
 from e6data_python_connector.typeId import *
 
-# Set up logging
-logger = logging.getLogger(__name__)
-
 apilevel = '2.0'
 threadsafety = 2  # Threads may share the e6xdb and connections.
 paramstyle = 'pyformat'  # Python extended format codes, e.g. ...WHERE name=%(name)s
@@ -138,20 +134,20 @@ def _get_shared_strategy():
     global _strategy_manager, _shared_strategy
 
     # Try to use multiprocessing.Manager for process-safe storage
-    # try:
-    #     if _strategy_manager is None:
-    #         _strategy_manager = multiprocessing.Manager()
-    #         _shared_strategy = _strategy_manager.dict()
-    #         _shared_strategy['active_strategy'] = None
-    #         _shared_strategy['last_check_time'] = 0
-    #         _shared_strategy['pending_strategy'] = None
-    #         _shared_strategy['query_strategy_map'] = _strategy_manager.dict()
-    #         _shared_strategy['last_transition_time'] = 0
-    #         _shared_strategy['session_invalidated'] = False
-    #     return _shared_strategy
-    # except:
-    #     # Fall back to thread-local storage if Manager fails
-    return _local_strategy_cache
+    try:
+        if _strategy_manager is None:
+            _strategy_manager = multiprocessing.Manager()
+            _shared_strategy = _strategy_manager.dict()
+            _shared_strategy['active_strategy'] = None
+            _shared_strategy['last_check_time'] = 0
+            _shared_strategy['pending_strategy'] = None
+            _shared_strategy['query_strategy_map'] = _strategy_manager.dict()
+            _shared_strategy['last_transition_time'] = 0
+            _shared_strategy['session_invalidated'] = False
+        return _shared_strategy
+    except:
+        # Fall back to thread-local storage if Manager fails
+        return _local_strategy_cache
 
 
 def _get_active_strategy():
@@ -181,11 +177,8 @@ def _set_active_strategy(strategy):
         current_time = time.time()
 
         # Only update transition time if strategy actually changed
-        old_strategy = shared_strategy['active_strategy']
-        if old_strategy != normalized_strategy:
+        if shared_strategy['active_strategy'] != normalized_strategy:
             shared_strategy['last_transition_time'] = current_time
-            # Debug log for strategy switches
-            logger.debug(f"Strategy switched from {old_strategy} to {normalized_strategy}")
 
         shared_strategy['active_strategy'] = normalized_strategy
         shared_strategy['last_check_time'] = current_time
@@ -214,12 +207,7 @@ def _set_pending_strategy(strategy):
         current_active = shared_strategy['active_strategy']
 
         if normalized_strategy != current_active:
-            old_pending = shared_strategy.get('pending_strategy')
             shared_strategy['pending_strategy'] = normalized_strategy
-            
-            # Debug log for pending strategy changes
-            if old_pending != normalized_strategy:
-                logger.debug(f"Pending strategy changed from {old_pending} to {normalized_strategy}")
 
 
 def _apply_pending_strategy():
@@ -227,19 +215,15 @@ def _apply_pending_strategy():
     with _strategy_lock:
         shared_strategy = _get_shared_strategy()
         if shared_strategy['pending_strategy']:
-            old_strategy = shared_strategy['active_strategy']
             new_strategy = shared_strategy['pending_strategy']
             current_time = time.time()
 
-            logger.debug(f"Strategy transition initiated: {old_strategy} -> {new_strategy}")
-            
             shared_strategy['active_strategy'] = new_strategy
             shared_strategy['pending_strategy'] = None
             shared_strategy['last_check_time'] = current_time
             shared_strategy['last_transition_time'] = current_time
             shared_strategy['session_invalidated'] = True  # Invalidate all sessions
 
-            logger.debug(f"Strategy successfully applied and sessions invalidated")
             return new_strategy
         return None
 
@@ -533,7 +517,11 @@ class Connection(object):
                             new_strategy = authenticate_response.new_strategy.lower()
                             if new_strategy != active_strategy:
                                 _set_pending_strategy(new_strategy)
-                                # Don't apply immediately - let new queries use fresh connections
+                                _apply_pending_strategy()
+                                self._session_id = None
+                                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
@@ -568,12 +556,15 @@ class Connection(object):
                                 _set_active_strategy(strategy)
 
                                 # Check for new strategy in authenticate response
-                                if hasattr(authenticate_response,
-                                           'new_strategy') and authenticate_response.new_strategy:
+                                if hasattr(authenticate_response, 'new_strategy') and authenticate_response.new_strategy:
                                     new_strategy = authenticate_response.new_strategy.lower()
                                     if new_strategy != strategy:
                                         _set_pending_strategy(new_strategy)
-                                        # Don't apply immediately - let new queries use fresh connections
+                                        _apply_pending_strategy()
+                                        self.close()
+                                        self._create_client()
+                                        self._session_id = None
+                                        return self.get_session_id
                                 break
                         except _InactiveRpcError as e:
                             if e.code() == grpc.StatusCode.UNKNOWN and 'status: 456' in e.details():
@@ -604,21 +595,6 @@ class Connection(object):
                         ).resume()
                         if status:
                             return self.get_session_id
-                            # authenticate_request = e6x_engine_pb2.AuthenticateRequest(
-                            #     user=self.__username,
-                            #     password=self.__password
-                            # )
-                            # authenticate_response = self._client.authenticate(
-                            #     authenticate_request,
-                            #     metadata=_get_grpc_header(cluster=self.cluster_uuid, strategy=_get_active_strategy())
-                            # )
-                            # self._session_id = authenticate_response.sessionId
-                            # # 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 != _get_active_strategy():
-                            #         _set_pending_strategy(new_strategy)
-                            #         # Don't apply immediately - let new queries use fresh connections
                         else:
                             raise e
                     else:

{e6data_python_connector-2.3.9rc6 → e6data_python_connector-2.3.9rc8}/e6data_python_connector/strategy.py

@@ -41,23 +41,23 @@ def _initialize_shared_state():
         if _shared_strategy is not None:
             return _shared_strategy
         
-        # try:
-        #     # Try to create multiprocessing Manager
-        #     _manager = multiprocessing.Manager()
-        #     _shared_strategy = _manager.dict({
-        #         'active_strategy': None,
-        #         'last_check_time': 0,
-        #         'pending_strategy': None,
-        #         'query_strategy_map': _manager.dict(),
-        #         'last_transition_time': 0,
-        #         'session_invalidated': False
-        #     })
-        #     _logger.debug("Successfully initialized multiprocessing Manager for strategy sharing")
-        #     return _shared_strategy
-        # except Exception as e:
-        #     # Fall back to thread-local storage if Manager fails
-        #     _logger.warning(f"Failed to initialize multiprocessing Manager: {e}. Using thread-local storage.")
-    return _local_strategy_cache
+        try:
+            # Try to create multiprocessing Manager
+            _manager = multiprocessing.Manager()
+            _shared_strategy = _manager.dict({
+                'active_strategy': None,
+                'last_check_time': 0,
+                'pending_strategy': None,
+                'query_strategy_map': _manager.dict(),
+                'last_transition_time': 0,
+                'session_invalidated': False
+            })
+            _logger.debug("Successfully initialized multiprocessing Manager for strategy sharing")
+            return _shared_strategy
+        except Exception as e:
+            # Fall back to thread-local storage if Manager fails
+            _logger.warning(f"Failed to initialize multiprocessing Manager: {e}. Using thread-local storage.")
+            return _local_strategy_cache
 
 
 def _get_shared_strategy():
@@ -85,14 +85,8 @@ def _set_active_strategy(strategy):
         _logger.warning(f"Invalid strategy value: {strategy}. Must be 'blue' or 'green'.")
         return
     
-    old_strategy = shared_strategy.get('active_strategy')
     shared_strategy['active_strategy'] = normalized_strategy
     shared_strategy['last_check_time'] = time.time()
-    
-    # Debug log for strategy switches
-    if old_strategy != normalized_strategy:
-        _logger.debug(f"Strategy switched from {old_strategy} to {normalized_strategy}")
-    
     _logger.info(f"Active deployment strategy set to: {normalized_strategy}")
 
 
@@ -111,13 +105,7 @@ def _set_pending_strategy(strategy):
     
     current_active = shared_strategy.get('active_strategy')
     if normalized_strategy != current_active:
-        old_pending = shared_strategy.get('pending_strategy')
         shared_strategy['pending_strategy'] = normalized_strategy
-        
-        # Debug log for pending strategy changes
-        if old_pending != normalized_strategy:
-            _logger.debug(f"Pending strategy changed from {old_pending} to {normalized_strategy}")
-        
         _logger.info(f"Pending deployment strategy set to: {normalized_strategy}")
 
 
@@ -172,15 +160,11 @@ def _apply_pending_strategy():
         if len(query_map) == 0:
             # No active queries, safe to transition
             _logger.info(f"Last query completed, applying pending strategy: {pending_strategy}")
-            _logger.debug(f"Strategy transition initiated: {active_strategy} -> {pending_strategy}")
-            
             shared_strategy['active_strategy'] = pending_strategy
             shared_strategy['pending_strategy'] = None
             shared_strategy['last_transition_time'] = time.time()
             shared_strategy['session_invalidated'] = True  # Invalidate all sessions
-            
             _logger.info(f"Strategy transition completed: {active_strategy} -> {pending_strategy}")
-            _logger.debug(f"Strategy successfully applied and sessions invalidated")
 
 
 def _is_strategy_cache_valid():

{e6data_python_connector-2.3.9rc6 → e6data_python_connector-2.3.9rc8/e6data_python_connector.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: e6data-python-connector
-Version: 2.3.9rc6
+Version: 2.3.9rc8
 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.9rc6-blue.svg)
+![version](https://img.shields.io/badge/version-2.3.9.rc8-blue.svg)
 
 ## Introduction
 

{e6data_python_connector-2.3.9rc6 → e6data_python_connector-2.3.9rc8}/setup.py

@@ -12,7 +12,7 @@
 
 import setuptools
 
-VERSION = (2, 3, 9,'rc6')
+VERSION = (2, 3, 9, 'rc8')
 
 
 def get_long_desc():