ibm-watsonx-orchestrate 1.10.2__py3-none-any.whl → 1.11.0__py3-none-any.whl

ibm_watsonx_orchestrate/flow_builder/node.py

@@ -6,14 +6,14 @@ import yaml
 from pydantic import BaseModel, Field, SerializeAsAny, create_model
 from enum import Enum
 
-from .types import DocExtConfigField, EndNodeSpec, NodeSpec, AgentNodeSpec, PromptNodeSpec, TimerNodeSpec, StartNodeSpec, ToolNodeSpec, UserFieldKind, UserFieldOption, UserNodeSpec, DocProcSpec, \
+from .types import Assignment, DocExtConfigField, EndNodeSpec, NodeSpec, AgentNodeSpec, PromptNodeSpec, TimerNodeSpec, StartNodeSpec, ToolNodeSpec, UserFieldKind, UserFieldOption, UserNodeSpec, DocProcSpec, \
                     DocExtSpec, DocExtConfig, DocClassifierSpec, DecisionsNodeSpec, DocClassifierConfig
 
 from .data_map import DataMap
 
 class Node(BaseModel):
     spec: SerializeAsAny[NodeSpec]
-    input_map: DataMap | None = None
+    input_map: dict[str, DataMap] | None = None
 
     def __call__(self, **kwargs):
         pass
@@ -40,10 +40,77 @@ class Node(BaseModel):
     def to_json(self) -> dict[str, Any]:
         model_spec = {}
         model_spec["spec"] = self.spec.to_json()
-        if self.input_map is not None:
-            model_spec['input_map'] = self.input_map.to_json()
+        if self.input_map is not None and "spec" in self.input_map:
+            model_spec['input_map'] = {
+                "spec": self.input_map["spec"].to_json()
+            }
 
         return model_spec
+    
+    def map_node_input_with_variable(self, target_input_variable: str, variable: str, default_value: str = None) -> None:
+        if self.input_map and "spec" in self.input_map:
+            maps = self.input_map["spec"].maps or []
+        else:
+            maps = []
+        
+        curr_map_metadata = {
+            "assignmentType": "variable"
+        }
+
+        target_variable = "self.input." + target_input_variable
+        value_expression = "flow." + variable
+
+        if default_value:
+            maps.append(Assignment(target_variable=target_variable, value_expression=value_expression, default_value=default_value, metadata=curr_map_metadata))
+        else:
+            maps.append(Assignment(target_variable=target_variable, value_expression=value_expression, metadata=curr_map_metadata))
+
+        node_input_map_spec = DataMap(maps=maps)
+        if self.input_map and "spec" in self.input_map:
+            self.input_map["spec"] = node_input_map_spec
+        else:
+            self.input_map = {"spec": node_input_map_spec}
+
+    def map_input(self, input_variable: str, expression: str, default_value: str = None) -> None:
+        if self.input_map and "spec" in self.input_map:
+            maps = self.input_map["spec"].maps or []
+        else:
+            maps = []
+        
+        curr_map_metadata = {
+            "assignmentType": "pyExpression"
+        }
+
+        target_variable = "self.input." + input_variable
+        value_expression = expression
+
+        if default_value:
+            maps.append(Assignment(target_variable=target_variable, value_expression=value_expression, default_value=default_value, metadata=curr_map_metadata))
+        else:
+            maps.append(Assignment(target_variable=target_variable, value_expression=value_expression, metadata=curr_map_metadata))
+
+        node_input_map_spec = DataMap(maps=maps)
+        if self.input_map and "spec" in self.input_map:
+            self.input_map["spec"] = node_input_map_spec
+        else:
+            self.input_map = {"spec": node_input_map_spec}
+
+    def map_node_input_with_none(self, target_input_variable: str) -> None:
+        if self.input_map and "spec" in self.input_map:
+            maps = self.input_map["spec"].maps or []
+        else:
+            maps = []
+        
+
+        target_variable = "self.input." + target_input_variable
+
+        maps.append(Assignment(target_variable=target_variable, value_expression=None))
+
+        node_input_map_spec = DataMap(maps=maps)
+        if self.input_map and "spec" in self.input_map:
+            self.input_map["spec"] = node_input_map_spec
+        else:
+            self.input_map = {"spec": node_input_map_spec}
 
 class StartNode(Node):
     def __repr__(self):
