e6data-python-connector 2.3.7rc2__py3-none-any.whl → 2.3.9__py3-none-any.whl

e6data_python_connector/dialect.py

@@ -229,6 +229,7 @@ class E6dataDialect(default.DefaultDialect):
         self.cluster_name = url.query.get("cluster-name")
         self.secure = url.query.get("secure") == "true"
         self.auto_resume = url.query.get("auto-resume", "true") == "true"  # default to True
+        self.debug = url.query.get("debug", "false") == "true"  # default to True
         if not self.catalog_name:
             raise Exception('Please specify catalog in query parameter.')
 
@@ -250,7 +251,8 @@ class E6dataDialect(default.DefaultDialect):
             "cluster_name": self.cluster_name,
             'secure': self.secure,
             'auto_resume': self.auto_resume,
-            'grpc_options': grpc_options
+            'grpc_options': grpc_options,
+            'debug': self.debug
         }
         return [], kwargs
 

e6data_python_connector/e6data_grpc.py

@@ -128,26 +128,18 @@ _local_strategy_cache = {
 # Strategy cache timeout in seconds (5 minutes)
 STRATEGY_CACHE_TIMEOUT = 300
 
+# Global set to track debug-enabled connections
+_debug_connections = set()
+
+def _strategy_debug_log(message):
+    """Log strategy debug messages if any connection has debug enabled."""
+    if _debug_connections:
+        print(f"[E6DATA_STRATEGY_DEBUG] {time.strftime('%Y-%m-%d %H:%M:%S')} - {message}")
+
 
 def _get_shared_strategy():
     """Get or create the shared strategy storage."""
-    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
+    return _local_strategy_cache
 
 
 def _get_active_strategy():
@@ -175,10 +167,14 @@ def _set_active_strategy(strategy):
     with _strategy_lock:
         shared_strategy = _get_shared_strategy()
         current_time = time.time()
+        old_strategy = shared_strategy.get('active_strategy')
 
         # Only update transition time if strategy actually changed
-        if shared_strategy['active_strategy'] != normalized_strategy:
+        if old_strategy != normalized_strategy:
             shared_strategy['last_transition_time'] = current_time
+            _strategy_debug_log(f"Setting active strategy: {old_strategy} -> {normalized_strategy}")
+        else:
+            _strategy_debug_log(f"Active strategy unchanged: {normalized_strategy}")
 
         shared_strategy['active_strategy'] = normalized_strategy
         shared_strategy['last_check_time'] = current_time
@@ -188,6 +184,9 @@ def _clear_strategy_cache():
     """Clear the cached strategy to force re-detection."""
     with _strategy_lock:
         shared_strategy = _get_shared_strategy()
+        old_strategy = shared_strategy.get('active_strategy')
+        if old_strategy:
+            _strategy_debug_log(f"Clearing strategy cache (was: {old_strategy})")
         shared_strategy['active_strategy'] = None
         shared_strategy['last_check_time'] = 0
         shared_strategy['pending_strategy'] = None
@@ -208,6 +207,8 @@ def _set_pending_strategy(strategy):
 
         if normalized_strategy != current_active:
             shared_strategy['pending_strategy'] = normalized_strategy
+            query_count = len(shared_strategy.get('query_strategy_map', {}))
+            _strategy_debug_log(f"Setting pending strategy: {normalized_strategy} (current: {current_active}, active queries: {query_count})")
 
 
 def _apply_pending_strategy():
@@ -219,11 +220,15 @@ def _apply_pending_strategy():
             new_strategy = shared_strategy['pending_strategy']
             current_time = time.time()
 
+            _strategy_debug_log(f"Applying pending strategy: {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
+            
+            _strategy_debug_log(f"Strategy transition complete. All sessions invalidated.")
 
             return new_strategy
         return None
@@ -250,6 +255,7 @@ 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}")
 
 
 def _get_query_strategy(query_id):
@@ -271,8 +277,11 @@ def _cleanup_query_strategy(query_id):
         shared_strategy = _get_shared_strategy()
         query_map = shared_strategy.get('query_strategy_map', {})
         if query_id in query_map:
+            strategy = query_map[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}")
 
 
 def _get_strategy_debug_info():
@@ -317,7 +326,9 @@ class Connection(object):
             cluster_name: str = None,
             secure: bool = False,
             auto_resume: bool = True,
+            scheme: str = 'e6data',
             grpc_options: dict = None,
+            debug: bool = False,
     ):
         """
         Parameters
@@ -340,6 +351,8 @@ class Connection(object):
                 Flag to use a secure channel for data transfer
             auto_resume: bool, Optional
                 Flag to enable auto resume of the cluster before the query execution
+            scheme: string, Optional
+                e6data supported scheme
             grpc_options: dict, Optional
                 Specify gRPC configuration
                 - keepalive_timeout_ms: This parameter defines the time, in milliseconds, that a gRPC connection should remain idle before sending a keepalive ping to check if the connection is still alive.
@@ -347,6 +360,8 @@ class Connection(object):
                 - max_send_message_length: Similar to max_receive_message_length, this parameter sets the maximum allowed size (in bytes) for outgoing messages from the gRPC client
                 - grpc_prepare_timeout: Timeout for prepare statement API call (default to 10 minutes).
                 - keepalive_time_ms: This parameter defines the time, in milliseconds, Default to 30 seconds
+            debug: bool, Optional
+                Flag to enable debug logging for blue-green deployment strategy changes
         """
         if not username or not password:
             raise ValueError("username or password cannot be empty.")
