ibm-watsonx-orchestrate 1.7.0a0__py3-none-any.whl → 1.8.0__py3-none-any.whl

ibm_watsonx_orchestrate/flow_builder/node.py

@@ -5,7 +5,7 @@ import uuid
 import yaml
 from pydantic import BaseModel, Field, SerializeAsAny
 
-from .types import EndNodeSpec, NodeSpec, AgentNodeSpec, PromptNodeSpec, StartNodeSpec, ToolNodeSpec, UserFieldKind, UserFieldOption, UserNodeSpec
+from .types import EndNodeSpec, NodeSpec, AgentNodeSpec, PromptNodeSpec, StartNodeSpec, ToolNodeSpec, UserFieldKind, UserFieldOption, UserNodeSpec, DocProcSpec, DecisionsNodeSpec
 from .data_map import DataMap
 
 class Node(BaseModel):
@@ -78,6 +78,8 @@ class UserNode(Node):
               description: str | None = None,
               default: Any | None = None,
               option: UserFieldOption | None = None,
+              min: Any | None = None,
+              max: Any | None = None,
               is_list: bool = False,
               custom: dict[str, Any] | None = None,
               widget: str | None = None):
@@ -88,6 +90,8 @@ class UserNode(Node):
                               description=description,
                               default=default,
                               option=option,
+                              min=min,
+                              max=max,
                               is_list=is_list,
                               custom=custom,
                               widget=widget)
@@ -105,7 +109,20 @@ class PromptNode(Node):
 
     def get_spec(self) -> PromptNodeSpec:
         return cast(PromptNodeSpec, self.spec)
+    
+class DocProcNode(Node):
+    def __repr__(self):
+        return f"DocProcNode(name='{self.spec.name}', description='{self.spec.description}')"
 
+    def get_spec(self) -> DocProcSpec:
+        return cast(DocProcSpec, self.spec)
+class DecisionsNode(Node):
+    def __repr__(self):
+        return f"DecisionsNode(name='{self.spec.name}', description='{self.spec.description}')"
+
+    def get_spec(self) -> DecisionsNodeSpec:
+        return cast(DecisionsNodeSpec, self.spec)
+    
 class NodeInstance(BaseModel):
     node: Node
     id: str # unique id of this task instance

ibm_watsonx_orchestrate/flow_builder/types.py

@@ -1,5 +1,7 @@
 from dataclasses import dataclass
-from enum import Enum
+from enum import Enum, StrEnum, auto
+from datetime import date
+import numbers
 import inspect
 import logging
 from typing import (
@@ -116,7 +118,7 @@ def _to_json_from_output_schema(schema: Union[ToolResponseBody, SchemaRef]) -> d
     return model_spec
 
 class NodeSpec(BaseModel):
-    kind: Literal["node", "tool", "user", "agent", "flow", "start", "decisions", "prompt", "branch", "wait", "foreach", "loop", "userflow", "end"] = "node"
+    kind: Literal["node", "tool", "user", "agent", "flow", "start", "decisions", "prompt", "branch", "wait", "foreach", "loop", "userflow", "end", "docproc" ] = "node"
     name: str
     display_name: str | None = None
     description: str | None = None
@@ -162,6 +164,24 @@ class NodeSpec(BaseModel):
 
         return model_spec
 
+class DocProcTask(StrEnum):
+    '''
+    Possible names for the Document processing task parameter
+    '''
+    text_extraction = auto()
+
+class DocProcSpec(NodeSpec):
+    task: DocProcTask = Field(description='The document processing operation name', default=DocProcTask.text_extraction)
+    
+    def __init__(self, **data):
+        super().__init__(**data)
+        self.kind = "docproc"
+
+    def to_json(self) -> dict[str, Any]:
+        model_spec = super().to_json()
+        model_spec["task"] = self.task
+        return model_spec
+    
 class StartNodeSpec(NodeSpec):
     def __init__(self, **data):
         super().__init__(**data)
@@ -296,6 +316,8 @@ class UserField(BaseModel):
     description: str | None = None
     default: Any | None = None
     option: UserFieldOption | None = None
+    min: Any | None = None,
+    max: Any | None = None,
     is_list: bool = False
     custom: dict[str, Any] | None = None
     widget: str | None = None
@@ -314,6 +336,10 @@ class UserField(BaseModel):
             model_spec["description"] = self.description
         if self.default:
             model_spec["default"] = self.default
+        if self.min:
+            model_spec["min"] = self.min
+        if self.max:
+            model_spec["min"] = self.max
         if self.is_list:
             model_spec["is_list"] = self.is_list
         if self.option:
@@ -356,7 +382,10 @@ class UserNodeSpec(NodeSpec):
               display_name: str | None = None, 
               description: str | None = None, 
               default: Any | None = None, 
-              option: list[str] | None = None, is_list: bool = False,
+              option: list[str] | None = None, 
+              min: Any | None = None,
+              max: Any | None = None,
+              is_list: bool = False,
               custom: dict[str, Any] | None = None,
               widget: str | None = None):
         userfield = UserField(name=name, 
@@ -366,6 +395,8 @@ class UserNodeSpec(NodeSpec):
                               description=description, 
                               default=default, 
                               option=option, 
+                              min=min,
+                              max=max,
                               is_list=is_list,
                               custom=custom,
                               widget=widget)
