uncertainty-engine-types 0.0.2__py3-none-any.whl → 0.0.4__py3-none-any.whl

uncertainty_engine_types/__init__.py

@@ -1,42 +1,44 @@
+from .context import Context
+from .conversation import Conversation
 from .execution_error import ExecutionError
 from .graph import Graph, NodeElement, NodeId, SourceHandle, TargetHandle
 from .handle import Handle
-from .llm import LLM, LLMManager, LLMProvider
+from .llm import LLMConfig, LLMProvider
 from .message import Message
-from .model import TwinLabModel, save_model
-from .node_info import NodeInfo, NodeInputInfo, NodeOutputInfo
-from .sensor_designer import SensorDesigner, save_sensor_designer
-from .sql import SQLDatabase, SQLKind, SQLManager
+from .model import TwinLabModel
+from .node_info import NodeInfo, NodeInputInfo, NodeOutputInfo, Versions
+from .sensor_designer import SensorDesigner
+from .sql import SQLConfig, SQLKind
 from .tabular_data import TabularData
 from .token import Token
-from .vector_store import VectorStoreConnection, VectorStoreManager, VectorStoreProvider
+from .vector_store import VectorStoreConfig, VectorStoreProvider
+from .version import __version__
+
 
 __all__ = [
+    "__version__",
+    "Context",
+    "Conversation",
     "ExecutionError",
     "Graph",
     "Handle",
-    "LLM",
-    "LLMManager",
+    "LLMConfig",
     "LLMProvider",
     "Message",
-    "Message",
     "NodeElement",
     "NodeId",
     "NodeInfo",
     "NodeInputInfo",
     "NodeOutputInfo",
-    "save_model",
-    "save_sensor_designer",
     "SensorDesigner",
     "SourceHandle",
-    "SQLDatabase",
+    "SQLConfig",
     "SQLKind",
-    "SQLManager",
     "TabularData",
     "TargetHandle",
     "Token",
     "TwinLabModel",
-    "VectorStoreConnection",
-    "VectorStoreManager",
+    "VectorStoreConfig",
     "VectorStoreProvider",
+    "Versions",
 ]

uncertainty_engine_types/context.py

@@ -0,0 +1,12 @@
+from pydantic import BaseModel
+
+from .node_info import NodeInfo
+
+
+class Context(BaseModel):
+    sync: bool
+    job_id: str
+    queue_url: str
+    cache_url: str
+    timeout: int
+    nodes: dict[str, NodeInfo]

uncertainty_engine_types/conversation.py

@@ -0,0 +1,7 @@
+from pydantic import BaseModel
+
+from .message import Message
+
+
+class Conversation(BaseModel):
+    messages: list[Message]

uncertainty_engine_types/llm.py

@@ -1,111 +1,21 @@
-from abc import ABC, abstractmethod
 from enum import Enum
 from typing import Optional
 
 from pydantic import BaseModel
-from typeguard import typechecked
 
 
-@typechecked
-class LLM(ABC):
-
-    @property
-    def temperature(self) -> float:
-        return self._temperature
-
-    @temperature.setter
-    def temperature(self, value: float) -> None:
-        if not 0.0 <= value <= 1.0:
-            raise ValueError("Temperature must be between 0.0 and 1.0")
-        self._temperature = value
-
-    @abstractmethod
-    def get_langchain_llm(self, query: str) -> "LLM":
-        """
-        Return a BaseLLM object from Langchain according to the provider type.
-        """
-        pass
-
-    def run_query(self, query: str) -> str:
-        """
-        Call the LLM with a query.
-        """
-        llm = self.get_langchain_llm()
-        return llm.invoke(query).content
-
-
-@typechecked
-class OpenAILLM(LLM):
-
-    def __init__(self, api_key: str, model: str, temperature: float = 0.0):
-        self.api_key = api_key
-        self.model = model
-        self.temperature = temperature
-
-    def get_langchain_llm(self):
-        from langchain_openai import ChatOpenAI
-
-        return ChatOpenAI(
-            model=self.model,
-            temperature=self.temperature,
-            api_key=self.api_key,
-        )
-
-
-@typechecked
-class OllamaLLM(LLM):
-    def __init__(self, url: str, model: str, temperature: float = 0.0):
-        self.url = url
-        self.model = model
-        self.temperature = temperature
-
-    def get_langchain_llm(self):
-        from langchain_ollama import ChatOllama
-
-        return ChatOllama(
-            base_url=self.url,
-            model=self.model,
-            temperature=self.temperature,
-        )
-
-
-@typechecked
 class LLMProvider(Enum):
     OPENAI = "openai"
     OLLAMA = "ollama"
 
 
