versionhq 1.1.9.0__py3-none-any.whl → 1.1.9.2__py3-none-any.whl

versionhq/__init__.py

@@ -18,7 +18,7 @@ from versionhq.tool.model import Tool
 from versionhq.tool.composio import Composio
 
 
-__version__ = "1.1.9.0"
+__version__ = "1.1.9.2"
 __all__ = [
     "Agent",
     "Customer",

versionhq/_utils/cache_handler.py

@@ -6,8 +6,8 @@ from pydantic import BaseModel, PrivateAttr
 class CacheHandler(BaseModel):
     _cache: Dict[str, Any] = PrivateAttr(default_factory=dict)
 
-    def add(self, tool, input, output):
+    def add(self, tool: str, input: str, output: Any) -> None:
         self._cache[f"{tool}-{input}"] = output
 
-    def read(self, tool, input) -> Optional[str]:
+    def read(self, tool: str, input: str) -> Optional[str]:
         return self._cache.get(f"{tool}-{input}")

versionhq/_utils/logger.py

@@ -10,23 +10,21 @@ class Printer:
             self._print_purple(content)
         elif color == "red":
             self._print_red(content)
-        elif color == "bold_green":
-            self._print_bold_green(content)
-        elif color == "bold_purple":
-            self._print_bold_purple(content)
-        elif color == "bold_blue":
-            self._print_bold_blue(content)
+        elif color == "green":
+            self._print_green(content)
+        elif color == "purple":
+            self._print_purple(content)
+        elif color == "blue":
+            self._print_blue(content)
         elif color == "yellow":
             self._print_yellow(content)
-        elif color == "bold_yellow":
-            self._print_bold_yellow(content)
         else:
             print(content)
 
-    def _print_bold_purple(self, content):
+    def _print_purple(self, content):
         print("\033[1m\033[95m {}\033[00m".format(content))
 
-    def _print_bold_green(self, content):
+    def _print_green(self, content):
         print("\033[1m\033[92m {}\033[00m".format(content))
 
     def _print_purple(self, content):
@@ -35,23 +33,18 @@ class Printer:
     def _print_red(self, content):
         print("\033[91m {}\033[00m".format(content))
 
-    def _print_bold_blue(self, content):
+    def _print_blue(self, content):
         print("\033[1m\033[94m {}\033[00m".format(content))
 
     def _print_yellow(self, content):
-        print("\033[93m {}\033[00m".format(content))
-
-    def _print_bold_yellow(self, content):
         print("\033[1m\033[93m {}\033[00m".format(content))
 
 
 class Logger(BaseModel):
-    verbose: bool = Field(default=False)
+    verbose: bool = Field(default=True)
     _printer: Printer = PrivateAttr(default_factory=Printer)
 
-    def log(self, level, message, color="bold_yellow"):
+    def log(self, level, message, color="yellow"):
         if self.verbose:
             timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-            self._printer.print(
-                f"\n[{timestamp}][{level.upper()}]: {message}", color=color
-            )
+            self._printer.print(f"\n[{timestamp}][{level.upper()}]: {message}", color=color)

versionhq/_utils/rpm_controller.py

@@ -1,6 +1,7 @@
 import threading
 import time
 from typing import Optional
+from typing_extensions import Self
 
 from pydantic import BaseModel, Field, PrivateAttr, model_validator
 
@@ -16,14 +17,14 @@ class RPMController(BaseModel):
     _shutdown_flag: bool = PrivateAttr(default=False)
 
     @model_validator(mode="after")
-    def reset_counter(self):
+    def reset_counter(self) -> Self:
         if self.max_rpm is not None:
             if not self._shutdown_flag:
                 self._lock = threading.Lock()
                 self._reset_request_count()
         return self
 
-    def check_or_wait(self):
+    def check_or_wait(self) -> bool:
         if self.max_rpm is None:
             return True
 
@@ -46,16 +47,16 @@ class RPMController(BaseModel):
         else:
             return _check_and_increment()
 
-    def stop_rpm_counter(self):
+    def stop_rpm_counter(self) -> None:
         if self._timer:
             self._timer.cancel()
             self._timer = None
 
-    def _wait_for_next_minute(self):
+    def _wait_for_next_minute(self) -> None:
         time.sleep(60)
         self._current_rpm = 0
 
-    def _reset_request_count(self):
+    def _reset_request_count(self) -> None:
         def _reset():
             self._current_rpm = 0
             if not self._shutdown_flag:

versionhq/_utils/usage_metrics.py

@@ -12,7 +12,7 @@ class UsageMetrics(BaseModel):
     completion_tokens: int = Field(default=0, description="Number of tokens used in completions")
     successful_requests: int = Field(default=0, description="Number of successful requests made")
 
-    def add_usage_metrics(self, usage_metrics: "UsageMetrics"):
+    def add_usage_metrics(self, usage_metrics: "UsageMetrics") -> None:
         """
         Add the usage metrics from another UsageMetrics object.
         """

versionhq/agent/model.py

@@ -1,22 +1,19 @@
 import os
 import uuid
-from abc import ABC
 from typing import Any, Dict, List, Optional, TypeVar
+from typing_extensions import Self
 from dotenv import load_dotenv
 from pydantic import UUID4, BaseModel, Field, InstanceOf, PrivateAttr, model_validator, field_validator
 from pydantic_core import PydanticCustomError
 
-from versionhq._utils.cache_handler import CacheHandler
 from versionhq._utils.logger import Logger
 from versionhq._utils.rpm_controller import RPMController
 from versionhq._utils.usage_metrics import UsageMetrics
-from versionhq.agent.parser import AgentAction
 from versionhq.llm.llm_vars import LLM_VARS
 from versionhq.llm.model import LLM, DEFAULT_CONTEXT_WINDOW
 from versionhq.task import TaskOutputFormat
 from versionhq.task.model import ResponseField
 from versionhq.tool.model import Tool, ToolSet
-from versionhq.tool.tool_handler import ToolHandler
 
 load_dotenv(override=True)
 T = TypeVar("T", bound="Agent")
@@ -51,18 +48,18 @@ class TokenProcess:
     completion_tokens: int = 0
     successful_requests: int = 0
 
-    def sum_prompt_tokens(self, tokens: int):
+    def sum_prompt_tokens(self, tokens: int) -> None:
         self.prompt_tokens = self.prompt_tokens + tokens
         self.total_tokens = self.total_tokens + tokens
 
-    def sum_completion_tokens(self, tokens: int):
+    def sum_completion_tokens(self, tokens: int) -> None:
         self.completion_tokens = self.completion_tokens + tokens
         self.total_tokens = self.total_tokens + tokens
 
-    def sum_cached_prompt_tokens(self, tokens: int):
+    def sum_cached_prompt_tokens(self, tokens: int) -> None:
         self.cached_prompt_tokens = self.cached_prompt_tokens + tokens
 
-    def sum_successful_requests(self, requests: int):
+    def sum_successful_requests(self, requests: int) -> None:
         self.successful_requests = self.successful_requests + requests
 
     def get_summary(self) -> UsageMetrics:
@@ -76,7 +73,7 @@ class TokenProcess:
 
 
 # @track_agent()
-class Agent(ABC, BaseModel):
+class Agent(BaseModel):
     """
     Agent class that run on LLM.
     Agents execute tasks alone or in the team, using RAG tools and knowledge base if any.
@@ -97,10 +94,7 @@ class Agent(ABC, BaseModel):
     backstory: Optional[str] = Field(default=None, description="system context passed to the LLM")
     knowledge: Optional[str] = Field(default=None, description="external knowledge fed to the agent")
     skillsets: Optional[List[str]] = Field(default_factory=list)
-
-    # tools
-    tools: Optional[List[Any]] = Field(default_factory=list)
-    tool_handler: InstanceOf[ToolHandler] = Field(default=None, description="handle tool cache and last used tool")
+    tools: Optional[List[Tool | Any]] = Field(default_factory=list)
 
     # team, task execution rules
     team: Optional[List[Any]] = Field(default=None, description="Team to which the agent belongs")
@@ -126,10 +120,7 @@ class Agent(ABC, BaseModel):
 
     # config, cache, error handling
     config: Optional[Dict[str, Any]] = Field(default=None, exclude=True, description="Configuration for the agent")
-    cache: bool = Field(default=True, description="Whether the agent should use a cache for tool usage.")
-    cache_handler: InstanceOf[CacheHandler] = Field(default=None, description="An instance of the CacheHandler class.")
     formatting_errors: int = Field(default=0, description="Number of formatting errors.")
-    verbose: bool = Field(default=True, description="Verbose mode for the Agent Execution")
     agent_ops_agent_name: str = None
     agent_ops_agent_id: str = None
 
@@ -146,7 +137,7 @@ class Agent(ABC, BaseModel):
 
 
     @model_validator(mode="after")
-    def validate_required_fields(self):
+    def validate_required_fields(self) -> Self:
         required_fields = ["role", "goal"]
         for field in required_fields:
             if getattr(self, field) is None:
@@ -155,7 +146,7 @@ class Agent(ABC, BaseModel):
 
 
     @model_validator(mode="after")
-    def set_up_llm(self):
+    def set_up_llm(self) -> Self:
         """
         Set up the base model and function calling model (if any) using the LLM class.
         Pass the model config params: `llm`, `max_tokens`, `max_execution_time`, `step_callback`,`respect_context_window` to the LLM class.
@@ -270,31 +261,42 @@ class Agent(ABC, BaseModel):
 
 
     @model_validator(mode="after")
-    def set_up_tools(self):
+    def set_up_tools(self) -> Self:
         """
         Similar to the LLM set up, when the agent has tools, we will declare them using the Tool class.
         """
-
         if not self.tools:
             pass
 
         else:
-            tools_in_class_format = []
-            for tool in self.tools:
-                if isinstance(tool, Tool):
-                    tools_in_class_format.append(tool)
-                elif isinstance(tool, str):
-                    tool_to_add = Tool(name=tool)
-                    tools_in_class_format.append(tool_to_add)
+            tool_list = []
+            def empty_func():
+                return "empty function"
+
+            for item in self.tools:
+                if isinstance(item, Tool):
+                    tool_list.append(item)
+
+                elif isinstance(item, dict):
+                    if "function" not in item:
+                       setattr(item, "function", empty_func)
+                    tool = Tool(**item)
+                    tool_list.append(tool)
+
+                elif isinstance(item, str):
+                    tool = Tool(name=item, function=empty_func)
+                    tool_list.append(tool)
+
                 else:
-                    pass
-            self.tools = tools_in_class_format
+                    tool_list.append(item) # address custom tool
+
+            self.tools = tool_list
 
         return self
 
 
     @model_validator(mode="after")
-    def set_up_backstory(self):
+    def set_up_backstory(self) -> Self:
         """
         Set up the backstory using a templated BACKSTORY when the backstory is None
         """
@@ -305,7 +307,7 @@ class Agent(ABC, BaseModel):
                 role=self.role,
                 knowledge=self.knowledge if isinstance(self.knowledge, str) else None,
                 skillsets=", ".join([item for item in self.skillsets]),
-                rag_tool_overview=", ".join([item.name for item in self.tools]),
+                rag_tool_overview=", ".join([item.name for item in self.tools if hasattr(item, "name")]) if self.tools else "",
                 goal=self.goal,
             )
             self.backstory = backstory
