linkml-store 0.1.11__tar.gz → 0.1.12__tar.gz

{linkml_store-0.1.11 → linkml_store-0.1.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: linkml-store
-Version: 0.1.11
+Version: 0.1.12
 Summary: linkml-store
 License: MIT
 Author: Author 1

{linkml_store-0.1.11 → linkml_store-0.1.12}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "linkml-store"
-version = "0.1.11"
+version = "0.1.12"
 description = "linkml-store"
 authors = ["Author 1 <author@org.org>"]
 license = "MIT"

{linkml_store-0.1.11 → linkml_store-0.1.12}/src/linkml_store/api/collection.py

@@ -346,7 +346,10 @@ class Collection(Generic[DatabaseType]):
         id_field = self.identifier_attribute_name
         if not id_field:
             raise ValueError(f"No identifier for {self.name}")
-        return self.find({id_field: ids})
+        if len(ids) == 1:
+            return self.find({id_field: ids[0]})
+        else:
+            return self.find({id_field: {"$in": ids}})
 
     def get_one(self, id: IDENTIFIER, **kwargs) -> Optional[OBJECT]:
         """
@@ -518,7 +521,7 @@ class Collection(Generic[DatabaseType]):
         :return:
         """
         cd = self.class_definition()
-        return cd is not None
+        return cd is not None and cd.attributes
 
     def load_from_source(self, load_if_exists=False):
         """
@@ -535,11 +538,19 @@ class Collection(Generic[DatabaseType]):
             kwargs = source.arguments or {}
             if source.local_path:
                 objects = load_objects(
-                    metadata.source.local_path, format=source.format, expected_type=source.expected_type, **kwargs
+                    metadata.source.local_path,
+                    format=source.format,
+                    expected_type=source.expected_type,
+                    compression=source.compression,
+                    **kwargs,
                 )
             elif metadata.source.url:
                 objects = load_objects_from_url(
-                    metadata.source.url, format=source.format, expected_type=source.expected_type, **kwargs
+                    metadata.source.url,
+                    format=source.format,
+                    expected_type=source.expected_type,
+                    compression=source.compression,
+                    **kwargs,
                 )
         self.insert(objects)
 
@@ -746,6 +757,7 @@ class Collection(Generic[DatabaseType]):
         sv: SchemaView = self.parent.schema_view
         if sv:
             cls = sv.get_class(self.target_class_name)
+            # cls = sv.schema.classes[self.target_class_name]
             if cls and not cls.attributes:
                 if not sv.class_induced_slots(cls.name):
                     for att in self._induce_attributes():
@@ -868,7 +880,7 @@ class Collection(Generic[DatabaseType]):
                     exact_dimensions_list.append(v.shape)
                     break
                 if isinstance(v, list):
-                    v = v[0]
+                    v = v[0] if v else None
                     multivalueds.append(True)
                 elif isinstance(v, dict):
                     v = list(v.values())[0]

{linkml_store-0.1.11 → linkml_store-0.1.12}/src/linkml_store/api/config.py

@@ -33,6 +33,7 @@ class CollectionSource(ConfiguredBaseModel):
     refresh_interval_days: Optional[float] = None
     expected_type: Optional[str] = None
     format: Optional[str] = None
+    compression: Optional[str] = None
     arguments: Optional[Dict[str, Any]] = None
 
 
@@ -73,11 +74,11 @@ class CollectionConfig(ConfiguredBaseModel):
         default=None,
         description="Metadata about the source",
     )
-    # TODO: derived_from
     derived_from: Optional[List[DerivationConfiguration]] = Field(
         default=None,
         description="LinkML-Map derivations",
     )
+    page_size: Optional[int] = Field(default=None, description="Suggested page size (items per page) in apps and APIs")
 
 
 class DatabaseConfig(ConfiguredBaseModel):

{linkml_store-0.1.11 → linkml_store-0.1.12}/src/linkml_store/api/database.py

@@ -19,7 +19,7 @@ from typing import (
 )
 
 from linkml_store.api.types import CollectionType
-from linkml_store.utils.format_utils import load_objects, render_output
+from linkml_store.utils.format_utils import Format, load_objects, render_output
 from linkml_store.utils.patch_utils import PatchDict
 
 try:
@@ -705,7 +705,7 @@ class Database(ABC, Generic[CollectionType]):
         """
         raise NotImplementedError()
 
-    def import_database(self, location: str, source_format: Optional[str] = None, **kwargs):
+    def import_database(self, location: str, source_format: Optional[Union[str, Format]] = None, **kwargs):
         """
         Import a database from a file or location.
 
@@ -713,11 +713,27 @@ class Database(ABC, Generic[CollectionType]):
         :param source_format: source format
         :param kwargs: additional arguments
         """
+        if isinstance(source_format, str):
+            source_format = Format(source_format)
+        if isinstance(source_format, Format):
+            if source_format.is_dump_format() and source_format in [Format.SQLDUMP_DUCKDB, Format.DUMP_MONGODB]:
+                # import into a test instance
+                tmp_handle = source_format.value
+                client = self.parent
+                tmp_db = client.attach_database(tmp_handle, alias="tmp")
+                # TODO: check for infinite recursion
+                tmp_db.import_database(location, source_format=source_format)
+                obj = {}
+                for coll in tmp_db.list_collections():
+                    qr = coll.find({}, limit=-1)
+                    obj[coll.alias] = qr.rows
+                self.store(obj)
+                return
         objects = load_objects(location, format=source_format)
         for obj in objects:
             self.store(obj)
 
-    def export_database(self, location: str, target_format: Optional[str] = None, **kwargs):
+    def export_database(self, location: str, target_format: Optional[Union[str, Format]] = None, **kwargs):
         """
         Export a database to a file or location.
 
@@ -726,10 +742,23 @@ class Database(ABC, Generic[CollectionType]):
         :param kwargs: additional arguments
         """
         obj = {}
+        if isinstance(target_format, str):
+            target_format = Format(target_format)
         for coll in self.list_collections():
             qr = coll.find({}, limit=-1)
             obj[coll.alias] = qr.rows
         logger.info(f"Exporting object with {len(obj)} collections to {location} in {target_format} format")
+        if isinstance(target_format, Format):
+            if target_format.is_dump_format() and target_format in [Format.SQLDUMP_DUCKDB, Format.DUMP_MONGODB]:
+                tmp_handle = target_format.value
+                client = self.parent
+                tmp_db = client.attach_database(tmp_handle, alias="tmp")
+                tmp_db.store(obj)
+                # TODO: check for infinite recursion
+                tmp_db.export_database(location, target_format=target_format)
+                return
+        if Path(location).is_dir():
+            raise ValueError(f"{location} is a directory; cannot write {target_format} to a dir")
         with open(location, "w", encoding="utf-8") as stream:
             stream.write(render_output(obj, format=target_format))
 

{linkml_store-0.1.11 → linkml_store-0.1.12}/src/linkml_store/api/stores/duckdb/duckdb_database.py

@@ -1,11 +1,10 @@
 import json
 import logging
 from pathlib import Path
-from typing import Optional
+from typing import Optional, Union
 
 import pandas as pd
 import sqlalchemy
-from duckdb import DuckDBPyConnection
 from linkml_runtime import SchemaView
 from linkml_runtime.linkml_model import ClassDefinition, SlotDefinition
 from linkml_runtime.utils.schema_builder import SchemaBuilder
@@ -14,6 +13,7 @@ from sqlalchemy import NullPool, text
 from linkml_store.api import Database
 from linkml_store.api.queries import Query, QueryResult
 from linkml_store.api.stores.duckdb.duckdb_collection import DuckDBCollection
+from linkml_store.utils.format_utils import Format
 from linkml_store.utils.sql_utils import introspect_schema, query_to_sql
 
 TYPE_MAP = {
@@ -45,7 +45,7 @@ class DuckDBDatabase(Database):
     types are used for nested inlined objects.
     """
 
-    _connection: DuckDBPyConnection = None
+    # _connection: DuckDBPyConnection = None
     _engine: sqlalchemy.Engine = None
     collection_class = DuckDBCollection
 
@@ -202,3 +202,31 @@ class DuckDBDatabase(Database):
                     cls = ClassDefinition(name=collection_metadata.type, attributes=collection_metadata.attributes)
                     schema.classes[cls.name] = cls
         return SchemaView(schema)
+
+    def export_database(self, location: str, target_format: Optional[Union[str, Format]] = None, **kwargs):
+        if target_format == "duckdb" or target_format == Format.SQLDUMP_DUCKDB:
+            path = Path(location)
+            if path.exists():
+                if path.is_file():
+                    path.unlink()
+            with self.engine.connect() as conn:
+                sql = text(f"EXPORT DATABASE '{location}'")
+                conn.execute(sql)
+        else:
+            super().export_database(location, target_format=target_format, **kwargs)
+
+    def import_database(self, location: str, source_format: Optional[str] = None, **kwargs):
+        """
+        Import a database from a file or location.
+
+        :param location: location of the file
+        :param source_format: source format
+        :param kwargs: additional arguments
+        """
+        if source_format == Format.SQLDUMP_DUCKDB.value or source_format == Format.SQLDUMP_DUCKDB:
+            with self.engine.connect() as conn:
+                sql = text(f"IMPORT DATABASE '{location}'")
+                conn.execute(sql)
+                conn.commit()
+        else:
+            super().import_database(location, source_format=source_format, **kwargs)

{linkml_store-0.1.11 → linkml_store-0.1.12}/src/linkml_store/api/stores/mongodb/mongodb_database.py

@@ -1,7 +1,8 @@
 # mongodb_database.py
 
 import logging
-from typing import Optional
+from pathlib import Path
+from typing import Optional, Union
 
 from pymongo import MongoClient
 from pymongo.database import Database as NativeDatabase
@@ -9,6 +10,9 @@ from pymongo.database import Database as NativeDatabase
 from linkml_store.api import Database
 from linkml_store.api.queries import Query, QueryResult
 from linkml_store.api.stores.mongodb.mongodb_collection import MongoDBCollection
+from linkml_store.utils.file_utils import safe_remove_directory
+from linkml_store.utils.format_utils import Format
+from linkml_store.utils.mongodb_utils import import_mongodb
 
 logger = logging.getLogger(__name__)
 
@@ -27,6 +31,8 @@ class MongoDBDatabase(Database):
     def __init__(self, handle: Optional[str] = None, **kwargs):
         if handle is None:
             handle = "mongodb://localhost:27017/test"
+        if handle == "mongodb":
+            handle = "mongodb://localhost:27017/temporary"
         super().__init__(handle=handle, **kwargs)
 
     @property
@@ -77,3 +83,27 @@ class MongoDBDatabase(Database):
             if collection_name not in self._collections:
                 collection = MongoDBCollection(name=collection_name, parent=self)
                 self._collections[collection_name] = collection
+
+    def export_database(self, location: str, target_format: Optional[Union[str, Format]] = None, **kwargs):
+        if target_format == Format.DUMP_MONGODB.value or target_format == Format.DUMP_MONGODB:
+            path = Path(location)
+            if path.exists():
+                safe_remove_directory(path, no_backup=True)
+            from linkml_store.utils.mongodb_utils import export_mongodb
+
+            export_mongodb(self.handle, location)
+        else:
+            super().export_database(location, target_format=target_format, **kwargs)
+
+    def import_database(self, location: str, source_format: Optional[str] = None, **kwargs):
+        """
+        Import a database from a file or location.
+
+        :param location: location of the file
+        :param source_format: source format
+        :param kwargs: additional arguments
+        """
+        if source_format == Format.DUMP_MONGODB.value or source_format == Format.DUMP_MONGODB:
+            import_mongodb(self.handle, location, drop=True)
+        else:
+            super().import_database(location, source_format=source_format, **kwargs)

{linkml_store-0.1.11 → linkml_store-0.1.12}/src/linkml_store/cli.py

@@ -228,7 +228,11 @@ def store(ctx, files, object, format):
 @click.pass_context
 @click.argument("files", type=click.Path(exists=True), nargs=-1)
 def import_database(ctx, files, format):
-    """Imports a database from a dump."""
+    """Imports a database from a dump.
+
+    See the `export` command for a full list of supported formats. The same
+    formats are generally supported for imports.
+    """
     settings = ctx.obj["settings"]
     db = settings.database
     if not files and not object:
@@ -242,7 +246,30 @@ def import_database(ctx, files, format):
 @click.option("--output", "-o", required=True, type=click.Path(), help="Output file path")
 @click.pass_context
 def export(ctx, output_type, output):
-    """Exports a database to a dump."""
+    """Exports a database to a standard dump format.
+
+    Example:
+
+        linkml-store -d duckdb:///countries.db export -O yaml -o countries.yaml
+
+    Export format will be guessed from extension if not specified
+
+    Example:
+
+        linkml-store -d duckdb:///countries.db export -o countries.json
+
+    Tree formats such as YAML and JSON can natively store an entire database; each collection
+    will be a distinct key in the database.
+
+    Additionally, native dump formats can be used:
+
+    Example:
+
+        linkml-store -d duckdb:///countries.db export -o countries -O duckdb
+
+    Here, `countries` is a directory. This is equivalent to running EXPORT DATABASE
+    (see https://duckdb.org/docs/sql/statements/export.html)
+    """
     settings = ctx.obj["settings"]
     db = settings.database
     if output_type is None:

{linkml_store-0.1.11 → linkml_store-0.1.12}/src/linkml_store/utils/format_utils.py

@@ -1,10 +1,14 @@
 import csv
+import gzip
+import io
 import json
+import logging
 import sys
+import tarfile
 from enum import Enum
 from io import StringIO
 from pathlib import Path
-from typing import Any, Dict, List, Optional, TextIO, Type, Union
+from typing import IO, Any, Dict, List, Optional, TextIO, Type, Union
 
 import pandas as pd
 import pystow
@@ -12,6 +16,8 @@ import yaml
 from pydantic import BaseModel
 from tabulate import tabulate
 
+logger = logging.getLogger(__name__)
+
 
 class Format(Enum):
     """
@@ -27,6 +33,35 @@ class Format(Enum):
     PARQUET = "parquet"
     FORMATTED = "formatted"
     TABLE = "table"
+    SQLDUMP_DUCKDB = "duckdb"
+    SQLDUMP_POSTGRES = "postgres"
+    DUMP_MONGODB = "mongodb"
+
+    @classmethod
+    def guess_format(cls, file_name: str) -> Optional["Format"]:
+        ext = Path(file_name).suffix.lower()
+
+        format_map = {
+            ".json": cls.JSON,
+            ".jsonl": cls.JSONL,
+            ".yaml": cls.YAML,
+            ".yml": cls.YAML,
+            ".tsv": cls.TSV,
+            ".csv": cls.CSV,
+            ".py": cls.PYTHON,
+            ".parquet": cls.PARQUET,
+            ".pq": cls.PARQUET,
+        }
+        fmt = format_map.get(ext, None)
+        if fmt is None:
+            if ext.startswith("."):
+                ext = ext[1:]
+            if ext in [f.value for f in Format]:
+                return Format(ext)
+        return fmt
+
+    def is_dump_format(self):
+        return self in [Format.SQLDUMP_DUCKDB, Format.SQLDUMP_POSTGRES, Format.DUMP_MONGODB]
 
 
 def load_objects_from_url(
@@ -46,15 +81,109 @@ def load_objects_from_url(
     :return: A list of dictionaries representing the loaded objects.
     """
     local_path = pystow.ensure("linkml", "linkml-store", url=url)
+    logger.info(f"synced to {local_path}")
     objs = load_objects(local_path, format=format, expected_type=expected_type, **kwargs)
     if not objs:
         raise ValueError(f"No objects loaded from URL: {url}")
     return objs
 
 
+def process_file(
+    f: IO, format: Format, expected_type: Optional[Type] = None, header_comment_token: Optional[str] = None
+) -> List[Dict[str, Any]]:
+    """
+    Process a single file and return a list of objects.
+    """
+    if format == Format.JSON:
+        objs = json.load(f)
+    elif format == Format.JSONL:
+        objs = [json.loads(line) for line in f]
+    elif format == Format.YAML:
+        if expected_type and expected_type == list:  # noqa E721
+            objs = list(yaml.safe_load_all(f))
+        else:
+            objs = yaml.safe_load(f)
+    elif format in [Format.TSV, Format.CSV]:
+        if header_comment_token:
+            while True:
+                pos = f.tell()
+                line = f.readline()
+                if not line.startswith(header_comment_token):
+                    f.seek(pos)
+                    break
+        delimiter = "\t" if format == Format.TSV else ","
+        reader = csv.DictReader(f, delimiter=delimiter)
+        objs = list(reader)
+    elif format == Format.PARQUET:
+        import pyarrow.parquet as pq
+
+        table = pq.read_table(f)
+        objs = table.to_pandas().to_dict(orient="records")
+    elif format in [Format.PYTHON, Format.FORMATTED, Format.TABLE]:
+        raise ValueError(f"Format {format} is not supported for loading objects")
+    else:
+        raise ValueError(f"Unsupported file format: {format}")
+
+    if not isinstance(objs, list):
+        objs = [objs]
+    return objs
+
+
 def load_objects(
+    file_path: Union[str, Path],
+    format: Optional[Union[Format, str]] = None,
+    compression: Optional[str] = None,
+    expected_type: Optional[Type] = None,
+    header_comment_token: Optional[str] = None,
+) -> List[Dict[str, Any]]:
+    """
+    Load objects from a file or archive in supported formats.
+    For tgz archives, it processes all files and concatenates the results.
+
+    :param file_path: The path to the file or archive.
+    :param format: The format of the file. Can be a Format enum or a string value.
+    :param compression: The compression type. Supports 'gz' for gzip and 'tgz' for tar.gz.
+    :param expected_type: The target type to load the objects into, e.g. list
+    :param header_comment_token: Token used for header comments to be skipped
+    :return: A list of dictionaries representing the loaded objects.
+    """
+    if isinstance(file_path, Path):
+        file_path = str(file_path)
+
+    if isinstance(format, str):
+        format = Format(format)
+
+    all_objects = []
+
+    if compression == "tgz":
+        with tarfile.open(file_path, "r:gz") as tar:
+            for member in tar.getmembers():
+                if member.isfile():
+                    f = tar.extractfile(member)
+                    if f:
+                        content = io.TextIOWrapper(f)
+                        member_format = Format.guess_format(member.name) if not format else format
+                        logger.debug(f"Processing tar member {member.name} with format {member_format}")
+                        all_objects.extend(process_file(content, member_format, expected_type, header_comment_token))
+    else:
+        if Path(file_path).is_dir():
+            raise ValueError(f"{file_path} is a dir, which is invalid for {format}")
+        mode = "rb" if format == Format.PARQUET or compression == "gz" else "r"
+        open_func = gzip.open if compression == "gz" else open
+        format = Format.guess_format(file_path) if not format else format
+        with open_func(file_path, mode) if file_path != "-" else sys.stdin as f:
+            if compression == "gz" and mode == "r":
+                f = io.TextIOWrapper(f)
+            all_objects = process_file(f, format, expected_type, header_comment_token)
+
+    logger.debug(f"Loaded {len(all_objects)} objects from {file_path}")
+    return all_objects
+
+
+def xxxload_objects(
     file_path: Union[str, Path],
     format: Union[Format, str] = None,
+    compression: Optional[str] = None,
     expected_type: Type = None,
     header_comment_token: Optional[str] = None,
 ) -> List[Dict[str, Any]]:
@@ -172,7 +301,7 @@ def write_output(
 
 
 def render_output(
-    data: Union[List[Dict[str, Any]], Dict[str, Any], pd.DataFrame], format: Union[Format, str] = Format.YAML
+    data: Union[List[Dict[str, Any]], Dict[str, Any], pd.DataFrame], format: Optional[Union[Format, str]] = Format.YAML
 ) -> str:
     """
     Render output data in JSON, JSONLines, YAML, CSV, or TSV format.
@@ -271,15 +400,4 @@ def guess_format(path: str) -> Optional[Format]:
     :param path: The path to the file.
     :return: The guessed format.
     """
-    if path.endswith(".json"):
-        return Format.JSON
-    elif path.endswith(".jsonl"):
-        return Format.JSONL
-    elif path.endswith(".yaml") or path.endswith(".yml"):
-        return Format.YAML
-    elif path.endswith(".tsv"):
-        return Format.TSV
-    elif path.endswith(".csv"):
-        return Format.CSV
-    else:
-        return None
+    return Format.guess_format(path)

linkml_store-0.1.12/src/linkml_store/utils/mongodb_utils.py

@@ -0,0 +1,145 @@
+import logging
+import os
+import subprocess
+from pathlib import Path
+from typing import Optional
+from urllib.parse import urlparse
+
+from pymongo import MongoClient
+from pymongo.database import Database
+
+logger = logging.getLogger(__name__)
+
+
+def extract_connection_info(db: Database):
+    client = db.client
+
+    # Get the host and port
+    host_info = client.address
+    if host_info:
+        host, port = host_info
+    else:
+        # For replica sets or sharded clusters, we might need to get this differently
+        host = client.HOST
+        port = client.PORT
+
+    # Get the database name
+    db_name = db.name
+
+    # Get username if available
+    username = None
+    if hasattr(client, "options") and hasattr(client.options, "credentials"):
+        credentials = client.options.credentials
+        if credentials:
+            username = credentials.username
+
+    return {"host": host, "port": port, "db_name": db_name, "username": username}
+
+
+def get_connection_string(client: MongoClient):
+    """
+    Extract a connection string from the MongoClient.
+    This avoids triggering truth value testing on Database objects.
+    """
+    if client.address:
+        host, port = client.address
+        return f"{host}:{port}"
+    if hasattr(client, "address") and client.address:
+        host, port = client.address
+        return f"{host}:{port}"
+    elif client.hosts:
+        # For replica sets, return all hosts
+        return ",".join(f"{host}:{port}" for host, port in client.hosts)
+    elif hasattr(client, "HOST"):
+        # If we can't determine hosts, use the entire URI
+        parsed_uri = urlparse(client.HOST)
+        return f"{parsed_uri.hostname}:{parsed_uri.port}"
+    else:
+        raise ValueError("Unable to determine connection string from client")
+
+
+def get_connection_info(db: Database):
+    """
+    Extract connection information from the Database object.
+    """
+    # Get the name of the database
+    db_name = db.name
+
+    # Get the client's node list (this should work for single nodes and replica sets)
+    node_list = db.client.nodes
+
+    if not node_list:
+        raise ValueError("Unable to determine connection information from database")
+
+    # Use the first node in the list (for single node setups, this will be the only node)
+    first_node = node_list[0]
+    host, port = first_node
+
+    return host, port, db_name
+
+
+def get_auth_from_client(client: MongoClient):
+    """Extract authentication details from MongoClient."""
+    if hasattr(client, "_MongoClient__options"):
+        # For older versions of PyMongo
+        options = client._MongoClient__options
+    elif hasattr(client, "options"):
+        # For newer versions of PyMongo
+        options = client.options
+    else:
+        return None, None, None
+
+    if hasattr(options, "credentials"):
+        creds = options.credentials
+        return creds.username, creds.password, creds.source
+    return None, None, None
+
+
+def connection_from_handle(handle: str):
+    if handle.startswith("mongodb://"):
+        handle = handle.replace("mongodb://", "")
+    host, db = handle.split("/")
+    return host, db
+
+
+def export_mongodb(handle: str, location: str, password: Optional[str] = None):
+    host, db_name = connection_from_handle(handle)
+
+    # Construct the mongodump command
+    cmd = ["mongodump", f"--host={host}", f"--db={db_name}"]
+    logger.info(f"Exporting MongoDB database {db_name} from {host} to {location}")
+    cmd.extend(["--out", location])
+    result = subprocess.run(cmd, check=True, capture_output=True, text=True)
+    logger.info(f"MongoDB export completed successfully. Output: {result.stdout}")
+
+
+def import_mongodb(handle: str, dump_dir: str, drop: bool = False):
+    host, db_name = connection_from_handle(handle)
+
+    # list dirs in dump_dir
+    dir_path = Path(dump_dir)
+    if not dir_path.is_dir():
+        raise ValueError(f"{dir_path} is not a dir")
+    directories = [name for name in os.listdir(dump_dir)]
+    if len(directories) != 1:
+        raise ValueError(f"Expected exactly one database in {dump_dir}, got: {directories}")
+    src_db_name = directories[0]
+
+    # Construct the mongorestore command
+    cmd = [
+        "mongorestore",
+        f"--host={host}",
+        f"--nsFrom={src_db_name}.*",
+        f"--nsTo={db_name}.*",
+        str(dump_dir),
+    ]
+
+    # Add drop option if specified
+    if drop:
+        cmd.append("--drop")
+    logger.info(f"CMD={cmd}")
+    # Execute mongorestore
+    result = subprocess.run(cmd, check=True, capture_output=True, text=True)
+    if result.stderr:
+        logger.warning(result.stderr)
+    logger.info(f"MongoDB import completed successfully. Output: {result.stdout} // {result.stderr}")