-@typechecked
-class LLMManager(BaseModel):
+class LLMConfig(BaseModel):
     """
-    Connection manager for Language Learning Models (LLMs).
+    Connection configuration for Language Learning Models (LLMs).
     """
 
-    url: str
     provider: str
     model: str
     temperature: float = 0.0
-    api_key: Optional[str] = None
-
-    def connect(self) -> LLM:
-        """
-        Connect to the LLM.
-        """
-
-        match self.provider:
-            case LLMProvider.OPENAI.value:
-                if self.api_key is None:
-                    raise ValueError("API key is required for OpenAI LLM")
-                return OpenAILLM(
-                    api_key=self.api_key,
-                    model=self.model,
-                    temperature=self.temperature,
-                )
-            case LLMProvider.OLLAMA.value:
-                return OllamaLLM(
-                    url=self.url,
-                    model=self.model,
-                    temperature=self.temperature,
-                )
-            case _:
-                raise ValueError(f"Unknown LLM provider: {self.provider}")
+    ollama_url: Optional[str] = None
+    openai_api_key: Optional[str] = None

uncertainty_engine_types/message.py

@@ -1,9 +1,30 @@
 from datetime import datetime
+from typing import Dict, Literal, Sequence, Union
 
-from pydantic import BaseModel
+from pydantic import BaseModel, model_validator
+
+
+Value = Union[str, float, int]
+StructuredOutput = Dict[str, Union[Value, Sequence[Value], Dict[str, Value]]]
 
 
 class Message(BaseModel):
-    role: str
-    content: str
+    role: Literal["instruction", "user", "engine"]
+    content: Union[str, StructuredOutput]
     timestamp: datetime
+
+    @model_validator(mode="before")
+    @classmethod
+    def validate(cls, values: Dict) -> Dict:
+        role = values.get("role")
+        content = values.get("content")
+
+        if role in ["instruction", "user"]:
+            if not isinstance(content, str):
+                raise ValueError(f"Content must be a string when role is {role}")
+        elif role == "engine":
+            if not isinstance(content, StructuredOutput):
+                raise ValueError(
+                    "Content must be a structured output when role is engine"
+                )
+        return values

uncertainty_engine_types/model.py

@@ -1,7 +1,3 @@
-from typing import Any, Dict, Tuple
-import json
-import tempfile
-
 from pydantic import BaseModel, ConfigDict
 
 
@@ -11,29 +7,3 @@ class TwinLabModel(BaseModel):
     metadata: dict
 
     model_config = ConfigDict(protected_namespaces=())
-
-    def load_model(self) -> Tuple[Any, Dict]:
-
-        from twinlab_models.models import model_type_from_str  # type: ignore
-
-        model_type = self.model_type
-        tl_model = model_type_from_str(model_type)
-
-        with tempfile.NamedTemporaryFile(mode="w", suffix=".json") as f:
-            # Write the JSON to the temporary file
-            json.dump(self.model_dump(), f)  # Changed dumps to dump
-            f.flush()
-            tl_model, meta_data = tl_model.load(f.name)
-
-        return tl_model, meta_data
-
-
-# TODO: Should this be a method of the type?
-def save_model(model, meta_data: dict) -> TwinLabModel:
-
-    with tempfile.NamedTemporaryFile(mode="r", suffix=".json") as f:
-        model.save(f.name, meta_data)
-        f.seek(0)
-        config = json.load(f)
-
-    return TwinLabModel(**config)

uncertainty_engine_types/node_info.py

@@ -2,10 +2,18 @@ from typing import Any, Optional
 
 from pydantic import BaseModel
 
+from .version import __version__
+
+
+class Versions(BaseModel):
+    base_image: str
+    types_lib: str = __version__
+    node: str
+
 
 class NodeInputInfo(BaseModel):
-    label: str
     type: str
+    label: str
     description: str
     required: bool = True
     set_in_node: bool = True
@@ -13,18 +21,21 @@ class NodeInputInfo(BaseModel):
 
 
 class NodeOutputInfo(BaseModel):
-    label: str
     type: str
+    label: str
     description: str
 
 
 class NodeInfo(BaseModel):
     id: str
-    version: int
     label: str
     category: str
     description: str
     long_description: str
+    image_name: str
     cost: int
     inputs: dict[str, NodeInputInfo]
     outputs: dict[str, NodeOutputInfo] = {}
+    queue_url: Optional[str] = None
+    cache_url: Optional[str] = None
+    versions: Versions

uncertainty_engine_types/sensor_designer.py

@@ -1,19 +1,5 @@
-import json
-
 from pydantic import BaseModel
 
 
 class SensorDesigner(BaseModel):
     bed: dict
-
-    def load_sensor_designer(self):
-
-        from twinlab_bed.BED import BED
-
-        bed = BED.from_json(json.dumps(self.bed))
-
-        return bed
-
-
-def save_sensor_designer(bed) -> SensorDesigner:
-    return SensorDesigner(bed=json.loads(bed.to_json()))

uncertainty_engine_types/sql.py

@@ -1,61 +1,15 @@
-from abc import ABC, abstractmethod
 from enum import Enum
-from typing import Any
 
 from pydantic import BaseModel
-from typeguard import typechecked
-
-
-class SQLDatabase(ABC):
-    @abstractmethod
-    def execute(self, query: str) -> list[tuple[Any, ...]]:
-        """
-        Execute the given query.
-
-        Parameters:
-            query (str): The SQL query to execute.
-
-        Returns:
-            str: The result of the query.
-        """
-        pass
-
-
-class PostgreSQL(SQLDatabase):
-    @typechecked
-    def __init__(
-        self, host: str, username: str, password: str, port: int, database: str
-    ):
-        import psycopg2
-
-        self.connection = psycopg2.connect(
-            host=host, user=username, password=password, port=port, database=database
-        )
-        self.cursor = self.connection.cursor()
-
-    @typechecked
-    def execute(self, query: str) -> list[tuple[Any, ...]]:
-        """
-        Execute the given query.
-
-        Parameters:
-            query (str): The SQL query to execute.
-
-        Returns:
-            str: The result of the query.
-        """
-
-        self.cursor.execute(query)
-        return self.cursor.fetchall()
 
 
 class SQLKind(Enum):
     POSTGRES = "POSTGRES"
 
 
-class SQLManager(BaseModel):
+class SQLConfig(BaseModel):
     """
-    Connection manager for SQL databases.
+    Connection configuration for SQL databases.
     """
 
     kind: SQLKind
@@ -64,21 +18,3 @@ class SQLManager(BaseModel):
     password: str
     port: int
     database: str
-
-    @typechecked
-    def connect(self) -> SQLDatabase:
-        """
-        Connect to the SQL database.
-        """
-
-        match self.kind:
-            case SQLKind.POSTGRES:
-                return PostgreSQL(
-                    host=self.host,
-                    username=self.username,
-                    password=self.password,
-                    port=self.port,
-                    database=self.database,
-                )
-            case _:
-                raise ValueError("Unsupported SQL kind")

uncertainty_engine_types/tabular_data.py

@@ -1,13 +1,5 @@
-from io import StringIO
-
 from pydantic import BaseModel
 
 
 class TabularData(BaseModel):
     csv: str
-
-    def load_dataframe(self):
-
-        import pandas as pd
-
-        return pd.read_csv(StringIO(self.csv))

uncertainty_engine_types/vector_store.py

@@ -1,108 +1,15 @@
-from abc import ABC, abstractmethod
 from enum import Enum
-from typing import Optional, Literal, List, Dict
 
 from pydantic import BaseModel
-from typeguard import typechecked
 
 
 class VectorStoreProvider(Enum):
     WEAVIATE = "weaviate"
 
 
-class VectorStoreConnection(ABC):
-    @abstractmethod
-    def ingest(self, texts, metadatas):
-        pass
-
-    @abstractmethod
-    def retrieve(self, query, k):
-        pass
-
-    @abstractmethod
-    def get_vector_store(self):
-        pass
-
-    @abstractmethod
-    def close(self):
-        pass
-
-
-@typechecked
-class WeaviateVectorStoreConnection(VectorStoreConnection):
-
-    def __init__(
-        self,
-        host: str,
-        port: str,
-        collection: str,
-        embedding_type: str,
-        embedding_model: str,
-        embedding_api_key: str,
-    ):
-
-        self.host = host
-        self.port = port
-        self.collection = collection
-        self.embedding_type = embedding_type
-        self.embedding_model = embedding_model
-        self.embedding_api_key = embedding_api_key
-        self.vector_store = get_persistent_vector_store(
-            host, port, collection, embedding_type, embedding_model, embedding_api_key
-        )
-
-    def ingest(self, texts: List[str], metadatas: List[Dict]) -> List[str]:
-        """
-        Ingest a list of texts into the vector store.
-
-        Args:
-            texts (List[str]): The texts to ingest.
-            metadatas (List[Dict]): The metadata associated with each text.
-
-        Returns:
-            List[str]: The IDs of the ingested texts.
-
-        """
-
-        return self.vector_store.add_texts(texts=texts, metadatas=metadatas)
-
-    def retrieve(self, query: Optional[str], k: int) -> List[Dict]:
-        """
-        Retrieve the k most relevant documents to a query.
-
-        Args:
-            query (Optional[str]): The query to retrieve documents for.
-            k (int): The number of documents to retrieve.
-
-        Returns:
-            List[str]: The IDs of the retrieved documents.
-
-        """
-
-        docs = self.vector_store.max_marginal_relevance_search(query=query, k=k)
-        docs_list = [
-            {"content": doc.page_content, "metadata": doc.metadata} for doc in docs
-        ]
-        return docs_list
-
-    def get_vector_store(self):
-        """
-        Get the underlying vector store.
-
-        Returns:
-            LangcahinWeaviateVectorStore: The underlying vector store.
-
-        """
-
-        return self.vector_store
-
-    def close(self):
-        self.vector_store._client.close()
-
-
-class VectorStoreManager(BaseModel):
+class VectorStoreConfig(BaseModel):
     """
-    Connection manager for a vector store.
+    Connection configuration for a vector store.
     """
 
     provider: str
@@ -112,119 +19,3 @@ class VectorStoreManager(BaseModel):
     embedding_type: str
     embedding_model: str
     embedding_api_key: str
-
-    @typechecked
-    def connect(self) -> WeaviateVectorStoreConnection:
-        """
-        Connect to the vector store.
-
-        Returns:
-            VectorStoreConnection: The vector store connection.
-        """
-
-        match self.provider:
-            case VectorStoreProvider.WEAVIATE.value:
-                return WeaviateVectorStoreConnection(
-                    host=self.host,
-                    port=self.port,
-                    collection=self.collection,
-                    embedding_type=self.embedding_type,
-                    embedding_model=self.embedding_model,
-                    embedding_api_key=self.embedding_api_key,
-                )
-            case _:
-                raise ValueError(f"Unknown vector store provider: {self.provider}")
-
-
-@typechecked
-def get_persistent_vector_store(
-    host: str,
-    port: str,
-    collection: str,
-    embedding_type: str,
-    embedding_model: str,
-    embedding_api_key: Optional[str] = None,
-):
-    """
-    Get a database client connected to a deployed Weaviate vector store
-    """
-
-    from langchain_weaviate import WeaviateVectorStore
-    from weaviate.connect import ConnectionParams
-    import weaviate
-
-    try:
-        client = weaviate.WeaviateClient(
-            connection_params=ConnectionParams.from_params(
-                http_host=host,
-                http_port=port,
-                http_secure=False,
-                grpc_host=host,
-                grpc_port="50051",
-                grpc_secure=False,
-            ),
-            skip_init_checks=True,
-        )
-        client.connect()
-    except Exception as e:
-        raise ValueError(f"Failed to connect to Weaviate: {e}")
-
-    embedding_function = get_embedding_function(
-        embedding_type, embedding_model, embedding_api_key
-    )
-
-    # check if a collection exists and makes one if it doesn't
-    if not client.collections.exists(collection):
-        client.collections.create(collection)
-
-    try:
-        vector_store = WeaviateVectorStore(
-            client=client,
-            index_name=collection,
-            text_key="text",
-            embedding=embedding_function,
-        )
-    except Exception as e:
-        raise ValueError(f"Failed to initialize Weaviate vector store: {e}")
-
-    return vector_store
-
-
-@typechecked
-def get_embedding_function(
-    embedding_type: Literal["huggingface", "openai"],
-    embedding_model: str,
-    embedding_api_key: Optional[str] = None,
-):
-    """
-    Get an embedding function based on the specified type and configuration.
-    """
-
-    from langchain_huggingface import HuggingFaceEmbeddings
-    from langchain_openai import OpenAIEmbeddings
-
-    match embedding_type:
-        case "huggingface":
-            try:
-                return HuggingFaceEmbeddings(model_name=embedding_model)
-            except Exception as e:
-                raise ValueError(
-                    f"Failed to initialize HuggingFace embedding model: {str(e)}"
-                ) from e
-
-        case "openai":
-            if not embedding_api_key:
-                raise ValueError("OpenAI embeddings require an API key")
-            try:
-                return OpenAIEmbeddings(
-                    model=embedding_model, api_key=embedding_api_key
-                )
-            except Exception as e:
-                raise ValueError(
-                    f"Failed to initialize OpenAI embedding model: {str(e)}"
-                ) from e
-
-        case _:
-            raise ValueError(
-                f"Embedding type must be one of ['huggingface', 'openai']. Got {embedding_type}"
-            )

