fdc-shared-kernel 0.0.149__tar.gz → 0.0.151__tar.gz

{fdc_shared_kernel-0.0.149 → fdc_shared_kernel-0.0.151}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fdc_shared_kernel
-Version: 0.0.149
+Version: 0.0.151
 Summary: Shared library for microservice
 Author-email: Shikhil S <shikhil.s@dbizsolution.com>, Ahammed Akdham N <ahammedakdham.n@dbizsolution.com>
 Classifier: Programming Language :: Python :: 3
@@ -42,6 +42,7 @@ Requires-Dist: azure-storage-queue==12.13.0
 Requires-Dist: pyodbc==5.1.0
 Requires-Dist: redshift_connector==2.1.2
 Requires-Dist: pypika
+Requires-Dist: snowflake-connector-python==3.16.0
 
 # FDC Shared Kernel
 

{fdc_shared_kernel-0.0.149 → fdc_shared_kernel-0.0.151}/fdc_shared_kernel.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fdc_shared_kernel
-Version: 0.0.149
+Version: 0.0.151
 Summary: Shared library for microservice
 Author-email: Shikhil S <shikhil.s@dbizsolution.com>, Ahammed Akdham N <ahammedakdham.n@dbizsolution.com>
 Classifier: Programming Language :: Python :: 3
@@ -42,6 +42,7 @@ Requires-Dist: azure-storage-queue==12.13.0
 Requires-Dist: pyodbc==5.1.0
 Requires-Dist: redshift_connector==2.1.2
 Requires-Dist: pypika
+Requires-Dist: snowflake-connector-python==3.16.0
 
 # FDC Shared Kernel
 

{fdc_shared_kernel-0.0.149 → fdc_shared_kernel-0.0.151}/fdc_shared_kernel.egg-info/SOURCES.txt

@@ -38,10 +38,12 @@ shared_kernel/data_warehouse_handlers/__init__.py
 shared_kernel/data_warehouse_handlers/factory.py
 shared_kernel/data_warehouse_handlers/mssql_handler.py
 shared_kernel/data_warehouse_handlers/redshift_handler.py
+shared_kernel/data_warehouse_handlers/snowflake_handler.py
 shared_kernel/data_warehouse_handlers/utils.py
 shared_kernel/data_warehouse_handlers/warehouse_handlers_map.py
 shared_kernel/data_warehouse_handlers/connections/mssql_warehouse_connection.py
 shared_kernel/data_warehouse_handlers/connections/redshift_warehouse_connection.py
+shared_kernel/data_warehouse_handlers/connections/snowflake_warehouse_connection.py
 shared_kernel/data_warehouse_handlers/query_executors/redshift_databricks_snowflake_query_executor.py
 shared_kernel/data_warehouse_handlers/query_executors/sqlalchemy_query_executor.py
 shared_kernel/database/__init__.py

{fdc_shared_kernel-0.0.149 → fdc_shared_kernel-0.0.151}/fdc_shared_kernel.egg-info/requires.txt

@@ -32,3 +32,4 @@ azure-storage-queue==12.13.0
 pyodbc==5.1.0
 redshift_connector==2.1.2
 pypika
+snowflake-connector-python==3.16.0

{fdc_shared_kernel-0.0.149 → fdc_shared_kernel-0.0.151}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "fdc_shared_kernel"
-version = "0.0.149"
+version = "0.0.151"
 requires-python = ">=3.7"
 readme = "README_pypi.md"
 description = "Shared library for microservice"

{fdc_shared_kernel-0.0.149 → fdc_shared_kernel-0.0.151}/requirements.txt

@@ -32,3 +32,4 @@ azure-storage-queue==12.13.0
 pyodbc==5.1.0
 redshift_connector==2.1.2
 pypika
+snowflake-connector-python==3.16.0

{fdc_shared_kernel-0.0.149 → fdc_shared_kernel-0.0.151}/shared_kernel/ai_chat_persistence/chat_persistence.py

@@ -9,7 +9,7 @@ config = Config()
 logger = Logger(config.get("APP_NAME"))
 
 class AIChatPersistence:
-    def __init__(self, session_token: str, org_id = None, user_id = None, payload = {}):
+    def __init__(self, session_token: str, name_space: str, org_id=None, user_id=None,  payload={}):
         self.session_token = session_token
         self.user_id = user_id
         if not self.session_token:
@@ -28,10 +28,8 @@ class AIChatPersistence:
             bus_type=config.get("ASYNC_EVENT_BUS_TYPE"),
             config={},
         )
-    
+        self.name_space = name_space
     def publish_event(self, data: dict):
-        self.data_bus.publish_event(event_name=data.get(
-            "event_name"), event_payload=data)
         return True
 
     
@@ -43,6 +41,7 @@ class AIChatPersistence:
                 "role": role,
                 "message_type": message_type,
                 "message": message,
