linkml-store 0.1.8__py3-none-any.whl → 0.1.9__py3-none-any.whl

linkml_store/api/stores/filesystem/filesystem_database.py

@@ -1,36 +1,72 @@
 import logging
+from pathlib import Path
 from typing import Optional
 
-from linkml_store.api import Collection, Database
-from linkml_store.api.config import CollectionConfig
-from linkml_store.api.stores.duckdb import DuckDBDatabase
+import yaml
+from linkml.utils.schema_builder import SchemaBuilder
+from linkml_runtime import SchemaView
+
+from linkml_store.api import Database
+from linkml_store.api.config import DatabaseConfig
 from linkml_store.api.stores.filesystem.filesystem_collection import FileSystemCollection
+from linkml_store.utils.format_utils import Format, load_objects
 
 logger = logging.getLogger(__name__)
 
 
 class FileSystemDatabase(Database):
     collection_class = FileSystemCollection
-    wrapped_database: Database = None
 
-    def __init__(self, handle: Optional[str] = None, recreate_if_exists: bool = False, **kwargs):
-        self.wrapped_database = DuckDBDatabase("duckdb:///:memory:")
+    directory_path: Optional[Path] = None
+    default_file_format: Optional[str] = None
+
+    def __init__(self, handle: Optional[str] = None, **kwargs):
+        handle = handle.replace("file:", "")
+        if handle.startswith("//"):
+            handle = handle[2:]
+        self.directory_path = Path(handle)
+        self.load_metadata()
         super().__init__(handle=handle, **kwargs)
 
-    def commit(self, **kwargs):
-        # TODO: sync
-        pass
+    @property
+    def metadata_path(self) -> Path:
+        return self.directory_path / ".linkml_metadata.yaml"
+
+    def load_metadata(self):
+        if self.metadata_path.exists():
+            md_dict = yaml.safe_load(open(self.metadata_path))
+            metadata = DatabaseConfig(**md_dict)
+        else:
+            metadata = DatabaseConfig()
+        self.metadata = metadata
 
     def close(self, **kwargs):
-        self.wrapped_database.close()
-
-    def create_collection(
-        self,
-        name: str,
-        alias: Optional[str] = None,
-        metadata: Optional[CollectionConfig] = None,
-        recreate_if_exists=False,
-        **kwargs,
-    ) -> Collection:
-        wd = self.wrapped_database
-        wd.create_collection()
+        pass
+
+    def init_collections(self):
+        metadata = self.metadata
+        if self._collections is None:
+            self._collections = {}
+        for name, collection_config in metadata.collections.items():
+            collection = FileSystemCollection(parent=self, **collection_config.dict())
+            self._collections[name] = collection
+        path = self.directory_path
+        if path.exists():
+            for fmt in Format:
+                suffix = fmt.value
+                logger.info(f"Looking for {suffix} files in {path}")
+                for f in path.glob(f"*.{suffix}"):
+                    logger.info(f"Found {f}")
+                    n = f.stem
+                    objs = load_objects(f, suffix, expected_type=list)
+                    collection = FileSystemCollection(parent=self, name=n)
+                    self._collections[n] = collection
+                    collection._set_objects(objs)
+
+    def induce_schema_view(self) -> SchemaView:
+        logger.info(f"Inducing schema view for {self.handle}")
+        sb = SchemaBuilder()
+
+        for collection_name in self.list_collection_names():
+            sb.add_class(collection_name)
+        return SchemaView(sb.schema)

linkml_store/api/stores/mongodb/mongodb_collection.py

@@ -26,17 +26,23 @@ class MongoDBCollection(Collection):
     def mongo_collection(self) -> MongoCollection:
         if not self.name:
             raise ValueError("Collection name not set")
-        return self.parent.native_db[self.name]
+        collection_name = self.alias or self.name
+        return self.parent.native_db[collection_name]
 
     def insert(self, objs: Union[OBJECT, List[OBJECT]], **kwargs):
         if not isinstance(objs, list):
             objs = [objs]
         self.mongo_collection.insert_many(objs)
+        # TODO: allow mapping of _id to id for efficiency
+        for obj in objs:
+            del obj["_id"]
+        self._post_insert_hook(objs)
 