@@ -83,6 +150,8 @@ class UserNode(Node):
               option: UserFieldOption | None = None,
               min: Any | None = None,
               max: Any | None = None,
+              direction: str | None = None,
+              input_map: DataMap | None = None,
               is_list: bool = False,
               custom: dict[str, Any] | None = None,
               widget: str | None = None):
@@ -97,7 +166,9 @@ class UserNode(Node):
                               max=max,
                               is_list=is_list,
                               custom=custom,
-                              widget=widget)
+                              widget=widget,
+                              direction=direction,
+                              input_map=input_map)
 
 class AgentNode(Node):
     def __repr__(self):

ibm_watsonx_orchestrate/flow_builder/types.py

@@ -28,6 +28,7 @@ from ibm_watsonx_orchestrate.agent_builder.tools.types import (
 )
 from .utils import get_valid_name
 
+
 logger = logging.getLogger(__name__)
 
 class JsonSchemaObjectRef(JsonSchemaObject):
@@ -337,13 +338,15 @@ class DocProcSpec(DocProcCommonNodeSpec):
         description="Optional list of key-value pair schemas to use for extraction.",
         default=None)
     plain_text_reading_order : PlainTextReadingOrder = Field(default=PlainTextReadingOrder.block_structure)
-
+    document_structure: bool = Field(default=False,description="Requests the entire document structure computed by WDU to be returned")
+    
     def __init__(self, **data):
         super().__init__(**data)
         self.kind = "docproc"
 
     def to_json(self) -> dict[str, Any]:
         model_spec = super().to_json()
+        model_spec["document_structure"] = self.document_structure
         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
@@ -360,7 +363,6 @@ class EndNodeSpec(NodeSpec):
     def __init__(self, **data):
         super().__init__(**data)
         self.kind = "end"
-
 class ToolNodeSpec(NodeSpec):
     tool: Union[str, ToolSpec] = Field(default = None, description="the tool to use")
 
@@ -421,9 +423,10 @@ class UserFieldKind(str, Enum):
     DateTime: str = "datetime"
     Time: str = "time"
     Number: str = "number"
-    Document: str = "document"
+    File: str = "file"
     Boolean: str = "boolean"
     Object: str = "object"
+    Choice: str = "any"
 
     def convert_python_type_to_kind(python_type: type) -> "UserFieldKind":
         if inspect.isclass(python_type):
@@ -463,8 +466,8 @@ class UserFieldKind(str, Enum):
             model_spec["format"] = "number"
         elif kind == UserFieldKind.Boolean:
             model_spec["type"] = "boolean"
-        elif kind == UserFieldKind.Document:
-            model_spec["format"] = "uri"
+        elif kind == UserFieldKind.File:
+            model_spec["format"] = "wxo-file"
         elif kind == UserFieldKind.Object:
             raise ValueError("Object user fields are not supported.")
         
@@ -483,6 +486,8 @@ class UserField(BaseModel):
     text: str | None = Field(default=None, description="A descriptive text that can be used to ask user about this field.")
     display_name: str | None = None
     description: str | None = None
+    direction: str | None = None
+    input_map: Any | None = None,
     default: Any | None = None
     option: UserFieldOption | None = None
     min: Any | None = None,
@@ -497,6 +502,15 @@ class UserField(BaseModel):
             model_spec["name"] = self.name
         if self.kind:
             model_spec["kind"] = self.kind.value
+        if self.direction:
+            model_spec["direction"] = self.direction  
+        if self.input_map:
+            # workaround for circular dependency related to Assigments in the Datamap module
+            from .data_map import DataMap
+            if self.input_map and not isinstance(self.input_map, DataMap):
+                raise TypeError("input_map must be an instance of DataMap")
+            #model_spec["input_map"] = self.input_map.to_json() 
+            model_spec["input_map"] = {"spec": self.input_map.to_json()}        
         if self.text:
             model_spec["text"] = self.text
         if self.display_name:
@@ -556,7 +570,15 @@ class UserNodeSpec(NodeSpec):
               max: Any | None = None,
               is_list: bool = False,
               custom: dict[str, Any] | None = None,