@@ -313,9 +315,7 @@ class Agent(ABC, BaseModel):
         return self
 
 
-    def invoke(
-            self, prompts: str, output_formats: List[TaskOutputFormat], response_fields: List[ResponseField], **kwargs
-            ) -> Dict[str, Any]:
+    def invoke(self, prompts: str, output_formats: List[TaskOutputFormat], response_fields: List[ResponseField], **kwargs) -> Dict[str, Any]:
         """
         Receive the system prompt in string and create formatted prompts using the system prompt and the agent's backstory.
         Then call the base model.
@@ -358,11 +358,10 @@ class Agent(ABC, BaseModel):
         return {"output": response.output if hasattr(response, "output") else response}
 
 
-    def execute_task(self, task, context: Optional[str] = None, tools: Optional[str] = None) -> str:
+    def execute_task(self, task, context: Optional[str] = None) -> str:
         """
-        Execute the task and return the output in string.
-        To simplify, the tools are cascaded from the `tools_called` under the `task` Task instance if any.
-        When the tools are given, the agent must use them.
+        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.
         The agent must consider the context to excute the task as well when it is given.
         """
 
@@ -371,13 +370,29 @@ class Agent(ABC, BaseModel):
             task_prompt += context
 
         tool_results = []
-        if task.tools_called:
-            for tool_called in task.tools_called:
-                tool_result = tool_called.tool.run()
+        if task.tools:
+            for item in task.tools:
+                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.can_use_agent_tools is True and self.tools:
+            for tool in self.tools:
+                tool_result = tool.run()
                 tool_results.append(tool_result)
 
-            if task.take_tool_res_as_final:
-                return tool_results
+        if task.take_tool_res_as_final:
+            return tool_results
+
+
 
         # if self.team and self.team._train:
         #     task_prompt = self._training_handler(task_prompt=task_prompt)
@@ -395,9 +410,7 @@ class Agent(ABC, BaseModel):
             self._times_executed += 1
             if self._times_executed > self.max_retry_limit:
                 raise e
-            result = self.execute_task(
-                task, context, [tool_called.tool for tool_called in task.tools_called]
-            )
+            result = self.execute_task(task, context)
 
         if self.max_rpm and self._rpm_controller:
             self._rpm_controller.stop_rpm_counter()

versionhq/agent/parser.py

@@ -73,9 +73,7 @@ class AgentParser:
     def parse(self, text: str) -> AgentAction | AgentFinish:
         thought = self._extract_thought(text)
         includes_answer = FINAL_ANSWER_ACTION in text
-        regex = (
-            r"Action\s*\d*\s*:[\s]*(.*?)[\s]*Action\s*\d*\s*Input\s*\d*\s*:[\s]*(.*)"
-        )
+        regex = r"Action\s*\d*\s*:[\s]*(.*?)[\s]*Action\s*\d*\s*Input\s*\d*\s*:[\s]*(.*)"
         action_match = re.search(regex, text, re.DOTALL)
         if action_match:
             if includes_answer:
@@ -127,18 +125,9 @@ class AgentParser:
     def _safe_repair_json(self, tool_input: str) -> str:
         UNABLE_TO_REPAIR_JSON_RESULTS = ['""', "{}"]
 
-        # Skip repair if the input starts and ends with square brackets
-        # Explanation: The JSON parser has issues handling inputs that are enclosed in square brackets ('[]').
-        # These are typically valid JSON arrays or strings that do not require repair. Attempting to repair such inputs
-        # might lead to unintended alterations, such as wrapping the entire input in additional layers or modifying
-        # the structure in a way that changes its meaning. By skipping the repair for inputs that start and end with
-        # square brackets, we preserve the integrity of these valid JSON structures and avoid unnecessary modifications.
         if tool_input.startswith("[") and tool_input.endswith("]"):
             return tool_input
 
-        # Before repair, handle common LLM issues:
-        # 1. Replace """ with " to avoid JSON parser errors
-
         tool_input = tool_input.replace('"""', '"')
 
         result = repair_json(tool_input)