+                "name_space": self.name_space
             },
            "event_meta": {
                "trace_id": self.trace_id,

fdc_shared_kernel-0.0.151/shared_kernel/data_warehouse_handlers/connections/snowflake_warehouse_connection.py

@@ -0,0 +1,139 @@
+import time
+import snowflake.connector
+from contextlib import contextmanager
+from snowflake.connector.errors import (
+    OperationalError,
+    ProgrammingError,
+    InterfaceError,
+    DatabaseError,
+)
+
+from shared_kernel.data_warehouse_handlers.utils import extract_snowflake_error_message
+from shared_kernel.dataclasses.warehouse_configs import SnowflakeConfig
+from shared_kernel.exceptions.http_exceptions import BadRequest
+from shared_kernel.interfaces.warehouse_connection import DataWarehouseConnection
+from shared_kernel.config import Config
+from shared_kernel.logger import Logger
+
+config = Config()
+logger = Logger(config.get("APP_NAME"))
+
+
+class SnowflakeWarehouseConnection(DataWarehouseConnection):
+    LIST_SCHEMAS_QUERY: str = """
+        SELECT schema_name
+        FROM information_schema.schemata
+        WHERE schema_name NOT IN ('INFORMATION_SCHEMA','SNOWFLAKE')
+        ORDER BY schema_name;
+    """
+    def __init__(self, source_config: SnowflakeConfig):
+        self._conn = None
+        self._cursor = None
+        self._snowflake_config = source_config
+        self.org_schema = None
+
+        if self._snowflake_config and self._snowflake_config.schema:
+            self.org_schema = self._snowflake_config.schema
+
+    def _create_connection_with_retry(self, retries: int = 3, delay: int = 5):
+        """Try to establish a connection with retry mechanism."""
+        for attempt in range(retries):
+            try:
+                try:
+                    cfg = self._snowflake_config
+                    logger.debug(f"Snowflake connection configuration: {cfg.__dict__}")
+
+                    self._conn = snowflake.connector.connect(
+                        user=cfg.user,
+                        password=cfg.password,
+                        account=cfg.account,
+                        database=cfg.database,
+                        schema=cfg.schema,
+                    )
+
+                except (InterfaceError, OperationalError, ProgrammingError, DatabaseError) as e:
+                    error_message = extract_snowflake_error_message(str(e))
+                    raise BadRequest(f"Connection to warehouse failed: {error_message}")
+
+                self._cursor = self._conn.cursor()
+
+                if not self.is_valid_connection():
+                    raise BadRequest("Connection validation failed")
+
+            except BadRequest as e:
+                logger.error(
+                    f"Connection attempt {attempt + 1} failed: {str(e)}",
+                    exc_info=True,
+                )
+
+                if attempt == retries - 1:
+                    raise BadRequest(str(e)) from e
+
+            except Exception as e:
+                logger.error(
+                    f"Connection attempt {attempt + 1} failed: {str(e)}",
+                    exc_info=True,
+                )
+
+                if attempt == retries - 1:
+                    raise BadRequest(
+                        f"Failed to connect after {retries} attempts due to {str(e)}"
+                    ) from e
+
+                time.sleep(delay)
+                self.close_connection()
+
+    @contextmanager
+    def get_connection(self, retries: int = 3, delay: float = 5):
+        """Context manager for database connections with retry mechanism"""
+        if not (self._conn and self.is_valid_connection()):
+            self._create_connection_with_retry(retries, delay)
+        try:
+            yield self._cursor
+        except Exception as e:
+            raise e
+        finally:
+            self._conn.commit()
+        return
+
+    def is_valid_connection(self) -> bool:
+        """Validate connection with a simple query"""
+        try:
+            if self._cursor is None:
+                return False
+            self._cursor.execute(
+                "SELECT current_user, current_database(), current_version();"
+            )
+            user, db, version = self._cursor.fetchone()
+            logger.debug(
+                f"Connected as {user} to {db}, version: {version}"
+            )
+            return True
+        except (OperationalError, ProgrammingError, InterfaceError) as e:
+            logger.error(f"Exception: {str(e)}")
+            raise e
+        except Exception as e:
+            logger.error(f"Exception: {str(e)}")
+            raise Exception(f"Connection failed.")
+
+    def close_connection(self):
+        """Safely close database connection"""
+        try:
+            if self._cursor:
+                self._cursor.close()
+                logger.info(
+                    f"Terminated warehouse cursor connection."
+                )
+            if self._conn:
+                self._conn.close()
+                logger.info(
+                    f"Terminated warehouse connection."
+                )
+        except Exception as e:
+            logger.error(
+                f"Error closing connection: {str(e)}",
+                exc_info=True,
+            )
+        finally:
+            self._cursor = None
+            self._conn = None

fdc_shared_kernel-0.0.151/shared_kernel/data_warehouse_handlers/snowflake_handler.py

@@ -0,0 +1,39 @@
+from pypika import Query
+
+from shared_kernel.data_warehouse_handlers.connections.snowflake_warehouse_connection import SnowflakeWarehouseConnection
+from shared_kernel.data_warehouse_handlers.query_executors.redshift_databricks_snowflake_query_executor import RedshiftDatabricksSnowflakeQueryExecutor
+from shared_kernel.dataclasses.warehouse_configs import SnowflakeConfig
+from shared_kernel.interfaces.data_warehouse_handler import WarehouseHandler
+
+
+class SnowflakeWarehouseHandler(WarehouseHandler):
+
+    def __init__(self, payload: dict=None):
+        super().__init__(payload)
+        self.payload = payload or {}
+        self.organization_license_type = self.payload.get("organization_license_type")
+        self.organization_id = self.payload.get("organization_id")
+
+    def get_config(self) -> SnowflakeConfig:
+        return SnowflakeConfig(
+            user=str(self.payload.get("user")).strip(),
+            password=str(self.payload.get("password")).strip(),
+            account=str(self.payload.get("account")).strip(),
+            database=str(self.payload.get("database")).strip(),
+            schema=str(self.payload.get("schema")).strip(),
+            schema_list=self.payload.get("schema_list"),
+        )    
+
+    def get_connection_object(self) -> SnowflakeWarehouseConnection:
+        self.connection = SnowflakeWarehouseConnection(
+            source_config=self.get_config()
+        )
+        return self.connection
+    
+    def get_query_executor_object(self) -> RedshiftDatabricksSnowflakeQueryExecutor:
+        self.query_executor = RedshiftDatabricksSnowflakeQueryExecutor(warehouse_connection=self.connection)
+        return self.query_executor
+    
+    def get_query_object(self) -> Query:
+        return Query
+