cognee 1.2.2.dev3__tar.gz → 1.2.2.dev4__tar.gz

{cognee-1.2.2.dev3 → cognee-1.2.2.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognee
-Version: 1.2.2.dev3
+Version: 1.2.2.dev4
 Summary: Cognee - is a library for enriching LLM context with a semantic layer for better understanding and reasoning.
 Project-URL: Homepage, https://www.cognee.ai
 Project-URL: Repository, https://github.com/topoteretes/cognee

{cognee-1.2.2.dev3 → cognee-1.2.2.dev4}/cognee/api/v1/export/export.py

@@ -18,6 +18,7 @@ async def export(
     destination: Optional[Union[str, Path]] = None,
     user=None,
     link_relations: bool = False,
+    include_permissions: bool = False,
 ) -> GraphSnapshot: ...
 
 
@@ -28,6 +29,7 @@ async def export(
     destination: Optional[Union[str, Path]] = None,
     user=None,
     link_relations: bool = False,
+    include_permissions: bool = False,
 ) -> ExportResult: ...
 
 
@@ -39,6 +41,7 @@ async def export(
     destination: Optional[Union[str, Path]] = None,
     user=None,
     link_relations: bool = False,
+    include_permissions: bool = False,
 ) -> ExportResult: ...
 
 
@@ -48,6 +51,7 @@ async def export(
     destination: Optional[Union[str, Path]] = None,
     user=None,
     link_relations: bool = False,
+    include_permissions: bool = False,
 ) -> Union[ExportResult, GraphSnapshot]:
     """Export a dataset's knowledge graph.
 
@@ -97,4 +101,5 @@ async def export(
             destination=destination,
             user=user,
             link_relations=link_relations,
+            include_permissions=include_permissions,
         )

{cognee-1.2.2.dev3 → cognee-1.2.2.dev4}/cognee/memify_pipelines/persist_agent_trace_feedbacks_in_knowledge_graph.py

@@ -81,7 +81,6 @@ async def persist_agent_trace_feedbacks_in_knowledge_graph_pipeline(
         extraction_tasks=extraction_tasks,
         enrichment_tasks=enrichment_tasks,
         dataset=dataset_to_write[0].id,
-        user=user,
         data=[{}],
         run_in_background=run_in_background,
     )

{cognee-1.2.2.dev3 → cognee-1.2.2.dev4}/cognee/memify_pipelines/persist_sessions_in_knowledge_graph.py

@@ -52,14 +52,13 @@ async def persist_sessions_in_knowledge_graph_pipeline(
         extraction_tasks = [Task(extract_user_sessions, session_ids=session_ids)]
 
         enrichment_tasks = [
-            Task(cognify_session, dataset_id=dataset_to_write[0].id, user=user),
+            Task(cognify_session, dataset_id=dataset_to_write[0].id),
         ]
 
         result = await memify(
             extraction_tasks=extraction_tasks,
             enrichment_tasks=enrichment_tasks,
             dataset=dataset_to_write[0].id,
-            user=user,
             data=[{}],
             run_in_background=run_in_background,
         )

{cognee-1.2.2.dev3 → cognee-1.2.2.dev4}/cognee/modules/migration/cogx.py

@@ -169,6 +169,7 @@ RECORD_FILES: Dict[str, str] = {
 
 MANIFEST_FILE = "manifest.json"
 RAW_NODES_FILE = "nodes.jsonl"
+PERMISSIONS_FILE = "permissions.json"
 
 
 class COGXManifest(BaseModel):
@@ -177,6 +178,11 @@ class COGXManifest(BaseModel):
     exported_at: Optional[datetime] = None
     counts: Dict[str, int] = Field(default_factory=dict)
     embedding_model: Optional[str] = None
+    # Cognee-origin archives only: the source store's stamped data-migration
+    # revision at export time. Raw nodes keep their source-store ids, so the
+    # importing store must not claim a newer revision than the exported data
+    # actually has (None = unknown; the import keeps its own stamp).
+    migration_revision: Optional[str] = None
     notes: List[str] = Field(default_factory=list)
 
 
@@ -209,12 +215,13 @@ class COGXArchiveWriter:
     def __init__(self, directory: Union[str, Path], source_system: str = "cognee"):
         self.directory = Path(directory)
         self.directory.mkdir(parents=True, exist_ok=True)
-        for file_name in (*RECORD_FILES.values(), RAW_NODES_FILE, MANIFEST_FILE):
+        for file_name in (*RECORD_FILES.values(), RAW_NODES_FILE, MANIFEST_FILE, PERMISSIONS_FILE):
             (self.directory / file_name).unlink(missing_ok=True)
         self.source_system = source_system
         self.counts: Dict[str, int] = {}
         self.notes: List[str] = []
         self.embedding_model: Optional[str] = None
+        self.migration_revision: Optional[str] = None
         self._handles: Dict[str, Any] = {}
 
     def __enter__(self) -> "COGXArchiveWriter":
@@ -254,6 +261,7 @@ class COGXArchiveWriter:
                 exported_at=datetime.now(timezone.utc),
                 counts=self.counts,
                 embedding_model=self.embedding_model,
+                migration_revision=self.migration_revision,
                 notes=self.notes,
             )
             manifest_path = self.directory / MANIFEST_FILE
@@ -269,6 +277,25 @@ def read_manifest(directory: Union[str, Path]) -> Optional[COGXManifest]:
     return manifest
 
 
+def write_social_layer(directory: Union[str, Path], payload: Dict[str, Any]) -> None:
+    """Persist the dataset's social layer (owner + grants, WITH credentials).
+
+    Written only on explicit request (``export(include_permissions=True)``):
+    the payload carries user emails, password HASHES, and account flags, so an
+    archive containing this file must be handled as a secret, not just data.
+    """
+    (Path(directory) / PERMISSIONS_FILE).write_text(
+        json.dumps(payload, indent=2, default=str), encoding="utf-8"
+    )
+
+
+def read_social_layer(directory: Union[str, Path]) -> Optional[Dict[str, Any]]:
+    permissions_path = Path(directory) / PERMISSIONS_FILE
+    if not permissions_path.exists():
+        return None
+    return json.loads(permissions_path.read_text(encoding="utf-8"))
+
+
 def _archive_file(base: Path, file_name: str) -> Optional[Path]:
     """Resolve ``base / file_name`` and confirm it stays inside ``base``.
 

{cognee-1.2.2.dev3 → cognee-1.2.2.dev4}/cognee/modules/migration/export.py

@@ -14,7 +14,7 @@ Formats:
 
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Optional, Union
+from typing import Any, Dict, Optional, Union
 from uuid import UUID
 
 from cognee.modules.migration.cogx import (
@@ -23,6 +23,7 @@ from cognee.modules.migration.cogx import (
     COGXEntity,
     COGXFact,
     parse_timestamp,
+    write_social_layer,
 )
 from cognee.modules.migration.formats import write_cypher, write_graphml, write_json
 from cognee.modules.migration.snapshot import GraphSnapshot, build_snapshot
@@ -51,13 +52,98 @@ class ExportResult:
         )
 
 
+def _user_payload(user_row) -> Dict[str, Any]:
+    return {
+        "email": user_row.email,
+        "hashed_password": user_row.hashed_password,
+        "is_active": user_row.is_active,
+        "is_superuser": user_row.is_superuser,
+        "is_verified": user_row.is_verified,
+    }
+
+
+async def _gather_social_layer(dataset_obj) -> Dict[str, Any]:
+    """The dataset's owner and ACL grants, including user credentials.
+
+    Emails, password hashes, and account flags are included so a
+    cognee-to-cognee restore can recreate functional accounts — which makes
+    an archive carrying this payload a SECRET. Only gathered on explicit
+    request (``include_permissions=True``).
+    """
+    from sqlalchemy import select
+
+    from cognee.infrastructure.databases.relational import get_relational_engine
+    from cognee.modules.users.models import ACL, Permission, User
+
+    db_engine = get_relational_engine()
+    async with db_engine.get_async_session() as session:
+        owner = await session.get(User, dataset_obj.owner_id)
+        rows = (
+            await session.execute(
+                select(User, Permission.name)
+                .join(ACL, ACL.principal_id == User.id)
+                .join(Permission, Permission.id == ACL.permission_id)
+                .where(ACL.dataset_id == dataset_obj.id)
+            )
+        ).all()
+
+    grants: Dict[str, Dict[str, Any]] = {}
+    for user_row, permission_name in rows:
+        grant = grants.setdefault(
+            user_row.email, {"user": _user_payload(user_row), "permissions": []}
+        )
+        grant["permissions"].append(permission_name)
+    return {
+        "owner": _user_payload(owner) if owner else None,
+        "grants": sorted(grants.values(), key=lambda g: g["user"]["email"]),
+    }
+
+
+async def _stored_migration_revision(dataset_id) -> Optional[str]:
+    """The source store's stamped data-migration revision, for the manifest.
+
+    Per-dataset bookkeeping with backend access control on, the global row
+    with it off. None (no row / never migrated / bookkeeping unreadable)
+    means "unknown" — the importer then keeps its own stamp.
+    """
+    from cognee.context_global_variables import backend_access_control_enabled
+    from cognee.infrastructure.databases.relational import get_relational_engine
+
+    try:
+        db_engine = get_relational_engine()
+        if backend_access_control_enabled():
+            from cognee.modules.users.models import DatasetDatabase
+
+            async with db_engine.get_async_session() as session:
+                record = await session.get(DatasetDatabase, dataset_id)
+            return record.migration_revision if record else None
+
+        from cognee.modules.migrations.models import (
+            GLOBAL_DATABASE_VERSION_ROW_ID,
+            GlobalDatabaseVersion,
+        )
+
+        async with db_engine.get_async_session() as session:
+            record = await session.get(GlobalDatabaseVersion, GLOBAL_DATABASE_VERSION_ROW_ID)
+        return record.global_migration_revision if record else None
+    except Exception as error:  # noqa: BLE001 — manifest metadata is best effort
+        logger.debug("Could not determine migration revision for manifest: %s", error)
+        return None
+
+
 def _write_cogx(
-    nodes, edges, destination: Path, dataset_name: str, embedding_model: Optional[str] = None
+    nodes,
+    edges,
+    destination: Path,
+    dataset_name: str,
+    embedding_model: Optional[str] = None,
+    migration_revision: Optional[str] = None,
 ) -> None:
     """Map graph nodes/edges onto typed COGX records; keep the rest raw."""
     with COGXArchiveWriter(destination, source_system="cognee") as writer:
         writer.add_note(f"Exported from Cognee dataset {dataset_name!r}.")
         writer.embedding_model = embedding_model
+        writer.migration_revision = migration_revision
         for node_id, properties in nodes:
             properties = properties or {}
             node_type = properties.get("type")
@@ -112,9 +198,16 @@ async def export_dataset(
     destination: Optional[Union[str, Path]] = None,
     user=None,
     link_relations: bool = False,
+    include_permissions: bool = False,
 ) -> Union[ExportResult, GraphSnapshot]:
     """Export an authorized dataset's graph. Requires read permission.
 
+    ``include_permissions`` (cogx only): additionally write the dataset's
+    social layer — owner and ACL grants WITH user credentials — into
+    ``permissions.json`` so a cognee-to-cognee restore recreates functional
+    accounts and grants. The archive then contains password hashes: treat it
+    as a secret.
+
     ``format="pydantic"`` returns a :class:`GraphSnapshot` (typed DataPoint
     instances, in memory; pass ``destination`` to also persist it as JSON).
     All other formats write a file and return an :class:`ExportResult`.
@@ -179,7 +272,16 @@ async def export_dataset(
             embedding_model = get_embedding_context_config().embedding_model
         except Exception as error:  # noqa: BLE001 — manifest metadata is best effort
             logger.debug("Could not determine embedding model for manifest: %s", error)
-        _write_cogx(nodes, edges, destination, dataset_obj.name, embedding_model=embedding_model)
+        _write_cogx(
+            nodes,
+            edges,
+            destination,
+            dataset_obj.name,
+            embedding_model=embedding_model,
+            migration_revision=await _stored_migration_revision(dataset_obj.id),
+        )
+        if include_permissions:
+            write_social_layer(destination, await _gather_social_layer(dataset_obj))
     elif format == "json":
         write_json(nodes, edges, destination)
     elif format == "graphml":