versionhq/clients/customer/__init__.py

@@ -0,0 +1,5 @@
+from enum import Enum
+
+
+class Status(str, Enum):
+    ON_WORKFLOW = "on_workflow"

versionhq/clients/customer/model.py

@@ -1,57 +1,53 @@
 import uuid
-from abc import ABC
+from abc import ABC, abstractmethod
 from typing import Any, Dict, List, Callable, Type, Optional, get_args, get_origin
-from pydantic import (
-    UUID4,
-    InstanceOf,
-    BaseModel,
-    ConfigDict,
-    Field,
-    create_model,
-    field_validator,
-    model_validator,
-)
+from pydantic import UUID4, InstanceOf, BaseModel, ConfigDict, Field, create_model, field_validator, model_validator
 from pydantic_core import PydanticCustomError
 
 from versionhq.clients.product.model import Product, ProductProvider
+from versionhq.clients.customer import Status
 
 
-class Customer(ABC, BaseModel):
+class BaseCustomer(ABC, BaseModel):
     """
-    Store the minimal information on the customer.
+    Abstract base class for the base customer
     """
 
     id: UUID4 = Field(default_factory=uuid.uuid4, frozen=True)
     name: Optional[str] = Field(default=None, description="customer's name if any")
-    product_list: Optional[List[Product]] = Field(
-        default=list, description="store products that the customer is associated with"
-    )
-    analysis: str = Field(
-        default=None, description="store the latest analysis results on the customer"
-    )
-    on_workflow: bool = Field(
-        default=False, description="`True` if they are on some messaging workflows"
-    )
-    on: Optional[str] = Field(
-        default=None, description="destination service for this customer if any"
-    )
+    products: Optional[List[Product]] = Field(default=list, description="store products that the customer is associated with")
+    analysis: str = Field(default=None, description="store the latest analysis results on the customer")
+    status: str = Field(default=Status.ON_WORKFLOW)
+
 
     @field_validator("id", mode="before")
     @classmethod
     def _deny_user_set_id(cls, v: Optional[UUID4]) -> None:
         if v:
