linkml-store 0.1.13__py3-none-any.whl → 0.1.14__py3-none-any.whl

linkml_store/utils/sklearn_utils.py

@@ -0,0 +1,193 @@
+import logging
+import os
+import re
+import shutil
+from pathlib import Path
+from typing import Dict, List, Optional, Union
+
+import numpy as np
+from linkml_runtime.utils.formatutils import underscore
+from sklearn.preprocessing import LabelEncoder, OneHotEncoder
+from sklearn.tree import DecisionTreeClassifier, _tree, export_graphviz
+
+logger = logging.getLogger(__name__)
+
+
+def tree_to_nested_expression(
+    tree: DecisionTreeClassifier,
+    feature_names: List[str],
+    categorical_features: Optional[List[str]] = None,
+    feature_encoders: Optional[Dict[str, Union[OneHotEncoder, LabelEncoder]]] = None,
+    target_encoder: Optional[LabelEncoder] = None,
+) -> str:
+    """
+    Convert a trained scikit-learn DecisionTreeClassifier to a nested Python conditional expression.
+
+    Args:
+    tree (DecisionTreeClassifier): A trained decision tree classifier.
+    feature_names (list): List of feature names (including one-hot encoded feature names).
+    categorical_features (list): List of original categorical feature names.
+    feature_encoders (dict): Dictionary mapping feature names to their respective OneHotEncoders or LabelEncoders.
+    target_encoder (LabelEncoder, optional): LabelEncoder for the target variable if it's categorical.
+
+    Returns:
+    str: A string representing the nested Python conditional expression.
+
+    Example:
+    >>> import numpy as np
+    >>> from sklearn.tree import DecisionTreeClassifier
+    >>> from sklearn.preprocessing import OneHotEncoder, LabelEncoder
+    >>>
+    >>> # Prepare sample data
+    >>> X = np.array([[0, 'A'], [0, 'B'], [1, 'A'], [1, 'B']])
+    >>> y = np.array(['No', 'Yes', 'Yes', 'No'])
+    >>>
+    >>> # Prepare the encoders
+    >>> feature_encoders = {'feature2': OneHotEncoder(sparse_output=False, handle_unknown='ignore')}
+    >>> target_encoder = LabelEncoder()
+    >>>
+    >>> # Encode the categorical feature and target
+    >>> X_encoded = np.column_stack([
+    ...     X[:, 0],
+    ...     feature_encoders['feature2'].fit_transform(X[:, 1].reshape(-1, 1))
+    ... ])
+    >>> y_encoded = target_encoder.fit_transform(y)
+    >>>
+    >>> # Train the decision tree
+    >>> clf = DecisionTreeClassifier(random_state=42)
+    >>> clf.fit(X_encoded, y_encoded)
+    DecisionTreeClassifier(random_state=42)
+    >>>
+    >>> # Convert to nested expression
+    >>> feature_names = ['feature1', 'feature2_A', 'feature2_B']
+    >>> categorical_features = ['feature2']
+    >>> expression = tree_to_nested_expression(clf, feature_names,
+    ...                                        categorical_features, feature_encoders, target_encoder)
+    >>> print(expression)
+    (("Yes" if ({feature1} <= 0.5000) else "No") if ({feature2} == "A")
+       else ("No" if ({feature1} <= 0.5000) else "Yes"))
+    """
+    tree_ = tree.tree_
+    feature_name = [feature_names[i] if i != _tree.TREE_UNDEFINED else "undefined!" for i in tree_.feature]
+
+    categorical_features = set(categorical_features or [])
+
+    def get_original_feature_name(name):
+        return name.split("_")[0] if "_" in name else name
+
+    def recurse(node):
+        if tree_.feature[node] != _tree.TREE_UNDEFINED:
+            name = feature_name[node]
+            threshold = tree_.threshold[node]
+            original_name = get_original_feature_name(name)
+            original_name_safe = underscore(original_name)
+            name_safe = underscore(name)
+
+            original_name_safe = "{" + original_name_safe + "}"
+            name_safe = "{" + name_safe + "}"
+
+            if original_name in categorical_features:
+                if feature_encoders is None or original_name not in feature_encoders:
+                    raise ValueError(f"Encoder is required for categorical feature {original_name}")
+
+                encoder = feature_encoders[original_name]
+                if isinstance(encoder, OneHotEncoder):
+                    # For one-hot encoded features, we check if the specific category is present
+                    category = name.split("_", 1)[1]  # Get everything after the first underscore
+                    condition = f'{original_name_safe} == "{category}"'
+                elif isinstance(encoder, LabelEncoder):
+                    category = encoder.inverse_transform([int(threshold)])[0]
+                    condition = f'{original_name_safe} == "{category}"'
+                else:
+                    raise ValueError(f"Unsupported encoder type for feature {original_name}")
+            else:
+                if np.isinf(threshold):
+                    condition = "True"
+                else:
+                    condition = f"{name_safe} <= {threshold:.4f}"
+
+            left_expr = recurse(tree_.children_left[node])
+            right_expr = recurse(tree_.children_right[node])
+
+            return f"({left_expr} if ({condition}) else {right_expr})"
+        else:
+            class_index = np.argmax(tree_.value[node])
+            if target_encoder:
+                class_label = target_encoder.inverse_transform([class_index])[0]
+                return f'"{class_label}"'
+            else:
+                return str(class_index)
+
+    return recurse(0)
+
+
+def escape_label(s: str) -> str:
+    """Escape special characters in label strings."""
+    s = str(s)
+    return re.sub(r"([<>])", r"\\\1", s)
+
+
+def visualize_decision_tree(
+    clf: DecisionTreeClassifier,
+    feature_names: List[str],
+    class_names: List[str] = None,
+    output_file: Union[Path, str] = "decision_tree.png",
+) -> None:
+    """
+    Generate a visualization of the decision tree and save it as a PNG file.
+
+    :param clf: Trained DecisionTreeClassifier
+    :param feature_names: List of feature names
+    :param class_names: List of class names (optional)
+    :param output_file: The name of the file to save the visualization (default: "decision_tree.png")
+
+    >>> # Create a sample dataset
+    >>> import pandas as pd
+    >>> data = pd.DataFrame({
+    ...     'age': [25, 30, 35, 40, 45],
+    ...     'income': [50000, 60000, 70000, 80000, 90000],
+    ...     'credit_score': [600, 650, 700, 750, 800],
+    ...     'approved': ['No', 'No', 'Yes', 'Yes', 'Yes']
+    ... })
+    >>>
+    >>> # Prepare features and target
+    >>> X = data[['age', 'income', 'credit_score']]
+    >>> y = data['approved']
+    >>>
+    >>> # Encode target variable
+    >>> le = LabelEncoder()
+    >>> y_encoded = le.fit_transform(y)
+    >>>
+    >>> # Train a decision tree
+    >>> clf = DecisionTreeClassifier(random_state=42)
+    >>> _ = clf.fit(X, y_encoded)
+    >>> # Visualize the tree
+    >>> visualize_decision_tree(clf, X.columns.tolist(), le.classes_, "tests/output/test_tree.png")
+    """
+    # Escape special characters in feature names and class names
+    escaped_feature_names = [escape_label(name) for name in feature_names]
+    escaped_class_names = [escape_label(name) for name in (class_names if class_names is not None else [])]
+
+    import graphviz
+
+    dot_data = export_graphviz(
+        clf,
+        out_file=None,
+        feature_names=escaped_feature_names,
+        class_names=escaped_class_names,
+        filled=True,
+        rounded=True,
+        special_characters=True,
+    )
+    # dot_data = escape_label(dot_data)
+    logger.info(f"Dot: {dot_data}")
+    dot_path = shutil.which("dot")
+    if not dot_path:
+        logger.warning("Graphviz 'dot' executable not found in PATH. Skipping visualization.")
+        return
+    os.environ["GRAPHVIZ_DOT"] = dot_path
+
+    graph = graphviz.Source(dot_data)
+    if isinstance(output_file, Path):
+        output_file = str(output_file)
+    graph.render(output_file.rsplit(".", 1)[0], format="png", cleanup=True)