-    def query(self, query: Query, **kwargs) -> QueryResult:
+    def query(self, query: Query, limit: Optional[int] = None, **kwargs) -> QueryResult:
         mongo_filter = self._build_mongo_filter(query.where_clause)
-        if query.limit:
-            cursor = self.mongo_collection.find(mongo_filter).limit(query.limit)
+        limit = limit or query.limit
+        if limit and limit >= 0:
+            cursor = self.mongo_collection.find(mongo_filter).limit(limit)
         else:
             cursor = self.mongo_collection.find(mongo_filter)
 

linkml_store/api/stores/mongodb/mongodb_database.py

@@ -29,9 +29,17 @@ class MongoDBDatabase(Database):
 
     def __init__(self, handle: Optional[str] = None, **kwargs):
         if handle is None:
-            handle = "mongodb://localhost:27017"
+            handle = "mongodb://localhost:27017/test"
         super().__init__(handle=handle, **kwargs)
 
+    @property
+    def _db_name(self) -> str:
+        if self.handle:
+            db = self.handle.split("/")[-1]
+        else:
+            db = "default"
+        return db
+
     @property
     def native_client(self) -> MongoClient:
         if self._native_client is None:
@@ -44,7 +52,7 @@ class MongoDBDatabase(Database):
             alias = self.metadata.alias
             if not alias:
                 alias = "default"
-            self._native_db = self.native_client[alias]
+            self._native_db = self.native_client[self._db_name]
         return self._native_db
 
     def commit(self, **kwargs):
@@ -58,9 +66,12 @@ class MongoDBDatabase(Database):
         self.native_client.drop_database(self.metadata.alias)
 
     def query(self, query: Query, **kwargs) -> QueryResult:
+        # TODO: DRY
         if query.from_table:
             collection = self.get_collection(query.from_table)
             return collection.query(query, **kwargs)
+        else:
+            raise NotImplementedError(f"Querying without a table is not supported in {self.__class__.__name__}")
 
     def init_collections(self):
         if self._collections is None:

linkml_store/api/types.py

@@ -0,0 +1,4 @@
+from typing import TypeVar
+
+DatabaseType = TypeVar("DatabaseType", bound="Database")  # noqa: F821
+CollectionType = TypeVar("CollectionType", bound="Collection")  # noqa: F821

linkml_store/cli.py

@@ -14,7 +14,7 @@ from linkml_store.api.queries import Query
 from linkml_store.index import get_indexer
 from linkml_store.index.implementations.simple_indexer import SimpleIndexer
 from linkml_store.index.indexer import Indexer