-              widget: str | None = None):
+              widget: str | None = None,
+              input_map: Any | None = None,
+              direction: str | None = None):
+        
+        # workaround for circular dependency related to Assigments in the Datamap module
+        from .data_map import DataMap
+        if input_map and not isinstance(input_map, DataMap):
+            raise TypeError("input_map must be an instance of DataMap")
+        
         userfield = UserField(name=name, 
                               kind=kind, 
                               text=text,
@@ -568,7 +590,9 @@ class UserNodeSpec(NodeSpec):
                               max=max,
                               is_list=is_list,
                               custom=custom,
-                              widget=widget)
+                              widget=widget,
+                              direction=direction,
+                              input_map=input_map)
         
         # find the index of the field
         i = 0
@@ -660,11 +684,28 @@ class PromptLLMParameters(BaseModel):
         if self.stop_sequences:
             model_spec["stop_sequences"] = self.stop_sequences
         return model_spec
+    
+class PromptExample(BaseModel):
+    input: Optional[str] = None
+    expected_output: Optional[str] = None
+    enabled: bool
+
+    def to_json(self) -> dict[str, Any]:
+        model_spec = {}
+        if self.input:
+            model_spec["input"] = self.input
+        if self.expected_output:
+            model_spec["expected_output"] = self.expected_output
+        if self.enabled:
+            model_spec["enabled"] = self.enabled
+        return model_spec
+
 
 
 class PromptNodeSpec(NodeSpec):
     system_prompt: str | list[str]
     user_prompt: str | list[str]
+    prompt_examples: Optional[list[PromptExample]]
     llm: Optional[str] 
     llm_parameters: Optional[PromptLLMParameters] 
 
@@ -682,7 +723,10 @@ class PromptNodeSpec(NodeSpec):
             model_spec["llm"] = self.llm
         if self.llm_parameters:
             model_spec["llm_parameters"] = self.llm_parameters.to_json()
-
+        if self.prompt_examples:
+            model_spec["prompt_examples"] = []
+            for example in self.prompt_examples:
+                model_spec["prompt_examples"].append(example.to_json())
         return model_spec
     
 class TimerNodeSpec(NodeSpec):
@@ -707,6 +751,47 @@ class Expression(BaseModel):
         model_spec["expression"] = self.expression;
         return model_spec
     
+class NodeIdCondition(BaseModel):
+    '''One Condition contains an expression, a node_id that branch should go to when expression is true, and a default indicator. '''
+    expression: Optional[str] = Field(description="A python expression to be run by the flow engine", default=None)
+    node_id: str = Field(description="ID of the node in the flow that branch node should go to")
+    default: bool = Field(description="Boolean indicating if the condition is default case")
+
+    def to_json(self) -> dict[str, Any]:
+        model_spec = {}
+        if self.expression:
+            model_spec["expression"] = self.expression
+        model_spec["node_id"] = self.node_id
+        model_spec["default"] = self.default
+        return model_spec
+
+
+class EdgeIdCondition(BaseModel):
+    '''One Condition contains an expression, an edge_id that branch should go to when expression is true, and a default indicator. '''
+    expression: Optional[str] = Field(description="A python expression to be run by the flow engine")
+    edge_id: str = Field(description="ID of the edge in the flow that branch node should go to")
+    default: bool = Field(description="Boolean indicating if the condition is default case")
+
+    def to_json(self) -> dict[str, Any]:
+        model_spec = {}
+        if self.expression:
+            model_spec["expression"] = self.expression
+        model_spec["edge_id"] = self.edge_id
+        model_spec["default"] = self.default
+        return model_spec
+
+class Conditions(BaseModel):
+    '''One Conditions is an array represents the if-else conditions of a complex branch'''
+    conditions: list = List[Union[NodeIdCondition, EdgeIdCondition]]
+
+    def to_json(self) -> dict[str, Any]:
+        model_spec = {}
+        condition_list = []
+        for condition in self.conditions:
+            condition_list.append(NodeIdCondition.model_validate(condition).to_json())
+        model_spec["conditions"] = condition_list
+        return model_spec
+    
 class MatchPolicy(Enum):
  
     FIRST_MATCH = 1
