e6data-python-connector 2.2.1rc4__tar.gz → 2.2.2__tar.gz

{e6data_python_connector-2.2.1rc4/e6data_python_connector.egg-info → e6data_python_connector-2.2.2}/PKG-INFO

@@ -1,9 +1,9 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: e6data-python-connector
-Version: 2.2.1rc4
+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
@@ -19,17 +19,26 @@ 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>=1.65.1
+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
+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.1rc4-blue.svg)
+![version](https://img.shields.io/badge/version-2.2.2-blue.svg)
 
 ## Introduction
 

{e6data_python_connector-2.2.1rc4 → e6data_python_connector-2.2.2}/README.md

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

e6data_python_connector-2.2.2/e6data_python_connector/cluster_manager.py

@@ -0,0 +1,261 @@
+import threading
+import time
+import e6data_python_connector.cluster_server.cluster_pb2 as cluster_pb2
+import e6data_python_connector.cluster_server.cluster_pb2_grpc as cluster_pb2_grpc
+import grpc
+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()
+
+
+status_lock = _StatusLock()
+
+
+class ClusterManager:
+    """
+    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),
+                credentials=grpc.ssl_channel_credentials()
+            )
+        else:
+            self._channel = grpc.insecure_channel(
+                target='{}:{}'.format(self._host, self._port)
+            )
+        return cluster_pb2_grpc.ClusterServiceStub(self._channel)
+
+    def resume(self) -> bool:
+        """
+        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,
+                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,
+                    metadata=_get_grpc_header(cluster=self.cluster_uuid)
+                )
+            elif current_status.status == 'active':
+                return True
+            elif current_status.status != 'resuming':
+                """
+                 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,
+                        metadata=_get_grpc_header(cluster=self.cluster_uuid)
+                    )
+                    if response.status == 'active':
+                        lock.set_active()
+                        return True
+                    if response.status in ['suspended', 'failed']:
+                        return False
+                    if time.time() > self._timeout:
+                        return False
+                except _InactiveRpcError as e:
+                    pass
+                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-2.2.1rc4 → e6data_python_connector-2.2.2}/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):
@@ -202,6 +223,10 @@ class Connection(object):
             )
         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):
         """
@@ -228,7 +253,8 @@ class Connection(object):
                             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(
@@ -496,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.
@@ -551,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,
@@ -635,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.1rc4 → e6data_python_connector-2.2.2/e6data_python_connector.egg-info}/PKG-INFO