-            raise PydanticCustomError(
-                "may_not_set_field", "This field is not to be set by the user.", {}
-            )
+            raise PydanticCustomError("may_not_set_field", "This field is not to be set by the user.", {})
+
 
     def customer_to(self) -> List[ProductProvider]:
         """
         Return list of ProductProvider if the customer has `product_list`
         """
 
-        res = list
-        if self.product_list:
-            for item in self.product_list:
+        res = []
+        if self.products:
+            for item in self.products:
                 if item.provider not in res:
                     res.appned(item.provider)
         return res
+
+
+    @abstractmethod
+    def _deploy(self, *args, **kwargs) -> Any:
+        """Any method to deploy targeting the customer"""
+
+
+class Customer(BaseCustomer):
+    id: UUID4 = Field(default_factory=uuid.uuid4, frozen=True)
+    name: Optional[str] = Field(default=None, description="customer's name if any")
+    products: Optional[List[Product]] = Field(default=list, description="store products that the customer is associated with")
+    analysis: str = Field(default=None, description="store the latest analysis results on the customer")
+    status: str = Field(default=Status.ON_WORKFLOW)

versionhq/clients/product/model.py

@@ -1,22 +1,23 @@
 import uuid
+from abc import ABC, abstractmethod
 from typing import Any, Dict, List, Callable, Type, Optional, get_args, get_origin
