graflo 1.3.3__py3-none-any.whl

graflo/db/connection/wsgi.py

@@ -0,0 +1,29 @@
+from typing import Dict
+
+from pydantic import Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class WSGIConfig(BaseSettings):
+    """Configuration for WSGI connections.
+
+    Note: WSGI is not a database db, so it doesn't inherit from DBConfig.
+    This is kept separate from database db configurations.
+    """
+
+    model_config = SettingsConfigDict(
+        env_prefix="WSGI_",
+        case_sensitive=False,
+    )
+
+    uri: str | None = Field(default=None, description="WSGI URI")
+    path: str = Field(default="/", description="WSGI path")
+    paths: Dict[str, str] = Field(
+        default_factory=dict, description="WSGI paths mapping"
+    )
+    listen_addr: str = Field(default="0.0.0.0", description="Listen address")
+
+    @classmethod
+    def from_docker_env(cls, docker_dir: str | None = None) -> "WSGIConfig":
+        """WSGI config doesn't typically use docker env files."""
+        raise NotImplementedError("WSGI config doesn't support from_docker_env")

graflo/db/manager.py

@@ -0,0 +1,119 @@
+"""Database connection manager for graph and source databases.
+
+This module provides a connection manager for handling database connections
+to different database implementations (ArangoDB, Neo4j, PostgreSQL, etc.).
+It manages connection lifecycle and configuration.
+
+Key Components:
+    - ConnectionManager: Main class for managing database connections
+    - DBType: Enum for supported database types
+
+The manager supports:
+    - Target databases (ArangoDB, Neo4j, TigerGraph) - OUTPUT
+    - Source databases (PostgreSQL, MySQL, MongoDB, etc.) - INPUT
+    - Connection configuration
+    - Context manager interface
+    - Automatic connection cleanup
+
+Example:
+    >>> from graflo.db.connection.onto import ArangoConfig
+    >>> config = ArangoConfig.from_env()
+    >>> with ConnectionManager(connection_config=config) as conn:
+    ...     conn.execute("FOR doc IN collection RETURN doc")
+"""
+
+from graflo.db.arango.conn import ArangoConnection
+from graflo.db.connection.onto import DBConfig, DBType, TARGET_DATABASES
+from graflo.db.neo4j.conn import Neo4jConnection
+from graflo.db.tigergraph.conn import TigerGraphConnection
+
+
+class ConnectionManager:
+    """Manager for database connections (both graph and source databases).
+
+    This class manages database connections to different database
+    implementations. It provides a context manager interface for safe
+    connection handling and automatic cleanup.
+
+    Supports:
+    - Target databases (OUTPUT): ArangoDB, Neo4j, TigerGraph
+    - Source databases (INPUT): PostgreSQL, MySQL, MongoDB, etc.
+
+    Attributes:
+        target_conn_mapping: Mapping of target database types to connection classes
+        config: Connection configuration
+        working_db: Current working database name
+        conn: Active database connection
+    """
+
+    # Target database connections (OUTPUT)
+    target_conn_mapping = {
+        DBType.ARANGO: ArangoConnection,
+        DBType.NEO4J: Neo4jConnection,
+        DBType.TIGERGRAPH: TigerGraphConnection,
+    }
+
+    # Source database connections (INPUT) - to be implemented
+    # source_conn_mapping = {
+    #     DBType.POSTGRES: PostgresConnection,
+    #     DBType.MYSQL: MySQLConnection,
+    #     DBType.MONGODB: MongoDBConnection,
+    # }
+
+    def __init__(
+        self,
+        connection_config: DBConfig,
+        **kwargs,
+    ):
+        """Initialize the connection manager.
+
+        Args:
+            connection_config: Database connection configuration
+            **kwargs: Additional configuration parameters
+        """
+        self.config: DBConfig = connection_config
+        self.working_db = kwargs.pop("working_db", None)
+        self.conn = None
+
+    def __enter__(self):
+        """Enter the context manager.
+
+        Creates and returns a new database connection.
+
+        Returns:
+            Connection: Database connection instance
+        """
+        # Check if database can be used as target
+        if not self.config.can_be_target():
+            raise ValueError(
+                f"Database type '{self.config.connection_type}' cannot be used as a target. "
+                f"Only these types can be targets: {[t.value for t in TARGET_DATABASES]}"
+            )
+
+        db_type = self.config.connection_type
+        cls = self.target_conn_mapping[db_type]
+
+        if self.working_db is not None:
+            self.config.database = self.working_db
+        self.conn = cls(config=self.config)
+        return self.conn
+
+    def close(self):
+        """Close the database connection.
+
+        Closes the active connection and performs any necessary cleanup.
+        """
+        if self.conn is not None:
+            self.conn.close()
+
+    def __exit__(self, exc_type, exc_value, exc_traceback):
+        """Exit the context manager.
+
+        Ensures the connection is properly closed when exiting the context.
+
+        Args:
+            exc_type: Exception type if an exception occurred
+            exc_value: Exception value if an exception occurred
+            exc_traceback: Exception traceback if an exception occurred
+        """
+        self.close()

graflo/db/neo4j/__init__.py

@@ -0,0 +1,16 @@
+"""Neo4j database implementation.
+
+This package provides Neo4j-specific implementations of the database interface,
+including connection management, query execution, and utility functions.
+
+Key Components:
+    - Neo4jConnection: Neo4j connection implementation
+    - Query: Cypher query execution and profiling
+    - Util: Neo4j-specific utility functions
+
+Example:
+    >>> from graflo.db.neo4j import Neo4jConnection
+    >>> conn = Neo4jConnection(config)
+    >>> result = conn.execute("MATCH (n:User) RETURN n")
+    >>> nodes = result.data()
+"""