e6data-python-connector 2.2.1rc5__tar.gz → 2.2.2.3rc2__tar.gz

{e6data_python_connector-2.2.1rc5/e6data_python_connector.egg-info → e6data_python_connector-2.2.2.3rc2}/PKG-INFO

@@ -1,9 +1,9 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: e6data-python-connector
-Version: 2.2.1rc5
+Version: 2.2.2.3rc2
 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.3.rc2-blue.svg)
 
 ## Introduction
 

{e6data_python_connector-2.2.1rc5 → e6data_python_connector-2.2.2.3rc2}/README.md

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

e6data_python_connector-2.2.2.3rc2/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.1rc5 → e6data_python_connector-2.2.2.3rc2}/e6data_python_connector/e6data_grpc.py

@@ -11,6 +11,7 @@ import datetime
 import logging
 import re
 import sys
+import time
 from decimal import Decimal
 from io import BytesIO
 from ssl import CERT_NONE, CERT_OPTIONAL, CERT_REQUIRED
@@ -53,14 +54,38 @@ 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):
+        max_retry = 5
+        current_retry = 0
+        while current_retry < max_retry:
+            try:
+                return func(self, *args, **kwargs)
+            except _InactiveRpcError as e:
+                current_retry += 1
+                if current_retry == max_retry:
+                    raise e
+                if e.code() == grpc.StatusCode.INTERNAL and 'Access denied' in e.details():
+                    time.sleep(0.2)
+                    print(f'RE_AUTH: Function Name: {func}')
+                    print(f'RE_AUTH: Error Found {e}')
+                else:
+                    raise e
+
+    return wrapper
 
 
 class HiveParamEscaper(ParamEscaper):
@@ -148,8 +173,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 +193,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 +212,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 +222,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 +251,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 +526,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 +582,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 +667,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 → e6data_python_connector-2.2.2.3rc2/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.1rc5
+Version: 2.2.2.3rc2
 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.3.rc2-blue.svg)
 
 ## Introduction
 

e6data_python_connector-2.2.2.3rc2/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.1rc5 → e6data_python_connector-2.2.2.3rc2}/setup.py

@@ -12,37 +12,45 @@
 
 import setuptools
 
-VERSION = [2, 2, 1, "rc5"]
+VERSION = (2, 2, 2, '3.rc2')
 
 
 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',
+        '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',
-        'sqlalchemy'
     ],
     classifiers=[
         "Operating System :: POSIX :: Linux",
@@ -51,7 +59,10 @@ setuptools.setup(
         'Programming Language :: Python :: 3.6',
         'Programming Language :: Python :: 3.7',
         'Programming Language :: Python :: 3.8',
-        'Programming Language :: Python :: 3.9'
+        'Programming Language :: Python :: 3.9',
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
     ],
     entry_points={
         'sqlalchemy.dialects': [

e6data_python_connector-2.2.1rc5/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.1rc5/e6data_python_connector.egg-info/requires.txt

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