@@ -376,6 +391,13 @@ class Connection(object):
             The default maximum time on client side to wait for the cluster to resume is 5 minutes.
             """
             self.grpc_auto_resume_timeout_seconds = self._grpc_options.pop('grpc_auto_resume_timeout_seconds')
+        
+        # Store debug flag and register with debug connections
+        self._debug = debug
+        if self._debug:
+            _debug_connections.add(id(self))
+            _strategy_debug_log(f"Debug mode enabled for connection {id(self)}")
+        
         self._create_client()
 
     @property
@@ -502,6 +524,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}")
                     try:
                         authenticate_response = self._client.authenticate(
                             authenticate_request,
@@ -515,10 +538,15 @@ 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
+                            _strategy_debug_log(f"Got 456 error with strategy {active_strategy}, clearing cache and retrying")
                             _clear_strategy_cache()
                             active_strategy = None
                         else:
@@ -537,8 +565,10 @@ class Connection(object):
                     else:
                         # Always try blue first, then green if it fails with 456
                         strategies = ['blue', 'green']
+                        _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}")
                         try:
                             authenticate_response = self._client.authenticate(
                                 authenticate_request,
@@ -547,19 +577,24 @@ 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}")
                                 _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():
                                 # Wrong strategy, try the next one
+                                _strategy_debug_log(f"Strategy {strategy} failed with 456 error, trying next")
                                 last_error = e
                                 continue
                             else:
@@ -586,21 +621,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:
@@ -646,6 +666,11 @@ class Connection(object):
             self._channel.close()
             self._channel = None
         self._session_id = None
+        
+        # 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)}")
 
     def check_connection(self):
         """
@@ -1092,6 +1117,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")
             _apply_pending_strategy()
 
         return clear_response
@@ -1115,6 +1141,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")
             _apply_pending_strategy()
 
     def status(self, query_id):

e6data_python_connector/strategy.py

@@ -40,24 +40,7 @@ def _initialize_shared_state():
     with _initialization_lock:
         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
+        return _local_strategy_cache
 
 
 def _get_shared_strategy():

{e6data_python_connector-2.3.7rc2.dist-info → e6data_python_connector-2.3.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: e6data-python-connector
-Version: 2.3.7rc2
+Version: 2.3.9
 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.7rc2-blue.svg)
