abstract-solcatcher-database 0.0.0.1__py3-none-any.whl

abstract_solcatcher_database/__init__.py

@@ -0,0 +1,6 @@
+from .db_funcs import *
+from .pair_updates import *
+from .query_functions import *
+from .utils import *
+from .transaction_utils import *
+from .managers import *

abstract_solcatcher_database/dbUtils.py

@@ -0,0 +1,327 @@
+import psycopg2,logging,traceback
+from psycopg2.extras import DictCursor
+from psycopg2 import sql, pool
+from abstract_utilities import make_list,SingletonMeta
+from abstract_security import get_env_value
+from abstract_utilities import get_logFile
+import logging,requests,httpx
+from logging.handlers import RotatingFileHandler
+from .python import *
+from typing import *
+from psycopg2.extras import RealDictCursor
+SOLCATCHER_POSTGRESQL_DBURL = get_env_value("SOLCATCHER_POSTGRESQL_DBURL")
+from threading import Lock
+from abstract_apis import get_headers
+from .python.db.dbConfig import getConnection
+# Load queries from JSON file
+# Asynchronous function to call Solcatcher TS
+async def async_call_solcatcher_ts(endpoint: str, **kwargs) -> Optional[Dict[str, Any]]:
+    async with httpx.AsyncClient() as client:
+        try:
+            response = await client.post(
+                url=f'https://solcatcher.io/ts/{endpoint}',
+                json=kwargs,
+                headers=get_headers()
+            )
+            response.raise_for_status()
+            response_data = response.json()
+            if isinstance(response_data, dict):
+                return response_data.get('result', response_data)
+            return response_data
+        except httpx.HTTPError as http_err:
+            logger.error(f"HTTP error occurred in async_call_solcatcher_ts: {http_err}")
+            return None
+        except Exception as err:
+            logger.error(f"An error occurred in async_call_solcatcher_ts: {err}")
+            return None
+def call_solcatcher_ts(endpoint: str, **kwargs) -> Optional[Dict[str, Any]]:
+        try:
+            response = requests.post(
+                url=f'https://solcatcher.io/ts/{endpoint}',
+                json=kwargs,
+                headers=get_headers()
+            )
+            response.raise_for_status()
+            response_data = response.json()
+            if isinstance(response_data, dict):
+                return response_data.get('result', response_data)
+            return response_data
+        except httpx.HTTPError as http_err:
+            logger.error(f"HTTP error occurred in async_call_solcatcher_ts: {http_err}")
+            return None
+        except Exception as err:
+            logger.error(f"An error occurred in async_call_solcatcher_ts: {err}")
+            return None
+# Asynchronous function to call Solcatcher DB
+async def async_call_solcatcher_db(endpoint: str, **kwargs) -> Optional[Dict[str, Any]]:
+    async with httpx.AsyncClient() as client:
+        try:
+            response = await client.post(
+                url=f'https://solcatcher.io/dbCalls/{endpoint}',
+                json=kwargs,
+                headers=get_headers()
+            )
+            response.raise_for_status()
+            response_data = response.json()
+            if isinstance(response_data, dict):
+                return response_data.get('result', response_data)
+            return response_data
+        except httpx.HTTPError as http_err:
+            logger.error(f"HTTP error occurred in async_call_solcatcher_db: {http_err}")
+            return None
+        except Exception as err:
+            logger.error(f"An error occurred in async_call_solcatcher_db: {err}")
+            return None
+# Asynchronous function to call Solcatcher DB
+def call_solcatcher_db(endpoint: str, **kwargs) -> Optional[Dict[str, Any]]:
+
+        try:
+            response = requests.post(
+                url=f'https://solcatcher.io/dbCalls/{endpoint}',
+                json=kwargs,
+                headers=get_headers()
+            )
+            response.raise_for_status()
+            response_data = response.json()
+            if isinstance(response_data, dict):
+                return response_data.get('result', response_data)
+            return response_data
+        except httpx.HTTPError as http_err:
+            logger.error(f"HTTP error occurred in async_call_solcatcher_db: {http_err}")
+            return None
+        except Exception as err:
+            logger.error(f"An error occurred in async_call_solcatcher_db: {err}")
+            return None
+logger=get_logFile('db')
+def get_connection():
+    """Get a connection from the pool."""
+    try:
+        logger.debug("Acquiring connection...")
+        conn = getConnection()
+        logger.debug("Connection acquired.")
+        return conn
+    except Exception as e:
+        logger.error(f"Error getting a connection from the pool: {e}")
+        return None
+def execute_query(query, values=None):
+    conn = get_connection()
+    try:
+        with conn.cursor(cursor_factory=RealDictCursor) as cursor:
+            logger.debug(f"Executing query: {query} with values: {values}")
+            cursor.execute(query, values)
+            if query.strip().lower().startswith("select"):
+                results = cursor.fetchall()  # Returns list of dictionaries
+                return results
+            else:
+                conn.commit()
+                return None
+    except Exception as e:
+        logger.error(f"Error executing query: {query} | Values: {values} | Error: {e}")
+        raise
+    finally:
+        release_connection(conn)
+def release_connection(conn):
+    """Release a connection back to the pool."""
+    try:
+        if conn:
+            logger.debug("Releasing connection...")
+            conn.close()  # Use conn.close() to release the connection
+            logger.debug("Connection released.")
+    except Exception as e:
+        logger.error(f"Error releasing the connection back to the pool: {e}")
+class columnNamesManager(metaclass=SingletonMeta):
+    def __init__(self):
+        if not hasattr(self, 'initialized'):  
+            self.initialized = True
+            self.columnNames = {}
+            self.lock = Lock()
+
+    def get_column_names(self, tableName, schema='public'):
+        with self.lock:
+            if tableName not in self.columnNames:
+                self.columnNames[tableName] = self.fetch_column_names(tableName, schema)
+        return self.columnNames[tableName]
+
+    def fetch_column_names(self, tableName, schema='public'):
+        """
+        Query column names for a table in a schema using information_schema.columns.
+        """
+        query = sql.SQL("""
+            SELECT column_name
+            FROM information_schema.columns
+            WHERE table_name = %s AND table_schema = %s
+            ORDER BY ordinal_position;
+        """)
+        
+        results = execute_query(query, [tableName, schema])
+        
+        if not results:
+            logger.warning(f"No columns found for table {tableName} in schema {schema}")
+        
+        return [row['column_name'] for row in results]
+
+    def zip_rows(self, tableName, rows, schema='public'):
+        column_names = self.get_column_names(tableName, schema)
+        return [dict(zip(column_names, row)) for row in rows]
+
+
+
+
+def run_query(query, values=()):
+    """
+    Run a SQL query and return the result.
+    """
+    conn = get_connection()
+    try:
+        with conn.cursor(cursor_factory=RealDictCursor) as cursor:
+            logger.debug(f"Running query: {query} with values: {values}")
+            cursor.execute(query, values)
+            if query.strip().lower().startswith("select"):
+                return cursor.fetchall()  # Return results as list of dictionaries
+            conn.commit()  # Commit for non-SELECT queries
+            return None
+    except Exception as e:
+        logger.error(f"Error running query: {query} | Values: {values} | Error: {e}")
+        raise
+    finally:
+        release_connection(conn)
+
+def aggregate_rows(query, values=None, errorMsg='Error Fetching Rows'):
+
+    try:
+        execute_query(query, values=values)
+    except Exception as e:
+        error_details = f"{errorMsg}:\n{str(e)}\nTraceback:\n{traceback.format_exc()}"
+
+
+
+
+def fetch_any_combo(columnNames='*', tableName='*', searchColumn=None, searchValue=None, anyValue=False, notNull=False, zipit=True, schema='public'):
+    conn = get_connection()
+    try:
+        # Validate inputs
+        if anyValue:
+            if not isinstance(searchValue, (list, tuple)):
+                raise ValueError("When 'anyValue' is True, 'searchValue' must be a list or tuple.")
+            if not searchValue:
+                raise ValueError("'searchValue' list cannot be empty when 'anyValue' is True.")
+        else:
+            if isinstance(searchValue, (list, tuple)):
+                if len(searchValue) != 1:
+                    raise ValueError("When 'anyValue' is False, 'searchValue' must be a single value.")
+                searchValue = searchValue[0]  # Extract the single value
+
+        # Prepare base query
+        if columnNames != '*':
+            if not isinstance(columnNames, list):
+                raise ValueError("'columnNames' must be a list of column names or '*'")
+            columns = sql.SQL(", ").join([sql.Identifier(col) for col in columnNames])
+        else:
+            columns = sql.SQL('*')
+        
+        query = sql.SQL("SELECT {} FROM {}.{}").format(
+            columns,
+            sql.Identifier(schema),
+            sql.Identifier(tableName),
+        )
+        params = []
+
+        # Handle search conditions
+        if searchColumn:
+            if searchValue is not None:
+                if anyValue:  # Handle multiple values using IN
+                    query += sql.SQL(" WHERE {} IN %s").format(sql.Identifier(searchColumn))
+                    params.append(tuple(searchValue))
+                else:  # Single value match
+                    query += sql.SQL(" WHERE {} = %s").format(sql.Identifier(searchColumn))
+                    params.append(searchValue)
+            elif notNull:
+                query += sql.SQL(" WHERE {} IS NOT NULL").format(sql.Identifier(searchColumn))
+        
+        rows = execute_query(query, params)
+
+        # Zip results if required
+        if zipit:
+            rows = getZipRows(tableName, rows, schema)
+        return rows
+
+    except Exception as e:
+        logger.error(f"Error in fetch_any_combo: {e}", exc_info=True)
+        return []
+    finally:
+        release_connection(conn)
+
+
+
+def real_query(query,params=[]):
+    conn = get_connection()
+    try:
+        with conn.cursor(cursor_factory=RealDictCursor) as cursor:  # Use RealDictCursor for named columns
+            cursor.execute(query, params)
+            results = cursor.fetchall()  # Fetch all rows as dictionaries
+        return results  # Already zipped by column names
+    except Exception as e:
+        logger.error(f"Error executing query: {e}", exc_info=True)
+        return []
+    finally:
+        release_connection(conn)
+
+def fetch_filtered_transactions_paginated(
+    sol_amount, 
+    operator="<", 
+    timestamp=None, 
+    timestamp_operator=None, 
+    limit=50, 
+    offset=0
+):
+    # SQL Query
+    query = f"""
+    SELECT
+        p.*, 
+        t.*,
+        m.*,
+        t2.id AS related_txn
+    FROM 
+        transactions t
+    JOIN 
+        pairs p ON t.pair_id = p.id
+    LEFT JOIN 
+        metadata m ON p.meta_id = m.id
+    LEFT JOIN 
+        transactions t2 ON t.pair_id = t2.pair_id AND t.signature != t2.signature
+    WHERE 
+        t.signature IN (
+            SELECT signature FROM pairs WHERE signature IS NOT NULL
+        )
+    AND 
+        t.program_id = p.program_id
+    AND 
+        EXISTS (
+            SELECT 1
+            FROM jsonb_array_elements(t.tcns) AS elem
+            WHERE (elem ->> 'sol_amount')::numeric {operator} %s
+    """
+
+    # Parameters for query execution
+    params = [sol_amount]
+
+    # Add timestamp filtering if provided
+    if timestamp and timestamp_operator:
+        query += f" AND (elem ->> 'timestamp')::bigint {timestamp_operator} %s"
+        params.append(int(timestamp))
+
+    # Add sorting and pagination
+    query += f") ORDER BY t.updated_at DESC LIMIT %s OFFSET %s;"
+    params.extend([limit, offset])
+
+    # Database connection and execution
+    response =  execute_query(query, params)
+    return response
+
+def get_column_names(tableName):
+    columns = columnNamesManager().get_column_names(tableName, schema='public')
+    return columns
+def getZipRows(tableName, rows, schema='public'):
+    columnNames = get_column_names(tableName)
+    return [dict(zip(columnNames, row)) for row in rows]
+