@@ -402,6 +433,8 @@ class UserNodeSpec(NodeSpec):
                                              default=prop_schema.default,
                                              option=self.setup_field_options(prop_schema.title, prop_schema.enum),
                                              is_list=prop_schema.type == "array",
+                                             min=prop_schema.minimum,
+                                             max=prop_schema.maximum,
                                              custom=prop_schema.model_extra))
 
     def setup_field_options(self, name: str, enums: List[str]) -> UserFieldOption:
@@ -415,6 +448,7 @@ class UserNodeSpec(NodeSpec):
 
 class AgentNodeSpec(ToolNodeSpec):
     message: str | None = Field(default=None, description="The instructions for the task.")
+    title: str | None = Field(default=None, description="The title of the message.")
     guidelines: str | None = Field(default=None, description="The guidelines for the task.")
     agent: str
 
@@ -430,6 +464,8 @@ class AgentNodeSpec(ToolNodeSpec):
             model_spec["guidelines"] = self.guidelines
         if self.agent:
             model_spec["agent"] = self.agent
+        if self.title:
+            model_spec["title"] = self.title
         return model_spec
 
 class PromptLLMParameters(BaseModel):
@@ -479,6 +515,7 @@ class PromptNodeSpec(NodeSpec):
             model_spec["llm_parameters"] = self.llm_parameters.to_json()
 
         return model_spec
+    
 
 class Expression(BaseModel):
     '''An expression could return a boolean or a value'''
@@ -553,10 +590,9 @@ class WaitNodeSpec(FlowControlNodeSpec):
         return my_dict
 
 class FlowSpec(NodeSpec):
- 
-
     # who can initiate the flow
     initiators: Sequence[str] = [ANY_USER]
+    schedulable: bool = False
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
@@ -566,6 +602,8 @@ class FlowSpec(NodeSpec):
         model_spec = super().to_json()
         if self.initiators:
             model_spec["initiators"] = self.initiators
+        
+        model_spec["schedulable"] = self.schedulable
 
         return model_spec
 
@@ -631,11 +669,11 @@ class TaskData(NamedTuple):
 
 class TaskEventType(Enum):
  
-    ON_TASK_WAIT = "on_task_wait" # the task is waiting for inputs before proceeding
-    ON_TASK_START = "on_task_start"
-    ON_TASK_END = "on_task_end"
-    ON_TASK_STREAM = "on_task_stream"
-    ON_TASK_ERROR = "on_task_error"
+    ON_TASK_WAIT = "task:on_task_wait" # the task is waiting for inputs before proceeding
+    ON_TASK_START = "task:on_task_start"
+    ON_TASK_END = "task:on_task_end"
+    ON_TASK_STREAM = "task:on_task_stream"
+    ON_TASK_ERROR = "task:on_task_error"
 
 class FlowData(BaseModel):
     '''This class represents the data that is passed between tasks in a flow.'''
