cmem-client 0.5.0__tar.gz → 0.7.1__tar.gz

{cmem_client-0.5.0 → cmem_client-0.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cmem-client
-Version: 0.5.0
+Version: 0.7.1
 Summary: Next generation eccenca Corporate Memory client library.
 License: Apache-2.0
 License-File: LICENSE
@@ -14,7 +14,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Dist: eccenca-marketplace-client (>=0.5.0,<0.6.0)
+Requires-Dist: eccenca-marketplace-client (>=0.7.0,<0.8.0)
 Requires-Dist: httpx (>=0.27.0,<0.28.0)
 Requires-Dist: pydantic (>=2.8.2,<3.0.0)
 Requires-Dist: pyjwt (>=2.8.0,<3.0.0)

{cmem_client-0.5.0 → cmem_client-0.7.1}/cmem_client/client.py

@@ -40,6 +40,7 @@ from cmem_client.config import Config
 from cmem_client.exceptions import ClientNoAuthProviderError
 from cmem_client.logging_utils import install_trace_logger
 from cmem_client.models.logging_config import LoggingConfig
+from cmem_client.repositories.files import FilesRepository
 from cmem_client.repositories.graph_imports import GraphImportsRepository
 from cmem_client.repositories.graphs import GraphsRepository
 from cmem_client.repositories.marketplace_packages import MarketplacePackagesRepository
@@ -113,6 +114,9 @@ class Client:
     _workflows: WorkflowsRepository
     """WorkflowsRepository object for workflow operations."""
 
+    _files: FilesRepository
+    """FilesRepository object for file operations."""
+
     def __init__(
         self,
         config: Config,
@@ -483,3 +487,15 @@ class Client:
         except AttributeError:
             self._workflows = WorkflowsRepository(client=self)
             return self._workflows
+
+    @property
+    def files(self) -> FilesRepository:
+        """Get the files repository for managing files
+
+        Returns: The files repository instance, created lazy on first access.
+        """
+        try:
+            return self._files
+        except AttributeError:
+            self._files = FilesRepository(client=self)
+            return self._files

{cmem_client-0.5.0 → cmem_client-0.7.1}/cmem_client/components/marketplace.py

@@ -14,6 +14,7 @@ from __future__ import annotations
 import logging
 from typing import TYPE_CHECKING
 
+from eccenca_marketplace_client.models.responses import PackageMetadata
 from httpx import HTTPError
 from xdg_base_dirs import xdg_cache_home
 
@@ -158,6 +159,14 @@ class Marketplace:
 
         return sorted([version.get("package_version") for version in versions])
 
+    def get_available_packages(self) -> list[PackageMetadata]:
+        """Get the available packages from the marketplace server."""
+        url = self.marketplace_url / "api/packages"
+        response = self._client.http.get(url=url)
+        response.raise_for_status()
+        packages_data = response.json()
+        return [PackageMetadata.model_validate(item) for item in packages_data]
+
     @property
     def marketplace_url(self) -> HttpUrl:
         """Get the marketplace server URL."""

{cmem_client-0.5.0 → cmem_client-0.7.1}/cmem_client/exceptions.py

@@ -80,3 +80,15 @@ class MarketplacePackagesDeleteError(RepositoryModificationError):
 
 class MarketplacePackagesExportError(BaseError):
     """Exception raised when a marketplace packages export fails."""
+
+
+class FilesImportError(RepositoryModificationError):
+    """Exception raised when a file import fails."""
+
+
+class FilesDeleteError(RepositoryModificationError):
+    """Exception raised when a file import fails."""
+
+
+class FilesExportError(RepositoryModificationError):
+    """Exception raised when a file export fails."""

{cmem_client-0.5.0 → cmem_client-0.7.1}/cmem_client/models/package.py

@@ -1,7 +1,9 @@
 """Marketplace package models."""
 
+from datetime import UTC, datetime
+
 from eccenca_marketplace_client.package_version import PackageVersion
-from pydantic import ConfigDict
+from pydantic import BaseModel, ConfigDict, Field
 
 from cmem_client.models.base import Model, ReadRepositoryItem
 
@@ -33,3 +35,21 @@ class Package(ReadRepositoryItem):
             The package_id which uniquely identifies this package.
         """
         return str(self.package_version.manifest.package_id)
+
+
+class PackageInstallationMetadata(BaseModel):
+    """Metadata about how and when a marketplace package was installed.
+
+    This metadata is stored as JSON in the RDF graph and used to determine
+    whether packages can be automatically removed when they are dependencies.
+    """
+
+    dependency_level: int = Field(
+        ge=0, description="Dependency depth (0 for direct installs, >0 for dependencies", default=0
+    )
+    installed_at: datetime = Field(description="Timestamp when the package was installed", default=datetime.now(tz=UTC))
+
+    @property
+    def is_direct_installed(self) -> bool:
+        """Indicates whether this package was installed directly"""
+        return self.dependency_level == 0

cmem_client-0.7.1/cmem_client/models/resource.py

@@ -0,0 +1,25 @@
+"""A file resource model"""
+
+from pydantic import Field
+
+from cmem_client.models.base import Model, ReadRepositoryItem
+
+
+class ResourceResponse(Model):
+    """API response model for a file resource"""
+
+    name: str = Field(description="Resource name")
+    full_path: str = Field(description="Path of the resource", alias="fullPath")
+    modified: str = Field(description="Resource last modified time")
+    size: int = Field(description="Resource size")
+
+
+class Resource(Model, ReadRepositoryItem):
+    """A file resource."""
+
+    file_id: str
+    project_id: str
+
+    def get_id(self) -> str:
+        """Get the resource ID in format 'project_id:file_id'"""
+        return f"{self.project_id}:{self.file_id}"

cmem_client-0.7.1/cmem_client/repositories/files.py

@@ -0,0 +1,181 @@
+"""Files Repository."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING, ClassVar
+
+from httpx import HTTPError
+from pydantic import TypeAdapter
+
+from cmem_client.repositories.protocols.export_item import ExportConfig, ExportItemProtocol
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+    from cmem_client.client import Client
+
+from cmem_client.exceptions import FilesDeleteError, FilesExportError, FilesImportError
+from cmem_client.models.item import FileImportItem, ImportItem
+from cmem_client.models.resource import Resource, ResourceResponse
+from cmem_client.repositories.base.plain_list import PlainListRepository
+from cmem_client.repositories.protocols.delete_item import DeleteConfig, DeleteItemProtocol
+from cmem_client.repositories.protocols.import_item import ImportConfig, ImportItemProtocol
+
+
+class FilesImportConfig(ImportConfig):
+    """Files Import Configuration."""
+
+
+class FilesExportConfig(ExportConfig):
+    """Files Export Configuration."""
+
+
+class FilesDeleteConfig(DeleteConfig):
+    """Files Delete Configuration."""
+
+
+class FilesRepository(PlainListRepository, ImportItemProtocol, DeleteItemProtocol, ExportItemProtocol):
+    """Repository for files"""
+
+    _client: Client
+    _dict: dict[str, Resource]
+    _allowed_import_items: ClassVar[Sequence[type[ImportItem]]] = [FileImportItem]
+
+    def fetch_data(self) -> None:
+        """Fetch all file resources from all projects."""
+        self._dict = {}
+        for project_id in self._client.projects:
+            for resource_data in self._get_resources(project_id):
+                resource = Resource(file_id=resource_data.full_path, project_id=project_id)
+                self._dict[resource.get_id()] = resource
+
+    def _get_resources(self, project_id: str) -> list[ResourceResponse]:
+        """GET retrieve list of resources."""
+        url = self._client.config.url_build_api / "workspace/projects" / project_id / "resources"
+        response = self._client.http.get(url=url)
+        response.raise_for_status()
+        adapter = TypeAdapter(list[ResourceResponse])
+        return adapter.validate_json(response.content)
+
+    def _import_item(
+        self,
+        path: Path | None = None,
+        replace: bool = False,
+        key: str | None = None,
+        configuration: FilesImportConfig | None = None,
+    ) -> str:
+        """Import a file to a specific project.
+
+        Args:
+            path: Local file path to upload
+            replace: Whether to replace existing file
+            key: Composite key in format 'project_id:file_path'
+            configuration: Import configuration
+
+        Returns:
+            Composite key in format 'project_id:file_path'
+        """
+        _ = configuration
+
+        if path is None:
+            raise FilesImportError("Path to file necessary.")
+
+        if key is None:
+            raise FilesImportError("Key in format 'project_id:file_path' is required.")
+
+        if ":" not in key:
+            raise FilesImportError(f"Invalid key format. Expected 'project_id:file_path', got '{key}'")
+
+        project_id, resource_name = key.split(":", 1)
+
+        if not replace and key in self._dict:
+            raise FilesImportError(f"File {key} already exists. Try replace.")
+
+        url = self._client.config.url_build_api / "workspace/projects" / project_id / "files"
+
+        with path.open("rb") as file:
+            try:
+                response = self._client.http.put(url, params={"path": resource_name}, content=file)
+                response.raise_for_status()
+            except HTTPError as e:
+                raise FilesImportError(f"Could not upload file '{resource_name}' to project '{project_id}'.") from e
+
+        self.fetch_data()
+        return key
+
+    def _delete_item(self, key: str, configuration: FilesDeleteConfig | None = None) -> None:
+        """Delete a file.
+
+        Args:
+            key: Composite key in format 'project_id:file_path'
+            configuration: Delete configuration
+        """
+        _ = configuration
+
+        if ":" not in key:
+            raise FilesDeleteError(f"Invalid key format. Expected 'project_id:file_path', got '{key}'")
+
+        project_id, file_path = key.split(":", 1)
+
+        url = self._client.config.url_build_api / "workspace/projects" / project_id / "files"
+        try:
+            response = self._client.http.delete(url=url, params={"path": file_path})
+            response.raise_for_status()
+        except HTTPError as e:
+            raise FilesDeleteError(f"Could not delete file '{file_path}' from project '{project_id}'.") from e
+
+    def _export_item(
+        self,
+        key: str,
+        path: Path | None,
+        replace: bool = False,
+        configuration: FilesExportConfig | None = None,
+    ) -> Path:
+        """Export a file from a specific project.
+
+        Args:
+            key: Composite key in format 'project_id:file_path'
+            path: Target export path
+            replace: Whether to replace existing file
+            configuration: Export configuration
+        """
+        _ = configuration
+
+        if key is None:
+            raise FilesExportError("No resource key specified.")
+
+        if ":" not in key:
+            raise FilesExportError(f"Invalid key format. Expected 'project_id:file_path', got '{key}'")
+
+        project_id, file_path = key.split(":", 1)
+
+        if path is None:
+            target_path = Path(file_path)
+        elif path.is_dir():
+            target_path = path / file_path
+        else:
+            target_path = path
+
+        if target_path.exists() and not replace:
+            raise FilesExportError(f"File '{target_path}' already exists. Try replace=True.")
+
+        url = self._client.config.url_build_api / "workspace/projects" / project_id / "files"
+
+        try:
+            with self._client.http.stream(
+                "GET",
+                url,
+                params={"path": file_path},
+            ) as response:
+                response.raise_for_status()
+
+                target_path.parent.mkdir(parents=True, exist_ok=True)
+                with target_path.open("wb") as file:
+                    for chunk in response.iter_bytes():
+                        file.write(chunk)
+
+        except HTTPError as e:
+            raise FilesExportError(f"Could not export file '{file_path}' from project '{project_id}'.") from e
+
+        return target_path

{cmem_client-0.5.0 → cmem_client-0.7.1}/cmem_client/repositories/graphs.py

@@ -209,6 +209,7 @@ class GraphsRepository(PlainListRepository, DeleteItemProtocol, ImportItemProtoc
         params = {"graph": key}
         response = self._client.http.delete(url=url, params=params)
         response.raise_for_status()
+        self._reload_vocabularies(key)
 
     def guess_file_type(self, path: Path) -> GraphFileSerialization:
         """Guess the RDF serialization format from a file path.

{cmem_client-0.5.0 → cmem_client-0.7.1}/cmem_client/repositories/marketplace_packages.py

@@ -8,14 +8,16 @@ from __future__ import annotations
 
 import shutil
 import tempfile
+from datetime import UTC, datetime
 from pathlib import Path
 from typing import TYPE_CHECKING, ClassVar
 from zipfile import BadZipFile, ZipFile
 
-from eccenca_marketplace_client.dependencies import PythonPackageDependency, VocabularyDependency
-from eccenca_marketplace_client.file_specs import GraphFileSpec, ProjectFileSpec
+from eccenca_marketplace_client.models.dependencies import MarketplacePackageDependency, PythonPackageDependency
+from eccenca_marketplace_client.models.files import GraphFileSpec, ImageFileSpec, ProjectFileSpec, TextFileSpec
 from eccenca_marketplace_client.ontology import (
     NS_IRI,
+    NS_PREFIX,
     get_data_graph_iri,
     get_delete_query,
     get_fetch_query,
@@ -23,22 +25,28 @@ from eccenca_marketplace_client.ontology import (
 )
 from eccenca_marketplace_client.package_graph import PackageGraph
 from eccenca_marketplace_client.package_version import PackageVersion
+from rdflib import Literal, Namespace, Variable
 
 from cmem_client.exceptions import (
     BaseError,
     MarketplacePackagesExportError,
     MarketplacePackagesImportError,
 )
+from cmem_client.models.project import Project, ProjectMetaData
 from cmem_client.models.python_package import PythonPackage
+from cmem_client.repositories.files import FilesImportConfig
 from cmem_client.repositories.graph_imports import GraphImport
 
 if TYPE_CHECKING:
     from collections.abc import Sequence
 
-from eccenca_marketplace_client.fields import PackageVersionIdentifier  # noqa: TC002  # Pydantic needs this at runtime
+from eccenca_marketplace_client.fields import (  # Pydantic needs this at runtime
+    MANIFEST_NAME,
+    PackageVersionIdentifier,
+)
 
 from cmem_client.models.item import DirectoryImportItem, FileImportItem, ImportItem, ZipImportItem
-from cmem_client.models.package import Package
+from cmem_client.models.package import Package, PackageInstallationMetadata
 from cmem_client.repositories.base.abc import Repository
 from cmem_client.repositories.graphs import GraphImportConfig
 from cmem_client.repositories.protocols.delete_item import DeleteConfig, DeleteItemProtocol
@@ -46,6 +54,19 @@ from cmem_client.repositories.protocols.export_item import ExportConfig, ExportI
 from cmem_client.repositories.protocols.import_item import ImportConfig, ImportItemProtocol
 
 MAX_DEPENDENCY_DEPTH = 5
+MARKETPLACE_PROJECT_ID = "marketplace-packages"
+
+
+def get_installation_metadata_query(package_iri: str) -> str:
+    """Get the query for the installation metadata of the package."""
+    return f"""
+    PREFIX {NS_PREFIX}: <{NS_IRI}>
+
+    SELECT ?installation_metadata
+    WHERE {{
+            <{get_data_graph_iri()}{package_iri}> {NS_PREFIX}:installationMetadata ?installation_metadata .
+    }}
+    """
 
 
 class MarketplacePackagesImportConfig(ImportConfig):
@@ -123,13 +144,16 @@ class MarketplacePackagesRepository(Repository, ImportItemProtocol, ExportItemPr
                 tmp_file.write(ontology_graph.serialize(format="turtle").encode("utf-8"))
 
             try:
+                get_ontology_graph()
                 self._client.graphs.import_item(
-                    path=tmp_path, replace=False, key=None, configuration=GraphImportConfig(register_as_vocabulary=True)
+                    path=tmp_path,
+                    replace=False,
+                    key=NS_IRI,
                 )
             finally:
                 tmp_path.unlink(missing_ok=True)
 
-    def _import_item(  # noqa: C901, PLR0912
+    def _import_item(  # noqa: C901, PLR0912, PLR0915
         self,
         path: Path | None = None,
         replace: bool = False,
@@ -176,6 +200,7 @@ class MarketplacePackagesRepository(Repository, ImportItemProtocol, ExportItemPr
         imported_imports: list[str] = []
         imported_python_packages: list[str] = []
         imported_vocabulary_packages: list[str] = []
+        imported_files: list[str] = []
 
         if manifest.package_id in self._dict:
             if replace:
@@ -183,6 +208,8 @@ class MarketplacePackagesRepository(Repository, ImportItemProtocol, ExportItemPr
             else:
                 raise MarketplacePackagesImportError("Package already imported. Try replace.")
 
+        self._create_assets_project()
+
         if not configuration.ignore_dependencies:
             # import python package dependencies first
             for dependency in manifest.dependencies:
@@ -193,7 +220,7 @@ class MarketplacePackagesRepository(Repository, ImportItemProtocol, ExportItemPr
                     imported_python_packages.append(dependency.pypi_id)
 
             for dependency in manifest.dependencies:
-                if isinstance(dependency, VocabularyDependency) and dependency.package_id not in self._dict:
+                if isinstance(dependency, MarketplacePackageDependency) and dependency.package_id not in self._dict:
                     if configuration.dependency_level >= MAX_DEPENDENCY_DEPTH:
                         self.logger.warning(
                             "Skipping dependency '%s' because the max depth of '%s' was reached.",
@@ -238,7 +265,18 @@ class MarketplacePackagesRepository(Repository, ImportItemProtocol, ExportItemPr
                     self._client.graph_imports.create_item(item=new_import, skip_if_existing=True)
                     imported_imports.append(new_import.get_id())
 
-            self._add_package_triples(package_version)
+            for file in manifest.files:
+                file_resource_path = f"{manifest.package_id}/{file.file_path}"
+                composite_key = f"{MARKETPLACE_PROJECT_ID}:{file_resource_path}"
+                self._client.files.import_item(
+                    path=package_version.get_file_path(file.file_path),
+                    key=composite_key,
+                    replace=True,
+                    configuration=FilesImportConfig(use_archive_handler=False),
+                )
+                imported_files.append(composite_key)
+
+            self._add_package_triples(package_version, configuration)
 
         # Rollback graphs + imports, projects, python packages
         except (BaseError, BadZipFile) as error:
@@ -254,6 +292,10 @@ class MarketplacePackagesRepository(Repository, ImportItemProtocol, ExportItemPr
                 self._client.python_packages.delete_item(key=python_package_id, skip_if_missing=True)
             for vocabulary_id in imported_vocabulary_packages:
                 self._client.marketplace_packages.delete_item(key=vocabulary_id, skip_if_missing=True)
+            for file in imported_files:
+                self._client.files.delete_item(key=file, skip_if_missing=True)
+            if len(self._dict) == 0:
+                self._client.projects.delete_item(MARKETPLACE_PROJECT_ID, skip_if_missing=True)
             raise MarketplacePackagesImportError(f"Failed to import package ({error!s})") from error
 
         self.fetch_data()
@@ -311,7 +353,15 @@ class MarketplacePackagesRepository(Repository, ImportItemProtocol, ExportItemPr
                     )
                     exported_files.append((exported_path, file_spec.file_path))
 
-            manifest_path = tmp_path / "manifest.json"
+                if isinstance(file_spec, (ImageFileSpec, TextFileSpec)):
+                    file_path = tmp_path / file_spec.file_path
+                    file_path.parent.mkdir(parents=True, exist_ok=True)
+                    file_resource_path = f"{manifest.package_id}/{file_spec.file_path}"
+                    composite_key = f"{MARKETPLACE_PROJECT_ID}:{file_resource_path}"
+                    self._client.files.export_item(key=composite_key, path=file_path)
+                    exported_files.append((file_path, file_spec.file_path))
+
+            manifest_path = tmp_path / MANIFEST_NAME
             manifest_path.write_text(manifest_json_str, encoding="utf-8")
 
             if path is None:
@@ -327,18 +377,18 @@ class MarketplacePackagesRepository(Repository, ImportItemProtocol, ExportItemPr
                 with ZipFile(path, mode="w") as zipf:
                     for file_path, file_name in exported_files:
                         zipf.write(file_path, file_name)
-                    zipf.write(manifest_path, "manifest.json")
+                    zipf.write(manifest_path, MANIFEST_NAME)
             else:
                 path.mkdir(parents=True, exist_ok=True)
                 for file_path, file_name in exported_files:
                     file_dest = path / file_name
                     file_dest.parent.mkdir(parents=True, exist_ok=True)
                     shutil.copy(file_path, file_dest)
-                shutil.copy(manifest_path, path / "manifest.json")
+                shutil.copy(manifest_path, path / MANIFEST_NAME)
 
         return path
 
-    def _delete_item(self, key: str, configuration: MarketplacePackagesDeleteConfig | None = None) -> None:
+    def _delete_item(self, key: str, configuration: MarketplacePackagesDeleteConfig | None = None) -> None:  # noqa: C901, PLR0912
         """Delete a package by its package_id.
 
         This method need be extended for new FileSpecs.
@@ -369,7 +419,7 @@ class MarketplacePackagesRepository(Repository, ImportItemProtocol, ExportItemPr
                     key=dependency.pypi_id, skip_if_missing=configuration.skip_missing_dependencies
                 )
 
-            if isinstance(dependency, VocabularyDependency):
+            if isinstance(dependency, MarketplacePackageDependency):
                 dependants = self._graph.get_package_dependants(dependency.package_id)
                 dependants.remove(package_id)
                 if len(dependants) > 0:
@@ -378,6 +428,21 @@ class MarketplacePackagesRepository(Repository, ImportItemProtocol, ExportItemPr
                         f"use by other packages: {', '.join(dependants)}"
                     )
                     continue
+
+                # check if to be deleted package was directly installed prior
+                install_metadata_bindings = self._client.store.sparql.query(
+                    get_installation_metadata_query(dependency.package_id)
+                ).bindings
+                if install_metadata_bindings:
+                    metadata_json_str = str(install_metadata_bindings[0][Variable("installation_metadata")])
+                    metadata = PackageInstallationMetadata.model_validate_json(metadata_json_str)
+                    if metadata.is_direct_installed:
+                        self._logger.warning(
+                            f"Marketplace package '{dependency.package_id}' can not be removed since "
+                            f"it was installed directly, not just via dependencies'"
+                        )
+                        continue
+
                 self._client.marketplace_packages.delete_item(
                     key=dependency.package_id, skip_if_missing=configuration.skip_missing_dependencies
                 )
@@ -393,9 +458,19 @@ class MarketplacePackagesRepository(Repository, ImportItemProtocol, ExportItemPr
                 deleted_import = GraphImport(from_graph=str(from_graph), to_graph=str(graph.graph_iri))
                 self._client.graph_imports.delete_item(key=deleted_import.get_id(), skip_if_missing=True)
 
+        for file in manifest.files:
+            file_resource_path = f"{manifest.package_id}/{file.file_path}"
+            composite_key = f"{MARKETPLACE_PROJECT_ID}:{file_resource_path}"
+            self._client.files.delete_item(key=composite_key, skip_if_missing=True)
+
         self._client.store.sparql.update(get_delete_query(package_iri))
 
-    def _add_package_triples(self, package: PackageVersion) -> None:
+        # Remaining package is removed by the protocol, marketplace vocabulary and project can be deleted safely
+        if len(self._dict) == 1 and key in self._dict:
+            self._client.graphs.delete_item(NS_IRI, skip_if_missing=True)
+            self._client.projects.delete_item(MARKETPLACE_PROJECT_ID, skip_if_missing=True)
+
+    def _add_package_triples(self, package: PackageVersion, config: MarketplacePackagesImportConfig) -> None:
         """Add a package to the data config graph in the Corporate Memory instance.
 
         Converts the package metadata to RDF triples and inserts them into the
@@ -404,10 +479,22 @@ class MarketplacePackagesRepository(Repository, ImportItemProtocol, ExportItemPr
 
         Args:
             package: The package metadata to add to the catalog.
+            config: The config object to determine if package was installed directly or
+                    as a dependency and more metadata.
         """
         self._add_marketplace_vocabulary()
         g = package.to_rdf_graph()
 
+        eccm = Namespace(NS_IRI)
+
+        metadata = PackageInstallationMetadata(
+            dependency_level=config.dependency_level,
+            installed_at=datetime.now(tz=UTC),
+        )
+
+        json_literal = Literal(metadata.model_dump_json())
+        g.add((package.iri(), eccm.installationMetadata, json_literal))
+
         triples = g.serialize(format="nt")
 
         sparql_update = f"""
@@ -484,3 +571,24 @@ class MarketplacePackagesRepository(Repository, ImportItemProtocol, ExportItemPr
             )
 
         return package_version
+
+    def _create_assets_project(self) -> None:
+        """Create the assets project for the marketplace."""
+        if MARKETPLACE_PROJECT_ID in self._client.projects:
+            return
+        mp_assets = Project(
+            name=MARKETPLACE_PROJECT_ID,
+            metaData=ProjectMetaData(
+                label="Marketplace Packages",
+                description="""This project contains all files that were installed via Marketplace packages.
+
+This project was created when you installed your first package.
+It will be deleted after the last package is uninstalled.
+
+For more information about marketplace packages, have a look at
+[documentation.eccenca.com](https://go.eccenca.com/feature/marketplace-packages).
+""",
+            ),
+        )
+        self._client.projects.create_item(mp_assets)
+        self._client.projects.fetch_data()

{cmem_client-0.5.0 → cmem_client-0.7.1}/cmem_client/repositories/protocols/delete_item.py

@@ -67,14 +67,13 @@ class DeleteItemProtocol(Protocol[ItemType, DeleteItemConfig_contra]):
             RepositoryModificationError: if an error occurs while creating the item
             HTTPError: for any other http error
         """
-        _ = configuration
         if key not in self._dict:
             if not skip_if_missing:
                 raise RepositoryModificationError(f"Repository item '{key}' does not exists.")
             self.logger.info("Item '%s' does not exists, therefore not deleting.", key)
             return
         try:
-            self._delete_item(key=key)
+            self._delete_item(key=key, configuration=configuration)
         except HTTPError as error:
             raise RepositoryModificationError(f"Error on deleting repository item '{key}'.") from error
 

{cmem_client-0.5.0 → cmem_client-0.7.1}/cmem_client/repositories/python_packages.py

@@ -38,7 +38,10 @@ class PythonPackagesRepository(PlainListRepository, DeleteItemProtocol, CreateIt
         """Install a Python package."""
         _ = configuration
         url = self._url("/api/python/installPackageByName")
-        return self._client.http.post(url, params={"name": item.name})
+        response = self._client.http.post(url, params={"name": item.name})
+        response.raise_for_status()
+        self._update_plugins()
+        return response
 
     def _delete_item(self, key: str, configuration: PythonPackagesDeleteConfig | None = None) -> None:
         """Delete item from repository."""
@@ -46,6 +49,7 @@ class PythonPackagesRepository(PlainListRepository, DeleteItemProtocol, CreateIt
         url = self._url("/api/python/uninstallPackage")
         response = self._client.http.post(url, params={"name": key})
         response.raise_for_status()
+        self._update_plugins()
 
     def delete_all(self) -> None:
         """Delete all items from the repository
@@ -56,3 +60,9 @@ class PythonPackagesRepository(PlainListRepository, DeleteItemProtocol, CreateIt
         self._delete_item("--all")
         if hasattr(self, "fetch_data"):
             self.fetch_data()
+
+    def _update_plugins(self) -> None:
+        """Update the python packages in CMEM"""
+        url = self._url("/api/python/updatePlugins")
+        response = self._client.http.get(url)
+        response.raise_for_status()

{cmem_client-0.5.0 → cmem_client-0.7.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "cmem-client"
-version = "0.5.0"
+version = "0.7.1"
 license = "Apache-2.0"
 description = "Next generation eccenca Corporate Memory client library."
 authors = ["eccenca GmbH <cmempy-developer@eccenca.com>"]
@@ -19,7 +19,7 @@ pydantic = "^2.8.2"
 httpx = "^0.27.0"
 pyjwt = "^2.8.0"
 rdflib = "^7.2.1"
-eccenca-marketplace-client = "^0.5.0"
+eccenca-marketplace-client = "^0.7.0"
 # eccenca-marketplace-client = {path = "eccenca-marketplace-client", develop = true}
 xdg-base-dirs = "^6.0.2"
 
@@ -34,7 +34,7 @@ pytest-dotenv = "^0.5.2"
 pytest-html = "^4.1.1"
 pytest-memray = { version = "^1.8.0",  markers = "platform_system != 'Windows'" }
 ruff = "^0.13.3"
-trivy-py-ecc = "^0.67.2"
+trivy-py-ecc = "^0.68.2"
 mkdocs = "^1.5.3"
 mkdocstrings = {extras = ["python"], version = "^0.26.1"}
 mkdocs-material = "^9.5.11"