ibm-watsonx-orchestrate 1.9.0b2__py3-none-any.whl → 1.10.0b1__py3-none-any.whl

ibm_watsonx_orchestrate/flow_builder/flows/flow.py

@@ -25,13 +25,13 @@ from ibm_watsonx_orchestrate.client.tools.tool_client import ToolClient
 from ibm_watsonx_orchestrate.client.tools.tempus_client import TempusClient
 from ibm_watsonx_orchestrate.client.utils import instantiate_client
 from ..types import (
-    EndNodeSpec, Expression, ForeachPolicy, ForeachSpec, LoopSpec, BranchNodeSpec, MatchPolicy, PromptLLMParameters, PromptNodeSpec, 
+    DocProcKVPSchema, EndNodeSpec, Expression, ForeachPolicy, ForeachSpec, LoopSpec, BranchNodeSpec, MatchPolicy, PlainTextReadingOrder, PromptLLMParameters, PromptNodeSpec, TimerNodeSpec,
     StartNodeSpec, ToolSpec, JsonSchemaObject, ToolRequestBody, ToolResponseBody, UserFieldKind, UserFieldOption, UserFlowSpec, UserNodeSpec, WaitPolicy,
-    DocProcSpec, TextExtractionResponse, DocProcInput, DecisionsNodeSpec, DecisionsRule, DocExtSpec, File
+    DocProcSpec, TextExtractionResponse, DocProcInput, DecisionsNodeSpec, DecisionsRule, DocExtSpec, File, DocumentClassificationResponse, DocClassifierSpec, DocumentProcessingCommonInput
 )
 from .constants import CURRENT_USER, START, END, ANY_USER
 from ..node import (
-    EndNode, Node, PromptNode, StartNode, UserNode, AgentNode, DataMap, ToolNode, DocProcNode, DecisionsNode, DocExtNode
+    EndNode, Node, PromptNode, StartNode, UserNode, AgentNode, DataMap, ToolNode, DocProcNode, DecisionsNode, DocExtNode, DocClassifierNode
 )
 from ..types import (
     AgentNodeSpec, extract_node_spec, FlowContext, FlowEventType, FlowEvent, FlowSpec,
@@ -115,6 +115,10 @@ class Flow(Node):
                 # we need a deep compare if the incoming schema and existing_schema is the same
                 # pydantic suppport nested comparison by default
 
+                if isinstance(schema, dict):
+                    # recast schema to support direct access
+                    schema = JsonSchemaObject.model_validate(schema)
+
                 schema.title = title
 
                 if schema == existing_schema:
@@ -199,30 +203,31 @@ class Flow(Node):
         self._refactor_spec_to_schemaref(node.spec)
                 
     def _refactor_spec_to_schemaref(self, spec: NodeSpec):
-        if spec.input_schema and (spec.input_schema.type == "object" or spec.input_schema.type == "array") :
+        if spec.input_schema and not isinstance(spec.input_schema, SchemaRef) and (spec.input_schema.type == "object" or spec.input_schema.type == "array") :
             if isinstance(spec.input_schema, ToolRequestBody):
                 spec.input_schema = self._add_schema_ref(JsonSchemaObject(type = spec.input_schema.type,
                                                                                 properties= spec.input_schema.properties,
                                                                                 required= spec.input_schema.required), 
                                                                 f"{spec.name}_input")
-        if spec.output_schema_object is not None and spec.output_schema_object.type == "object":
-            spec.output_schema = self._add_schema_ref(spec.output_schema_object, spec.output_schema_object.title)
-            spec.output_schema_object = None
-        elif spec.output_schema is not None:
-            if isinstance(spec.output_schema, ToolResponseBody):
-                if spec.output_schema.type == "object":
-                    json_obj = JsonSchemaObject(type = spec.output_schema.type,
-                            description=spec.output_schema.description,
-                            properties= spec.output_schema.properties,
-                            items = spec.output_schema.items,
-                            uniqueItems=spec.output_schema.uniqueItems,
-                            anyOf=spec.output_schema.anyOf,
-                            required= spec.output_schema.required)
-                    spec.output_schema = self._add_schema_ref(json_obj, f"{spec.name}_output")
-                elif spec.output_schema.type == "array":
-                    if hasattr(spec.output_schema, "items") and hasattr(spec.output_schema.items, "type") and spec.output_schema.items.type == "object":
-                        schema_ref = self._add_schema_ref(spec.output_schema.items)
-                        spec.output_schema.items = JsonSchemaObjectRef(ref=f"{schema_ref.ref}")
+        if not isinstance(spec.output_schema, SchemaRef):
+            if spec.output_schema_object is not None and spec.output_schema_object.type == "object":
+                spec.output_schema = self._add_schema_ref(spec.output_schema_object, spec.output_schema_object.title)
+                spec.output_schema_object = None
+            elif spec.output_schema is not None:
+                if isinstance(spec.output_schema, ToolResponseBody):
+                    if spec.output_schema.type == "object":
+                        json_obj = JsonSchemaObject(type = spec.output_schema.type,
+                                description=spec.output_schema.description,
+                                properties= spec.output_schema.properties,
+                                items = spec.output_schema.items,
+                                uniqueItems=spec.output_schema.uniqueItems,
+                                anyOf=spec.output_schema.anyOf,
+                                required= spec.output_schema.required)
+                        spec.output_schema = self._add_schema_ref(json_obj, f"{spec.name}_output")
+                    elif spec.output_schema.type == "array":
+                        if hasattr(spec.output_schema, "items") and hasattr(spec.output_schema.items, "type") and spec.output_schema.items.type == "object":
+                            schema_ref = self._add_schema_ref(spec.output_schema.items)
+                            spec.output_schema.items = JsonSchemaObjectRef(ref=f"{schema_ref.ref}")
 
     # def refactor_datamap_spec_to_schemaref(self, spec: FnDataMapSpec):
     #    '''TODO'''
@@ -433,23 +438,95 @@ class Flow(Node):
         node = self._add_node(node)
         return cast(PromptNode, node)
     
+    def docclassfier(self, 
+            name: str, 
+            llm : str = "watsonx/meta-llama/llama-3-2-90b-vision-instruct",
+            version: str = "TIP",
+            display_name: str| None = None,
+            classes: type[BaseModel]| None = None, 
+            description: str | None = None,
+            min_confidence: float = 0.0,
+            input_map: DataMap = None) -> DocClassifierNode:
+        
+        if name is None :
+            raise ValueError("name must be provided.")
+        
+        doc_classifier_config = DocClassifierNode.generate_config(llm=llm, min_confidence=min_confidence,input_classes=classes)
+
+        input_schema_obj = _get_json_schema_obj(parameter_name = "input", type_def = DocumentProcessingCommonInput)
+        output_schema_obj = _get_json_schema_obj(parameter_name = "output", type_def = DocumentClassificationResponse)
+        
+        if "$defs" in output_schema_obj.model_extra:
+            output_schema_obj.model_extra.pop("$defs")
+        # Create the docclassifier spec
+        task_spec = DocClassifierSpec(
+            name=name,
+            display_name=display_name if display_name is not None else name,
+            description=description,
+            input_schema=_get_tool_request_body(input_schema_obj),
+            output_schema=_get_tool_response_body(output_schema_obj),
+            output_schema_object = output_schema_obj,
+            config=doc_classifier_config,
+            version=version
+        )
+        node = DocClassifierNode(spec=task_spec)
+
+        # setup input map
+        if input_map:
+            node.input_map = self._get_data_map(input_map)
+        
+        # add the node to the list of node
+        
+        node = self._add_node(node)
+        return cast(DocClassifierNode, node)
+        
+        
+    def timer(self,
+          name: str,
+          delay: int,
+          display_name: str | None = None,
+          description: str | None = None,
+          input_map: DataMap = None) -> Node:
+
+        if name is None:
+            raise ValueError("name must be provided.")
+        if delay < 0:
+            raise ValueError("delay must be non-negative.")
+
+        timer_spec = TimerNodeSpec(
+            name=name,
+            display_name=display_name if display_name is not None else name,
+            description=description,
+            delay=delay
+        )
+
+        node = Node(spec=timer_spec)
+
+        if input_map:
+            node.input_map = self._get_data_map(input_map)
+
+        node = self._add_node(node)
+        return node
+
+    
     def docext(self, 
             name: str, 
-            llm : str = "meta-llama/llama-3-2-11b-vision-instruct",
+            llm : str = "watsonx/meta-llama/llama-3-2-90b-vision-instruct",
             version: str = "TIP",
             display_name: str| None = None,
-            input_entities: type[BaseModel]| None = None, 
+            fields: type[BaseModel]| None = None, 
             description: str | None = None,
-            input_map: DataMap = None) -> tuple[DocExtNode, type[BaseModel]]:
+            input_map: DataMap = None,
+            enable_hw: bool = False) -> tuple[DocExtNode, type[BaseModel]]:
         
         if name is None :
             raise ValueError("name must be provided.")
 