linkml_store/utils/stats_utils.py

@@ -0,0 +1,53 @@
+import numpy as np
+import pandas as pd
+
+
+def predictive_power(df, target_col, feature_cols, cv=5):
+    from sklearn.model_selection import cross_val_score
+    from sklearn.preprocessing import LabelEncoder
+    from sklearn.tree import DecisionTreeClassifier
+
+    # Prepare the data
+    X = df[feature_cols].copy()  # Create an explicit copy
+    y = df[target_col].copy()
+
+    # Encode categorical variables
+    for col in X.columns:
+        if X[col].dtype == "object":
+            X[col] = LabelEncoder().fit_transform(X[col].astype(str))
+
+    if y.dtype == "object":
+        y = LabelEncoder().fit_transform(y.astype(str))
+
+    # Adjust cv based on the number of unique values in y
+    n_unique = len(np.unique(y))
+    cv = min(cv, n_unique)
+
+    # Train a decision tree and get cross-validated accuracy
+    clf = DecisionTreeClassifier(random_state=42)
+
+    if cv < 2:
+        # If cv is less than 2, we can't do cross-validation, so we'll just fit and score
+        clf.fit(X, y)
+        return clf.score(X, y)
+    else:
+        scores = cross_val_score(clf, X, y, cv=cv)
+        return scores.mean()
+
+
+def analyze_predictive_power(df, columns=None, cv=5):
+    if columns is None:
+        columns = df.columns
+    results = pd.DataFrame(index=columns, columns=["predictive_power", "features"])
+
+    for target_col in columns:
+        feature_cols = [col for col in columns if col != target_col]
+        try:
+            power = predictive_power(df, target_col, feature_cols, cv)
+            results.loc[target_col, "predictive_power"] = power
+            results.loc[target_col, "features"] = ", ".join(feature_cols)
+        except Exception as e:
+            print(f"Error processing {target_col}: {str(e)}")
+            results.loc[target_col, "predictive_power"] = np.nan
+
+    return results