-from linkml_store.utils.format_utils import Format, guess_format, load_objects, render_output
+from linkml_store.utils.format_utils import Format, guess_format, load_objects, render_output, write_output
 from linkml_store.utils.object_utils import object_path_update
 
 index_type_option = click.option(
@@ -181,6 +181,7 @@ def insert(ctx, files, object, format):
             objects = yaml.safe_load(object_str)
             collection.insert(objects)
             click.echo(f"Inserted {len(objects)} objects from {object_str} into collection '{collection.name}'.")
+    collection.commit()
 
 
 @cli.command()
@@ -213,9 +214,9 @@ def store(ctx, files, object, format):
 
 
 @cli.command(name="import")
-@click.argument("files", type=click.Path(exists=True), nargs=-1)
 @click.option("--format", "-f", help="Input 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."""
     settings = ctx.obj["settings"]
@@ -242,13 +243,77 @@ def export(ctx, output_type, output):
 
 
 @cli.command()
-@click.option("--where", "-w", type=click.STRING, help="WHERE clause for the query")
+@click.option("--output", "-o", type=click.Path(), help="Output file path")
+@click.option("--output-type", "-O", type=format_choice, default="json", help="Output format")
+@click.option("--other-database", "-D", required=False, help="Path to the other database")
+@click.option("--other-collection", "-X", required=True, help="Name of the other collection")
+@click.option("--identifier-attribute", "-I", required=False, help="Primary key name")
+@click.pass_context
+def diff(ctx, output, output_type, other_database, other_collection, identifier_attribute):
+    """Diffs two collectoons to create a patch."""
+    settings = ctx.obj["settings"]
+    db = settings.database
+    collection = settings.collection
+    if not collection:
+        raise ValueError("Collection must be specified.")
+    other_db = settings.client.get_database(other_database) if other_database else db
+    other_collection = other_db.get_collection(other_collection)
+    if identifier_attribute:
+        collection.set_identifier_attribute_name(identifier_attribute)
+        other_collection.set_identifier_attribute_name(identifier_attribute)
+    diff = collection.diff(other_collection)
+    write_output(diff, output_type, target=output)
+
+
+@cli.command()
+@click.option("--identifier-attribute", "-I", required=False, help="Primary key name")
+@click.argument("patch_files", type=click.Path(exists=True), nargs=-1)
+@click.pass_context
+def apply(ctx, patch_files, identifier_attribute):
+    """
+    Apply a patch to a collection.
+    """
+    settings = ctx.obj["settings"]
+    collection = settings.collection
+    if not collection:
+        raise ValueError("Collection must be specified.")
+    if identifier_attribute:
+        collection.set_identifier_attribute_name(identifier_attribute)
+    for patch_file in patch_files:
+        patch_objs = load_objects(patch_file, expected_type=list)
+        collection.apply_patches(patch_objs)
+
+
+@cli.command()
+@click.option("--where", "-w", type=click.STRING, help="WHERE clause for the query, as YAML")
 @click.option("--limit", "-l", type=click.INT, help="Maximum number of results to return")
 @click.option("--output-type", "-O", type=format_choice, default="json", help="Output format")
 @click.option("--output", "-o", type=click.Path(), help="Output file path")
 @click.pass_context
 def query(ctx, where, limit, output_type, output):
-    """Query objects from the specified collection."""
+    """Query objects from the specified collection.
+
+
+    Leave the query field blank to return all objects in the collection.
+
+    Examples:
+
+        linkml-store -d duckdb:///countries.db -c countries query
+
+    Queries can be specified in YAML, as basic key-value pairs
+
+    Examples:
+
+        linkml-store -d duckdb:///countries.db -c countries query -w 'code: NZ'
+
+    More complex queries can be specified using MongoDB-style query syntax
+
+    Examples:
+
+        linkml-store -d file:. -c persons query  -w 'occupation: {$ne: Architect}'
+
+    Finds all people who are not architects.
+    """
     collection = ctx.obj["settings"].collection
     where_clause = yaml.safe_load(where) if where else None
     query = Query(from_table=collection.name, where_clause=where_clause, limit=limit)
@@ -326,6 +391,21 @@ def _get_index(index_type=None, **kwargs) -> Indexer:
         raise ValueError(f"Unknown index type: {index_type}")
 
 
+@cli.command()
+@click.option("--where", "-w", type=click.STRING, help="WHERE clause for the query")
+@click.option("--output-type", "-O", type=format_choice, default=Format.FORMATTED.value, help="Output format")
+@click.option("--output", "-o", type=click.Path(), help="Output file path")
+@click.pass_context
+def describe(ctx, where, output_type, output):
+    """
+    Describe the collection schema.
+    """
+    where_clause = yaml.safe_load(where) if where else None
+    collection = ctx.obj["settings"].collection
+    df = collection.find(where_clause, limit=1).rows_dataframe
+    write_output(df.describe(include="all").transpose(), output_type, target=output)
+
+
 @cli.command()
 @index_type_option
 @click.option("--cached-embeddings-database", "-E", help="Path to the database where embeddings are cached")
@@ -335,9 +415,7 @@ def index(ctx, index_type, **kwargs):
     """
     Create an index over a collection.
 
-    :param ctx:
-    :param index_type:
-    :return:
+    By default a simple trigram index is used.
     """
     collection = ctx.obj["settings"].collection
     ix = get_indexer(index_type, **kwargs)
@@ -397,6 +475,9 @@ def search(ctx, search_term, where, limit, index_type, output_type, output, auto
 @cli.command()
 @click.pass_context
 def indexes(ctx):
+    """
+    Show the indexes for a collection.
+    """
     collection = ctx.obj["settings"].collection
     for name, ix in collection.indexers.items():
         click.echo(f"{name}: {type(ix)}\n{ix.model_json()}")

linkml_store/utils/change_utils.py

@@ -0,0 +1,17 @@
+from typing import List
+
+from linkml_store.api.collection import OBJECT
+
+
+def insert_operation_to_patches(objs: List[OBJECT], **kwargs):
+    """
+    Translate a list of objects to a list of patches for insertion.
+
+    Note: inserts are always treated as being at the start of a list
+
+    :param objs: objects to insert
+    :param kwargs: additional arguments
+    """
+    patches = []
+    for obj in objs:
+        patches.append({"op": "add", "path": "/0", "value": obj})

linkml_store/utils/format_utils.py

@@ -4,8 +4,9 @@ import sys
 from enum import Enum
 from io import StringIO
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional, TextIO, Type, Union
 
+import pandas as pd
 import yaml
 from pydantic import BaseModel
 
@@ -20,9 +21,13 @@ class Format(Enum):
     YAML = "yaml"
     TSV = "tsv"
     CSV = "csv"
+    PARQUET = "parquet"
+    FORMATTED = "formatted"
 
 
-def load_objects(file_path: Union[str, Path], format: Union[Format, str] = None) -> List[Dict[str, Any]]:
+def load_objects(
+    file_path: Union[str, Path], format: Union[Format, str] = None, expected_type: Type = None
+) -> List[Dict[str, Any]]:
     """
     Load objects from a file in JSON, JSONLines, YAML, CSV, or TSV format.
 
@@ -32,6 +37,7 @@ def load_objects(file_path: Union[str, Path], format: Union[Format, str] = None)
 
     :param file_path: The path to the file.
     :param format: The format of the file. Can be a Format enum or a string value.
+    :param expected_type: The target type to load the objects into.
     :return: A list of dictionaries representing the loaded objects.
     """
     if isinstance(format, str):
@@ -40,24 +46,39 @@ def load_objects(file_path: Union[str, Path], format: Union[Format, str] = None)
     if isinstance(file_path, Path):
         file_path = str(file_path)
 
+    if not format and (file_path.endswith(".parquet") or file_path.endswith(".pq")):
+        format = Format.PARQUET
+
+    mode = "r"
+    if format == Format.PARQUET:
+        mode = "rb"
+
     if file_path == "-":
         # set file_path to be a stream from stdin
         f = sys.stdin
     else:
-        f = open(file_path)
+        f = open(file_path, mode)
 
     if format == Format.JSON or (not format and file_path.endswith(".json")):
         objs = json.load(f)
     elif format == Format.JSONL or (not format and file_path.endswith(".jsonl")):
         objs = [json.loads(line) for line in f]
     elif format == Format.YAML or (not format and (file_path.endswith(".yaml") or file_path.endswith(".yml"))):
-        objs = yaml.safe_load(f)
+        if expected_type and expected_type == list:
+            objs = list(yaml.safe_load_all(f))
+        else:
+            objs = yaml.safe_load(f)
     elif format == Format.TSV or (not format and file_path.endswith(".tsv")):
         reader = csv.DictReader(f, delimiter="\t")
         objs = list(reader)
     elif format == Format.CSV or (not format and file_path.endswith(".csv")):
         reader = csv.DictReader(f)
         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")
     else:
         raise ValueError(f"Unsupported file format: {file_path}")
     if not isinstance(objs, list):
@@ -65,7 +86,40 @@ def load_objects(file_path: Union[str, Path], format: Union[Format, str] = None)
     return objs
 
 
-def render_output(data: Union[List[Dict[str, Any]], Dict[str, Any]], format: Union[Format, str] = Format.YAML) -> str:
+def write_output(
+    data: Union[List[Dict[str, Any]], Dict[str, Any], pd.DataFrame],
+    format: Union[Format, str] = Format.YAML,
+    target: Optional[Union[TextIO, str, Path]] = None,
+) -> None:
+    """
+    Write output data to a file in JSON, JSONLines, YAML, CSV, or TSV format.
+
+    >>> write_output([{"a": 1, "b": 2}, {"a": 3, "b": 4}], Format.JSON, sys.stdout)
+    [
+      {
+        "a": 1,
+        "b": 2
+      },
+      {
+        "a": 3,
+        "b": 4
+        }
+    ]
+    """
+    output_str = render_output(data, format)
+    if target:
+        if isinstance(target, str):
+            with open(target, "w") as target:
+                target.write(output_str)
+        else:
+            target.write(output_str)
+    else:
+        print(output_str)
+
+
+def render_output(
+    data: Union[List[Dict[str, Any]], Dict[str, Any], pd.DataFrame], format: Union[Format, str] = Format.YAML
+) -> str:
     """
     Render output data in JSON, JSONLines, YAML, CSV, or TSV format.
 
@@ -89,6 +143,14 @@ def render_output(data: Union[List[Dict[str, Any]], Dict[str, Any]], format: Uni
     if isinstance(format, str):
         format = Format(format)
 
+    if format == Format.FORMATTED:
+        if not isinstance(data, pd.DataFrame):
+            data = pd.DataFrame(data)
+        return str(data)
+
+    if isinstance(data, pd.DataFrame):
+        data = data.to_dict(orient="records")
+
     if isinstance(data, BaseModel):
         data = data.model_dump()
 
@@ -97,16 +159,19 @@ def render_output(data: Union[List[Dict[str, Any]], Dict[str, Any]], format: Uni
     elif format == Format.JSONL:
         return "\n".join(json.dumps(obj) for obj in data)
     elif format == Format.YAML:
-        return yaml.safe_dump(data, sort_keys=False)
+        if isinstance(data, list):
+            return yaml.safe_dump_all(data, sort_keys=False)
+        else:
+            return yaml.safe_dump(data, sort_keys=False)
     elif format == Format.TSV:
         output = StringIO()
-        writer = csv.DictWriter(output, fieldnames=data[0].keys(), delimiter="\t")
+        writer = csv.DictWriter(output, fieldnames=get_fieldnames(data), delimiter="\t")
         writer.writeheader()
         writer.writerows(data)
         return output.getvalue()
     elif format == Format.CSV:
         output = StringIO()
-        writer = csv.DictWriter(output, fieldnames=data[0].keys())
+        writer = csv.DictWriter(output, fieldnames=get_fieldnames(data))
         writer.writeheader()
         writer.writerows(data)
         return output.getvalue()
@@ -114,6 +179,22 @@ def render_output(data: Union[List[Dict[str, Any]], Dict[str, Any]], format: Uni
         raise ValueError(f"Unsupported output format: {format}")
 
 
+def get_fieldnames(data: List[Dict[str, Any]]) -> List[str]:
+    """
+    Get the fieldnames of a list of dictionaries.
+
+    >>> get_fieldnames([{"a": 1, "b": 2}, {"a": 3, "b": 4}])
+    ['a', 'b']
+
+    :param data: The list of dictionaries.
+    :return: The fieldnames.
+    """
+    fieldnames = []
+    for obj in data:
+        fieldnames.extend([k for k in obj.keys() if k not in fieldnames])
+    return fieldnames
+
+
 def guess_format(path: str) -> Optional[Format]:
     """
     Guess the format of a file based on its extension.

linkml_store/utils/patch_utils.py

@@ -0,0 +1,126 @@
+from typing import Any, Dict, List, Optional, TypedDict
+
+import jsonpatch
+
+
+class PatchDict(TypedDict):
+    op: str
+    path: str
+    value: Optional[Any]
+    _from: Optional[str]
+
+
+def apply_patches(obj: Any, patches: List[PatchDict], primary_key: Optional[str] = None, in_place=False) -> Any:
+    """
+    Apply a set of patches to an object.
+
+    If the object is a list, the primary key must be specified.
+
+    >>> objs = [{'id': 'F1', 'name': 'Cheese'}, {'id': 'F2', 'name': 'Bread'}]
+    >>> patches = [{'op': 'replace', 'path': '/F1/name', 'value': 'Toast'}]
+    >>> apply_patches(objs, patches, primary_key='id')
+    [{'id': 'F1', 'name': 'Toast'}, {'id': 'F2', 'name': 'Bread'}]
+
+    :param obj: object to patch
+    :param patches: list of patches, conforming to the JSON Patch format
+    :param primary_key: key to use as the primary key for the objects (if obj is a list)
+    :param in_place: whether to apply the patches in place
+    :return:
+    """
+    if isinstance(obj, dict):
+        patch_obj = jsonpatch.JsonPatch(patches)
+        return patch_obj.apply(obj, in_place=in_place)
+    elif isinstance(obj, list):
+        if not primary_key:
+            raise ValueError("Primary key must be specified for list objects")
+        return apply_patches_to_list(obj, patches, primary_key, in_place=in_place)
+    else:
+        raise ValueError(f"Unsupported object type: {type(obj)}")
+
+
+def apply_patches_to_list(
+    objects: List[Dict[str, Any]], patches: List[PatchDict], primary_key: str, in_place=False
+) -> List[Dict[str, Any]]:
+    """
+    Apply a set of patches to a list of objects.
+
+
+
+    :param objects: list of objects
+    :param patches: list of patches, conforming to the JSON Patch format
+    :param primary_key: key to use as the primary key for the objects
+    :param in_place: whether to apply the patches in place
+    :return:
+    """
+    objs_as_dict = {obj[primary_key]: obj for obj in objects}
+    result = apply_patches_to_keyed_list(objs_as_dict, patches, in_place=in_place)
+    return list(result.values())
+
+
+def apply_patches_to_keyed_list(
+    objs_as_dict: Dict[str, Dict[str, Any]], patches: List[PatchDict], in_place=False
+) -> Dict[str, Dict[str, Any]]:
+    """
+    Apply a set of patches to a list of objects, where the objects are keyed by a primary key
+
+    :param objs_as_dict:
+    :param patches:
+    :param in_place:
+    :return:
+    """
+    patch_obj = jsonpatch.JsonPatch(patches)
+    result = patch_obj.apply(objs_as_dict, in_place=in_place)
+    return result
+
+
+def patches_from_objects_lists(
+    src_objs: List[Dict[str, Any]], dst_objs: List[Dict[str, Any]], primary_key: str, exclude_none=True
+) -> List[PatchDict]:
+    """
+    Generate a set of patches to transform src_objs into tgt_objs.
+
+    >>> src_objs = [{'id': 'F1', 'name': 'Cheese'}, {'id': 'F2', 'name': 'Bread'}]
+    >>> tgt_objs = [{'id': 'F1', 'name': 'Toast'}, {'id': 'F2', 'name': 'Bread'}]
+    >>> patches_from_objects_lists(src_objs, tgt_objs, primary_key='id')
+    [{'op': 'replace', 'path': '/F1/name', 'value': 'Toast'}]
+
+    by default exclude_none is True, so None values are excluded from the patch
+
+    >>> tgt_objs = [{'id': 'F1', 'name': 'Toast'}, {'id': 'F2', 'name': None}]
+    >>> patches_from_objects_lists(src_objs, tgt_objs, primary_key='id')
+    [{'op': 'replace', 'path': '/F1/name', 'value': 'Toast'}, {'op': 'remove', 'path': '/F2/name'}]
+
+    if exclude_none is False, None values are treated as being set to None
+
+    >>> patches_from_objects_lists(src_objs, tgt_objs, primary_key='id', exclude_none=False)
+    [{'op': 'replace', 'path': '/F1/name', 'value': 'Toast'}, {'op': 'replace', 'path': '/F2/name', 'value': None}]
+
+    See also: `<https://github.com/orgs/linkml/discussions/1975>`_
+
+    Note the patches are sorted deterministically, first by path, then by operation.
+    This helps ensure operations on the same object are grouped together
+
+    :param src_objs: source objects
+    :param dst_objs: target objects
+    :param primary_key: key to use as the primary key for the objects
+    :param exclude_none: whether to exclude None values from the patch
+    :return:
+    """
+    src_objs_as_dict = {obj[primary_key]: obj for obj in src_objs}
+    dst_objs_as_dict = {obj[primary_key]: obj for obj in dst_objs}
+    if exclude_none:
+        src_objs_as_dict = {k: remove_nones(v) for k, v in src_objs_as_dict.items()}
+        dst_objs_as_dict = {k: remove_nones(v) for k, v in dst_objs_as_dict.items()}
+    patch_obj = jsonpatch.JsonPatch.from_diff(src_objs_as_dict, dst_objs_as_dict)
+    pl = patch_obj.patch
+    return sorted(pl, key=lambda x: (x["path"], x["op"]))
+
+
+def remove_nones(obj: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Remove None values from a dictionary.
+
+    :param obj:
+    :return:
+    """
+    return {k: v for k, v in obj.items() if v is not None}