e6data-python-connector 2.2.1rc5__py3-none-any.whl → 2.2.2__py3-none-any.whl

e6data_python_connector/cluster_manager.py

@@ -7,27 +7,97 @@ from grpc._channel import _InactiveRpcError
 import multiprocessing
 
 
+def _get_grpc_header(engine_ip=None, cluster=None):
+    metadata = []
+    if engine_ip:
+        metadata.append(('plannerip', engine_ip))
+    if cluster:
+        metadata.append(('cluster-uuid', cluster))
+    return metadata
+
+
 class _StatusLock:
+    """
+    A thread-safe and process-safe lock manager designed for managing
+    concurrent access protection in multithreaded and multiprocessing environments.
+
+    This class encapsulates locking mechanisms using threading and multiprocessing
+    modules to ensure an operation's atomicity and handle shared resources safely.
+
+    Attributes:
+       _LOCK_TIMEOUT (int): The maximum timeout (in milliseconds) to try
+           acquiring a lock before raising an error.
+       _status_thread_lock (threading.Lock): A thread-level lock to synchronize
+           access among threads in the same process.
+       _status_multiprocessing_lock (multiprocessing.Semaphore): A
+           process-level lock to synchronize access across different processes.
+       _is_active (bool): A boolean flag indicating whether the lock
+           is currently active (True) or not (False).
+    """
+
     _LOCK_TIMEOUT = 500
 
     def __init__(self):
+        """
+        Initializes the _StatusLock instance with its respective
+        thread and multiprocessing locks and sets the active flag to False.
+        """
         self._status_thread_lock = threading.Lock()
         self._status_multiprocessing_lock = multiprocessing.Semaphore()
         self._is_active = False
 
     @property
     def is_active(self) -> bool:
+        """
+        Checks if the lock is currently active.
+
+        Returns:
+            bool: True if the lock is active, False otherwise.
+        """
+
         return self._is_active
 
     def set_active(self):
+        """
+        Activates the lock by setting the `_is_active` flag to True.
+        This can be used for manually marking the state of the lock
+        as active during synchronization operations.
+        """
+
         self._is_active = True
 
     def __enter__(self):
+        """
+        Enters a context-managed locking block.
+
+        Acquires both the thread-level lock and process-level semaphore
+        to ensure the current operation can safely access shared resources.
+
+        Raises:
+           TimeoutError: If the lock cannot be acquired within the timeout period.
+
+        Returns:
+           _StatusLock: The current instance of the lock, used for context management.
+        """
+
         self._status_thread_lock.acquire(timeout=self._LOCK_TIMEOUT)
         self._status_multiprocessing_lock.acquire(timeout=self._LOCK_TIMEOUT)
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):
+        """
+        Exits a context-managed locking block.
+
+        Releases both the thread-level lock and process-level semaphore
+        to allow other operations to acquire the lock. Handles cleanup
+        regardless of whether an exception occurred.
+
+        Args:
+            exc_type (Type[BaseException]): The type of exception raised (if any).
+            exc_val (BaseException): The exception instance raised (if any).
+            exc_tb (Traceback): The traceback object of the exception (if any).
+        """
+
         self._status_thread_lock.release()
         self._status_multiprocessing_lock.release()
 
@@ -36,16 +106,58 @@ status_lock = _StatusLock()
 
 
 class ClusterManager:
-    def __init__(self, host: str, port: int, user: str, password: str, secure_channel: bool = False, timeout=60 * 3):
+    """
+    A manager for handling operations and connections with a remote cluster infrastructure.
+    Provides methods to manage cluster states, such as resuming or suspending its activity,
+    by interacting with a gRPC-based remote service.
+
+    Attributes:
+        _host (str): The hostname or IP address of the cluster service.
+        _port (int): The port number used to connect to the cluster service.
+        _user (str): The username for authentication with the cluster service.
+        _password (str): The password for authentication with the cluster service.
+        _timeout (float): The timeout threshold (as an epoch timestamp) for operations,
+            defaulting to 3 minutes from initialization.
+        _secure_channel (bool): Indicates whether a secure gRPC channel
+            (SSL/TLS) should be used for communication; defaults to False.
+        cluster_uuid (str): The unique identifier for the target cluster.
+    """
+
+    def __init__(self, host: str, port: int, user: str, password: str, secure_channel: bool = False, timeout=60 * 3, cluster_uuid=None):
+        """
+        Initializes a new instance of the ClusterManager class.
+
+        Args:
+            host (str): The hostname or IP address of the cluster service.
+            port (int): The port number for accessing the cluster service.
+            user (str): The username used for connecting to the cluster service.
+            password (str): The password used for connecting to the cluster service.
+            secure_channel (bool, optional): Whether to use a secure
+                gRPC channel for communication; defaults to False.
+            timeout (int, optional): The timeout duration (in seconds) for operations;
+                defaults to 3 minutes.
+            cluster_uuid (str, optional): The unique identifier for the target cluster;
+                defaults to None.
+        """
+
         self._host = host
         self._port = port
         self._user = user
         self._password = password
         self._timeout = time.time() + timeout
         self._secure_channel = secure_channel