@@ -724,7 +809,7 @@ class BranchNodeSpec(FlowControlNodeSpec):
     cases (dict[str | bool, str]): A dictionary of labels to node names. The keys can be strings or booleans.
     match_policy (MatchPolicy): The policy to use when evaluating the expression.
     '''
-    evaluator: Expression
+    evaluator: Expression | Conditions
     cases: dict[str | bool, str] = Field(default = {},
                                          description="A dictionary of labels to node names.")
     match_policy: MatchPolicy = Field(default = MatchPolicy.FIRST_MATCH)
@@ -808,7 +893,7 @@ class UserFlowSpec(FlowSpec):
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
-        self.kind = "userflow"
+        self.kind = "user_flow"
 
     def to_json(self) -> dict[str, Any]:
         model_spec = super().to_json()
@@ -917,6 +1002,255 @@ class Assignment(BaseModel):
     default_value: Any | None = None
     metadata: dict = Field(default_factory=dict[str, Any])
 
+class Style(BaseModel):
+    style_id: str = Field(default="", description="Style Identifier which will be used for reference in other objects")
+    font_size: str = Field(default="", description="Font size")
+    font_name: str = Field(default="", description="Font name")
+    is_bold: str = Field(default="", description="Whether or not the the font is bold")
+    is_italic: str = Field(default="", description="Whether or not the the font is italic")
+
+class PageMetadata(BaseModel):
+    page_number: Optional[int] = Field(default=None, description="Page number, starting from 1")
+    page_image_width: Optional[int] = Field(default=None, description="Width of the page in pixels, assuming the page is an image with default 72 DPI")
+    page_image_height: Optional[int] = Field(default=None, description="Height of the page in pixels, assuming the page is an image with default 72 DPI")
+    dpi: Optional[int] = Field(default=None, description="The DPI to use for the page image, as specified in the input to the API")
+    document_type: Optional[str] = Field(default="", description="Document type")
+
+class Metadata(BaseModel):
+    num_pages: int = Field(description="Total number of pages in the document")
+    title: Optional[str] = Field(default=None, description="Document title as obtained from source document")
+    language: Optional[str] = Field(default=None, description="Determined by the lang specifier in the <html> tag, or <meta> tag")
+    url: Optional[str] = Field(default=None, description="URL of the document")
+    keywords: Optional[str] = Field(default=None, description="Keywords associated with document")
+    author: Optional[str] = Field(default=None, description="Author of the document")
+    publication_date: Optional[str] = Field(default=None, description="Best effort bases for a publication date (may be the creation date)")
+    subject: Optional[str] = Field(default=None, description="Subject as obtained from the source document")
+    charset: str = Field(default="", description="Character set used for the output")
+    output_tokens_flag: Optional[bool] = Field(default=None, description="Whether individual tokens are output, as specified in the input to the API")
+    output_bounding_boxes_flag: Optional[bool] = Field(default=None, description="Whether bounding boxes are output, as requested in the input to the API")
+    pages_metadata: Optional[List[PageMetadata]] = Field(default=[], description="List of page-level metadata objects")
+
+class Section(BaseModel):
+    id: str = Field(default="", description="Unique identifier for the section")
+    parent_id: str = Field(default="", description="Unique identifier which denotes parent of this structure")
+    children_ids: List[str] = Field(default="", description="Unique Ids of first level children structures under this structure in correct sequence")
+    section_number: str = Field(default="", description="Section identifier identified in the document")
+    section_level: str = Field(default="", description="Nesting level of section identified in the document")
+    bbox_list: Optional[List[DocProcBoundingBox]] = Field(default=None, description="Cross-pages bounding boxes of that section")
+
+
+class SectionTitle(BaseModel):
+    id: str = Field(default="", description="Unique identifier for the section")
+    parent_id: str = Field(default="", description="Unique identifier which denotes parent of this structure")
+    children_ids: Optional[List[str]] = Field(default=None, description="Unique Ids of first level children structures under this structure in correct sequence")
+    text_alignment: Optional[str] = Field(default="", description="Text alignment of the section title")
+    text: str = Field(default="", description="Text property added to all objects")
+    bbox: Optional[DocProcBoundingBox] = Field(default=None, description="The bounding box of the section title")
+
+class List_(BaseModel):
+    id: str = Field(..., description="Unique identifier for the list")
+    title: Optional[str] = Field(None, description="List title")
+    parent_id: str = Field(..., description="Unique identifier which denotes parent of this structure")
+    children_ids: List[str] = Field(..., description="Unique Ids of first level children structures under this structure in correct sequence")
+    bbox_list: Optional[List[DocProcBoundingBox]] = Field(None, description="Cross-pages bounding boxes of that table")
+
+
+class ListItem(BaseModel):
+    id: str = Field(..., description="Unique identifier for the list item")
+    parent_id: str = Field(..., description="Unique identifier which denotes parent of this structure")
+    children_ids: Optional[List[str]] = Field(None, description="Unique Ids of first level children structures under this structure in correct sequence")
+    text: str = Field(..., description="Text property added to all objects")
+    bbox: Optional[DocProcBoundingBox] = Field(None, description="The bounding box of the list item")
+
+
+class ListIdentifier(BaseModel):
+    id: str = Field(..., description="Unique identifier for the list item")
+    parent_id: str = Field(..., description="Unique identifier which denotes parent of this structure")
+    children_ids: List[str] = Field(..., description="Unique Ids of first level children structures under this structure in correct sequence")
+
+class Table(BaseModel):
+    id: str = Field(..., description="Unique identifier for the table")
+    parent_id: str = Field(..., description="Unique identifier which denotes parent of this structure")
+    children_ids: List[str] = Field(..., description="Unique Ids of first level children structures under this structure in correct sequence, in this case, table rows")
+    bbox_list: Optional[List[DocProcBoundingBox]] = Field(None, description="Cross-pages bounding boxes of that table")
+
+
+class TableRow(BaseModel):
+    id: str = Field(..., description="Unique identifier for the table row")
+    parent_id: str = Field(..., description="Unique identifier which denotes parent of this structure")
+    children_ids: List[str] = Field(..., description="Unique Ids of first level children structures under this structure in correct sequence, in this case, table cells")
+    bbox: Optional[DocProcBoundingBox] = Field(None, description="The bounding box of the table row")
+
+
+class TableCell(BaseModel):
+    id: str = Field(..., description="Unique identifier for the table cell")
+    parent_id: str = Field(..., description="Unique identifier which denotes parent of this structure")
+    is_row_header: bool = Field(..., description="Whether the cell is part of row header or not")
+    is_col_header: bool = Field(..., description="Whether the cell is part of column header or not")
+    col_span: int = Field(..., description="Column span of the cell")
+    row_span: int = Field(..., description="Row span of the cell")
+    col_start: int = Field(..., description="Column start of the cell within the table")
+    row_start: int = Field(..., description="Row start of the cell within the table")
+    children_ids: Optional[List[str]] = Field(None, description="Children structures, e.g., paragraphs")
+    text: str = Field(..., description="Text property added to all objects")
+    bbox: Optional[DocProcBoundingBox] = Field(None, description="The bounding box of the table cell")
+
+class Subscript(BaseModel):
+    id: str = Field(..., description="Unique identifier for the subscript")
+    parent_id: str = Field(..., description="Unique identifier which denotes parent of this structure")
+    children_ids: List[str] = Field(default_factory=list, description="Unique Ids of first level children structures under this structure in correct sequence")
+    token_id_ref: Optional[str] = Field(None, description="Id of the token to which the subscript belongs")
+    text: str = Field(..., description="Text property added to all objects")
+
+
+class Superscript(BaseModel):
+    id: str = Field(..., description="Unique identifier for the superscript")
+    parent_id: str = Field(..., description="Unique identifier which denotes parent of this structure")
+    footnote_ref: str = Field(..., description="Matching footnote id found on the page")
+    token_id_ref: Optional[str] = Field(None, description="Id of the token to which the superscript belongs")
+    children_ids: List[str] = Field(default_factory=list, description="Unique Ids of first level children structures under this structure in correct sequence")
+    text: str = Field(..., description="Text property added to all objects")
+
+
+class Footnote(BaseModel):
+    id: str = Field(..., description="Unique identifier for the footnote")
+    parent_id: str = Field(..., description="Unique identifier which denotes parent of this structure")
+    children_ids: List[str] = Field(default_factory=list, description="Unique Ids of first level children structures under this structure in correct sequence")
+    text: str = Field(..., description="Text property added to all objects")
+
+
+class Paragraph(BaseModel):
+    id: str = Field(..., description="Unique identifier for the paragraph")
+    parent_id: str = Field(..., description="Unique identifier which denotes parent of this structure")
+    children_ids: List[str] = Field(default_factory=list, description="Unique Ids of first level children structures under this structure in correct sequence, in this case, tokens")
+    text_alignment: Optional[str] = Field(None, description="Text alignment of the paragraph")
+    indentation: Optional[int] = Field(None, description="Paragraph indentation")
+    text: str = Field(..., description="Text property added to all objects")
+    bbox_list: Optional[DocProcBoundingBox] = Field(default=None, description="Cross-pages bounding boxes of that Paragraph")
+
+
+class CodeSnippet(BaseModel):
+    id: str = Field(..., description="Unique identifier for the code snippet")
+    parent_id: str = Field(..., description="Unique identifier which denotes parent of this structure")
+    children_ids: List[str] = Field(default_factory=list, description="Unique Ids of first level children structures under this structure in correct sequence, in this case, tokens")
+    text: str = Field(..., description="Text of the code snippet. It can contain multiple lines, including empty lines or lines with leading spaces.")
+
+
+class Picture(BaseModel):
+    id: str = Field(..., description="Unique identifier for the picture")
+    parent_id: str = Field(..., description="Unique identifier which denotes parent of this structure")
+    children_ids: List[str] = Field(default_factory=list, description="Unique identifiers of the tokens extracted from this picture, if any")
+    text: Optional[str] = Field(None, description="Text extracted from this picture")
+    verbalization: Optional[str] = Field(None, description="Verbalization of this picture")
+    path: Optional[str] = Field(None, description="Path in the output location where the picture itself was saved")
+    picture_class: Optional[str] = Field(None, description="The classification result of the picture")
+    bbox: Optional[DocProcBoundingBox] = Field(None, description="The bounding box of the picture in the context of the page, expressed as pixel coordinates with respect to pages_metadata.page_image_height and pages_metadata.page_image_width")
+
+
+class PageHeader(BaseModel):
+    id: str = Field(..., description="Unique identifier for the page header")
+    parent_id: str = Field(..., description="Unique identifier which denotes parent of this structure")
+    text: Optional[str] = Field(None, description="The page header text")
+    bbox: Optional[DocProcBoundingBox] = Field(None, description="The bounding box of the page header")
+    children_ids: List[str] = Field(default_factory=list, description="Unique Ids of first level children structures under this structure in correct sequence, in this case, tokens")
+
+
+class PageFooter(BaseModel):
+    id: str = Field(..., description="Unique identifier for the page footer")
+    parent_id: str = Field(..., description="Unique identifier which denotes parent of this structure")
+    text: Optional[str] = Field(None, description="The page footer text")
+    bbox: Optional[DocProcBoundingBox] = Field(None, description="The bounding box of the page footer")
+    children_ids: List[str] = Field(default_factory=list, description="Unique Ids of first level children structures under this structure in correct sequence, in this case, tokens")
+
+
+class BarCode(BaseModel):
+    id: str = Field(..., description="Unique identifier for the bar code")
+    parent_id: str = Field(..., description="Unique identifier which denotes parent of this structure")
+    text: Optional[str] = Field(None, description="The value of the bar code")
+    format: Optional[str] = Field(None, description="The format of the bar code")
+    path: Optional[str] = Field(None, description="Path in the output location where the var code picture is saved")
+    bbox: Optional[DocProcBoundingBox] = Field(None, description="The bounding box of the bar code in the context of the page, expressed as pixel coordinates with respect to pages_metadata.page_image_height and pages_metadata.page_image_width")
+
+
+class QRCode(BaseModel):
+    id: str = Field(..., description="Unique identifier for the QR code")
+    parent_id: str = Field(..., description="Unique identifier which denotes parent of this structure")
+    text: Optional[str] = Field(None, description="The value of the QR code")
+    path: Optional[str] = Field(None, description="Path in the output location where the var code picture is saved")
+    bbox: Optional[DocProcBoundingBox] = Field(None, description="The bounding box of the bar code in the context of the page, expressed as pixel coordinates with respect to pages_metadata.page_image_height and pages_metadata.page_image_width")
+
+
+class Token(BaseModel):
+    id: str = Field(..., description="Unique identifier for the list identifier")
+    parent_id: Optional[str] = Field(None, description="Unique identifier which denotes parent of this structure")
+    style_id: Optional[str] = Field(None, description="Identifier of the style object associated with this token")
+    text: str = Field(..., description="Actual text of the token")
+    bbox: Optional[DocProcBoundingBox] = Field(None, description="The bounding box of the token in the context of the page, expressed as pixel coordinates with respect to pages_metadata.page_image_height and pages_metadata.page_image_width")
+    confidence: Optional[float] = Field(None, description="Confidence score for the token")
+
+class Structures(BaseModel):
+    sections: Optional[List[Section]] = Field(
+        default=None, description="All Section objects found in the document"
+    )
+    section_titles: Optional[List[SectionTitle]] = Field(
+        default=None, description="All SectionTitle objects found in the document"
+    )
+    lists: Optional[List[List_]] = Field(
+        default=None, description="All List objects found in the document"
+    )
+    list_items: Optional[List[ListItem]] = Field(
+        default=None, description="All ListItem objects found in the document"
+    )
+    list_identifiers: Optional[List[ListIdentifier]] = Field(
+        default=None, description="All ListIdentifier objects found in the document"
+    )
+    tables: Optional[List[Table]] = Field(
+        default=None, description="All Table objects found in the document"
+    )
+    table_rows: Optional[List[TableRow]] = Field(
+        default=None, description="All TableRow objects found in the document"
+    )
+    table_cells: Optional[List[TableCell]] = Field(
+        default=None, description="All TableCell objects found in the document"
+    )
+    subscripts: Optional[List[Subscript]] = Field(
+        default=None, description="All Subscript objects found in the document"
+    )
+    superscripts: Optional[List[Superscript]] = Field(
+        default=None, description="All Superscript objects found in the document"
+    )
+    footnotes: Optional[List[Footnote]] = Field(
+        default=None, description="All Footnote objects found in the document"
+    )
+    paragraphs: Optional[List[Paragraph]] = Field(
+        default=None, description="All Paragraph objects found in the document"
+    )
+    code_snippets: Optional[List[CodeSnippet]] = Field(
+        default=None, description="All CodeSnippet objects found in the document"
+    )
+    pictures: Optional[List[Picture]] = Field(
+        default=None, description="All Picture objects found in the document"
+    )
+    page_headers: Optional[List[PageHeader]] = Field(
+        default=None, description="All PageHeader objects found in the document"
+    )
+    page_footers: Optional[List[PageFooter]] = Field(
+        default=None, description="All PageFooter objects found in the document"
+    )
+    bar_codes: Optional[List[BarCode]] = Field(
+        default=None, description="All BarCode objects found in the document"
+    )
+    tokens: Optional[List[Token]] = Field(
+        default=None, description="All Token objects found in the document"
+    )
+
+class AssemblyJsonOutput(BaseModel):
+    metadata: Metadata = Field(description="Metadata about this document")
+    styles: Optional[List[Style]] = Field(description="Font styles used in this document")
+    kvps: Optional[DocProcKVP] = Field(description="Key value pairs found in the document")
+    top_level_structures: List[str] = Field(default=[], description="Array of ids of the top level structures which belong directly under the document")
+    all_structures: Structures = Field(default=None, description="An object containing of all flattened structures identified in the document")
+
 class LanguageCode(StrEnum):
     '''
     The ISO-639 language codes understood by Document Processing functions.

{ibm_watsonx_orchestrate-1.10.2.dist-info → ibm_watsonx_orchestrate-1.11.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ibm-watsonx-orchestrate
-Version: 1.10.2
+Version: 1.11.0
 Summary: IBM watsonx.orchestrate SDK
 Author-email: IBM <support@ibm.com>
 License: MIT License
@@ -11,7 +11,7 @@ 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.24.2
-Requires-Dist: ibm-watsonx-orchestrate-evaluation-framework==1.0.8
+Requires-Dist: ibm-watsonx-orchestrate-evaluation-framework==1.1.1
 Requires-Dist: jsonref==1.1.0
 Requires-Dist: langchain-core<=0.3.63
 Requires-Dist: langsmith<=0.3.45