@@ -1,9 +1,9 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: e6data-python-connector
-Version: 2.2.1rc4
+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
@@ -19,17 +19,26 @@ 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>=1.65.1
+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
+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.1rc4-blue.svg)
+![version](https://img.shields.io/badge/version-2.2.2-blue.svg)
 
 ## Introduction
 

e6data_python_connector-2.2.2/e6data_python_connector.egg-info/requires.txt

@@ -0,0 +1,8 @@
+sqlalchemy>=1.0.0
+future==1.0.0
+python-dateutil==2.9.0.post0
+pycryptodome==3.19.1
+pytz==2024.1
+thrift==0.20.0
+grpcio==1.65.1
+grpcio-tools

{e6data_python_connector-2.2.1rc4 → e6data_python_connector-2.2.2}/setup.py

@@ -12,35 +12,44 @@
 
 import setuptools
 
-VERSION = [2, 2, 1, 'rc4']
+VERSION = (2, 2, 2)
 
 
 def get_long_desc():
-    with open("README.md", "r") as fh:
-        long_description = fh.read()
-    return long_description
+    """
+    Reads the `README.md` file to provide a detailed description of the package.
+
+    Returns:
+        str: The content of the README.md file as a string.
+    """
+    try:
+        with open("README.md", "r", encoding="utf-8") as fh:  # Explicitly specifying encoding.
+            return fh.read()
+    except FileNotFoundError:
+        # Fallback if README.md is missing.
+        return "Client for the e6data distributed SQL Engine."
 
 
 setuptools.setup(
     name="e6data-python-connector",
-    version='.'.join('%s' % v for v in VERSION),
-    author="Uniphi, Inc.",
+    version=".".join(map(str, VERSION)),  # More Pythonic way to convert tuple to string.
+    author="e6data, Inc.",
     author_email="info@e6data.com",
     description="Client for the e6data distributed SQL Engine.",
     long_description=get_long_desc(),
     long_description_content_type="text/markdown",
     url='https://github.com/e6x-labs/e6data-python-connector',
-    packages=setuptools.find_packages(),
+    packages=setuptools.find_packages(),  # Automatically detects all packages in the source tree.
     license="Apache 2.0",
-    include_package_data=True,
+    include_package_data=True,  # Includes non-Python files specified in MANIFEST.in.
     install_requires=[
         'sqlalchemy>=1.0.0',
-        'future',
-        'python-dateutil',
-        'pycryptodome',
-        'pytz',
-        'thrift',
-        'grpcio>=1.65.1',
+        'future==1.0.0',
+        'python-dateutil==2.9.0.post0',
+        'pycryptodome==3.19.1',
+        'pytz==2024.1',
+        'thrift==0.20.0',
+        'grpcio==1.65.1',
         'grpcio-tools',
     ],
     classifiers=[

e6data_python_connector-2.2.1rc4/e6data_python_connector/cluster_manager.py

@@ -1,105 +0,0 @@
-import threading
-import time
-import e6data_python_connector.cluster_server.cluster_pb2 as cluster_pb2
-import e6data_python_connector.cluster_server.cluster_pb2_grpc as cluster_pb2_grpc
-import grpc
-from grpc._channel import _InactiveRpcError
-import multiprocessing
-
-
-class _StatusLock:
-    _LOCK_TIMEOUT = 500
-
-    def __init__(self):
-        self._status_thread_lock = threading.Lock()
-        self._status_multiprocessing_lock = multiprocessing.Semaphore()
-        self._is_active = False
-
-    @property
-    def is_active(self) -> bool:
-        return self._is_active
-
-    def set_active(self):
-        self._is_active = True
-
-    def __enter__(self):
-        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):
-        self._status_thread_lock.release()
-        self._status_multiprocessing_lock.release()
-
-
-status_lock = _StatusLock()
-
-
-class ClusterManager:
-    def __init__(self, host: str, port: int, user: str, password: str, secure_channel: bool = False, timeout=60 * 3):
-        self._host = host
-        self._port = port
-        self._user = user
-        self._password = password
-        self._timeout = time.time() + timeout
-        self._secure_channel = secure_channel
-
-    @property
-    def _get_connection(self):
-        if self._secure_channel:
-            self._channel = grpc.secure_channel(
-                target='{}:{}'.format(self._host, self._port),
-                credentials=grpc.ssl_channel_credentials()
-            )
-        else:
-            self._channel = grpc.insecure_channel(
-                target='{}:{}'.format(self._host, self._port)
-            )
-        return cluster_pb2_grpc.ClusterServiceStub(self._channel)
-
-    def resume(self) -> bool:
-        """
-        Return True if cluster came to active state else False.
-        """
-        with status_lock as lock:
-            if lock.is_active:
-                return True
-            status_payload = cluster_pb2.ClusterStatusRequest(
-                user=self._user,
-                password=self._password
-            )
-            current_status = self._get_connection.status(status_payload)
-            if current_status.status == 'suspended':
-                payload = cluster_pb2.ResumeRequest(
-                    user=self._user,
-                    password=self._password
-                )
-                response = self._get_connection.resume(payload)
-            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.
-                """
-                return False
-            while True:
-                try:
-                    status_payload = cluster_pb2.ClusterStatusRequest(
-                        user=self._user,
-                        password=self._password
-                    )
-                    response = self._get_connection.status(status_payload)
-                    if response.status == 'active':
-                        lock.set_active()
-                        return True
-                    if response.status in ['suspended', 'failed']:
-                        return False
-                    if time.time() > self._timeout:
-                        return False
-                except _InactiveRpcError as e:
-                    pass
-                time.sleep(5)
-
-    def suspend(self):
-        pass

e6data_python_connector-2.2.1rc4/e6data_python_connector.egg-info/requires.txt

@@ -1,8 +0,0 @@
-sqlalchemy>=1.0.0
-future
-python-dateutil
-pycryptodome
-pytz
-thrift
-grpcio>=1.65.1
-grpcio-tools