+        self.cluster_uuid = cluster_uuid
 
     @property
     def _get_connection(self):
+        """
+        Dynamically establishes a gRPC connection to the cluster service.
+
+        Returns:
+            cluster_pb2_grpc.ClusterServiceStub: A gRPC client stub
+                for interacting with the cluster service methods.
+        """
+
         if self._secure_channel:
             self._channel = grpc.secure_channel(
                 target='{}:{}'.format(self._host, self._port),
@@ -59,37 +171,75 @@ class ClusterManager:
 
     def resume(self) -> bool:
         """
-        Return True if cluster came to active state else False.
+        Resumes the cluster if it is currently suspended or not in the 'active' state.
+
+        This method interacts with the remote cluster service to verify its current
+        status. If suspended, it sends a resume request and monitors
+        the cluster's state until it becomes active or fails.
+
+        The operation uses a locking mechanism (`status_lock`) to ensure thread-safe
+        and process-safe state transitions.
+
+        Returns:
+            bool: True if the cluster resumes successfully and becomes active;
+                  False if the cluster cannot be resumed, remains suspended, or fails.
+
+        Raises:
+            _InactiveRpcError: An exception raised if there is a communication error
+                while interacting with the remote cluster service.
+
+        Notes:
+            - If the cluster is already active, this method completes successfully
+              without further actions.
+            - If the cluster is in a 'resuming' state, this method waits for the
+              cluster to transition to 'active' or any terminal state (e.g., 'failed').
+            - The operation is subject to the `_timeout` threshold;
+              if the timeout expires, the method returns False.
         """
+
         with status_lock as lock:
             if lock.is_active:
                 return True
+
+            # Retrieve the current cluster status
             status_payload = cluster_pb2.ClusterStatusRequest(
                 user=self._user,
                 password=self._password
             )
-            current_status = self._get_connection.status(status_payload)
+            current_status = self._get_connection.status(
+                status_payload,
+                metadata=_get_grpc_header(cluster=self.cluster_uuid)
+            )
             if current_status.status == 'suspended':
+                # Send the resume request
                 payload = cluster_pb2.ResumeRequest(
                     user=self._user,
                     password=self._password
                 )
-                response = self._get_connection.resume(payload)
+                response = self._get_connection.resume(
+                    payload,
+                    metadata=_get_grpc_header(cluster=self.cluster_uuid)
+                )
             elif current_status.status == 'active':
                 return True
             elif current_status.status != 'resuming':
                 """
-                If cluster is in resuming state already, start watching for the status.
-                Cluster is in different state, cannot resume.
-                """
+                 If cluster cannot be resumed due to its current state, 
+                 or already in a process of resuming, terminate the operation.
+                 """
                 return False
+
+            # Wait for the cluster to become active
             while True:
                 try:
                     status_payload = cluster_pb2.ClusterStatusRequest(
                         user=self._user,
                         password=self._password
                     )
-                    response = self._get_connection.status(status_payload)
+                    response = self._get_connection.status(
+                        status_payload,
+                        metadata=_get_grpc_header(cluster=self.cluster_uuid)
+                    )
                     if response.status == 'active':
                         lock.set_active()
                         return True
@@ -102,4 +252,10 @@ class ClusterManager:
                 time.sleep(5)
 
     def suspend(self):
+        """
+        Suspends the cluster operations (not implemented).
+
+        Placeholder method to be implemented for suspending a cluster,
+        typically interacting with the remote cluster service API.
+        """
         pass

e6data_python_connector/e6data_grpc.py

@@ -53,14 +53,35 @@ def _parse_timestamp(value):
             value = datetime.datetime.strptime(value, format)
         else:
             raise Exception(
-                'Cannot convert "{}" into a datetime'.format(value))
+                'Cannot convert "{}" into a datetime'.format(value)
+            )
     else:
         value = None
     return value
 
 
-TYPES_CONVERTER = {"DECIMAL_TYPE": Decimal,
-                   "TIMESTAMP_TYPE": _parse_timestamp}
+TYPES_CONVERTER = {
+    "DECIMAL_TYPE": Decimal,
+    "TIMESTAMP_TYPE": _parse_timestamp
+}
+
+
+def re_auth(func):
+    def wrapper(self, *args, **kwargs):
+        try:
+            return func(self, *args, **kwargs)
+        except _InactiveRpcError as e:
+            print(f'RE_AUTH: Function Name: {func}')
+            print(f'RE_AUTH: Error Found {e}')
+            if e.code() == grpc.StatusCode.INTERNAL and 'Access denied' in e.details():
+                print('RE_AUTH: Initialising re-authentication.')
+                self.connection.get_re_authenticate_session_id()
+                print(f'RE_AUTH: Re-auth successful.')
+                return func(self, *args, **kwargs)
+            else:
+                raise e
+
+    return wrapper
 
 
 class HiveParamEscaper(ParamEscaper):
@@ -148,8 +169,6 @@ class Connection(object):
                 - max_receive_message_length: This parameter sets the maximum allowed size (in bytes) for incoming messages on the gRPC server.
                 - 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).
-                #keep-alive parameters
-                - keepalive_time_ms: This parameter defines the time, in milliseconds, Default to 30 seconds
         """
         if not username or not password:
             raise ValueError("username or password cannot be empty.")
@@ -170,18 +189,16 @@ class Connection(object):
         self._auto_resume = auto_resume
 
         self._keepalive_timeout_ms = 900000
-        self._keepalive_time_ms = 30000
         self._max_receive_message_length = -1
         self._max_send_message_length = 300 * 1024 * 1024  # mb
         self.grpc_prepare_timeout = 10 * 60  # 10 minutes
 
-        if type(grpc_options) == dict:
+        if isinstance(grpc_options, dict):
             self._keepalive_timeout_ms = grpc_options.get('keepalive_timeout_ms') or self._keepalive_timeout_ms
             self._max_receive_message_length = grpc_options.get(
                 'max_receive_message_length') or self._max_receive_message_length
             self._max_send_message_length = grpc_options.get('max_send_message_length') or self._max_send_message_length
             self.grpc_prepare_timeout = grpc_options.get('grpc_prepare_timeout') or self.grpc_prepare_timeout
-            self._keepalive_time_ms = grpc_options.get('keepalive_time_ms') or self._keepalive_time_ms
         self._create_client()
 
     def _create_client(self):
@@ -191,12 +208,7 @@ class Connection(object):
                 options=[
                     ("grpc.keepalive_timeout_ms", self._keepalive_timeout_ms),
                     ('grpc.max_send_message_length', self._max_send_message_length),
-                    ('grpc.max_receive_message_length', self._max_receive_message_length),
-                    ('grpc.keepalive_time_ms', self._keepalive_time_ms),
-                    ('grpc.keepalive_permit_without_calls', 1),  # Allow keep-alives with no active RPCs
-                    ('grpc.http2.max_pings_without_data', 0),  # Unlimited pings without data
-                    ('grpc.http2.min_time_between_pings_ms', 15000),  # Minimum 15 seconds between pings
-                    ('grpc.http2.min_ping_interval_without_data_ms', 15000)# Minimum 15 seconds between pings without data
+                    ('grpc.max_receive_message_length', self._max_receive_message_length)
                 ],
                 credentials=grpc.ssl_channel_credentials()
             )
