cognee 0.5.0__py3-none-any.whl → 0.5.0.dev0__py3-none-any.whl

{cognee-0.5.0.dist-info → cognee-0.5.0.dev0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.28.0
+Generator: hatchling 1.27.0
 Root-Is-Purelib: true
 Tag: py3-none-any

cognee/api/v1/ui/node_setup.py

@@ -1,360 +0,0 @@
-import os
-import platform
-import subprocess
-import tempfile
-from pathlib import Path
-
-import requests
-
-from cognee.shared.logging_utils import get_logger
-
-logger = get_logger()
-
-
-def get_nvm_dir() -> Path:
-    """
-    Get the nvm directory path following standard nvm installation logic.
-    Uses XDG_CONFIG_HOME if set, otherwise falls back to ~/.nvm.
-    """
-    xdg_config_home = os.environ.get("XDG_CONFIG_HOME")
-    if xdg_config_home:
-        return Path(xdg_config_home) / "nvm"
-    return Path.home() / ".nvm"
-
-
-def get_nvm_sh_path() -> Path:
-    """
-    Get the path to nvm.sh following standard nvm installation logic.
-    """
-    return get_nvm_dir() / "nvm.sh"
-
-
-def check_nvm_installed() -> bool:
-    """
-    Check if nvm (Node Version Manager) is installed.
-    """
-    try:
-        # Check if nvm is available in the shell
-        # nvm is typically sourced in shell config files, so we need to check via shell
-        if platform.system() == "Windows":
-            # On Windows, nvm-windows uses a different approach
-            result = subprocess.run(
-                ["nvm", "version"],
-                capture_output=True,
-                text=True,
-                timeout=10,
-                shell=True,
-            )
-        else:
-            # On Unix-like systems, nvm is a shell function, so we need to source it
-            # First check if nvm.sh exists
-            nvm_path = get_nvm_sh_path()
-            if not nvm_path.exists():
-                logger.debug(f"nvm.sh not found at {nvm_path}")
-                return False
-
-            # Try to source nvm and check version, capturing errors
-            result = subprocess.run(
-                ["bash", "-c", f"source {nvm_path} && nvm --version"],
-                capture_output=True,
-                text=True,
-                timeout=10,
-            )
-
-            if result.returncode != 0:
-                # Log the error to help diagnose configuration issues
-                if result.stderr:
-                    logger.debug(f"nvm check failed: {result.stderr.strip()}")
-                return False
-
-        return result.returncode == 0
-    except Exception as e:
-        logger.debug(f"Exception checking nvm: {str(e)}")
-        return False
-
-
-def install_nvm() -> bool:
-    """
-    Install nvm (Node Version Manager) on Unix-like systems.
-    """
-    if platform.system() == "Windows":
-        logger.error("nvm installation on Windows requires nvm-windows.")
-        logger.error(
-            "Please install nvm-windows manually from: https://github.com/coreybutler/nvm-windows"
-        )
-        return False
-
-    logger.info("Installing nvm (Node Version Manager)...")
-
-    try:
-        # Download and install nvm
-        nvm_install_script = "https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.3/install.sh"
-        logger.info(f"Downloading nvm installer from {nvm_install_script}...")
-
-        response = requests.get(nvm_install_script, timeout=60)
-        response.raise_for_status()
-
-        # Create a temporary script file
-        with tempfile.NamedTemporaryFile(mode="w", suffix=".sh", delete=False) as f:
-            f.write(response.text)
-            install_script_path = f.name
-
-        try:
-            # Make the script executable and run it
-            os.chmod(install_script_path, 0o755)
-            result = subprocess.run(
-                ["bash", install_script_path],
-                capture_output=True,
-                text=True,
-                timeout=120,
-            )
-
-            if result.returncode == 0:
-                logger.info("✓ nvm installed successfully")
-                # Source nvm in current shell session
-                nvm_dir = get_nvm_dir()
-                if nvm_dir.exists():
-                    return True
-                else:
-                    logger.warning(
-                        f"nvm installation completed but nvm directory not found at {nvm_dir}"
-                    )
-                    return False
-            else:
-                logger.error(f"nvm installation failed: {result.stderr}")
-                return False
-        finally:
-            # Clean up temporary script
-            try:
-                os.unlink(install_script_path)
-            except Exception:
-                pass
-
-    except requests.exceptions.RequestException as e:
-        logger.error(f"Failed to download nvm installer: {str(e)}")
-        return False
-    except Exception as e:
-        logger.error(f"Failed to install nvm: {str(e)}")
-        return False
-
-
-def install_node_with_nvm() -> bool:
-    """
-    Install the latest Node.js version using nvm.
-    Returns True if installation succeeds, False otherwise.
-    """
-    if platform.system() == "Windows":
-        logger.error("Node.js installation via nvm on Windows requires nvm-windows.")
-        logger.error("Please install Node.js manually from: https://nodejs.org/")
-        return False
-
-    logger.info("Installing latest Node.js version using nvm...")
-
-    try:
-        # Source nvm and install latest Node.js
-        nvm_path = get_nvm_sh_path()
-        if not nvm_path.exists():
-            logger.error(f"nvm.sh not found at {nvm_path}. nvm may not be properly installed.")
-            return False
-
-        nvm_source_cmd = f"source {nvm_path}"
-        install_cmd = f"{nvm_source_cmd} && nvm install node"
-
-        result = subprocess.run(
-            ["bash", "-c", install_cmd],
-            capture_output=True,
-            text=True,
-            timeout=300,  # 5 minutes timeout for Node.js installation
-        )
-
-        if result.returncode == 0:
-            logger.info("✓ Node.js installed successfully via nvm")
-
-            # Set as default version
-            use_cmd = f"{nvm_source_cmd} && nvm alias default node"
-            subprocess.run(
-                ["bash", "-c", use_cmd],
-                capture_output=True,
-                text=True,
-                timeout=30,
-            )
-
-            # Add nvm to PATH for current session
-            # This ensures node/npm are available in subsequent commands
-            nvm_dir = get_nvm_dir()
-            if nvm_dir.exists():
-                # Update PATH for current process
-                nvm_bin = nvm_dir / "versions" / "node"
-                # Find the latest installed version
-                if nvm_bin.exists():
-                    versions = sorted(nvm_bin.iterdir(), reverse=True)
-                    if versions:
-                        latest_node_bin = versions[0] / "bin"
-                        if latest_node_bin.exists():
-                            current_path = os.environ.get("PATH", "")
-                            os.environ["PATH"] = f"{latest_node_bin}:{current_path}"
-
-            return True
-        else:
-            logger.error(f"Failed to install Node.js: {result.stderr}")
-            return False
-
-    except subprocess.TimeoutExpired:
-        logger.error("Timeout installing Node.js (this can take several minutes)")
-        return False
-    except Exception as e:
-        logger.error(f"Error installing Node.js: {str(e)}")
-        return False
-
-
-def check_node_npm() -> tuple[bool, str]:  # (is_available, error_message)
-    """
-    Check if Node.js and npm are available.
-    If not available, attempts to install nvm and Node.js automatically.
-    """
-
-    try:
-        # Check Node.js - try direct command first, then with nvm if needed
-        result = subprocess.run(["node", "--version"], capture_output=True, text=True, timeout=10)
-        if result.returncode != 0:
-            # If direct command fails, try with nvm sourced (in case nvm is installed but not in PATH)
-            nvm_path = get_nvm_sh_path()
-            if nvm_path.exists():
-                result = subprocess.run(
-                    ["bash", "-c", f"source {nvm_path} && node --version"],
-                    capture_output=True,
-                    text=True,
-                    timeout=10,
-                )
-                if result.returncode != 0 and result.stderr:
-                    logger.debug(f"Failed to source nvm or run node: {result.stderr.strip()}")
-        if result.returncode != 0:
-            # Node.js is not installed, try to install it
-            logger.info("Node.js is not installed. Attempting to install automatically...")
-
-            # Check if nvm is installed
-            if not check_nvm_installed():
-                logger.info("nvm is not installed. Installing nvm first...")
-                if not install_nvm():
-                    return (
-                        False,
-                        "Failed to install nvm. Please install Node.js manually from https://nodejs.org/",
-                    )
-
-            # Install Node.js using nvm
-            if not install_node_with_nvm():
-                return (
-                    False,
-                    "Failed to install Node.js. Please install Node.js manually from https://nodejs.org/",
-                )
-
-            # Verify installation after automatic setup
-            # Try with nvm sourced first
-            nvm_path = get_nvm_sh_path()
-            if nvm_path.exists():
-                result = subprocess.run(
-                    ["bash", "-c", f"source {nvm_path} && node --version"],
-                    capture_output=True,
-                    text=True,
-                    timeout=10,
-                )
-                if result.returncode != 0 and result.stderr:
-                    logger.debug(
-                        f"Failed to verify node after installation: {result.stderr.strip()}"
-                    )
-            else:
-                result = subprocess.run(
-                    ["node", "--version"], capture_output=True, text=True, timeout=10
-                )
-            if result.returncode != 0:
-                nvm_path = get_nvm_sh_path()
-                return (
-                    False,
-                    f"Node.js installation completed but node command is not available. Please restart your terminal or source {nvm_path}",
-                )
-
-        node_version = result.stdout.strip()
-        logger.debug(f"Found Node.js version: {node_version}")
-
-        # Check npm - handle Windows PowerShell scripts
-        if platform.system() == "Windows":
-            # On Windows, npm might be a PowerShell script, so we need to use shell=True
-            result = subprocess.run(
-                ["npm", "--version"], capture_output=True, text=True, timeout=10, shell=True
-            )
-        else:
-            # On Unix-like systems, if we just installed via nvm, we may need to source nvm
-            # Try direct command first
-            result = subprocess.run(
-                ["npm", "--version"], capture_output=True, text=True, timeout=10
-            )
-            if result.returncode != 0:
-                # Try with nvm sourced
-                nvm_path = get_nvm_sh_path()
-                if nvm_path.exists():
-                    result = subprocess.run(
-                        ["bash", "-c", f"source {nvm_path} && npm --version"],
-                        capture_output=True,
-                        text=True,
-                        timeout=10,
-                    )
-                    if result.returncode != 0 and result.stderr:
-                        logger.debug(f"Failed to source nvm or run npm: {result.stderr.strip()}")
-
-        if result.returncode != 0:
-            return False, "npm is not installed or not in PATH"
-
-        npm_version = result.stdout.strip()
-        logger.debug(f"Found npm version: {npm_version}")
-
-        return True, f"Node.js {node_version}, npm {npm_version}"
-
-    except subprocess.TimeoutExpired:
-        return False, "Timeout checking Node.js/npm installation"
-    except FileNotFoundError:
-        # Node.js is not installed, try to install it
-        logger.info("Node.js is not found. Attempting to install automatically...")
-
-        # Check if nvm is installed
-        if not check_nvm_installed():
-            logger.info("nvm is not installed. Installing nvm first...")
-            if not install_nvm():
-                return (
-                    False,
-                    "Failed to install nvm. Please install Node.js manually from https://nodejs.org/",
-                )
-
-        # Install Node.js using nvm
-        if not install_node_with_nvm():
-            return (
-                False,
-                "Failed to install Node.js. Please install Node.js manually from https://nodejs.org/",
-            )
-
-        # Retry checking Node.js after installation
-        try:
-            result = subprocess.run(
-                ["node", "--version"], capture_output=True, text=True, timeout=10
-            )
-            if result.returncode == 0:
-                node_version = result.stdout.strip()
-                # Check npm
-                nvm_path = get_nvm_sh_path()
-                if nvm_path.exists():
-                    result = subprocess.run(
-                        ["bash", "-c", f"source {nvm_path} && npm --version"],
-                        capture_output=True,
-                        text=True,
-                        timeout=10,
-                    )
-                    if result.returncode == 0:
-                        npm_version = result.stdout.strip()
-                        return True, f"Node.js {node_version}, npm {npm_version}"
-                    elif result.stderr:
-                        logger.debug(f"Failed to source nvm or run npm: {result.stderr.strip()}")
-        except Exception as e:
-            logger.debug(f"Exception retrying node/npm check: {str(e)}")
-
-        return False, "Node.js/npm not found. Please install Node.js from https://nodejs.org/"
-    except Exception as e:
-        return False, f"Error checking Node.js/npm: {str(e)}"

cognee/api/v1/ui/npm_utils.py

@@ -1,50 +0,0 @@
-import platform
-import subprocess
-from pathlib import Path
-from typing import List
-
-from cognee.shared.logging_utils import get_logger
-from .node_setup import get_nvm_sh_path
-
-logger = get_logger()
-
-
-def run_npm_command(cmd: List[str], cwd: Path, timeout: int = 300) -> subprocess.CompletedProcess:
-    """
-    Run an npm command, ensuring nvm is sourced if needed (Unix-like systems only).
-    Returns the CompletedProcess result.
-    """
-    if platform.system() == "Windows":
-        # On Windows, use shell=True for npm commands
-        return subprocess.run(
-            cmd,
-            cwd=cwd,
-            capture_output=True,
-            text=True,
-            timeout=timeout,
-            shell=True,
-        )
-    else:
-        # On Unix-like systems, try direct command first
-        result = subprocess.run(
-            cmd,
-            cwd=cwd,
-            capture_output=True,
-            text=True,
-            timeout=timeout,
-        )
-        # If it fails and nvm might be installed, try with nvm sourced
-        if result.returncode != 0:
-            nvm_path = get_nvm_sh_path()
-            if nvm_path.exists():
-                nvm_cmd = f"source {nvm_path} && {' '.join(cmd)}"
-                result = subprocess.run(
-                    ["bash", "-c", nvm_cmd],
-                    cwd=cwd,
-                    capture_output=True,
-                    text=True,
-                    timeout=timeout,
-                )
-                if result.returncode != 0 and result.stderr:
-                    logger.debug(f"npm command failed with nvm: {result.stderr.strip()}")
-        return result

cognee/eval_framework/Dockerfile

@@ -1,29 +0,0 @@
-FROM python:3.11-slim
-
-# Set environment variables
-ENV PIP_NO_CACHE_DIR=true
-ENV PATH="${PATH}:/root/.poetry/bin"
-ENV PYTHONPATH=/app
-ENV SKIP_MIGRATIONS=true
-
-# System dependencies
-RUN apt-get update && apt-get install -y \
-    gcc \
-    libpq-dev \
-    git \
-    curl \
-    build-essential \
-    && rm -rf /var/lib/apt/lists/*
-
-WORKDIR /app
-
-COPY pyproject.toml poetry.lock README.md /app/
-
-RUN pip install poetry
-
-RUN poetry config virtualenvs.create false
-
-RUN poetry install --extras distributed --extras evals --extras deepeval --no-root
-
-COPY cognee/ /app/cognee
-COPY distributed/ /app/distributed

cognee/infrastructure/databases/dataset_database_handler/__init__.py

@@ -1,3 +0,0 @@
-from .dataset_database_handler_interface import DatasetDatabaseHandlerInterface
-from .supported_dataset_database_handlers import supported_dataset_database_handlers
-from .use_dataset_database_handler import use_dataset_database_handler

cognee/infrastructure/databases/dataset_database_handler/dataset_database_handler_interface.py

@@ -1,80 +0,0 @@
-from typing import Optional
-from uuid import UUID
-from abc import ABC, abstractmethod
-
-from cognee.modules.users.models.User import User
-from cognee.modules.users.models.DatasetDatabase import DatasetDatabase
-
-
-class DatasetDatabaseHandlerInterface(ABC):
-    @classmethod
-    @abstractmethod
-    async def create_dataset(cls, dataset_id: Optional[UUID], user: Optional[User]) -> dict:
-        """
-        Return a dictionary with database connection/resolution info for a graph or vector database for the given dataset.
-        Function can auto handle deploying of the actual database if needed, but is not necessary.
-        Only providing connection info is sufficient, this info will be mapped when trying to connect to the provided dataset in the future.
-        Needed for Cognee multi-tenant/multi-user and backend access control support.
-
-        Dictionary returned from this function will be used to create a DatasetDatabase row in the relational database.
-        From which internal mapping of dataset -> database connection info will be done.
-
-        The returned dictionary is stored verbatim in the relational database and is later passed to
-        resolve_dataset_connection_info() at connection time. For safe credential handling, prefer
-        returning only references to secrets or role identifiers, not plaintext credentials.
-
-        Each dataset needs to map to a unique graph or vector database when backend access control is enabled to facilitate a separation of concern for data.
-
-        Args:
-            dataset_id: UUID of the dataset if needed by the database creation logic
-            user: User object if needed by the database creation logic
-        Returns:
-            dict: Connection info for the created graph or vector database instance.
-        """
-        pass
-
-    @classmethod
-    async def resolve_dataset_connection_info(
-        cls, dataset_database: DatasetDatabase
-    ) -> DatasetDatabase:
-        """
-        Resolve runtime connection details for a dataset’s backing graph/vector database.
-        Function is intended to be overwritten to implement custom logic for resolving connection info.
-
-        This method is invoked right before the application opens a connection for a given dataset.
-        It receives the DatasetDatabase row that was persisted when create_dataset() ran and must
-        return a modified instance of DatasetDatabase with concrete connection parameters that the client/driver can use.
-        Do not update these new DatasetDatabase values in the relational database to avoid storing secure credentials.
-
-        In case of separate graph and vector database handlers, each handler should implement its own logic for resolving
-        connection info and only change parameters related to its appropriate database, the resolution function will then
-        be called one after another with the updated DatasetDatabase value from the previous function as the input.
-
-        Typical behavior:
-        - If the DatasetDatabase row already contains raw connection fields (e.g., host/port/db/user/password
-        or api_url/api_key), return them as-is.
-        - If the row stores only references (e.g., secret IDs, vault paths, cloud resource ARNs/IDs, IAM
-        roles, SSO tokens), resolve those references by calling the appropriate secret manager or provider
-        API to obtain short-lived credentials and assemble the final connection DatasetDatabase object.
-        - Do not persist any resolved or decrypted secrets back to the relational database. Return them only
-        to the caller.
-
-        Args:
-            dataset_database: DatasetDatabase row from the relational database
-        Returns:
-            DatasetDatabase: Updated instance with resolved connection info
-        """
-        return dataset_database
-
-    @classmethod
-    @abstractmethod
-    async def delete_dataset(cls, dataset_database: DatasetDatabase) -> None:
-        """
-        Delete the graph or vector database for the given dataset.
-        Function should auto handle deleting of the actual database or send a request to the proper service to delete/mark the database as not needed for the given dataset.
-        Needed for maintaining a database for Cognee multi-tenant/multi-user and backend access control.
-
-        Args:
-            dataset_database: DatasetDatabase row containing connection/resolution info for the graph or vector database to delete.
-        """
-        pass

cognee/infrastructure/databases/dataset_database_handler/supported_dataset_database_handlers.py

@@ -1,18 +0,0 @@
-from cognee.infrastructure.databases.graph.neo4j_driver.Neo4jAuraDevDatasetDatabaseHandler import (
-    Neo4jAuraDevDatasetDatabaseHandler,
-)
-from cognee.infrastructure.databases.vector.lancedb.LanceDBDatasetDatabaseHandler import (
-    LanceDBDatasetDatabaseHandler,
-)
-from cognee.infrastructure.databases.graph.kuzu.KuzuDatasetDatabaseHandler import (
-    KuzuDatasetDatabaseHandler,
-)
-
-supported_dataset_database_handlers = {
-    "neo4j_aura_dev": {
-        "handler_instance": Neo4jAuraDevDatasetDatabaseHandler,
-        "handler_provider": "neo4j",
-    },
-    "lancedb": {"handler_instance": LanceDBDatasetDatabaseHandler, "handler_provider": "lancedb"},
-    "kuzu": {"handler_instance": KuzuDatasetDatabaseHandler, "handler_provider": "kuzu"},
-}

cognee/infrastructure/databases/dataset_database_handler/use_dataset_database_handler.py

@@ -1,10 +0,0 @@
-from .supported_dataset_database_handlers import supported_dataset_database_handlers
-
-
-def use_dataset_database_handler(
-    dataset_database_handler_name, dataset_database_handler, dataset_database_provider
-):
-    supported_dataset_database_handlers[dataset_database_handler_name] = {
-        "handler_instance": dataset_database_handler,
-        "handler_provider": dataset_database_provider,
-    }

cognee/infrastructure/databases/graph/kuzu/KuzuDatasetDatabaseHandler.py

@@ -1,81 +0,0 @@
-import os
-from uuid import UUID
-from typing import Optional
-
-from cognee.infrastructure.databases.graph.get_graph_engine import create_graph_engine
-from cognee.base_config import get_base_config
-from cognee.modules.users.models import User
-from cognee.modules.users.models import DatasetDatabase
-from cognee.infrastructure.databases.dataset_database_handler import DatasetDatabaseHandlerInterface
-
-
-class KuzuDatasetDatabaseHandler(DatasetDatabaseHandlerInterface):
-    """
-    Handler for interacting with Kuzu Dataset databases.
-    """
-
-    @classmethod
-    async def create_dataset(cls, dataset_id: Optional[UUID], user: Optional[User]) -> dict:
-        """
-        Create a new Kuzu instance for the dataset. Return connection info that will be mapped to the dataset.
-
-        Args:
-            dataset_id: Dataset UUID
-            user: User object who owns the dataset and is making the request
-
-        Returns:
-            dict: Connection details for the created Kuzu instance
-
-        """
-        from cognee.infrastructure.databases.graph.config import get_graph_config
-
-        graph_config = get_graph_config()
-
-        if graph_config.graph_database_provider != "kuzu":
-            raise ValueError(
-                "KuzuDatasetDatabaseHandler can only be used with Kuzu graph database provider."
-            )
-
-        graph_db_name = f"{dataset_id}.pkl"
-        graph_db_url = graph_config.graph_database_url
-        graph_db_key = graph_config.graph_database_key
-        graph_db_username = graph_config.graph_database_username
-        graph_db_password = graph_config.graph_database_password
-
-        return {
-            "graph_database_name": graph_db_name,
-            "graph_database_url": graph_db_url,
-            "graph_database_provider": graph_config.graph_database_provider,
-            "graph_database_key": graph_db_key,
-            "graph_dataset_database_handler": "kuzu",
-            "graph_database_connection_info": {
-                "graph_database_username": graph_db_username,
-                "graph_database_password": graph_db_password,
-            },
-        }
-
-    @classmethod
-    async def delete_dataset(cls, dataset_database: DatasetDatabase):
-        base_config = get_base_config()
-        databases_directory_path = os.path.join(
-            base_config.system_root_directory, "databases", str(dataset_database.owner_id)
-        )
-        graph_file_path = os.path.join(
-            databases_directory_path, dataset_database.graph_database_name
-        )
-        graph_engine = create_graph_engine(
-            graph_database_provider=dataset_database.graph_database_provider,
-            graph_database_url=dataset_database.graph_database_url,
-            graph_database_name=dataset_database.graph_database_name,
-            graph_database_key=dataset_database.graph_database_key,
-            graph_file_path=graph_file_path,
-            graph_database_username=dataset_database.graph_database_connection_info.get(
-                "graph_database_username", ""
-            ),
-            graph_database_password=dataset_database.graph_database_connection_info.get(
-                "graph_database_password", ""
-            ),
-            graph_dataset_database_handler="",
-            graph_database_port="",
-        )
-        await graph_engine.delete_graph()