-        doc_ext_config = DocExtNode.generate_config(llm=llm, input_entites=input_entities)
+        doc_ext_config = DocExtNode.generate_config(llm=llm, fields=fields)
 
-        DocExtFieldValue = DocExtNode.generate_docext_field_value_model(input_entities=input_entities)
+        DocExtFieldValue = DocExtNode.generate_docext_field_value_model(fields=fields)
         
-        input_schema_obj = _get_json_schema_obj(parameter_name = "input", type_def = File)
+        input_schema_obj = _get_json_schema_obj(parameter_name = "input", type_def = DocumentProcessingCommonInput)
         output_schema_obj = _get_json_schema_obj("output", DocExtFieldValue)
 
         if "$defs" in output_schema_obj.model_extra:
@@ -464,7 +541,8 @@ class Flow(Node):
             output_schema=_get_tool_response_body(output_schema_obj),
             output_schema_object = output_schema_obj,
             config=doc_ext_config,
-            version=version
+            version=version,
+            enable_hw=enable_hw
         )
         node = DocExtNode(spec=task_spec)
 
@@ -523,9 +601,12 @@ class Flow(Node):
     def docproc(self, 
             name: str, 
             task: str,
+            plain_text_reading_order : PlainTextReadingOrder = PlainTextReadingOrder.block_structure,
             display_name: str|None=None,
             description: str | None = None,
-            input_map: DataMap = None) -> DocProcNode:
+            input_map: DataMap = None,
+            kvp_schemas: list[DocProcKVPSchema] = None,
+            enable_hw: bool = False) -> DocProcNode:
 
         if name is None :
             raise ValueError("name must be provided.")