@@ -206,16 +218,15 @@ class Connection(object):
                 options=[
                     ("grpc.keepalive_timeout_ms", self._keepalive_timeout_ms),
                     ('grpc.max_send_message_length', self._max_send_message_length),
-                    ('grpc.max_receive_message_length', self._max_receive_message_length),
-                    ('grpc.keepalive_time_ms', self._keepalive_time_ms),
-                    ('grpc.keepalive_permit_without_calls', 1),  # Allow keep-alives with no active RPCs
-                    ('grpc.http2.max_pings_without_data', 0),  # Unlimited pings without data
-                    ('grpc.http2.min_time_between_pings_ms', 15000),  # Minimum 15 seconds between pings
-                    ('grpc.http2.min_ping_interval_without_data_ms', 15000)# Minimum 15 seconds between pings without data
+                    ('grpc.max_receive_message_length', self._max_receive_message_length)
                 ]
             )
         self._client = e6x_engine_pb2_grpc.QueryEngineServiceStub(self._channel)
 
+    def get_re_authenticate_session_id(self):
+        self._session_id = None
+        return self.get_session_id
+
     @property
     def get_session_id(self):
         """
@@ -236,13 +247,14 @@ class Connection(object):
                     raise ValueError("Invalid credentials.")
             except _InactiveRpcError as e:
                 if self._auto_resume:
-                    if e.code() == grpc.StatusCode.UNKNOWN and 'Stream removed' in e.details():
+                    if e.code() == grpc.StatusCode.UNAVAILABLE and 'status: 503' in e.details():
                         status = ClusterManager(
                             host=self._host,
                             port=self._port,
                             user=self.__username,
                             password=self.__password,
-                            secure_channel=self._secure_channel
+                            secure_channel=self._secure_channel,
+                            cluster_uuid=self.cluster_uuid
                         ).resume()
                         if status:
                             authenticate_request = e6x_engine_pb2.AuthenticateRequest(
@@ -510,6 +522,7 @@ class Cursor(DBAPICursor):
         )
         return self.connection.client.status(status_request, metadata=self.metadata)
 
+    @re_auth
     def execute(self, operation, parameters=None, **kwargs):
         """Prepare and execute a database operation (query or command).
         Return values are not defined.