+![version](https://img.shields.io/badge/version-2.3.9-blue.svg)
 
 ## Introduction
 
@@ -93,6 +93,55 @@ conn = Connection(
 )
 ```
 
+#### Connection Parameters
+
+The `Connection` class supports the following parameters:
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `host` | str | Yes | - | IP address or hostname of the e6data cluster |
+| `port` | int | Yes | - | Port of the e6data engine (typically 80) |
+| `username` | str | Yes | - | Your e6data Email ID |
+| `password` | str | Yes | - | Access Token generated in the e6data console |
+| `database` | str | No | None | Database to perform queries on |
+| `catalog` | str | No | None | Catalog name |
+| `cluster_name` | str | No | None | Name of the cluster for cluster-specific operations |
+| `secure` | bool | No | False | Enable SSL/TLS for secure connections |
+| `auto_resume` | bool | No | True | Automatically resume cluster if suspended |
+| `grpc_options` | dict | No | None | Additional gRPC configuration options |
+
+#### Secure Connection Example
+
+To establish a secure connection using SSL/TLS:
+
+```python
+conn = Connection(
+    host=host,
+    port=443,  # Typically 443 for secure connections
+    username=username,
+    password=password,
+    database=database,
+    cluster_name='production-cluster',
+    secure=True  # Enable SSL/TLS
+)
+```
+
+#### Cluster-Specific Connection
+
+When working with multiple clusters, specify the cluster name:
+
+```python
+conn = Connection(
+    host=host,
+    port=port,
+    username=username,
+    password=password,
+    database=database,
+    cluster_name='analytics-cluster-01',  # Specify cluster name
+    secure=True
+)
+```
+
 ### Perform a Queries & Get Results
 
 ```python

{e6data_python_connector-2.3.7rc2.dist-info → e6data_python_connector-2.3.9.dist-info}/RECORD

@@ -4,10 +4,10 @@ e6data_python_connector/common.py,sha256=nk0CDQ5j1iu8DctBOXX4QypPYmxSgIgoA-Cn1UZ
 e6data_python_connector/constants.py,sha256=h5w0lWiFsxz__zUZRlo1f72-8mT_vt9gcWvtWh0viFI,682
 e6data_python_connector/datainputstream.py,sha256=nHQmb0kAdNJWSubhJ6M156EZjBjImpiQOGKlxXC0DnA,25841
 e6data_python_connector/date_time_utils.py,sha256=zmIwRhEGJwDvCOUjAl6VTDWGppluA-DPl_ioHTNpJKI,14413
-e6data_python_connector/dialect.py,sha256=4GHNzbbOULhXqi9WPJ7oz-d8aLVze41Zp4uSQ43QAv8,11626
-e6data_python_connector/e6data_grpc.py,sha256=bKmtPaJfCZv395njTjJSOem8kVHCfTkL-nsNtcPqMWc,57701
+e6data_python_connector/dialect.py,sha256=oj-vyH_P6RQcRzRgDHN8dTwTQpkB2meaNMvykWpdTzc,11741
+e6data_python_connector/e6data_grpc.py,sha256=9loOth3-7d8T7VWUIXUVGkCBfdSizy4OtgvaAfd79VI,59208
 e6data_python_connector/exceptions.py,sha256=vrUqdzMq3LjbCmvr5_TcRq9eKmdqGfe-uVjR0BJQf5U,382
-e6data_python_connector/strategy.py,sha256=bv01noiP6TN80LBWeuRw1HoMaCacFP1rDWOxktIo11w,7334
+e6data_python_connector/strategy.py,sha256=whAC-C031XFirP71hXKqdiMTJRIUUEvc34tuo2W8k-0,6539
 e6data_python_connector/typeId.py,sha256=2EMNWK2SO5CBReNuJphma6xp-69r9GDwwys66t-kSk0,1777
 e6data_python_connector/cluster_server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 e6data_python_connector/cluster_server/cluster_pb2.py,sha256=BWxO5vG1SVkx2y-i6A6wvP5sfb8KNKosyl2N5lIsVd8,2339
@@ -62,9 +62,9 @@ test/tests_grpc.py,sha256=VRqJwW2BVRpL3c0BnwCKvtowogAS_0JYa1Ss4ynqTss,5916
 test/validate_decimal128.py,sha256=8m7FFD3nOHFkPKpN1kCd5MDDzfeEEJnMnOoSeXmX_I0,3320
 test/validate_implementation.py,sha256=2keEodBGxztdG1kgavTq-p-cLw1L9UNQLkXTfIijBNQ,5569
 test/verify_decimal_fix.py,sha256=n7XUV4dbo7kTdx-mVqhha9Nr6_bkDudwplHTdV-rM_Y,1051
-e6data_python_connector-2.3.7rc2.dist-info/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
-e6data_python_connector-2.3.7rc2.dist-info/METADATA,sha256=G5Ict2zfOSkxDqnJfZaIWR4FzW0DhULXhQMFr4TM5hA,12777
-e6data_python_connector-2.3.7rc2.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-e6data_python_connector-2.3.7rc2.dist-info/entry_points.txt,sha256=MDK4cAOND0preLvq2Tlpnz00wXnP_Y_UopqJsAf3U7Y,77
-e6data_python_connector-2.3.7rc2.dist-info/top_level.txt,sha256=uOWV7xMMlZxe030EIU4bGUuKJ-W78lKxX4YHA7YFclw,29
-e6data_python_connector-2.3.7rc2.dist-info/RECORD,,
+e6data_python_connector-2.3.9.dist-info/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
+e6data_python_connector-2.3.9.dist-info/METADATA,sha256=QKpmS6oLS0597Tnzui5eB2bXAX_NzFgaFcp-1Iqqrv8,14325
+e6data_python_connector-2.3.9.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
+e6data_python_connector-2.3.9.dist-info/entry_points.txt,sha256=MDK4cAOND0preLvq2Tlpnz00wXnP_Y_UopqJsAf3U7Y,77
+e6data_python_connector-2.3.9.dist-info/top_level.txt,sha256=uOWV7xMMlZxe030EIU4bGUuKJ-W78lKxX4YHA7YFclw,29
+e6data_python_connector-2.3.9.dist-info/RECORD,,