@@ -547,7 +628,10 @@ class Flow(Node):
             input_schema=_get_tool_request_body(input_schema_obj),
             output_schema=_get_tool_response_body(output_schema_obj),
             output_schema_object = output_schema_obj,
-            task=task
+            task=task,
+            plain_text_reading_order=plain_text_reading_order,
+            enable_hw=enable_hw,
+            kvp_schemas=kvp_schemas
         )
 
         node = DocProcNode(spec=task_spec)

ibm_watsonx_orchestrate/flow_builder/node.py

@@ -6,8 +6,8 @@ import yaml
 from pydantic import BaseModel, Field, SerializeAsAny, create_model
 from enum import Enum
 
-from .types import EndNodeSpec, NodeSpec, AgentNodeSpec, PromptNodeSpec, StartNodeSpec, ToolNodeSpec, UserFieldKind, UserFieldOption, UserNodeSpec, DocProcSpec, \
-                    DocExtSpec, DocExtConfig, LanguageCode, DecisionsNodeSpec
+from .types import DocExtConfigField, EndNodeSpec, NodeSpec, AgentNodeSpec, PromptNodeSpec, TimerNodeSpec, StartNodeSpec, ToolNodeSpec, UserFieldKind, UserFieldOption, UserNodeSpec, DocProcSpec, \
+                    DocExtSpec, DocExtConfig, DocClassifierSpec, DecisionsNodeSpec, DocClassifierConfig
 
 from .data_map import DataMap
 
@@ -120,6 +120,24 @@ class DocProcNode(Node):
     def get_spec(self) -> DocProcSpec:
         return cast(DocProcSpec, self.spec)
     
+class DocClassifierNode(Node):
+    def __repr__(self):
+        return f"DocClassifierNode(name='{self.spec.name}', description='{self.spec.description}')"
+
+    def get_spec(self) -> DocClassifierSpec:
+        return cast(DocClassifierSpec, self.spec)
+
+    @staticmethod
+    def generate_config(llm: str, input_classes: type[BaseModel], min_confidence: float) -> DocClassifierConfig:
+        return DocClassifierConfig(llm=llm, classes=input_classes.__dict__.values(), min_confidence=min_confidence)
+    
+class TimerNode(Node):
+    def __repr__(self):
+        return f"TimerNode(name='{self.spec.name}', description='{self.spec.description}')"
+
+    def get_spec(self) -> TimerNodeSpec:
+        return cast(TimerNodeSpec, self.spec)
+    
 class DocExtNode(Node):
     def __repr__(self):
         return f"DocExtNode(name='{self.spec.name}', description='{self.spec.description}')"
