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

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

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

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

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

{e6data_python_connector-2.3.9rc5 → e6data_python_connector-2.3.9rc6}/e6data_python_connector/cluster_manager.py

@@ -213,30 +213,25 @@ class ClusterManager:
                     user=self._user,
                     password=self._password
                 )
-                print('STATUS', payload)
             elif request_type == "resume":
                 payload = cluster_pb2.ResumeRequest(
                     user=self._user,
                     password=self._password
                 )
-                print('RESUME', payload)
 
         # If we have an active strategy, use it first
         if current_strategy is not None:
             try:
                 if request_type == "status":
-
                     response = self._get_connection.status(
                         payload,
                         metadata=_get_grpc_header(cluster=self.cluster_uuid, strategy=current_strategy)
                     )
-                    print('STATUS 2', response, payload)
                 elif request_type == "resume":
                     response = self._get_connection.resume(
                         payload,
                         metadata=_get_grpc_header(cluster=self.cluster_uuid, strategy=current_strategy)
                     )
-                    print('RESUME 2', response, payload)
                 else:
                     raise ValueError(f"Unknown request type: {request_type}")
 
@@ -259,13 +254,11 @@ class ClusterManager:
                                 payload,
                                 metadata=_get_grpc_header(cluster=self.cluster_uuid, strategy=alternative_strategy)
                             )
-                            print('STATUS 3', response, payload)
                         elif request_type == "resume":
                             response = self._get_connection.resume(
                                 payload,
                                 metadata=_get_grpc_header(cluster=self.cluster_uuid, strategy=alternative_strategy)
                             )
-                            print('RESUME 3', response, payload)
 
                         # Update active strategy since the alternative worked
                         _set_active_strategy(alternative_strategy)
@@ -295,13 +288,11 @@ class ClusterManager:
                         payload,
                         metadata=_get_grpc_header(cluster=self.cluster_uuid, strategy=strategy)
                     )
-                    print('STATUS 4', response, payload)
                 elif request_type == "resume":
                     response = self._get_connection.resume(
                         payload,
                         metadata=_get_grpc_header(cluster=self.cluster_uuid, strategy=strategy)
                     )
-                    print('RESUME 4', response, payload)
                 else:
                     raise ValueError(f"Unknown request type: {request_type}")
 
@@ -374,15 +365,13 @@ class ClusterManager:
             # Retrieve the current cluster status with strategy header
             try:
                 current_status = self._try_cluster_request("status")
-            except _InactiveRpcError as e:
-                print('ERROR', e, 'Returning false1')
+            except _InactiveRpcError:
                 return False
             if current_status.status == 'suspended':
                 # Send the resume request with strategy header
                 try:
                     response = self._try_cluster_request("resume")
-                except _InactiveRpcError as e:
-                    print('ERROR', e, 'Returning false2')
+                except _InactiveRpcError:
                     return False
             elif current_status.status == 'active':
                 return True
@@ -391,18 +380,15 @@ class ClusterManager:
                  If cluster cannot be resumed due to its current state, 
                  or already in a process of resuming, terminate the operation.
                  """
-                print('ERROR', '!resuming', 'Returning false3')
                 return False
 
             for status in self._check_cluster_status():
                 if status == 'active':
                     return True
                 elif status == 'failed' or time.time() > self._timeout:
-                    print('ERROR', 'timed-out', 'Returning false3')
                     return False
                 # Wait for 5 seconds before the next status check
                 time.sleep(5)
-            print('ERROR', 'Nothing worked', 'Returning false3')
             return False
 
     def suspend(self):

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

@@ -7,6 +7,7 @@ from __future__ import absolute_import
 from __future__ import unicode_literals
 
 import datetime
+import logging
 import re
 import sys
 import time
@@ -27,6 +28,9 @@ 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
@@ -134,20 +138,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():
@@ -177,8 +181,11 @@ def _set_active_strategy(strategy):
         current_time = time.time()
 
         # Only update transition time if strategy actually changed
-        if shared_strategy['active_strategy'] != normalized_strategy:
+        old_strategy = shared_strategy['active_strategy']
+        if old_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
@@ -207,7 +214,12 @@ 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():
@@ -219,12 +231,15 @@ def _apply_pending_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
 
@@ -380,7 +395,6 @@ class Connection(object):
             """
             self.grpc_auto_resume_timeout_seconds = self._grpc_options.pop('grpc_auto_resume_timeout_seconds')
         self._create_client()
-        self._hash = str(datetime.datetime.now().timestamp()) + 'hash' + str(id(self))
 
     @property
     def _get_grpc_options(self):
@@ -521,7 +535,6 @@ class Connection(object):
                                 _set_pending_strategy(new_strategy)
                                 # Don't apply immediately - let new queries use fresh connections
                     except _InactiveRpcError as e:
-                        print(self._hash, self.cluster_name, 'Error during authentication with active strategy:', active_strategy, file=sys.stderr)
                         if e.code() == grpc.StatusCode.UNKNOWN and 'status: 456' in e.details():
                             # Strategy changed, clear cache and retry
                             _clear_strategy_cache()
@@ -563,7 +576,6 @@ class Connection(object):
                                         # Don't apply immediately - let new queries use fresh connections
                                 break
                         except _InactiveRpcError as e:
-                            print(self._hash, self.cluster_name, 'Error during authentication with strategy:', strategy, file=sys.stderr)
                             if e.code() == grpc.StatusCode.UNKNOWN and 'status: 456' in e.details():
                                 # Wrong strategy, try the next one
                                 last_error = e
@@ -590,24 +602,23 @@ class Connection(object):
                             cluster_uuid=self.cluster_name,
                             timeout=self.grpc_auto_resume_timeout_seconds
                         ).resume()
-                        print(self._hash, self.cluster_name, 'Cluster resume status:', status, file=sys.stderr)
                         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_name, 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
+                            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:
@@ -615,7 +626,6 @@ class Connection(object):
                 else:
                     raise e
             except Exception as e:
-                print(self._hash, self.cluster_name, 'Error during authentication:', e, file=sys.stderr)
                 self._channel.close()
                 raise e
         return self._session_id

{e6data_python_connector-2.3.9rc5 → e6data_python_connector-2.3.9rc6}/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,8 +85,14 @@ 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}")
 
 
@@ -105,7 +111,13 @@ 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}")
 
 
@@ -160,11 +172,15 @@ 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.9rc5 → e6data_python_connector-2.3.9rc6/e6data_python_connector.egg-info}/PKG-INFO

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

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

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