@@ -667,9 +705,9 @@ class FlowContext(BaseModel):
     
 class FlowEventType(Enum):
  
-    ON_FLOW_START = "on_flow_start"
-    ON_FLOW_END = "on_flow_end"
-    ON_FLOW_ERROR = "on_flow_error"
+    ON_FLOW_START = "flow:on_flow_start"
+    ON_FLOW_END = "flow:on_flow_end"
+    ON_FLOW_ERROR = "flow:on_flow_error"
 
 
 @dataclass
@@ -691,9 +729,227 @@ class Assignment(BaseModel):
             e.g. "node.input.name" or "=f'{node.output.name}_{node.output.id}'"
 
     '''
-    target: str
-    source: str
+    target_variable: str
+    value_expression: str | None = None
+    has_no_value: bool = False
+    default_value: Any | None = None
+    metadata: dict = Field(default_factory=dict[str, Any])
+
+class LanguageCode(StrEnum):
+    '''
+    The ISO-639 language codes understood by Document Processing functions.
+    A special 'en_hw' code is used to enable an English handwritten model.
+    '''
+    en = auto()
+    fr = auto()
+    en_hw = auto()
+
+class File(BaseModel):
+    '''
+    This class represents the input of a Document processing task. 
+
+    Attributes:
+        document_ref (bytes|str): This is either a URL to the location of the document bytes or an ID that we use to resolve the location of the document
+        language (LanguageCode): Optional language code used when processing the input document
+    '''
+    # This is declared as bytes but the runtime will understand if a URL is send in as input.
+    # We need to use bytes here for Chat-with-doc to recognize the input as a File.
+    document_ref: bytes | str = Field(
+        description="Either an ID or a URL identifying the document to be used.", 
+        title='Document reference', 
+        default=None, 
+        json_schema_extra={"format": "binary"})
+    language: Optional[LanguageCode] = Field(
+        description='Optional language code of the document, defaults to "en"', 
+        title='Document language code', 
+        default=LanguageCode.en)
+
+class TextExtraction(BaseModel):
+    '''
+    This class represents the output generated by a "text_extraction" document processing (docproc) operation.
+    Attributes:
+        text (str): the text extracted from the input document.
+    '''
+    text: str = Field(description='The text extracted from the input document', title='Text extraction')
+
+class TextExtractionResponse(BaseModel):
+    '''
+    The text extraction operation response.
+    Attributes:
+        output (TextExtraction): a wrapper for the text extraction response
+    '''
+    output: TextExtraction = Field(description='The text extraction response')
+
+
+class DecisionsCondition(BaseModel):
+    _condition: str | None = None
+
+    def greater_than(self, value: Union[numbers.Number, date, str]) -> Self:
+        self._check_type_is_number_or_date_or_str(value)
+        self._condition = f"> {self._format_value(value)}"
+        return self
+
+    def greater_than_or_equal(self, value: Union[numbers.Number, date, str]) -> Self:
+        self._check_type_is_number_or_date_or_str(value)
+        self._condition = f">= {self._format_value(value)}"
+        return self
+
+    def less_than(self, value: Union[numbers.Number, date, str]) -> Self:
+        self._check_type_is_number_or_date_or_str(value)
+        self._condition = f"< {self._format_value(value)}"
+        return self
+
+    def less_than_or_equal(self, value: Union[numbers.Number, date, str]) -> Self:
+        self._check_type_is_number_or_date_or_str(value)
+        self._condition = f"<= {self._format_value(value)}"
+        return self
+
+    def equal(self, value: Union[numbers.Number, date, str]) -> Self:
+        self._check_type_is_number_or_date_or_str(value)
+        self._condition = f"== {self._format_value(value)}"
+        return self
+
+    def not_equal(self, value: Union[numbers.Number, date, str]) -> Self:
+        self._check_type_is_number_or_date_or_str(value)
+        self._condition = f"== {self._format_value(value)}"
+        return self
+    
+    def contains(self, value: str) -> Self:
+        self._check_type_is_str(value)
+        self._condition = f"contains {self._format_value(value)}"
+        return self
+
+    def not_contains(self, value: str) -> Self:
+        self._check_type_is_str(value)
+        self._condition = f"doesNotContain {self._format_value(value)}"
+        return self
+
+    def is_in(self, value: str) -> Self:
+        self._check_type_is_str(value)
+        self._condition = f"in {self._format_value(value)}"
+        return self
+
+    def is_not_in(self, value: str) -> Self:
+        self._check_type_is_str(value)
+        self._condition = f"notIn {self._format_value(value)}"
+        return self
+
+    def startswith(self, value: str) -> Self:
+        self._check_type_is_str(value)
+        self._condition = f"startsWith {self._format_value(value)}"
+        return self
+
+    def endswith(self, value: str) -> Self:
+        self._check_type_is_str(value)
+        self._condition = f"endsWith {self._format_value(value)}"
+        return self
+
+
+    def in_range(self, startValue: Union[numbers.Number, date], endValue: Union[numbers.Number, date], 
+                 startsInclusive: bool = False, endsInclusive: bool = False) -> Self:
+        self._check_type_is_number_or_date_or_str(startValue)
+        self._check_type_is_number_or_date_or_str(endValue)
+        if type(startValue) is not type(endValue):
+            raise TypeError("startValue and endValue must be of the same type")
+        start_op = "[" if startsInclusive else "("    # [ is inclusive, ( is exclusive
+        end_op =  "]" if endsInclusive else ")" 
+        self._condition = f"{start_op}{self._format_value(startValue)}:{self._format_value(endValue)}{end_op}"
+        return self
+
+    def _check_type_is_number_or_date(self, value: Union[numbers.Number, date]):
+        if not isinstance(value, (numbers.Number, date)):
+            raise TypeError("Value must be a number or a date")
+
+    def _check_type_is_number_or_date_or_str(self, value: Union[numbers.Number, date, str]):
+        if not isinstance(value, (numbers.Number, date, str)):
+            raise TypeError("Value must be a number or a date or a string")
+        
+    def _check_type_is_str(self, value: str):
+        if not isinstance(value, str):
+            raise TypeError("Value must be a string")
+    
+    @staticmethod
+    def _format_value(value: Union[numbers.Number, date, str]):
+        if isinstance(value, numbers.Number):
+            return f"{value}"
+        if isinstance(value, date):
+            return f"\"{value.strftime('%B %d, %Y')}\""
+        return f"\"{value}\""
+    
+    def condition(self):
+        return self._condition
+
+
+
+class DecisionsRule(BaseModel):
+    '''
+    A set of decisions rules.
+    '''
+    _conditions: dict[str, str]
+    _actions: dict[str, Union[numbers.Number, str]]
+
+    def __init__(self, **data):
+        super().__init__(**data)
+        self._conditions = {}
+        self._actions = {}
+
+    def condition(self, key: str, cond: DecisionsCondition) -> Self:
+        self._conditions[key] = cond.condition()
+        return self
     
+    def action(self, key: str, value: Union[numbers.Number, date, str]) -> Self:
+        if isinstance(value, date):
+            self._actions[key] = value.strftime("%B %d, %Y")
+            return self
+        self._actions[key] = value
+        return self
+
+    def to_json(self) -> dict[str, Any]:
+        '''
+        Serialize the rules into JSON object
+        '''
+        model_spec = {}
+        if self._conditions:
+            model_spec["conditions"] = self._conditions
+        if self._actions:
+            model_spec["actions"] = self._actions
+        return model_spec
+
+
+class DecisionsNodeSpec(NodeSpec):
+    '''
+    Node specification for Decision Table
+    '''
+    locale: str | None = None
+    rules: list[DecisionsRule]
+    default_actions: dict[str, Union[int, float, complex, str]] | None
+
+    def __init__(self, **data):
+        super().__init__(**data)
+        self.kind = "decisions"
+
+    def default_action(self, key: str, value: Union[int, float, complex, date, str]) -> Self:
+        '''
+        create a new default action
+        '''
+        if isinstance(value, date):
+            self.default_actions[key] = value.strftime("%B %d, %Y")
+            return self
+        self.default_actions[key] = value
+        return self
+
+    def to_json(self) -> dict[str, Any]:
+        model_spec = super().to_json()
+        if self.locale:
+            model_spec["locale"] = self.locale
+        if self.rules:
+            model_spec["rules"] = [rule.to_json() for rule in self.rules]
+        if self.default_actions:
+            model_spec["default_actions"] = self.default_actions
+
+        return model_spec
+
+
 def extract_node_spec(
         fn: Callable | PythonTool,
         name: Optional[str] = None,

ibm_watsonx_orchestrate/flow_builder/utils.py

@@ -87,9 +87,15 @@ def _get_tool_request_body(schema_obj: JsonSchemaObject) -> ToolRequestBody:
         return None
     
     if isinstance(schema_obj, JsonSchemaObject):
-        request_obj = ToolRequestBody(type='object', properties=schema_obj.properties, required=schema_obj.required)
-        if schema_obj.model_extra:
-            request_obj.__pydantic_extra__ = schema_obj.model_extra
+        if schema_obj.type == "object":
+            request_obj = ToolRequestBody(type='object', properties=schema_obj.properties, required=schema_obj.required)
+            if schema_obj.model_extra:
+                request_obj.__pydantic_extra__ = schema_obj.model_extra
+        else:  # we need to wrap a simple type with an object
+            request_obj = ToolRequestBody(type='object', properties={}, required=[])
+            request_obj.properties["data"] = schema_obj
+            if schema_obj.model_extra:
+                request_obj.__pydantic_extra__ = schema_obj.model_extra
 
         return request_obj
     
@@ -162,17 +168,27 @@ async def import_flow_model(model):
 
     return tool_id
 
-def import_flow_support_tools():
+def import_flow_support_tools(model):
 
     if not is_local_dev():
         # we can't import support tools into non-local environments yet
-        return
+        return []
+
+        
+    schedulable = False
+    if "schedulable" in model["spec"]:
+        schedulable = model["spec"]["schedulable"]
 
     client = instantiate_client(TempusClient)
 
     logger.info(f"Import 'get_flow_status' tool spec...")
     tools = [create_flow_status_tool("i__get_flow_status_intrinsic_tool__")]
 
+    if schedulable:
+        get_schedule_tool = create_get_schedule_tool("i__get_schedule_intrinsic_tool__")
+        delete_schedule_tool = create_delete_schedule_tool("i__delete_schedule_intrinsic_tool__")
+        tools.extend([get_schedule_tool, delete_schedule_tool])
+
     return tools
 
 # Assisted by watsonx Code Assistant
@@ -187,7 +203,7 @@ def create_flow_status_tool(flow_status_tool: str, TEMPUS_ENDPOINT: str="http://
     )
 
     openapi_binding = OpenApiToolBinding(
-        http_path="/flows",
+        http_path="/v1/flows",
         http_method="GET",
         security=[],
         servers=[TEMPUS_ENDPOINT]
@@ -213,3 +229,102 @@ def create_flow_status_tool(flow_status_tool: str, TEMPUS_ENDPOINT: str="http://
 
     return OpenAPITool(spec=spec)
 
+
+def create_get_schedule_tool(name: str, TEMPUS_ENDPOINT: str="http://wxo-tempus-runtime:9044") -> dict:
+
+    spec = ToolSpec(
+        name=name,
+        description="Use this tool to show the current schedules.",
+        permission='read_only',
+        display_name= "Get Schedules"
+    )
+
+    openapi_binding = OpenApiToolBinding(
+        http_path="/v1/schedules/simple",
+        http_method="GET",
+        security=[],
+        servers=[TEMPUS_ENDPOINT]
+    )
+    
+    spec.binding = ToolBinding(openapi=openapi_binding)
+    # Input Schema
+    properties = {
+        "query_schedule_id": {
+            "type": "string",
+            "title": "schedule_id",
+            "description": "Identifies the schedule instance.",
+            "in": "query"
+        },
+        "query_schedule_name": {
+            "type": "string",
+            "title": "schedule_name",
+            "description": "Identifies the schedule name.",
+            "in": "query"
+        },
+    }
+    
+    spec.input_schema = ToolRequestBody(
+        type='object',
+        properties=properties,
+        required=[]
+    )
+
+    response_properties = {
+        "schedule_id": {
+            "type": "string",
+        },
+        "schedule_name": {
+            "type": "string",
+        },
+        "schedule_data": {
+            "type": "string",
+        },
+        "schedule_time": {
+            "type": "string",
+        }
+    }
+
+    spec.output_schema = ToolResponseBody(type='object',
+                                          properties=response_properties,
+                                          description='Return the information about the schedule.')
+
+    return OpenAPITool(spec=spec)
+
+
+def create_delete_schedule_tool(name: str, TEMPUS_ENDPOINT: str="http://wxo-tempus-runtime:9044") -> dict:
+
+    spec = ToolSpec(
+        name=name,
+        description="Use this tool to delete/remove a schedule based on the schedule_id.",
+        permission='read_only',
+        display_name= "Delete Schedule"
+    )
+
+    openapi_binding = OpenApiToolBinding(
+        http_path="/v1/schedules/{schedule_id}",
+        http_method="DELETE",
+        security=[],
+        servers=[TEMPUS_ENDPOINT]
+    )
+    
+    spec.binding = ToolBinding(openapi=openapi_binding)
+    # Input Schema
+    properties = {
+        "path_schedule_id": {
+            "type": "string",
+            "title": "schedule_id",
+            "description": "Identifies the schedule instance.",
+            "in": "query"
+        }
+    }
+    
+    spec.input_schema = ToolRequestBody(
+        type='object',
+        properties=properties,
+        required=[]
+    )
+
+    spec.output_schema = ToolResponseBody(type='object',
+                                          description='Schedule deleted.')
+
+    return OpenAPITool(spec=spec)

ibm_watsonx_orchestrate/utils/exceptions.py

@@ -0,0 +1,23 @@
+import logging
+import sys
+import os
+
+logger = logging.getLogger(__name__)
+
+class BadRequest(Exception):
+    def __init__(self, message: str):
+        super().__init__(message)
+        self.message = message
+        logger.error(message)
+
+        # We need to exit to avoid getting 2 error messages printed
+        # We don't want to exit while running tests
+        # Only exit if not running in a test and no --debug
+        if not self._in_test() and "--debug" not in sys.argv:
+            sys.exit(1)
+
+    def _in_test(self):
+        return "PYTEST_CURRENT_TEST" in os.environ
+
+    def __str__(self):
+        return self.message

{ibm_watsonx_orchestrate-1.7.0a0.dist-info → ibm_watsonx_orchestrate-1.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ibm-watsonx-orchestrate
-Version: 1.7.0a0
+Version: 1.8.0
 Summary: IBM watsonx.orchestrate SDK
 Author-email: IBM <support@ibm.com>
 License: MIT License
@@ -10,13 +10,13 @@ Requires-Dist: certifi>=2024.8.30
 Requires-Dist: click<8.2.0,>=8.0.0
 Requires-Dist: docstring-parser<1.0,>=0.16
 Requires-Dist: httpx<1.0.0,>=0.28.1
-Requires-Dist: ibm-cloud-sdk-core>=3.22.0
-Requires-Dist: ibm-watsonx-orchestrate-evaluation-framework==1.0.2
+Requires-Dist: ibm-cloud-sdk-core>=3.24.2
+Requires-Dist: ibm-watsonx-orchestrate-evaluation-framework==1.0.8
 Requires-Dist: jsonref==1.1.0
 Requires-Dist: jsonschema<5.0.0,>=4.23.0
-Requires-Dist: langchain-community<1.0.0,>=0.3.12
+Requires-Dist: langchain-core<=0.3.63
+Requires-Dist: langsmith<=0.3.45
 Requires-Dist: munch>=4.0.0
-Requires-Dist: numpy>=1.26.0
 Requires-Dist: packaging>=24.2
 Requires-Dist: pydantic<3.0.0,>=2.10.3
 Requires-Dist: pyjwt<3.0.0,>=2.10.1