@@ -128,23 +146,29 @@ class DocExtNode(Node):
         return cast(DocExtSpec, self.spec)
     
     @staticmethod
-    def generate_config(llm: str, input_entites: type[BaseModel]) -> DocExtConfig:
-        entities = input_entites.__dict__.values()
-        return DocExtConfig(llm=llm, entities=entities)
+    def generate_config(llm: str, fields: type[BaseModel]) -> DocExtConfig:
+        return DocExtConfig(llm=llm, fields=fields.__dict__.values())
     
     @staticmethod
-    def generate_docext_field_value_model(input_entities: type[BaseModel]) -> type[BaseModel]:
+    def generate_docext_field_value_model(fields: type[BaseModel]) -> type[BaseModel]:
         create_field_value_description = lambda field_name: "Extracted value for " + field_name
+        field_definitions = {}
+
+        for name, value in fields.model_dump().items():
+            field_type = str  
+            field_kwargs = {
+                "title": value['name'],
+                "description": create_field_value_description(value['name']),
+                "type": value["type"] if value["type"] != "date" else "string"
+            }
+
+            # Add json_schema_extra if type is 'date'
+            if value["type"] == "date":
+                field_kwargs["json_schema_extra"] = {"format": "date"}
+
+            field_definitions[name] = (field_type, Field(**field_kwargs))
 
-        DocExtFieldValue = create_model(
-                "DocExtFieldValue",
-                    **{
-                        name: (str, Field(
-                            title=value['name'], 
-                            description=create_field_value_description(value['name']),
-                            )
-                        )
-                        for name, value in input_entities.model_dump().items()})
+        DocExtFieldValue = create_model("DocExtFieldValue", **field_definitions)
         return DocExtFieldValue
     
 class DecisionsNode(Node):

ibm_watsonx_orchestrate/flow_builder/types.py

@@ -4,12 +4,16 @@ from datetime import date
 import numbers
 import inspect
 import logging
+import uuid
+import re
+import time
 from typing import (
     Annotated, Any, Callable, Self, cast, Literal, List, NamedTuple, Optional, Sequence, Union, NewType
 )
 from typing_extensions import Doc
 
 import docstring_parser
+from pydantic import computed_field, field_validator
 from pydantic import BaseModel, Field, GetCoreSchemaHandler, GetJsonSchemaHandler, RootModel
 from pydantic_core import core_schema
 from pydantic.json_schema import JsonSchemaValue
@@ -124,7 +128,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", "docproc" ] = "node"
+    kind: Literal["node", "tool", "user", "agent", "flow", "start", "decisions", "prompt", "timer", "branch", "wait", "foreach", "loop", "userflow", "end", "docproc", "docext", "docclassifier" ] = "node"
     name: str
     display_name: str | None = None
     description: str | None = None
@@ -170,7 +174,7 @@ class NodeSpec(BaseModel):
 
         return model_spec
 
-class DocExtConfigEntity(BaseModel):
+class DocExtConfigField(BaseModel):
     name: str = Field(description="Entity name")
     type: Literal["string", "date", "number"] = Field(default="string",  description="The type of the entity values")
     description: str = Field(title="Description", description="Description of the entity", default="")
@@ -180,18 +184,89 @@ class DocExtConfigEntity(BaseModel):
     examples: list[str] = Field(title="Examples", description="Examples that help the LLM understand the expected entity mentions", default=[])
 
 class DocExtConfig(BaseModel):
-    domain: str = Field(description="Domiain of the document", default="other")
+    domain: str = Field(description="Domain of the document", default="other")
     type: str = Field(description="Document type", default="agreement")
     llm: str = Field(description="The LLM used for the document extraction", default="meta-llama/llama-3-2-11b-vision-instruct")
-    entities: list[DocExtConfigEntity] = Field(default=[])
+    fields: list[DocExtConfigField] = Field(default=[])
 
 class LanguageCode(StrEnum):
     en = auto()
     fr = auto()
 