{linkml_store-0.1.13.dist-info → linkml_store-0.1.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: linkml-store
-Version: 0.1.13
+Version: 0.1.14
 Summary: linkml-store
 License: MIT
 Author: Author 1
@@ -24,6 +24,7 @@ Provides-Extra: mongodb
 Provides-Extra: neo4j
 Provides-Extra: pyarrow
 Provides-Extra: renderer
+Provides-Extra: scipy
 Provides-Extra: tests
 Provides-Extra: validation
 Requires-Dist: black (>=24.0.0) ; extra == "tests"
@@ -51,9 +52,12 @@ Requires-Dist: pyarrow ; extra == "pyarrow"
 Requires-Dist: pydantic (>=2.0.0,<3.0.0)
 Requires-Dist: pymongo ; extra == "mongodb"
 Requires-Dist: pystow (>=0.5.4,<0.6.0)
+Requires-Dist: scikit-learn ; extra == "scipy"
+Requires-Dist: scipy ; extra == "scipy"
 Requires-Dist: seaborn ; extra == "analytics"
 Requires-Dist: sqlalchemy
 Requires-Dist: streamlit (>=1.32.2,<2.0.0) ; extra == "app"
+Requires-Dist: tiktoken ; extra == "llm"
 Requires-Dist: uvicorn ; extra == "fastapi"
 Description-Content-Type: text/markdown
 
@@ -61,7 +65,7 @@ Description-Content-Type: text/markdown
 
 An AI-ready data management and integration platform. LinkML-Store
 provides an abstraction layer over multiple different backends
-(including DuckDB, MongoDB, and local filesystems), allowing for
+(including DuckDB, MongoDB, Neo4j, and local filesystems), allowing for
 common query, index, and storage operations.
 
 For full documentation, see [https://linkml.io/linkml-store/](https://linkml.io/linkml-store/)
@@ -99,6 +103,23 @@ linkml-store -d duckdb:///db/my.db -c persons validate
 * API
 * Streamlit applications
 
+## The CRUDSI pattern
+
+Most database APIs implement the **CRUD** pattern: Create, Read, Update, Delete.
+LinkML-Store adds **Search** and **Inference** to this pattern, making it **CRUDSI**.
+
+The notion of "Search" and "Inference" is intended to be flexible and extensible,
+including:
+
+* Search
+   * Traditional keyword search
+   * Search using LLM Vector embeddings (*without* a dedicated vector database)
+   * Pluggable specialized search, e.g. genomic sequence (not yet implemented)
+* Inference (encompassing  *validation*, *repair*, and inference of missing data)
+   * Classic rule-based inference
+   * Inference using LLM Retrieval Augmented Generation (RAG)
+   * Statistical/ML inference
+
 ## Features
 
 ### Multiple Adapters
@@ -108,6 +129,8 @@ LinkML-Store is designed to work with multiple backends, giving a common abstrac
 * [MongoDB](https://linkml.io/linkml-store/how-to/Use-MongoDB.html)
 * [DuckDB](https://linkml.io/linkml-store/tutorials/Python-Tutorial.html)
 * [Solr](https://linkml.io/linkml-store/how-to/Query-Solr-using-CLI.html)
+* [Neo4j](https://linkml.io/linkml-store/how-to/Use-Neo4j.html)
+
 * Filesystem
 
 Coming soon: any RDBMS, any triplestore, Neo4J, HDF5-based stores, ChromaDB/Vector dbs ...

{linkml_store-0.1.13.dist-info → linkml_store-0.1.14.dist-info}/RECORD

@@ -1,9 +1,9 @@
 linkml_store/__init__.py,sha256=jlU6WOUAn8cKIhzbTULmBTWpW9gZdEt7q_RI6KZN1bY,118
 linkml_store/api/__init__.py,sha256=3CelcFEFz0y3MkQAzhQ9JxHIt1zFk6nYZxSmYTo8YZE,226
-linkml_store/api/client.py,sha256=aiWhLSAY0Wj7EfoXdEXMtGId1LSbvGya8dGEKdOB0iI,10989
-linkml_store/api/collection.py,sha256=Qi89f-iUSC1zKUgqSMuooklteO0wbJfYbeVkpn8CbIM,36186
-linkml_store/api/config.py,sha256=E-ma5hXQrs5Gyet2BB6CFJyPqNjXwAr1pr9H7AT2vOc,5159
-linkml_store/api/database.py,sha256=W5PzpIua8w6eCUqugGqOV6Y7O15g5FSZzzaQKDOfqak,28297
+linkml_store/api/client.py,sha256=3klBXenQVbLjNQF3WmYfjASt3zvKOfWaCNp5aJM81Ec,12034
+linkml_store/api/collection.py,sha256=7JndC6A9r3OVbR9aB6d_bdaYN53XU4FpppUterygOaE,37800
+linkml_store/api/config.py,sha256=71pxQ5jM-ETxJWU7CzmKjsH6IEJUMP5sml381u9TYVk,5654
+linkml_store/api/database.py,sha256=QVvUuLQPCxB4cvsS7rXqPSfoHkhcMzP9vUcsjkuEYds,29051
 linkml_store/api/queries.py,sha256=w0qnNeCH6pC9WTGoEQYd300MF6o0G3atz2YxN3WecAs,2028
 linkml_store/api/stores/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 linkml_store/api/stores/chromadb/__init__.py,sha256=e9BkOPuPnVQKA5PRKDulag59yGNHDP3U2_DnPSrFAKM,132
@@ -20,7 +20,7 @@ linkml_store/api/stores/hdf5/__init__.py,sha256=l4cIh3v7P0nPbwGIsfuCMD_serQ8q8c7
 linkml_store/api/stores/hdf5/hdf5_collection.py,sha256=mnpLMYehn3PuaIjp2dXrIWu8jh-bdQ84X2Ku83jMdEY,3805
 linkml_store/api/stores/hdf5/hdf5_database.py,sha256=EZbjrpaqiNDEFvoD5dZNcGBXA8z6HRNL81emueTZWNw,2714
 linkml_store/api/stores/mongodb/__init__.py,sha256=OSFCr7RQlDEe-O-Y0P_i912oAMK-L3pC7Cnj7sxlwAk,510
-linkml_store/api/stores/mongodb/mongodb_collection.py,sha256=W-j1tkk8h1-zzjIRe-IYAnAOwlFSwr4fnDtgiu7RsVI,6695
+linkml_store/api/stores/mongodb/mongodb_collection.py,sha256=unN0v7RYlGIiJxEhbNRxZ86TVQ4ELlAsNWTwEbg7E_g,6831
 linkml_store/api/stores/mongodb/mongodb_database.py,sha256=Y9MIV0KSRGCyopz8vGEivhSuvF0vZLCDJd29cdqMIX8,3857
 linkml_store/api/stores/neo4j/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 linkml_store/api/stores/neo4j/neo4j_collection.py,sha256=a-Az5_ypdBMgeNyhrTW7q-ik-vYPCDDONIK7N_CDA9c,17449
@@ -30,7 +30,7 @@ linkml_store/api/stores/solr/solr_collection.py,sha256=ZlxC3JbVaHfSA4HuTeJTsp6qe
 linkml_store/api/stores/solr/solr_database.py,sha256=TFjqbY7jAkdrhAchbNg0E-mChSP7ogNwFExslbvX7Yo,2877
 linkml_store/api/stores/solr/solr_utils.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 linkml_store/api/types.py,sha256=3aIQtDFMvsSmjuN5qrR2vNK5sHa6yzD_rEOPA6tHwvg,176
-linkml_store/cli.py,sha256=_oDbqElZIWKHJ6ruJyu57rbg2IYUr7U-0AqDlKz6jug,21126
+linkml_store/cli.py,sha256=6JN5kqAIQeatKQndrQlHxMj-7hClRuaDNnR_fIx-9l4,26529
 linkml_store/constants.py,sha256=x4ZmDsfE9rZcL5WpA93uTKrRWzCD6GodYXviVzIvR38,112
 linkml_store/graphs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 linkml_store/graphs/graph_map.py,sha256=bYRxv8n1YPnFqE9d6JKNmRawb8EAhsPlHhBue0gvtZE,712
@@ -39,19 +39,30 @@ linkml_store/index/implementations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQe
 linkml_store/index/implementations/llm_indexer.py,sha256=LI5f8SLF_rJY5W6wZPLaUqpyoq-VDW_KqlCBNDNm_po,4827
 linkml_store/index/implementations/simple_indexer.py,sha256=KnkFJtXTHnwjhD_D6ZK2rFhBID1dgCedcOVPEWAY2NU,1282
 linkml_store/index/indexer.py,sha256=K-TDPzdTyGFo6iG4XI_A_3IpwDbKeiTIbdr85NIL5r8,4918
+linkml_store/inference/__init__.py,sha256=b8NAFNZjOYU_8gOvxdyCyoiHOOl5Ai2ckKs1tv7ZkkY,342
+linkml_store/inference/implementations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+linkml_store/inference/implementations/rag_inference_engine.py,sha256=TG6nPy2QowycZRPKGwzBF80Wq6Qb7wyrA1gG_h47gYw,5812
+linkml_store/inference/implementations/rule_based_inference_engine.py,sha256=bncdfRdqjj37DIUQLCzxTJNMwEHPWsWXiom4iN6m_q8,5774
+linkml_store/inference/implementations/sklearn_inference_engine.py,sha256=UsvtwS76lSyf3_7O1cLNxoBqkPIRwCqJcdiOFKy7lw4,12672
+linkml_store/inference/inference_config.py,sha256=xgl3VmueErLIOnQQn4HdC2STJNY6yKoPasWmym4ltHQ,2014
+linkml_store/inference/inference_engine.py,sha256=-X8UFZwEYfavM-cfkEb-77JptWmNQUHBnxAuKdjUi7o,5513
+linkml_store/inference/inference_engine_registry.py,sha256=6o66gvBYBwdeAKm62zqqvfaBlcopVP_cla3L6uXGsHA,3015
 linkml_store/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 linkml_store/utils/change_utils.py,sha256=O2rvSvgTKB60reLLz9mX5OWykAA_m93bwnUh5ZWa0EY,471
 linkml_store/utils/file_utils.py,sha256=rQ7-XpmI6_Kx_dhEnI98muFRr0MmgI_kZ_9cgJBf_0I,1411
-linkml_store/utils/format_utils.py,sha256=aBS0uUhvdgPEXzw72iGfSezmHZFnqHtPuFUbVR4cfbA,13174
+linkml_store/utils/format_utils.py,sha256=JA7E-XYgkIGTXBSyTKSRrN7ZHeXOJ8-wpSjRTCAAAso,10680
 linkml_store/utils/io.py,sha256=JHUrWDtlZC2jtN_PQZ4ypdGIyYlftZEN3JaCvEPs44w,884
+linkml_store/utils/llm_utils.py,sha256=ItszPvHuQ6joU6vf30jGYfut5q9vrma3eYHighr1wOs,2840
 linkml_store/utils/mongodb_utils.py,sha256=Rl1YmMKs1IXwSsJIViSDChbi0Oer5cBnMmjka2TeQS8,4665
 linkml_store/utils/neo4j_utils.py,sha256=y3KPmDZ8mQmePgg0lUeKkeKqzEr2rV226xxEtHc5pRg,1266
-linkml_store/utils/object_utils.py,sha256=is6T2gruvVKvWD5ZntcAl6Qi3L154FObEho_b_crTuE,2539
-linkml_store/utils/pandas_utils.py,sha256=INL8aZ5v2OeLg-Uzfa8P1cpnMMKA1DumiTB0q175tw8,1389
+linkml_store/utils/object_utils.py,sha256=dAF9WmtWwAXdAnTN-UwbiCbBJt3Wdcsp8Z4lz8lVscY,2642
+linkml_store/utils/pandas_utils.py,sha256=djiFPO3YbgRVo2XAZuKCtgH8QVLuUyPIsfS8e-0umsU,3182
 linkml_store/utils/patch_utils.py,sha256=q-h_v68okyruzdPTEHCe0WubbQHKpi1qy5bJ9vFWDo8,4823
 linkml_store/utils/query_utils.py,sha256=HWt46BsGWoIGiNBTtvpXGY6onPRWsQky6eu_9cYqbvo,3440
 linkml_store/utils/schema_utils.py,sha256=iJiZxo5NGr7v87h4DV6V9DrDOZHSswMRuf0N4V2rVtg,646
+linkml_store/utils/sklearn_utils.py,sha256=itPpcrsbbyOazdjmivaaZ1lyZeytm0a0hJ2AS8ziUgg,7590
 linkml_store/utils/sql_utils.py,sha256=T41w_vsc3SauTJQkDMwid_nOtKW1YOKyUuaxEf470hk,5938
+linkml_store/utils/stats_utils.py,sha256=4KqBb1bqDgAmq-1fJLLu5B2paPgoZZc3A-gnyVam4bI,1799
 linkml_store/webapi/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 linkml_store/webapi/html/__init__.py,sha256=hwp5eeBJKH65Bvv1x9Z4vsT1tLSYtb9Dq4I9r1kL1q0,69
 linkml_store/webapi/html/base.html.j2,sha256=hoiV2uaSxxrQp7VuAZBOHueH7czyJMYcPBRN6dZFYhk,693
@@ -60,8 +71,8 @@ linkml_store/webapi/html/database_details.html.j2,sha256=qtXdavbZb0mohiObI9dvJtk
 linkml_store/webapi/html/databases.html.j2,sha256=a9BCWQYfPeFhdUd31CWhB0yWhTIFXQayO08JgjyqKoc,294
 linkml_store/webapi/html/generic.html.j2,sha256=KtLaO2HUEF2Opq-OwHKgRKetNWe8IWc6JuIkxRPsywk,1018
 linkml_store/webapi/main.py,sha256=B0Da575kKR7X88N9ykm99Dem8FyBAW9f-w3A_JwUzfw,29165
-linkml_store-0.1.13.dist-info/LICENSE,sha256=77mDOslUnalYnuq9xQYZKtIoNEzcH9mIjvWHOKjamnE,1086
-linkml_store-0.1.13.dist-info/METADATA,sha256=ouYb20TN5M2D12IUx9qspIIOiI-6qmrPpe1b6xx9xhU,5609
-linkml_store-0.1.13.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-linkml_store-0.1.13.dist-info/entry_points.txt,sha256=gWxVsHqx-t-UKWFHFzawQTvs4is4vC1rCF5AeKyqWWk,101
-linkml_store-0.1.13.dist-info/RECORD,,
+linkml_store-0.1.14.dist-info/LICENSE,sha256=77mDOslUnalYnuq9xQYZKtIoNEzcH9mIjvWHOKjamnE,1086
+linkml_store-0.1.14.dist-info/METADATA,sha256=T5BZ87qj1w2xyCkQErRa4ErFwvDKNMfahOGWYRkPQmg,6525
+linkml_store-0.1.14.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+linkml_store-0.1.14.dist-info/entry_points.txt,sha256=gWxVsHqx-t-UKWFHFzawQTvs4is4vC1rCF5AeKyqWWk,101
+linkml_store-0.1.14.dist-info/RECORD,,