@@ -565,6 +578,7 @@ class Cursor(DBAPICursor):
 
             self._query_id = prepare_statement_response.queryId
             self._engine_ip = prepare_statement_response.engineIP
+
             execute_statement_request = e6x_engine_pb2.ExecuteStatementV2Request(
                 engineIP=self._engine_ip,
                 sessionId=self.connection.get_session_id,
@@ -649,7 +663,6 @@ class Cursor(DBAPICursor):
         return self._fetch_all()
 
     def fetchmany(self, size: int = None):
-        # _logger.info("fetching all from overriden method")
         if size is None:
             size = self.arraysize
         if self._data is None:

{e6data_python_connector-2.2.1rc5.dist-info → e6data_python_connector-2.2.2.dist-info}/METADATA

@@ -1,9 +1,9 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: e6data-python-connector
-Version: 2.2.1rc5
+Version: 2.2.2
 Summary: Client for the e6data distributed SQL Engine.
 Home-page: https://github.com/e6x-labs/e6data-python-connector
-Author: Uniphi, Inc.
+Author: e6data, Inc.
 Author-email: info@e6data.com
 License: Apache 2.0
 Classifier: Operating System :: POSIX :: Linux
@@ -13,21 +13,32 @@ Classifier: Programming Language :: Python :: 3.6
 Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: sqlalchemy>=1.0.0
-Requires-Dist: future
-Requires-Dist: python-dateutil
-Requires-Dist: pycryptodome
-Requires-Dist: pytz
-Requires-Dist: thrift
-Requires-Dist: grpcio
+Requires-Dist: future==1.0.0
+Requires-Dist: python-dateutil==2.9.0.post0
+Requires-Dist: pycryptodome==3.19.1
+Requires-Dist: pytz==2024.1
+Requires-Dist: thrift==0.20.0
+Requires-Dist: grpcio==1.65.1
 Requires-Dist: grpcio-tools
-Requires-Dist: sqlalchemy
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: summary
 
 # e6data Python Connector
 
-![version](https://img.shields.io/badge/version-2.2.0-blue.svg)
+![version](https://img.shields.io/badge/version-2.2.2-blue.svg)
 
 ## Introduction
 

{e6data_python_connector-2.2.1rc5.dist-info → e6data_python_connector-2.2.2.dist-info}/RECORD

@@ -1,11 +1,11 @@
 e6data_python_connector/__init__.py,sha256=x_VwhPQ7XLlthR-NJL9Vl7lkLBRCG2pSjmyZSBHOBpM,103
-e6data_python_connector/cluster_manager.py,sha256=21UW7Sr4t5_ZlnxmcutLp-OI2jB1ldGnUmfRsa4qbxA,3635
+e6data_python_connector/cluster_manager.py,sha256=ZKxsMDgUuEKuRxNxo6vFhV8q4-Il3Rg-hX8niaACMso,10163
 e6data_python_connector/common.py,sha256=nk0CDQ5j1iu8DctBOXX4QypPYmxSgIgoA-Cn1UZXLic,9976
 e6data_python_connector/constants.py,sha256=h5w0lWiFsxz__zUZRlo1f72-8mT_vt9gcWvtWh0viFI,682
 e6data_python_connector/datainputstream.py,sha256=2XKW__PCGfTQ55Puqgie2LZdk_WU-YKwpEIUOQEF-sY,12592
 e6data_python_connector/date_time_utils.py,sha256=zmIwRhEGJwDvCOUjAl6VTDWGppluA-DPl_ioHTNpJKI,14413
 e6data_python_connector/dialect.py,sha256=hkVRjXxx9DhS8-aHpSoyMVhhHxVs3jdTE60x2aOAf5I,11312
-e6data_python_connector/e6data_grpc.py,sha256=fuIA7BFcr-9ZoA7Gn1H0cKMNDbPZ_LjEES2-Y3YoIDI,27491
+e6data_python_connector/e6data_grpc.py,sha256=B5MsAKsI6Syx9QGDpDOXxQn4tjEwiByA4HevrSczbFs,26981
 e6data_python_connector/exceptions.py,sha256=vrUqdzMq3LjbCmvr5_TcRq9eKmdqGfe-uVjR0BJQf5U,382
 e6data_python_connector/typeId.py,sha256=2EMNWK2SO5CBReNuJphma6xp-69r9GDwwys66t-kSk0,1777
 e6data_python_connector/cluster_server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -21,9 +21,9 @@ e6data_python_connector/server/e6x_engine_pb2.py,sha256=BxJjbijNrEqXQTWEhzLm54Fq
 e6data_python_connector/server/e6x_engine_pb2.pyi,sha256=_aQDLFbSCQ7ubK0Z5ZKh9_VAHFaXbMV55MXYXr85srg,18693
 e6data_python_connector/server/e6x_engine_pb2_grpc.py,sha256=n-eTCsAjsmpgPA_bDansKZq_zMmqkK6TlQGn6IdT6L4,46671
 e6data_python_connector/server/ttypes.py,sha256=uWxwSp4m6e-7SeSEckbZtSduGYmfzXWM09iy5eltBPA,21227
-e6data_python_connector-2.2.1rc5.dist-info/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
-e6data_python_connector-2.2.1rc5.dist-info/METADATA,sha256=t4CARz0HcgGFDIiBHcw5p3KSWJBJDTcIXEmApCawz7c,6944
-e6data_python_connector-2.2.1rc5.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-e6data_python_connector-2.2.1rc5.dist-info/entry_points.txt,sha256=MDK4cAOND0preLvq2Tlpnz00wXnP_Y_UopqJsAf3U7Y,77
-e6data_python_connector-2.2.1rc5.dist-info/top_level.txt,sha256=ChOS6qLf-SQycXr0uBiVxomIfYfbH2SgwrOWhW79ab0,24
-e6data_python_connector-2.2.1rc5.dist-info/RECORD,,
+e6data_python_connector-2.2.2.dist-info/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
+e6data_python_connector-2.2.2.dist-info/METADATA,sha256=SDpjML-yRccpZOxJSqLr_L1O9Ph7YHkokCdwCYrjRzk,7309
+e6data_python_connector-2.2.2.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
+e6data_python_connector-2.2.2.dist-info/entry_points.txt,sha256=MDK4cAOND0preLvq2Tlpnz00wXnP_Y_UopqJsAf3U7Y,77
+e6data_python_connector-2.2.2.dist-info/top_level.txt,sha256=ChOS6qLf-SQycXr0uBiVxomIfYfbH2SgwrOWhW79ab0,24
+e6data_python_connector-2.2.2.dist-info/RECORD,,

{e6data_python_connector-2.2.1rc5.dist-info → e6data_python_connector-2.2.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.6.0)
+Generator: setuptools (75.8.2)
 Root-Is-Purelib: true
 Tag: py3-none-any