+class DocProcTask(StrEnum):
+    '''
+    Possible names for the Document processing task parameter
+    '''
+    text_extraction = auto()
+    custom_field_extraction = auto()
+    custom_document_classification = auto()
+
+class CustomClassOutput(BaseModel):
+    class_name: str = Field(
+        title="Class Name",
+        description="Class Name of the Document",
+        default=[],
+    )
+
+class DocumentClassificationResponse(BaseModel):
+    custom_class_response: CustomClassOutput = Field(
+        title="Custom Classification",
+        description="The Class extracted by the llm",
+    )
+
+class DocClassifierClass(BaseModel):
+    class_name: str = Field(title='Class Name', description="The predicted, normalized document class name based on provided name")
+
+    @field_validator("class_name", mode="before")
+    @classmethod
+    def normalize_name(cls, name) -> str:
+        pattern = r'^[a-zA-Z0-9_]{1,29}$'
+        if not re.match(pattern, name): 
+            raise ValueError(f"class_name \"{name}\" is not valid. class_name should contain only letters (a-z, A-Z), digits (0-9), and underscores (_)")
+        return name
+    
+    @computed_field(description="A uuid for identifying classes, For easy filtering of documents classified in a class", return_type=str)
+    def class_id(self) -> str:
+        return str(uuid.uuid5(uuid.uuid1(), self.class_name + str(time.time())))
+
+class DocClassifierConfig(BaseModel):
+    domain: str = Field(description="Domain of the document", default="other",title="Domain")
+    type: Literal["class_configuration"] = Field(description="Document type", default="class_configuration",title="Type")
+    llm: str = Field(description="The LLM used for the document classfier", default="watsonx/meta-llama/llama-3-2-11b-vision-instruct",title="LLM")
+    min_confidence: float = Field(description="The minimal confidence acceptable for an extracted field value", default=0.0,le=1.0, ge=0.0 ,title="Minimum Confidence")
+    classes: list[DocClassifierClass] = Field(default=[], description="Classes which are needed to classify provided by user", title="Classes")
+
 class DocProcCommonNodeSpec(NodeSpec):
+    task: DocProcTask = Field(description='The document processing operation name', default=DocProcTask.text_extraction)
     enable_hw: bool | None = Field(description="Boolean value indicating if hand-written feature is enabled.", title="Enable handwritten", default=False)
 
+    def __init__(self, **data):
+        super().__init__(**data)
+    
+    def to_json(self) -> dict[str, Any]:
+        model_spec = super().to_json()
+        model_spec["task"] = self.task
+        model_spec["enable_hw"] = self.enable_hw
+        
+        return model_spec
+    
+
+
+class DocClassifierSpec(DocProcCommonNodeSpec):
+    version : str = Field(description="A version of the spec")
+    config : DocClassifierConfig
+
+    def __init__(self, **data):
+        super().__init__(**data)
+        self.kind = "docclassifier"
+
+    def to_json(self) -> dict[str, Any]:
+        model_spec = super().to_json()
+        model_spec["version"] = self.version
+        model_spec["config"] = self.config.model_dump()
+        model_spec["task"] = DocProcTask.custom_document_classification
+        return model_spec
+    
 class DocExtSpec(DocProcCommonNodeSpec):
     version : str = Field(description="A version of the spec")
     config : DocExtConfig
@@ -204,6 +279,7 @@ class DocExtSpec(DocProcCommonNodeSpec):
         model_spec = super().to_json()
         model_spec["version"] = self.version
         model_spec["config"] = self.config.model_dump()
+        model_spec["task"] = DocProcTask.custom_field_extraction
         return model_spec
     
 class DocProcField(BaseModel):
@@ -251,19 +327,17 @@ class DocProcKVP(BaseModel):
     table_name: Optional[str] = Field(default=None, description="The name of the table the key-value pair belongs to. This is used to group key-value pairs together in a table.")
     table_row_index: Optional[int] = Field(default=None, description="The index of the row in the table the key-value pair belongs to. This is used to group key-value pairs together in a table.")
 
-class DocProcTask(StrEnum):
-    '''
-    Possible names for the Document processing task parameter
-    '''
-    text_extraction = auto()
+class PlainTextReadingOrder(StrEnum):
+    block_structure = auto()
+    simple_line = auto()
 
 class DocProcSpec(DocProcCommonNodeSpec):