+
 from pydantic import UUID4, InstanceOf, BaseModel, ConfigDict, Field, create_model, field_validator, model_validator
 from pydantic_core import PydanticCustomError
 
+from versionhq.tool import ComposioAppName
+
 
-class ProductProvider(BaseModel):
+class ProductProvider(ABC, BaseModel):
     """
-    Store the minimal client information.
-    `data_pipeline` and `destinations` are for composio plug-in.
-    (!REFINEME) Create an Enum list for the options.
-    (!REFINEME) Create an Enum list for regions.
+    Abstract class for the product provider entity.
     """
 
     id: UUID4 = Field(default_factory=uuid.uuid4, frozen=True)
-    name: Optional[str] = Field(default=None, description="client name")
+    name: Optional[str] = Field(default=None)
     region: Optional[str] = Field(default=None, description="region of client's main business operation")
-    data_pipeline: Optional[List[str]] = Field(default=None, description="store the data pipelines that the client is using")
-    destinations: Optional[List[str]] = Field(default=None,description="store the destination services that the client is using")
+    data_pipelines: Optional[List[ComposioAppName | str]] = Field(default_factory=list)
+    destination_services: Optional[List[ComposioAppName | str]] = Field(default=None)
 
     @field_validator("id", mode="before")
     @classmethod

versionhq/clients/workflow/model.py

@@ -2,6 +2,7 @@ import uuid
 from abc import ABC
 from datetime import date, datetime, time, timedelta
 from typing import Any, Dict, List, Callable, Type, Optional, get_args, get_origin
+from typing_extensions import Self
 from pydantic import UUID4, InstanceOf, BaseModel, ConfigDict, Field, field_validator, model_validator
 from pydantic_core import PydanticCustomError
 
@@ -9,6 +10,7 @@ from versionhq.clients.product.model import Product
 from versionhq.clients.customer.model import Customer
 from versionhq.agent.model import Agent
 from versionhq.team.model import Team
+from versionhq.tool import ComposioAppName
 
 
 class ScoreFormat:
