qtype 0.0.1__py3-none-any.whl

qtype/semantic/model.py

@@ -0,0 +1,354 @@
+"""
+Semantic Intermediate Representation models.
+
+This module contains the semantic models that represent a resolved QType
+specification where all ID references have been replaced with actual object
+references.
+
+Generated automatically with command:
+qtype generate semantic-model
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict, Field
+
+# Import enums and type aliases from DSL
+from qtype.dsl.model import VariableType  # noqa: F401
+from qtype.dsl.model import (
+    ArrayTypeDefinition,
+    DecoderFormat,
+    ObjectTypeDefinition,
+    StructuralTypeEnum,
+)
+from qtype.dsl.model import Variable as DSLVariable  # noqa: F401
+
+
+class Variable(DSLVariable, BaseModel):
+    """Semantic version of DSL Variable with ID references resolved."""
+
+    value: Any | None = Field(None, description="The value of the variable")
+
+    def is_set(self) -> bool:
+        return self.value is not None
+
+
+class ImmutableModel(BaseModel):
+    """Base model that can't be mutated but can be cached."""
+
+    id: str = Field(..., description="Unique ID of this model.")
+
+    model_config = ConfigDict(frozen=True)
+
+    def __hash__(self) -> int:
+        return hash(self.id)  # Hash based on a hashable field
+
+
+class Application(BaseModel):
+    """Defines a QType application that can include models, variables, and other components."""
+
+    id: str = Field(..., description="Unique ID of the application.")
+    description: str | None = Field(
+        None, description="Optional description of the application."
+    )
+    memories: list[Memory] = Field(
+        [], description="List of memory definitions used in this application."
+    )
+    models: list[Model] = Field(
+        [], description="List of models used in this application."
+    )
+    types: list[ObjectTypeDefinition | ArrayTypeDefinition] = Field(
+        [], description="List of custom types defined in this application."
+    )
+    variables: list[Variable] = Field(
+        [], description="List of variables used in this application."
+    )
+    flows: list[Flow] = Field(
+        [], description="List of flows defined in this application."
+    )
+    auths: list[AuthorizationProvider] = Field(
+        [], description="List of authorization providers used for API access."
+    )
+    tools: list[Tool] = Field(
+        [], description="List of tools available in this application."
+    )
+    indexes: list[Index] = Field(
+        [], description="List of indexes available for search operations."
+    )
+    telemetry: TelemetrySink | None = Field(
+        None, description="Optional telemetry sink for observability."
+    )
+
+
+class AuthorizationProvider(ImmutableModel):
+    """Defines how tools or providers authenticate with APIs, such as OAuth2 or API keys."""
+
+    id: str = Field(
+        ..., description="Unique ID of the authorization configuration."
+    )
+    api_key: str | None = Field(
+        None, description="API key if using token-based auth."
+    )
+    client_id: str | None = Field(None, description="OAuth2 client ID.")
+    client_secret: str | None = Field(
+        None, description="OAuth2 client secret."
+    )
+    host: str | None = Field(
+        None, description="Base URL or domain of the provider."
+    )
+    scopes: list[str] = Field([], description="OAuth2 scopes required.")
+    token_url: str | None = Field(None, description="Token endpoint URL.")
+    type: str = Field(
+        ..., description="Authorization method, e.g., 'oauth2' or 'api_key'."
+    )
+
+
+class Step(BaseModel):
+    """Base class for components that take inputs and produce outputs."""
+
+    id: str = Field(..., description="Unique ID of this component.")
+    inputs: list[Variable] = Field(
+        [], description="Input variables required by this step."
+    )
+    outputs: list[Variable] = Field(
+        [], description="Variable where output is stored."
+    )
+
+
+class Index(ImmutableModel):
+    """Base class for searchable indexes that can be queried by search steps."""
+
+    id: str = Field(..., description="Unique ID of the index.")
+    args: dict[str, Any] = Field(
+        {},
+        description="Index-specific configuration and connection parameters.",
+    )
+    auth: AuthorizationProvider | None = Field(
+        None, description="AuthorizationProvider for accessing the index."
+    )
+    name: str = Field(..., description="Name of the index/collection/table.")
+
+
+class Model(ImmutableModel):
+    """Describes a generative model configuration, including provider and model ID."""
+
+    id: str = Field(..., description="Unique ID for the model.")
+    auth: AuthorizationProvider | None = Field(
+        None, description="AuthorizationProvider used for model access."
+    )
+    inference_params: dict[str, Any] = Field(
+        {},
+        description="Optional inference parameters like temperature or max_tokens.",
+    )
+    model_id: str | None = Field(
+        None,
+        description="The specific model name or ID for the provider. If None, id is used",
+    )
+    provider: str = Field(
+        ..., description="Name of the provider, e.g., openai or anthropic."
+    )
+
+
+class Memory(ImmutableModel):
+    """Session or persistent memory used to store relevant conversation or state data across steps or turns."""
+
+    id: str = Field(..., description="Unique ID of the memory block.")
+    token_limit: int = Field(
+        100000, description="Maximum number of tokens to store in memory."
+    )
+    chat_history_token_ratio: float = Field(
+        0.7, description="Ratio of chat history tokens to total memory tokens."
+    )
+    token_flush_size: int = Field(
+        3000,
+        description="Size of memory to flush when it exceeds the token limit.",
+    )
+
+
+class TelemetrySink(BaseModel):
+    """Defines an observability endpoint for collecting telemetry data from the QType runtime."""
+
+    id: str = Field(
+        ..., description="Unique ID of the telemetry sink configuration."
+    )
+    auth: AuthorizationProvider | None = Field(
+        None,
+        description="AuthorizationProvider used to authenticate telemetry data transmission.",
+    )
+    endpoint: str = Field(
+        ..., description="URL endpoint where telemetry data will be sent."
+    )
+
+
+class TypeDefinitionBase(BaseModel):
+    """Semantic version of TypeDefinitionBase."""
+
+    id: str = Field(
+        ..., description="The unique identifier for this custom type."
+    )
+    kind: StructuralTypeEnum = Field(
+        ...,
+        description="The kind of structure this type represents (object/array).",
+    )
+    description: str | None = Field(
+        None, description="A description of what this type represents."
+    )
+
+
+class Condition(Step):
+    """Conditional logic gate within a flow. Supports branching logic for execution based on variable values."""
+
+    else_: Step | None = Field(
+        None,
+        description="Optional step to run if condition fails.",
+        alias="else",
+    )
+    equals: Variable | None = Field(
+        None, description="Match condition for equality check."
+    )
+    then: Step = Field(..., description="Step to run if condition matches.")
+
+
+class Decoder(Step):
+    """Defines a step that decodes string data into structured outputs.
+
+    If parsing fails, the step will raise an error and halt execution.
+    Use conditional logic in your flow to handle potential parsing errors.
+    """
+
+    format: DecoderFormat = Field(
+        DecoderFormat.json,
+        description="Format in which the decoder processes data. Defaults to JSON.",
+    )
+
+
+class Flow(Step):
+    """Defines a flow of steps that can be executed in sequence or parallel.
+    If input or output variables are not specified, they are inferred from
+    the first and last step, respectively.
+    """
+
+    steps: list[Step] = Field(..., description="List of steps or step IDs.")
+
+
+class LLMInference(Step):
+    """Defines a step that performs inference using a language model.
+    It can take input variables and produce output variables based on the model's response."""
+
+    memory: Memory | None = Field(
+        None,
+        description="Memory object to retain context across interactions.",
+    )
+    model: Model = Field(..., description="The model to use for inference.")
+    system_message: str | None = Field(
+        None,
+        description="Optional system message to set the context for the model.",
+    )
+
+
+class PromptTemplate(Step):
+    """Defines a prompt template with a string format and variable bindings.
+    This is used to generate prompts dynamically based on input variables."""
+
+    template: str = Field(
+        ...,
+        description="String template for the prompt with variable placeholders.",
+    )
+
+
+class Search(Step):
+    """Base class for search operations against indexes."""
+
+    filters: dict[str, Any] = Field(
+        {}, description="Optional filters to apply during search."
+    )
+    index: Index = Field(
+        ..., description="Index to search against (object or ID reference)."
+    )
+
+
+class Tool(Step):
+    """
+    Base class for callable functions or external operations available to the model or as a step in a flow.
+    """
+
+    name: str = Field(..., description="Name of the tool function.")
+    description: str = Field(
+        ..., description="Description of what the tool does."
+    )
+
+
+class DocumentIndex(Index):
+    """Document search index for text-based search (e.g., Elasticsearch, OpenSearch)."""
+
+    pass
+
+
+class VectorIndex(Index):
+    """Vector database index for similarity search using embeddings."""
+
+    embedding_model: EmbeddingModel = Field(
+        ...,
+        description="Embedding model used to vectorize queries and documents.",
+    )
+
+
+class EmbeddingModel(Model):
+    """Describes an embedding model configuration, extending the base Model class."""
+
+    dimensions: int = Field(
+        ...,
+        description="Dimensionality of the embedding vectors produced by this model.",
+    )
+
+
+class Agent(LLMInference):
+    """Defines an agent that can perform tasks and make decisions based on user input and context."""
+
+    tools: list[Tool] = Field(
+        ..., description="List of tools available to the agent."
+    )
+
+
+class DocumentSearch(Search):
+    """Performs document search against a document index."""
+
+    pass
+
+
+class VectorSearch(Search):
+    """Performs vector similarity search against a vector index."""
+
+    default_top_k: int | None = Field(
+        ...,
+        description="Number of top results to retrieve if not provided in the inputs.",
+    )
+
+
+class APITool(Tool):
+    """Tool that invokes an API endpoint."""
+
+    endpoint: str = Field(..., description="API endpoint URL to call.")
+    method: str = Field(
+        "GET", description="HTTP method to use (GET, POST, PUT, DELETE, etc.)."
+    )
+    auth: AuthorizationProvider | None = Field(
+        None,
+        description="Optional AuthorizationProvider for API authentication.",
+    )
+    headers: dict[str, str] = Field(
+        {}, description="Optional HTTP headers to include in the request."
+    )
+
+
+class PythonFunctionTool(Tool):
+    """Tool that calls a Python function."""
+
+    function_name: str = Field(
+        ..., description="Name of the Python function to call."
+    )
+    module_path: str = Field(
+        ..., description="Optional module path where the function is defined."
+    )

qtype/semantic/resolver.py

@@ -0,0 +1,97 @@
+"""
+Semantic resolution logic for QType.
+
+This module contains functions to transform DSL QTypeSpec objects into their
+semantic intermediate representation equivalents, where all ID references
+are resolved to actual object references.
+"""
+
+import logging
+from typing import Any
+
+import qtype.dsl.domain_types
+import qtype.dsl.model as dsl
+from qtype.dsl.validator import _is_dsl_type, _resolve_forward_ref
+from qtype.semantic import model as ir
+from qtype.semantic.errors import SemanticResolutionError
+
+logger = logging.getLogger(__name__)
+
+FIELDS_TO_IGNORE = {"Application.references"}
+
+
+def to_semantic_ir(
+    dslobj: qtype.dsl.domain_types.StrictBaseModel,
+    symbol_table: dict[str, Any],
+) -> Any:
+    """
+    Convert a DSL QTypeSpec object to its semantic intermediate representation (IR).
+
+    Args:
+        dsl: The DSL QTypeSpec object to convert.
+
+    Returns:
+        ir.Application: The semantic IR representation of the DSL object.
+    """
+
+    obj_id = getattr(dslobj, "id", None)
+    if obj_id and obj_id in symbol_table:
+        # If the object is already in the symbol table, return it.
+        return symbol_table[obj_id]
+
+    if isinstance(dslobj, list):
+        # If the object is a list, we will resolve each item in the list.
+        return [to_semantic_ir(item, symbol_table) for item in dslobj]  # type: ignore
+
+    if isinstance(dslobj, dsl.Enum):
+        # if the variable is an enum, just return it. The semantic classes use the same class
+        return dslobj
+
+    if _is_dsl_type(_resolve_forward_ref(type(dslobj))):
+        # If the object is a DSL type, we will resolve it to its semantic IR.
+        # First get the constructor with the same class name. i.e., dsl.Application -> ir.Application
+        class_name = dslobj.__class__.__name__
+        ir_class = getattr(ir, class_name, None)
+        if not ir_class:
+            raise SemanticResolutionError(
+                f"Could not find Semantic class for DSL type: {class_name}"
+            )
+        # iterate over the parameters of the DSL object and convert them to their semantic IR equivalents.
+        params = {
+            name: to_semantic_ir(value, symbol_table)
+            for name, value in dslobj
+            if f"{class_name}.{name}" not in FIELDS_TO_IGNORE
+        }
+        ir.Variable.model_rebuild()
+        result = ir_class(**params)
+        symbol_table[obj_id] = result  # type: ignore
+        return result
+    elif isinstance(dslobj, list):
+        return [to_semantic_ir(item, symbol_table) for item in dslobj]  # type: ignore
+    else:
+        return dslobj
+
+
+def resolve(application: dsl.Application) -> ir.Application:
+    """
+    Resolve a DSL Application into its semantic intermediate representation.
+
+    This function transforms the DSL Application into its IR equivalent,
+    resolving all ID references to actual object references.
+
+    Args:
+        application: The DSL Application to transform
+
+    Returns:
+        dsl.Application: The resolved IR application
+    """
+    # Next, we'll build up the semantic representation.
+    # This will create a map of all objects by their ID, ensuring that we can resolve
+    # references to actual objects.
+    result = to_semantic_ir(application, {})
+    if not isinstance(result, ir.Application):
+        raise SemanticResolutionError(
+            "The root object must be an Application, but got: "
+            f"{type(result).__name__}"
+        )
+    return result

qtype-0.0.1.dist-info/METADATA

@@ -0,0 +1,120 @@
+Metadata-Version: 2.4
+Name: qtype
+Version: 0.0.1
+Summary: DSL for Generative AI Prototyping
+Author-email: Lou Kratz <lou.kratz+qtype@bazaarvoice.com>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/bazaarvoice/qtype
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: jsonschema>=4.24.0
+Requires-Dist: pydantic>=2.11.5
+Requires-Dist: pyyaml>=6.0.2
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: openai>=1.93.0
+Requires-Dist: fsspec>=2025.5.1
+Requires-Dist: pydantic-yaml>=1.5.1
+Dynamic: license-file
+
+# QType
+
+**QType is a domain-specific language (DSL) for rapid prototyping of AI applications.**  
+It is designed to help developers define modular, composable AI systems using a structured YAML-based specification. QType supports models, prompts, tools, retrievers, and flow orchestration, and is extensible for code generation or live interpretation.
+
+---
+
+## 🚀 Quick Start
+
+Install QType:
+
+```bash
+pip install qtype[interpreter]
+```
+
+Create a file `hello_world.qtype.yaml` that executes a single chat question:
+```yaml
+id: hello_world
+flows:
+  - id: simple_qa_flow
+    steps:
+      - id: llm_inference_step
+        model: 
+          id: gpt-4o
+          provider: openai
+          auth: 
+            id: openai_auth
+            type: api_key
+            api_key: ${OPENAI_KEY}
+        system_message: |
+          You are a helpful assistant.
+        inputs:
+          - id: prompt
+            type: text
+        outputs:
+          - id: response_message
+            type: text
+```
+
+Put your openai api key into your `.env` file:
+```
+echo "OPENAI_KEY=sk...." >> .env
+```
+
+Validate that the file matches the spec:
+```
+qtype validate hello_world.qtype.yaml
+```
+
+You should see:
+```
+INFO: ✅ Schema validation successful.
+INFO: ✅ Model validation successful.
+INFO: ✅ Language validation successful
+INFO: ✅ Semantic validation successful
+```
+
+Finally,execute the flow.
+```
+qtype run flow '{"prompt":"What is the airspeed of a laden swallow?"}' hello_world.qtype.yaml 
+```
+
+You should see (something similar to):
+
+```
+INFO: Executing flow: simple_qa_flow
+
+The airspeed of a laden swallow is a humorous reference from the movie "Monty Python and the Holy Grail." In the film, the question is posed as "What is the airspeed velocity of an unladen swallow?" The joke revolves around the absurdity and specificity of the question, and it doesn't have a straightforward answer. However, if you're curious about the real-life airspeed of a swallow, the European Swallow (Hirundo rustica) typically flies at around 11 meters per second, or 24 miles per hour, when unladen. The concept of a "laden" swallow is part of the humor, as it would depend on what the swallow is carrying and is not a standard measurement.
+```
+
+---
+
+See the [full docs](https://bazaarvoice.github.io/qtype/) for more examples and guides.
+
+## 🤝 Contributing
+
+Contributions welcome! Please follow the instructions in the [contribution guide](https://bazaarvoice.github.io/qtype/contributing/).
+
+## 📄 License
+
+This project is licensed under the **MIT License**.  
+See the [LICENSE](./LICENSE) file for details.
+
+---
+
+## 🧠 Philosophy
+
+QType is built around modularity, traceability, and rapid iteration. It aims to empower developers to quickly scaffold ideas into usable AI applications without sacrificing maintainability or control.
+
+Stay tuned for upcoming features like:
+- Integrated OpenTelemetry tracing
+- Validation via LLM-as-a-judge
+- UI hinting via input display types
+- Flow state switching and conditional routing
+
+---
+
+Happy hacking with QType! 🛠️
+
+
+[![Generate JSON Schema](https://github.com/bazaarvoice/qtype/actions/workflows/github_workflows_generate-schema.yml/badge.svg)](https://github.com/bazaarvoice/qtype/actions/workflows/github_workflows_generate-schema.yml) [![Publish to PyPI](https://github.com/bazaarvoice/qtype/actions/workflows/publish-pypi.yml/badge.svg)](https://github.com/bazaarvoice/qtype/actions/workflows/publish-pypi.yml)

qtype-0.0.1.dist-info/RECORD

@@ -0,0 +1,49 @@
+qtype/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+qtype/cli.py,sha256=TjqZ6N0RGRZAcFm8Q6WkzXS_oV6cvYvsmbFdP8x9a-o,2113
+qtype/loader.py,sha256=4Ty5B0qWNQeehexh0anlP7hDmsso0bj7-IVt5VqnHWA,10992
+qtype/commands/__init__.py,sha256=Qo4M07zm5I63r8STxDjvt5fhP1jygdXTsExNGELkefc,257
+qtype/commands/convert.py,sha256=Mkk8BAJDOmZ_nPsa0YtzjdxxBMScWk-qeYye4ojWA0o,2453
+qtype/commands/generate.py,sha256=G8Uk4QdBRCmPErjihFbI2T8hB-M_yqLoQiw3-y7P8Mo,3587
+qtype/commands/run.py,sha256=iPg_fnmxx6mPr2I3l0rlJqFEciQCb6r52vKKO_BgW8w,5946
+qtype/commands/validate.py,sha256=gJjpT9tSCedV2vIuvhPyYIUgNip6RYYXbVK6PKlCPXk,2573
+qtype/commons/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+qtype/commons/generate.py,sha256=UBuknsU3f1G-Hz1VhtLTNnDu02repJh8fkrlP4OHqqI,2831
+qtype/commons/tools.py,sha256=pJFY5mPiFErXVFLw2GtiFoWnS8xCNaDVtk-opkoB-zs,5004
+qtype/converters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+qtype/converters/tools_from_api.py,sha256=qsycjLGZDnawND8JtK97avAEJcpAm5FGs8nDgePXzbc,774
+qtype/converters/tools_from_module.py,sha256=PQjISjj7Nqk_SPegA0fM0FPeKaVml9S15NuiTk-oCaQ,10270
+qtype/converters/types.py,sha256=CG9H6yK8tH8kCed6Yw-v8IDMFBOT9GcRlqHz4inbzMI,861
+qtype/dsl/__init__.py,sha256=FJ7T-bOEwfu96Vj5UuwHHTgYL5kGw1qyAk087DwRJFs,35
+qtype/dsl/base_types.py,sha256=ZMX5mAAOducSG_89SxniJWUGCsit1MU3EKrrzvSPmB4,687
+qtype/dsl/document.py,sha256=LzcDSV9DDfCAWpqm-mdxAwLNHmErb0_ypEPk5WnI5QU,3998
+qtype/dsl/domain_types.py,sha256=VglaF7eTVjUmLvubQeNQo2ZA0pRooQXZ-OPJ6edQBIk,1539
+qtype/dsl/model.py,sha256=mAgqfG1us1mT53nYd0gAIwOSgudLSDlwQjUlG5MDfRg,21169
+qtype/dsl/validator.py,sha256=yuDFPHfErPTIpZXCIyBrwpZJAitMEW0jNL8867KixUA,17130
+qtype/interpreter/__init__.py,sha256=IaRF90JLFbsTLKz9LTOMI_Pz4xwVaEyXPNaXV7sLou8,43
+qtype/interpreter/api.py,sha256=DrBV0fF6f4HiGSgXzHE07FwOr5Qe7uBQ2yQ6UjDOUTU,3872
+qtype/interpreter/conversions.py,sha256=17EKzKRSTKsGWlXemXdvHVdefZTonMyB0Ui6dIEtN7M,5584
+qtype/interpreter/exceptions.py,sha256=Il8IF0UAtYWQXwvOVQCY-csfRzC1iOejHM1G-nF5EfY,288
+qtype/interpreter/flow.py,sha256=2u1wRahNFQaRRklnU4uW7_UKSD73-uZe_WiYlKitXQg,1233
+qtype/interpreter/resource_cache.py,sha256=XylIIh7RFHs4JdOZWx24a3P-sH0qjgqU9_vri9ztAXU,1014
+qtype/interpreter/step.py,sha256=6rLznFCc8FT0edCbeA7mUYCz8NHhZzTIBpXTxrlG9eE,2084
+qtype/interpreter/telemetry.py,sha256=p1nmup-V_TBM64giYySewpjJOF5_FZgK_KTE5ad38Uk,632
+qtype/interpreter/typing.py,sha256=DdAgV78XurX2JnhBK5wHsYTtPyo9RjOytqxJJzDpwR4,2588
+qtype/interpreter/steps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+qtype/interpreter/steps/agent.py,sha256=Yg56YjTlrwc4oJ-f7ZBazF4ii2oJX8zMhETHF0-ArAU,4008
+qtype/interpreter/steps/condition.py,sha256=E86aRWQpjz18QuKwcGyoIPoOKAvTDZgnpg9qXw6xYas,1128
+qtype/interpreter/steps/decoder.py,sha256=2cyb2NaQzl5NcrGxP6d68ZsVflm8ldkwJsazRxQArY0,2887
+qtype/interpreter/steps/llm_inference.py,sha256=snariFHhvsDBixHeUpZLg8_V6BZIYOlSyVf6QsbRyd8,4358
+qtype/interpreter/steps/prompt_template.py,sha256=Hs4ZANMqDViZVEPhD2v6JcUJ0DdMkahDJwnDfAXidak,1582
+qtype/interpreter/steps/search.py,sha256=wyVFwg5wVXytsm2JyNPwkuBAWpxEunP-dAiqhDZyii4,660
+qtype/interpreter/steps/tool.py,sha256=zAL9us_KRrcaw_sktD1z2pm0Z2W9ruMd3rrjqk7TI_k,1996
+qtype/semantic/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+qtype/semantic/errors.py,sha256=dmdxGkVHrTwfiEHj5RFu2q11dAtefsivpLdJd6QynK0,119
+qtype/semantic/generate.py,sha256=JTQALEP0DCbx13HpuR7zsP5Nnk_XYkEAFpLutmRZmIQ,13299
+qtype/semantic/model.py,sha256=XmPoEqFQFKXHKC0hj-p9aEiuzUM4Q0qCHHskly3X5CM,11308
+qtype/semantic/resolver.py,sha256=D3CmRmr_ACL54ZCbc9HxXCuCZ37bNtSzlPLMpOeeOcw,3439
+qtype-0.0.1.dist-info/licenses/LICENSE,sha256=1KA5EgYBSR0O6nCH2HEvk6Di53YKJ9r_VCR7G8G8qAY,11341
+qtype-0.0.1.dist-info/METADATA,sha256=-qtCCCsTEA8veBIYr-z8yx4djIWdVlxSQzwUQsCp91w,4026
+qtype-0.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+qtype-0.0.1.dist-info/entry_points.txt,sha256=5y4vj8RLvgl2tXSj-Hm7v5-Tn3kP4-UonjNoN-mfaQE,41
+qtype-0.0.1.dist-info/top_level.txt,sha256=ONroH5B0mZ51jr7NSWCK0weFwwCO7wBLmyVS1YqNU14,6
+qtype-0.0.1.dist-info/RECORD,,

qtype-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

qtype-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+qtype = qtype.cli:main