-    task: DocProcTask = Field(description='The document processing operation name', default=DocProcTask.text_extraction)
-    kvp_schema: List[DocProcKVPSchema] | None = Field(
+    kvp_schemas: List[DocProcKVPSchema] | None = Field(
         title='KVP schemas',
         description="Optional list of key-value pair schemas to use for extraction.",
         default=None)
-    
+    plain_text_reading_order : PlainTextReadingOrder = Field(default=PlainTextReadingOrder.block_structure)
+
     def __init__(self, **data):
         super().__init__(**data)
         self.kind = "docproc"
@@ -271,8 +345,12 @@ class DocProcSpec(DocProcCommonNodeSpec):
     def to_json(self) -> dict[str, Any]:
         model_spec = super().to_json()
         model_spec["task"] = self.task
+        if self.plain_text_reading_order != PlainTextReadingOrder.block_structure:
+            model_spec["plain_text_reading_order"] = self.plain_text_reading_order
+        if self.kvp_schemas is not None:
+            model_spec["kvp_schemas"] = self.kvp_schemas
         return model_spec
-    
+
 class StartNodeSpec(NodeSpec):
     def __init__(self, **data):
         super().__init__(**data)
@@ -607,6 +685,18 @@ class PromptNodeSpec(NodeSpec):
 
         return model_spec
     
+class TimerNodeSpec(NodeSpec):
+    delay: int 
+    
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.kind = "timer"
+
+    def to_json(self) -> dict[str, Any]:
+        model_spec = super().to_json()
+        if self.delay:
+            model_spec["delay"] = self.delay
+        return model_spec
 
 class Expression(BaseModel):
     '''An expression could return a boolean or a value'''
@@ -866,24 +956,25 @@ class File(str):
             "wrap_data": False,
             "required": []
         }
-    
-class DocExtInput(BaseModel):
-    document_ref: bytes | File = Field(description="Either an ID or a URL identifying the document to be used.", title='Document reference', default=None, json_schema_extra={"format": "binary"})
+class DocumentProcessingCommonInput(BaseModel):
+    '''
+    This class represents the common input of docext, docproc and docclassifier node 
 
+    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
+    '''
+    document_ref: bytes | File = Field(description="Either an ID or a URL identifying the document to be used.", title='Document reference', default=None, json_schema_extra={"format": "binary"})
 
-class DocProcInput(BaseModel):
+class DocProcInput(DocumentProcessingCommonInput):
     '''
     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
         kvp_schemas (List[DocProcKVPSchema]): Optional list of key-value pair schemas to use for extraction. If not provided or None, no KVPs will be extracted. If an empty list is provided, we will use the internal schemas to extract KVPS.
     '''
     # 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 | File = Field(description="Either an ID or a URL identifying the document to be used.", title='Document reference', default=None, json_schema_extra={"format": "binary"})
-    kvp_schemas: Optional[List[DocProcKVPSchema]] = Field(
+    kvp_schemas: Optional[List[DocProcKVPSchema]] | str = Field(
         title='KVP schemas',
         description="Optional list of key-value pair schemas to use for extraction.",
         default=None)
@@ -892,11 +983,9 @@ class TextExtractionResponse(BaseModel):
     '''
     The text extraction operation response.
     Attributes:
-        text (str): the text extracted from the input document.
-        kvps (Optional[list[DocProcKVP]]): A list of key-value pairs extracted from the document. If no KVPs were extracted, this will be None.
+        output_file_ref (str): The url to the file that contains the extracted text and kvps. 
     '''
-    text: str = Field(description='The text extracted from the input document', title='text')
-    kvps: Optional[list[DocProcKVP]] = Field(description="A list of key-value pairs extracted from the document.", default=None)
+    output_file_ref: str = Field(description='The url to the file that contains the extracted text and kvps.', title="output_file_ref")
 
 
 class DecisionsCondition(BaseModel):

ibm_watsonx_orchestrate/run/connections.py

@@ -24,8 +24,8 @@ def oauth2_auth_code(app_id:str) -> OAuth2TokenCredentials:
 # def oauth2_implicit(app_id:str) -> BearerTokenAuthCredentials:
 #     return get_application_connection_credentials(ConnectionType.OAUTH2_IMPLICIT, app_id=app_id)
 
-# def oauth2_password(app_id:str) -> BearerTokenAuthCredentials:
-#     return get_application_connection_credentials(ConnectionType.OAUTH2_PASSWORD, app_id=app_id)
+def oauth2_password(app_id:str) -> OAuth2TokenCredentials:
+    return get_application_connection_credentials(ConnectionType.OAUTH2_PASSWORD, app_id=app_id)
 
 def oauth2_client_creds(app_id:str) -> OAuth2TokenCredentials:
     return get_application_connection_credentials(ConnectionType.OAUTH2_CLIENT_CREDS, app_id=app_id)

{ibm_watsonx_orchestrate-1.9.0b2.dist-info → ibm_watsonx_orchestrate-1.10.0b1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ibm-watsonx-orchestrate
-Version: 1.9.0b2
+Version: 1.10.0b1
 Summary: IBM watsonx.orchestrate SDK
 Author-email: IBM <support@ibm.com>
 License: MIT License