@@ -56,14 +58,12 @@ class Score:
 class MessagingComponent(ABC, BaseModel):
     layer_id: int = Field(default=0, description="add id of the layer: 0, 1, 2")
     message: str = Field(default=None, max_length=1024, description="text message content to be sent")
-    interval: Optional[str] = Field(
-        default=None, description="interval to move on to the next layer. if this is the last layer, set as `None`"
-    )
-    score: float | InstanceOf[Score] = Field(default=None)
-    condition: str = Field(default=None, max_length=128, description="condition to execute the next messaging component")
+    score: InstanceOf[Score] = Field(default=None)
+    condition: str = Field(default=None, max_length=128, description="condition to execute the next component")
+    interval: Optional[str] = Field(default=None, description="ideal interval to set to assess the condition")
 
 
-    def store_scoring_result(self, scoring_subject: str, score_raw: int | Score | ScoreFormat = None):
+    def store_scoring_result(self, subject: str, score_raw: int | Score | ScoreFormat = None) -> Self:
         """
         Set up the `score` field
         """
@@ -73,12 +73,12 @@ class MessagingComponent(ABC, BaseModel):
 
         elif isinstance(score_raw, ScoreFormat):
             score_instance = Score()
-            setattr(score_instance, scoring_subject, score_raw)
+            setattr(score_instance, subject, score_raw)
             setattr(self, "score", score_instance)
 
         elif isinstance(score_raw, int) or isinstance(score_raw, float):
             score_instance, score_format_instance = Score(), ScoreFormat(rate=score_raw, weight=1)
-            setattr(score_instance, "kwargs", { scoring_subject: score_format_instance })
+            setattr(score_instance, "kwargs", { subject: score_format_instance })
             setattr(self, "score", score_instance)
 
         else:
@@ -99,23 +99,17 @@ class MessagingWorkflow(ABC, BaseModel):
     model_config = ConfigDict()
 
     id: UUID4 = Field(default_factory=uuid.uuid4, frozen=True)
-    components: List[MessagingComponent] = Field(default_factory=list, description="store messaging components in the workflow")
+    messaging_components: List[MessagingComponent] = Field(default_factory=list, description="store messaging components in the workflow")
 
     # responsible tean or agents
-    team: Optional[Team] = Field(default=None, description="store `Team` instance responsibile for autopiloting this workflow")
-    agents: Optional[List[Agent]] = Field(
-        default=None, description="store `Agent` instances responsible for autopiloting this workflow. if the team exsits, this field remains as `None`")
+    team: Optional[Team] = Field(default=None, description="store a responsibile team to autopilot the workflow")
+    agents: Optional[List[Agent]] = Field(default=None, description="store responsible agents. None when the team exists")
 
     # metrics
-    destination: Optional[str | None] = Field(default=None, description="destination service to launch this workflow")
+    destination: Optional[ComposioAppName | str] = Field(default=None, description="destination service to launch the workflow")
     product: InstanceOf[Product] = Field(default=None)
     customer: InstanceOf[Customer] = Field(default=None)
-
-    metrics: List[Dict[str, Any]] | List[str] = Field(
-        default=None,
-        max_length=256,
-        description="store metrics that used to predict and track the performance of this workflow."
-    )
+    performance_metrics: List[Dict[str, Any]] | List[str] = Field(default=None, max_length=256, description="performance metrics to track")
 
     @field_validator("id", mode="before")
     @classmethod
@@ -131,11 +125,11 @@ class MessagingWorkflow(ABC, BaseModel):
         Prioritize customer's destination to the product provider's destination list.
         """
         if self.destination is None:
-            if self.customer is not None:
-                self.destination = self.customer.on
+            # if self.customer is not None:
+            #     self.destination = self.customer.on
 
-            elif self.product.provider is not None and self.product.provider.destinations:
-                self.destination = self.product.provider.destinations[0]
+            if self.product.provider is not None and self.product.provider.destination_services:
+                self.destination = self.product.provider.destination_services[0]
 
         return self
 
@@ -154,7 +148,7 @@ class MessagingWorkflow(ABC, BaseModel):
 
 
     @property
-    def name(self):
+    def name(self) -> str:
         if self.customer.id:
             return f"Workflow ID: {self.id} - on {self.product.id} for {self.customer.id}"
         else: