versionhq 1.1.10.2__py3-none-any.whl → 1.1.10.4__py3-none-any.whl

versionhq/__init__.py

@@ -18,7 +18,7 @@ from versionhq.tool.model import Tool
 from versionhq.tool.composio_tool import ComposioHandler
 
 
-__version__ = "1.1.10.2"
+__version__ = "1.1.10.4"
 __all__ = [
     "Agent",
     "Customer",

versionhq/agent/model.py

@@ -255,9 +255,9 @@ class Agent(BaseModel):
         llm.timeout = self.max_execution_time if llm.timeout is None else llm.timeout
         llm.max_tokens = self.max_tokens if self.max_tokens else llm.max_tokens
 
-        # if self.callbacks:
-        #     llm.callbacks = self.callbacks
-        #     llm._set_callbacks(llm.callbacks)
+        if self.callbacks:
+            llm.callbacks = self.callbacks
+            llm._set_callbacks(llm.callbacks)
 
         if self.respect_context_window == False:
             llm.context_window_size = DEFAULT_CONTEXT_WINDOW_SIZE
@@ -364,9 +364,6 @@ class Agent(BaseModel):
             task_execution_counter += 1
             self._logger.log(level="info", message=f"Agent response: {raw_response}", color="blue")
 
-            if raw_response and self.callbacks:
-                for item in self.callbacks:
-                    raw_response = item(raw_response)
 
         except Exception as e:
             self._logger.log(level="error", message=f"An error occured. The agent will retry: {str(e)}", color="red")
@@ -379,10 +376,6 @@ class Agent(BaseModel):
                 task_execution_counter += 1
                 self._logger.log(level="info", message=f"Agent #{task_execution_counter} response: {raw_response}", color="blue")
 
-                if raw_response and self.callbacks:
-                    for item in self.callbacks:
-                        raw_response = item(raw_response)
-
             if not raw_response:
                 self._logger.log(level="error", message="Received None or empty response from the model", color="red")
                 raise ValueError("Invalid response from LLM call - None or empty.")
@@ -390,7 +383,7 @@ class Agent(BaseModel):
         return raw_response
 
 
-    def execute_task(self, task, context: Optional[str] = None, task_tools: Optional[List[Tool | ToolSet]] = None) -> str:
+    def execute_task(self, task, context: Optional[str] = None, task_tools: Optional[List[Tool | ToolSet]] = list()) -> str:
         """
         Execute the task and return the response in string.
         The agent utilizes the tools in task or their own tools if the task.can_use_agent_tools is True.
@@ -405,24 +398,6 @@ class Agent(BaseModel):
         if context is not task.prompt_context:
             task_prompt += context
 
-            # if agent_tools_to_run_without_llm:
-            #     tool_results = []
-            #     for item in agent_tools_to_run_without_llm:
-            #         if isinstance(item, ToolSet):
-            #             tool_result = item.tool.run(**item.kwargs)
-            #             tool_results.append(tool_result)
-            #         elif isinstance(item, Tool):
-            #             tool_result = item.run()
-            #             tool_results.append(tool_result)
-            #         else:
-            #             try:
-            #                 item.run()
-            #             except:
-            #                 pass
-
-            #     if task.tool_res_as_final is True:
-            #         return tool_results
-
         # if self.team and self.team._train:
         #     task_prompt = self._training_handler(task_prompt=task_prompt)
         # else:

versionhq/llm/llm_vars.py

@@ -16,7 +16,7 @@ litellm.pick_cheapest_chat_models_from_llm_provider(custom_llm_provider: str, n=
 
 MODELS = {
     "openai": [
-        "gpt-3.5-turbo",
+        # "gpt-3.5-turbo",
         "gpt-4",
         "gpt-4o",
         "gpt-4o-mini",

versionhq/llm/model.py

@@ -196,17 +196,18 @@ class LLM(BaseModel):
         """
         Execute LLM based on the agent's params and model params.
         """
+        litellm.drop_params = True
 
         with suppress_warnings():
             if len(self.callbacks) > 0:
-                self._set_callbacks(self.callbacks)
+                self._set_callbacks(self.callbacks) # passed by agent
 
             try:
                 if tools:
                     self.tools = [item.tool.properties if isinstance(item, ToolSet) else item.properties for item in tools]
 
                 if response_format:
-                    self.response_format = { "type": "json_object" } if self.model == "gpt-3.5-turbo" or tool_res_as_final else response_format
+                    self.response_format = { "type": "json_object" } if tool_res_as_final else response_format
 
                 provider = self.provider if self.provider else "openai"
 
@@ -227,6 +228,7 @@ class LLM(BaseModel):
                 res = litellm.completion(messages=messages, stream=False, **params)
 
                 if self.tools:
+                    messages.append(res["choices"][0]["message"])
                     tool_calls = res["choices"][0]["message"]["tool_calls"]
                     tool_res = ""
 
@@ -242,18 +244,23 @@ class LLM(BaseModel):
                                 tool_instance = tool.tool
                                 args = tool.kwargs
                                 res = tool_instance.run(params=args)
-                                tool_res += str(res)
+
+                                if tool_res_as_final:
+                                    tool_res += str(res)
+                                else:
+                                    messages.append({ "role": "tool", "tool_call_id": item.id, "content": str(res) })
 
                             elif (isinstance(tool, Tool) or type(tool) == Tool) and (tool.name.replace(" ", "_") == func_name or tool.func.__name__ == func_name):
                                 res = tool.run(params=func_args)
-                                tool_res += str(res)
+                                if tool_res_as_final:
+                                    tool_res += str(res)
+                                else:
+                                    messages.append({ "role": "tool", "tool_call_id": item.id, "content": str(res) })
 
-                    if tool_res_as_final == True:
+                    if tool_res_as_final:
                         return tool_res
-                        pass
 
                     else:
-                        messages.append({ "role": "tool", "tool_call_id": tool_calls.id, "content": tool_res })
                         res = litellm.completion(messages=messages, stream=False, **params)
 
                 return res["choices"][0]["message"]["content"]

versionhq/task/model.py

@@ -4,10 +4,10 @@ import datetime
 import uuid
 from concurrent.futures import Future
 from hashlib import md5
-from typing import Any, Dict, List, Set, Optional, Tuple, Callable, Type
+from typing import Any, Dict, List, Set, Optional, Tuple, Callable, Type, TypeVar
 from typing_extensions import Annotated, Self
 
-from pydantic import UUID4, BaseModel, Field, PrivateAttr, field_validator, model_validator, create_model, InstanceOf
+from pydantic import UUID4, BaseModel, Field, PrivateAttr, field_validator, model_validator, create_model, InstanceOf, field_validator
 from pydantic_core import PydanticCustomError
 
 from versionhq._utils.process_config import process_config
@@ -96,8 +96,8 @@ class ResponseField(BaseModel):
                 for item in self.properties:
                     p.update(**item._format_props())
 
-                    if item.required:
-                        r.append(item.title)
+                    # if item.required:
+                    r.append(item.title)
 
             props = {
                 "type": schema_type,
@@ -161,15 +161,15 @@ class ResponseField(BaseModel):
 
 class TaskOutput(BaseModel):
     """
-    Store the final output of the task in TaskOutput class.
-    Depending on the task output format, use `raw`, `pydantic`, `json_dict` accordingly.
+    A class to store the final output of the given task in raw (string), json_dict, and pydantic class formats.
     """
 
     task_id: UUID4 = Field(default_factory=uuid.uuid4, frozen=True, description="store Task ID")
     raw: str = Field(default="", description="Raw output of the task")
     json_dict: Dict[str, Any] = Field(default=None, description="`raw` converted to dictionary")
-    pydantic: Optional[Any] = Field(default=None, description="`raw` converted to the abs. pydantic model")
+    pydantic: Optional[Any] = Field(default=None)
     tool_output: Optional[Any] = Field(default=None, description="store tool result when the task takes tool output as its final output")
+    gott: Optional[Any] = Field(default=None, description="store task or agent callback outcome")
 
     def __str__(self) -> str:
         return str(self.pydantic) if self.pydantic else str(self.json_dict) if self.json_dict else self.raw
@@ -244,7 +244,7 @@ class Task(BaseModel):
     # execution rules
     allow_delegation: bool = Field(default=False, description="ask other agents for help and run the task instead")
     async_execution: bool = Field(default=False,description="whether the task should be executed asynchronously or not")
-    callback: Optional[Any] = Field(default=None, description="callback to be executed after the task is completed.")
+    callback: Optional[Callable] = Field(default=None, description="callback to be executed after the task is completed.")
     callback_kwargs: Optional[Dict[str, Any]] = Field(default_factory=dict, description="kwargs for the callback when the callback is callable")
 
     # recording
@@ -256,7 +256,7 @@ class Task(BaseModel):
 
     @model_validator(mode="before")
     @classmethod
-    def process_model_config(cls, values: Dict[str, Any]) -> None:
+    def process_config(cls, values: Dict[str, Any]) -> None:
         return process_config(values_to_update=values, model_class=cls)
 
 
@@ -276,16 +276,16 @@ class Task(BaseModel):
         return self
 
 
-    @model_validator(mode="after")
-    def set_attributes_based_on_config(self) -> Self:
-        """
-        Set attributes based on the task configuration.
-        """
+    # @model_validator(mode="after")
+    # def set_attributes_based_on_config(self) -> Self:
+    #     """
+    #     Set attributes based on the task configuration.
+    #     """
 
-        if self.config:
-            for key, value in self.config.items():
-                setattr(self, key, value)
-        return self
+    #     if self.config:
+    #         for key, value in self.config.items():
+    #             setattr(self, key, value)
+    #     return self
 
 
     @model_validator(mode="after")
@@ -322,7 +322,7 @@ class Task(BaseModel):
         if self.pydantic_custom_output:
             output_prompt = f"""
 Your response MUST STRICTLY follow the given repsonse format:
-JSON schema: {str({k: v for k, v in self.pydantic_custom_output.__fields__.items()})}
+JSON schema: {str(self.pydantic_custom_output)}
 """
 
         elif self.response_fields:
@@ -380,16 +380,13 @@ Ref. Output image: {output_formats_to_follow}
 
     def _structure_response_format(self, data_type: str = "object", model_provider: str = "gemini") -> Dict[str, Any] | None:
         """
-        Create and return a valid response format using
-            - mannual response schema from `self.response_fields`, or
-            - SDK objects from `pydantic_custom_output`.
-        OpenAI:
-        https://platform.openai.com/docs/guides/structured-outputs?context=ex1#function-calling-vs-response-format
-        https://platform.openai.com/docs/guides/structured-outputs?context=with_parse#some-type-specific-keywords-are-not-yet-supported
-        Gemini:
+        Structure a response format either from`response_fields` or `pydantic_custom_output`.
+        1 nested item is accepted.
         """
 
-        response_schema = None
+        from versionhq.task.structured_response import StructuredOutput
+
+        response_format: Dict[str, Any] = None
 
         if self.response_fields:
             properties, required_fields = {}, []
@@ -406,37 +403,19 @@ Ref. Output image: {output_formats_to_follow}
                 "type": "object",
                 "properties": properties,
                 "required": required_fields,
-                "additionalProperties": False, # for openai
+                "additionalProperties": False,
             }
 
-
-        elif self.pydantic_custom_output:
-            response_schema = {
-                **self.pydantic_custom_output.model_json_schema(),
-                "additionalProperties": False,
-                "required": [k for k, v in self.pydantic_custom_output.__fields__.items()],
-                "strict": True,
+            response_format = {
+                "type": "json_schema",
+                "json_schema": { "name": "outcome", "schema": response_schema }
             }
 
 
-        if response_schema:
-            if model_provider == "gemini":
-                return {
-                    "type": data_type,
-                    "response_schema": response_schema,
-                    "enforce_validation": True
-                }
+        elif self.pydantic_custom_output:
+            response_format = StructuredOutput(response_format=self.pydantic_custom_output)._format()
 
-            if model_provider == "openai":
-                if self.pydantic_custom_output:
-                    return self.pydantic_custom_output
-                else:
-                    return {
-                        "type": "json_schema",
-                        "json_schema": { "name": "outcome", "strict": True, "schema": response_schema },
-                    }
-        else:
-            return None
+        return response_format
 
 
     def _create_json_output(self, raw: str) -> Dict[str, Any]:
@@ -477,17 +456,16 @@ Ref. Output image: {output_formats_to_follow}
 
     def _create_pydantic_output(self, raw: str = None, json_dict: Dict[str, Any] = None) -> InstanceOf[BaseModel]:
         """
-        Create pydantic output from the `raw` result.
+        Create pydantic output from raw or json_dict output.
         """
 
-        output_pydantic = None
-        json_dict = json_dict
+        output_pydantic = self.pydantic_custom_output
 
         try:
-            if not json_dict:
-                json_dict = self._create_json_output(raw=raw)
+            json_dict = json_dict if json_dict else self._create_json_output(raw=raw)
 
-            output_pydantic = self.pydantic_custom_output(**json_dict)
+            for k, v in json_dict.items():
+                setattr(output_pydantic, k, v)
 
         except:
             pass
@@ -597,16 +575,18 @@ Ref. Output image: {output_formats_to_follow}
         self.output = task_output
         self.processed_by_agents.add(agent.role)
 
-        if self.callback:
-            self.callback({ **self.callback_kwargs, **self.output.__dict__ })
+        if self.callback and isinstance(self.callback, Callable):
+            callback_res = self.callback(**self.callback_kwargs, **task_output.json_dict)
+            task_output.callback_output = callback_res
 
-        # if self.output_file:
+        # if self.output_file: ## disabled for now
         #     content = (
         #         json_output
         #         if json_output
         #         else pydantic_output.model_dump_json() if pydantic_output else result
         #     )
         #     self._save_file(content)
+
         ended_at = datetime.datetime.now()
         self.execution_span_in_sec = (ended_at - started_at).total_seconds()
 

versionhq/task/structured_response.py

@@ -0,0 +1,140 @@
+from typing import Dict, Optional, Type, List, Any, TypeVar
+
+from pydantic import BaseModel, Field, InstanceOf
+
+from versionhq.llm.llm_vars import SchemaType
+from versionhq.llm.model import LLM
+
+
+"""
+Structure a response schema (json schema) from the given Pydantic model.
+"""
+
+
+class StructuredObject:
+    """
+    A class to store the structured dictionary.
+    """
+    provider: str = "openai"
+    field: Type[Field]
+
+    title: str
+    dtype: str = "object"
+    properties: Dict[str, Dict[str, str]] = dict()
+    required: List[str] = list()
+    additionalProperties: bool = False
+
+    def __init__(self, name, field: Type[Field], provider: str | InstanceOf[LLM] = "openai"):
+        self.title = name
+        self.field = field
+        self.dtype = "object"
+        self.additionalProperties = False
+        self.provider = provider if isinstance(provider, str) else provider.provider
+
+    def _format(self):
+        if not self.field:
+            pass
+        else:
+            description = self.field.description if hasattr(self.field, "description") and self.field.description is not None else ""
+            self.properties.update({"item": { "type": SchemaType(self.field.annotation.__args__).convert() }})
+            self.required.append("item")
+
+            return {
+                self.title: {
+                    "type": self.dtype,
+                    "description": description,
+                    "properties": self.properties,
+                    "additionalProperties": self.additionalProperties,
+                    "required": self.required
+                }
+            }
+
+
+
+class StructuredList:
+    """
+    A class to store a structured list with 1 nested object.
+    """
+    provider: str = "openai"
+    field: Type[Field]
+    title: str = ""
+    dtype: str = "array"
+    items: Dict[str, Dict[str, str]] = dict()
+
+    def __init__(self, name, field: Type[Field], provider: str | LLM = "openai"):
+        self.provider = provider if isinstance(provider, str) else provider.provider
+        self.field = field
+        self.title = name
+        self.dtype = "array"
+        self.items = dict()
+
+
+    def _format(self):
+        field = self.field
+        if not field:
+            pass
+        else:
+            description = "" if field.description is None else field.description
+            props = {}
+
+            for item in field.annotation.__args__:
+                nested_object_type = item.__origin__ if hasattr(item, "__origin__") else item
+
+                if nested_object_type == dict:
+                    props.update({
+                        "nest":  {
+                            "type": "object",
+                            "properties": { "item": { "type": "string"} }, #! REFINEME - field title <>`item`
+                            "required": ["item",],
+                            "additionalProperties": False
+                        }})
+
+                elif nested_object_type == list:
+                    props.update({
+                        # "nest":  {
+                            "type": "array",
+                            "items": { "type": "string" } , #! REFINEME - field title <>`item`
+                        # }
+                        })
+                else:
+                    props.update({ "type": SchemaType(nested_object_type).convert() })
+
+            self.items = { **props }
+            return {
+                 self.title: {
+                    "type": self.dtype,
+                    "description": description,
+                    "items": self.items,
+                }
+            }
+
+
+class StructuredOutput(BaseModel):
+    response_format: Any = None
+    provider: str = "openai"
+    applicable_models: List[InstanceOf[LLM] | str] = list()
+    name: str = ""
+    schema: Dict[str, Any] = dict(type="object", additionalProperties=False, properties=dict(), required=list())
+
+
+    def _format(self, **kwargs):
+        if self.response_format is None:
+            pass
+
+        self.name = self.response_format.__name__
+
+        for name, field in self.response_format.model_fields.items():
+            self.schema["required"].append(name)
+
+            if hasattr(field.annotation, "__origin__") and field.annotation.__origin__ == dict:
+                self.schema["properties"].update(StructuredObject(name=name, field=field)._format())
+
+            elif hasattr(field.annotation, "__origin__") and field.annotation.__origin__ == list:
+                self.schema["properties"].update(StructuredList(name=name, field=field)._format())
+            else:
+                self.schema["properties"].update({ name: { "type": SchemaType(field.annotation).convert(), **kwargs }})
+
+        return {
+            "type": "json_schema",
+            "json_schema": { "name": self.name, "schema": self.schema }
+        }

{versionhq-1.1.10.2.dist-info → versionhq-1.1.10.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: versionhq
-Version: 1.1.10.2
+Version: 1.1.10.4
 Summary: LLM orchestration frameworks for model-agnostic AI agents that handle complex outbound workflows
 Author-email: Kuriko Iwai <kuriko@versi0n.io>
 License: MIT License

{versionhq-1.1.10.2.dist-info → versionhq-1.1.10.4.dist-info}/RECORD

@@ -1,4 +1,4 @@
-versionhq/__init__.py,sha256=GkGY1ob5I6BdJjds_hdxOYWJ8n3EIWjTAQ48v1UheoQ,951
+versionhq/__init__.py,sha256=Qyl2FbktMQEDCkzVHeRjD9bAfYO_1XpEMXph6wJHu4w,951
 versionhq/_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 versionhq/_utils/i18n.py,sha256=TwA_PnYfDLA6VqlUDPuybdV9lgi3Frh_ASsb_X8jJo8,1483
 versionhq/_utils/logger.py,sha256=U-MpeGueA6YS8Ptfy0VnU_ePsZP-8Pvkvi0tZ4s_UMg,1438
@@ -6,7 +6,7 @@ versionhq/_utils/process_config.py,sha256=jbPGXK2Kb4iyCugJ3FwRJuU0wL5Trq2x4xFQz2
 versionhq/_utils/rpm_controller.py,sha256=dUgFd6JtdjiLLTRmrjsBHdTaLn73XFuKpLbJh7thf2A,2289
 versionhq/_utils/usage_metrics.py,sha256=hhq1OCW8Z4V93vwW2O2j528EyjOlF8wlTsX5IL-7asA,1106
 versionhq/agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-versionhq/agent/model.py,sha256=g8S8d0uHORrpq2mAUzo1Tx1hZmtYKk8HT55iOICSte8,20344
+versionhq/agent/model.py,sha256=6lXKEPOo8BLpiUWppMQkeenb1NR0i7LIBAvfPvSLLSQ,19281
 versionhq/agent/parser.py,sha256=Z_swUPO3piJQuYU8oVYwXWeR2zjmNb4PxbXZeR-GlIg,4694
 versionhq/agent/TEMPLATES/Backstory.py,sha256=Gub3SUbdrNAwV0ITLYdZFJ4VFZRDfDRPdBZrtlknrds,554
 versionhq/agent/TEMPLATES/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -19,14 +19,15 @@ versionhq/clients/product/model.py,sha256=hLTvvQsatNuq0DtyTqpP_gRKgnv6N4uRjavnGf
 versionhq/clients/workflow/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 versionhq/clients/workflow/model.py,sha256=FNftenLLoha0bkivrjId32awLHAkBwIT8iNljdic_bw,6003
 versionhq/llm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-versionhq/llm/llm_vars.py,sha256=SSrkrph1Nf6nvwsqf48vMovs2byxbL33CI8kcoakHK0,8759
-versionhq/llm/model.py,sha256=2waDxP_pISqqF2MTTdvzARi0hS9xna_d7YoGMwf8RGM,13020
+versionhq/llm/llm_vars.py,sha256=PO__b-h5e-6oQ-uoIgXx3lPSAUPUwXYfdVRW73fvX14,8761
+versionhq/llm/model.py,sha256=KAONedzfpGFpkQCv0THJGj2ffMxrrDSRcN7bsYEuGv0,13386
 versionhq/storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 versionhq/storage/task_output_storage.py,sha256=xoBJHeqUyQt6iJoR1WQTghP-fyxXL66qslpX1QC2-4o,4827
 versionhq/task/__init__.py,sha256=l2r_g01i91JAGlOoHZP_Gh2WCk6mo9D19lcqt7sKMpQ,186
 versionhq/task/formatter.py,sha256=N8Kmk9vtrMtBdgJ8J7RmlKNMdZWSmV8O1bDexmCWgU0,643
 versionhq/task/log_handler.py,sha256=KJRrcNZgFSKhlNzvtYFnvtp6xukaF1s7ifX9u4zWrN8,1683
-versionhq/task/model.py,sha256=Kj_a67TitiQsy9uZST7yDdi3mXcQqRhbdOF3DZ_fwjA,26207
+versionhq/task/model.py,sha256=-ZBCHXdNdvSQKeSeu-GloE_JYYR2Ljei8faTLY4Nn98,25441
+versionhq/task/structured_response.py,sha256=h5GbbkCNJ27f4AbHcriGctQLFSp4qlmq2REDEfSd8xU,4786
 versionhq/team/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 versionhq/team/model.py,sha256=NzcRXWwP0adWL9vsnsmI-A5dOcE3199FGmGgemUB2VA,20043
 versionhq/team/team_planner.py,sha256=XkM93ItI59cuEzMN1s1jJ-B4LyalSZnAlYBY5SUCbVs,3603
@@ -37,8 +38,8 @@ versionhq/tool/composio_tool_vars.py,sha256=FvBuEXsOQUYnN7RTFxT20kAkiEYkxWKkiVtg
 versionhq/tool/decorator.py,sha256=C4ZM7Xi2gwtEMaSeRo-geo_g_MAkY77WkSLkAuY0AyI,1205
 versionhq/tool/model.py,sha256=5qG-OH7zohvepPDOjdjDulhEqmNUM4osiyk5LaxmSiU,12333
 versionhq/tool/tool_handler.py,sha256=2m41K8qo5bGCCbwMFferEjT-XZ-mE9F0mDUOBkgivOI,1416
-versionhq-1.1.10.2.dist-info/LICENSE,sha256=7CCXuMrAjPVsUvZrsBq9DsxI2rLDUSYXR_qj4yO_ZII,1077
-versionhq-1.1.10.2.dist-info/METADATA,sha256=UJJNvaPJqRsEQepGITgpHi6rcGmpXPO-zS_tuNVJpiY,16356
-versionhq-1.1.10.2.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-versionhq-1.1.10.2.dist-info/top_level.txt,sha256=DClQwxDWqIUGeRJkA8vBlgeNsYZs4_nJWMonzFt5Wj0,10
-versionhq-1.1.10.2.dist-info/RECORD,,
+versionhq-1.1.10.4.dist-info/LICENSE,sha256=7CCXuMrAjPVsUvZrsBq9DsxI2rLDUSYXR_qj4yO_ZII,1077
+versionhq-1.1.10.4.dist-info/METADATA,sha256=czccqTaFssL2JXVnEcP62zWL2BIsnHAlfPYeH8hc8yQ,16356
+versionhq-1.1.10.4.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+versionhq-1.1.10.4.dist-info/top_level.txt,sha256=DClQwxDWqIUGeRJkA8vBlgeNsYZs4_nJWMonzFt5Wj0,10
+versionhq-1.1.10.4.dist-info/RECORD,,