uncertainty_engine_types/version.py

@@ -0,0 +1 @@
+__version__ = "0.0.4"

{uncertainty_engine_types-0.0.2.dist-info → uncertainty_engine_types-0.0.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: uncertainty-engine-types
-Version: 0.0.2
+Version: 0.0.4
 Summary: Common type definitions for the Uncertainty Engine
 Author: Freddy Wordingham
 Author-email: freddy@digilab.ai
@@ -10,14 +10,10 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Requires-Dist: pandas (>=2.2.3,<3.0.0)
 Requires-Dist: pydantic (>=2.10.5,<3.0.0)
-Requires-Dist: typeguard (>=2.13.3,<2.14.0)
 Description-Content-Type: text/markdown
 
-<div style="color: black; background-color: #edf497;">
-    <img src="./assets/images/uncertainty-engine-logo.png">
-</div>
+![Uncertainty Engine banner](https://github.com/digiLab-ai/uncertainty-engine-types/raw/main/assets/images/uncertainty-engine-logo.png)
 
 # Types
 

uncertainty_engine_types-0.0.4.dist-info/RECORD

@@ -0,0 +1,19 @@
+uncertainty_engine_types/__init__.py,sha256=AbQ7nlKUqTMJ7MuFWBLrUGPnnz-KeNxjRjw_mlud6wU,1104
+uncertainty_engine_types/context.py,sha256=k9rlArn-L2x1P5vWy5khfuqJW5tJOqr3NlhubZCbyG4,209
+uncertainty_engine_types/conversation.py,sha256=uDHTr4uPzjkcflhyFAanfiQ1KbEIs4C9jogrwzOEt_s,122
+uncertainty_engine_types/execution_error.py,sha256=tvIBuZPM8UhFUERHCEqoW8blAYYuBq1ZqidO0i_BCGs,105
+uncertainty_engine_types/graph.py,sha256=ii2YT2jxoRB7UhcceI2k_ArKmlUXEwBCRBpsEUjL2Qg,265
+uncertainty_engine_types/handle.py,sha256=DEu3aCwJsOuinQ2Gxdy6dZbwnCHAXkplIT4WNL6o7oQ,444
+uncertainty_engine_types/llm.py,sha256=oivoY3aDv5Rsk8FWA-vOPEFfK9a6-SqSyu01AlEuO7o,406
+uncertainty_engine_types/message.py,sha256=KncFJQHL_ko8nfOuso_eh7i2gB0y4nXI6gBW9U8lAEY,971
+uncertainty_engine_types/model.py,sha256=sVP4e25uV114XOGbcDxvvngcI6bMXRaM3zLRLKP30C0,188
+uncertainty_engine_types/node_info.py,sha256=5_t18hKJ4ZOhB-64DzPzr7Teq9S1HeB7VXHL2J8UVeA,784
+uncertainty_engine_types/sensor_designer.py,sha256=hr3ek4_dRjRK0-78uaT6h8-bGUCm7Mfs6mxJSWxE64c,80
+uncertainty_engine_types/sql.py,sha256=SBzmgMEZ-sa-OBRoZbmKiOqddop4zJixgxx-JCus9fY,298
+uncertainty_engine_types/tabular_data.py,sha256=i_1LfgQqxDanPRWuDkP3Hd8-9eVet6FbPIlPZlAi1n0,76
+uncertainty_engine_types/token.py,sha256=4tQQkvl-zsYoVk8ZEx0cB2JiU0VDRJ6uUe76XBXEpBY,178
+uncertainty_engine_types/vector_store.py,sha256=9fYPJ04jWcy2DruyUSjiKQAgmqq-wgeAi5dBIrAOm30,392
+uncertainty_engine_types/version.py,sha256=1mptEzQihbdyqqzMgdns_j5ZGK9gz7hR2bsgA_TnjO4,22
+uncertainty_engine_types-0.0.4.dist-info/METADATA,sha256=f2-J06g-f0RHmgs30Q0GEzxlrCQMG5OOxt0B19YFzZs,3596
+uncertainty_engine_types-0.0.4.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+uncertainty_engine_types-0.0.4.dist-info/RECORD,,

{uncertainty_engine_types-0.0.2.dist-info → uncertainty_engine_types-0.0.4.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.0.0
+Generator: poetry-core 2.1.1
 Root-Is-Purelib: true
 Tag: py3-none-any

uncertainty_engine_types-0.0.2.dist-info/RECORD

@@ -1,16 +0,0 @@
-uncertainty_engine_types/__init__.py,sha256=jWiOjdxBRqGT1tjnKA0oEFc9xp9rDCKmZIDgt0jxFr4,1123
-uncertainty_engine_types/execution_error.py,sha256=tvIBuZPM8UhFUERHCEqoW8blAYYuBq1ZqidO0i_BCGs,105
-uncertainty_engine_types/graph.py,sha256=ii2YT2jxoRB7UhcceI2k_ArKmlUXEwBCRBpsEUjL2Qg,265
-uncertainty_engine_types/handle.py,sha256=DEu3aCwJsOuinQ2Gxdy6dZbwnCHAXkplIT4WNL6o7oQ,444
-uncertainty_engine_types/llm.py,sha256=n85oICjqxFoa6S9BzrSAydu6giRDbq8-dCTRn41pzzI,2796
-uncertainty_engine_types/message.py,sha256=On9n0S4U6nOMKmJfQDOnlBSF8MhHjiuekQEKVH84kj0,145
-uncertainty_engine_types/model.py,sha256=TzOZt0np3ECdzfxewZfTX93k1FrPBh25D6BJaEIJ9v8,1070
-uncertainty_engine_types/node_info.py,sha256=Xh9NQKwSc3V4IkESF5-RcOPTkzQcOveYR7J1nvKBjFI,556
-uncertainty_engine_types/sensor_designer.py,sha256=_91bBp0k2OnFN9QuDkHhfbhCalVfxCtH6lGciazYZdI,350
-uncertainty_engine_types/sql.py,sha256=rNpGqCe1BMvYiJIv_z9kk6BhVa_1Qn30HZcIfYA1vuo,1914
-uncertainty_engine_types/tabular_data.py,sha256=y56F_Np-qPij9ioACcAobNna_Dwm3rfad3PKpdhRSkM,209
-uncertainty_engine_types/token.py,sha256=4tQQkvl-zsYoVk8ZEx0cB2JiU0VDRJ6uUe76XBXEpBY,178
-uncertainty_engine_types/vector_store.py,sha256=lsWEzjVvOsfUy2qmoI4ZEF9ieukMi1Z6Mt0XYTcq-f0,6370
-uncertainty_engine_types-0.0.2.dist-info/METADATA,sha256=nWPZIPTswNUrVaMlQYe5G3swFp_ccQLEnkCKs0dWWaA,3665
-uncertainty_engine_types-0.0.2.dist-info/WHEEL,sha256=RaoafKOydTQ7I_I3JTrPCg6kUmTgtm4BornzOqyEfJ8,88
-uncertainty_engine_types-0.0.2.dist-info/RECORD,,