uipath 2.1.127__tar.gz → 2.1.128__tar.gz

{uipath-2.1.127 → uipath-2.1.128}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath
-Version: 2.1.127
+Version: 2.1.128
 Summary: Python SDK and CLI for UiPath Platform, enabling programmatic interaction with automation services, process management, and deployment tools.
 Project-URL: Homepage, https://uipath.com
 Project-URL: Repository, https://github.com/UiPath/uipath-python

{uipath-2.1.127 → uipath-2.1.128}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "uipath"
-version = "2.1.127"
+version = "2.1.128"
 description = "Python SDK and CLI for UiPath Platform, enabling programmatic interaction with automation services, process management, and deployment tools."
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.10"

uipath-2.1.128/src/uipath/utils/dynamic_schema.py

@@ -0,0 +1,128 @@
+"""Json schema to dynamic pydantic model."""
+
+from enum import Enum
+from typing import Any, Dict, List, Type, Union
+
+from pydantic import BaseModel, Field, create_model
+
+
+def jsonschema_to_pydantic(
+    schema: dict[str, Any],
+) -> Type[BaseModel]:
+    """Convert a schema dict to a pydantic model.
+
+    Modified version of https://github.com/kreneskyp/jsonschema-pydantic to account for three unresolved issues.
+      1. Support for title
+      2. Better representation of optionals.
+      3. Support for optional
+
+    Args:
+        schema: JSON schema.
+        definitions: Definitions dict. Defaults to `$def`.
+
+    Returns: Pydantic model.
+    """
+    dynamic_type_counter = 0
+    combined_model_counter = 0
+
+    def convert_type(prop: dict[str, Any]) -> Any:
+        nonlocal dynamic_type_counter, combined_model_counter
+        if "$ref" in prop:
+            # This is the full path. It will be updated in update_forward_refs.
+            return prop["$ref"].split("/")[-1].capitalize()
+
+        if "type" in prop:
+            type_mapping = {
+                "string": str,
+                "number": float,
+                "integer": int,
+                "boolean": bool,
+                "array": List,
+                "object": Dict[str, Any],
+                "null": None,
+            }
+
+            type_ = prop["type"]
+
+            if "enum" in prop:
+                dynamic_members = {
+                    f"KEY_{i}": value for i, value in enumerate(prop["enum"])
+                }
+
+                base_type: Any = type_mapping.get(type_, Any)
+
+                class DynamicEnum(base_type, Enum):
+                    pass
+
+                type_ = DynamicEnum(prop.get("title", "DynamicEnum"), dynamic_members)  # type: ignore[call-arg]
+                return type_
+            elif type_ == "array":
+                item_type: Any = convert_type(prop.get("items", {}))
+                return List[item_type]  # noqa F821
+            elif type_ == "object":
+                if "properties" in prop:
+                    if "title" in prop and prop["title"]:
+                        title = prop["title"]
+                    else:
+                        title = f"DynamicType_{dynamic_type_counter}"
+                        dynamic_type_counter += 1
+
+                    fields: dict[str, Any] = {}
+                    required_fields = prop.get("required", [])
+
+                    for name, property in prop.get("properties", {}).items():
+                        pydantic_type = convert_type(property)
+                        field_kwargs = {}
+                        if "default" in property:
+                            field_kwargs["default"] = property["default"]
+                        if name not in required_fields:
+                            # Note that we do not make this optional. This is due to a limitation in Pydantic/Python.
+                            # If we convert the Optional type back to json schema, it is represented as type | None.
+                            # pydantic_type = Optional[pydantic_type]
+
+                            if "default" not in field_kwargs:
+                                field_kwargs["default"] = None
+                        if "description" in property:
+                            field_kwargs["description"] = property["description"]
+                        if "title" in property:
+                            field_kwargs["title"] = property["title"]
+
+                        fields[name] = (pydantic_type, Field(**field_kwargs))
+
+                    object_model = create_model(title, **fields)
+                    if "description" in prop:
+                        object_model.__doc__ = prop["description"]
+                    return object_model
+                else:
+                    return Dict[str, Any]
+            else:
+                return type_mapping.get(type_, Any)
+
+        elif "allOf" in prop:
+            combined_fields = {}
+            for sub_schema in prop["allOf"]:
+                model = convert_type(sub_schema)
+                combined_fields.update(model.__annotations__)
+            combined_model = create_model(
+                f"CombinedModel_{combined_model_counter}", **combined_fields
+            )
+            combined_model_counter += 1
+            return combined_model
+
+        elif "anyOf" in prop:
+            unioned_types = tuple(
+                convert_type(sub_schema) for sub_schema in prop["anyOf"]
+            )
+            return Union[unioned_types]
+        elif prop == {} or "type" not in prop:
+            return Any
+        else:
+            raise ValueError(f"Unsupported schema: {prop}")
+
+    namespace: dict[str, Any] = {}
+    for name, definition in schema.get("$defs", schema.get("definitions", {})).items():
+        model = convert_type(definition)
+        namespace[name.capitalize()] = model
+    model = convert_type(schema)
+    model.model_rebuild(force=True, _types_namespace=namespace)
+    return model

{uipath-2.1.127 → uipath-2.1.128}/tests/cli/utils/test_dynamic_schema.py

@@ -1,3 +1,4 @@
+from enum import Enum
 from typing import List, Optional
 
 from pydantic import BaseModel, Field
@@ -5,12 +6,16 @@ from pydantic import BaseModel, Field
 from uipath.utils.dynamic_schema import jsonschema_to_pydantic
 
 
-def test_dynamic_schema():
+def atest_dynamic_schema():
     # Arrange
     class InnerSchema(BaseModel):
-        """Inner schema description."""
+        """Inner schema description including a self-reference."""
 
-        pass
+        self_reference: Optional["InnerSchema"] = None
+
+    class CustomEnum(str, Enum):
+        KEY_1 = "VALUE_1"
+        KEY_2 = "VALUE_2"
 
     class Schema(BaseModel):
         """Schema description."""
@@ -70,7 +75,7 @@ def test_dynamic_schema():
         )
 
         nested_object: InnerSchema = Field(
-            default=InnerSchema(),
+            default=InnerSchema(self_reference=None),
             title="Nested Object Title",
             description="Nested Object Description",
         )
@@ -85,6 +90,12 @@ def test_dynamic_schema():
             description="List Nested Object Description",
         )
 
+        enum: CustomEnum = Field(
+            default=CustomEnum.KEY_1,
+            title="Enum Title",
+            description="Enum Description",
+        )
+
     schema_json = Schema.model_json_schema()
 
     # Act

{uipath-2.1.127 → uipath-2.1.128}/uv.lock

@@ -3047,7 +3047,7 @@ wheels = [
 
 [[package]]
 name = "uipath"
-version = "2.1.127"
+version = "2.1.128"
 source = { editable = "." }
 dependencies = [
     { name = "azure-monitor-opentelemetry" },

uipath-2.1.127/src/uipath/utils/dynamic_schema.py

@@ -1,111 +0,0 @@
-"""Json schema to dynamic pydantic model."""
-
-from typing import Any, Dict, List, Optional, Type, Union
-
-from pydantic import BaseModel, Field, create_model
-
-
-def jsonschema_to_pydantic(
-    schema: dict[str, Any],
-    definitions: Optional[dict[str, Any]] = None,
-) -> Type[BaseModel]:
-    """Convert a schema dict to a pydantic model.
-
-    Modified version of https://github.com/kreneskyp/jsonschema-pydantic to account for two unresolved issues.
-
-    Args:
-        schema: JSON schema.
-        definitions: Definitions dict. Defaults to `$def`.
-
-    Returns: Pydantic model.
-    """
-    title = schema.get("title", "DynamicModel")
-    assert isinstance(title, str), "Title of a model must be a string."
-
-    description = schema.get("description", None)
-
-    # top level schema provides definitions
-    if definitions is None:
-        if "$defs" in schema:
-            definitions = schema["$defs"]
-        elif "definitions" in schema:
-            definitions = schema["definitions"]
-        else:
-            definitions = {}
-
-    def convert_type(prop: dict[str, Any]) -> Any:
-        if "$ref" in prop:
-            ref_path = prop["$ref"].split("/")
-            ref = definitions[ref_path[-1]]
-            return jsonschema_to_pydantic(ref, definitions)
-
-        if "type" in prop:
-            type_mapping = {
-                "string": str,
-                "number": float,
-                "integer": int,
-                "boolean": bool,
-                "array": List,
-                "object": Dict[str, Any],
-                "null": None,
-            }
-
-            type_ = prop["type"]
-
-            if type_ == "array":
-                item_type: Any = convert_type(prop.get("items", {}))
-                assert isinstance(item_type, type)
-                return List[item_type]  # noqa F821
-            elif type_ == "object":
-                if "properties" in prop:
-                    return jsonschema_to_pydantic(prop, definitions)
-                else:
-                    return Dict[str, Any]
-            else:
-                return type_mapping.get(type_, Any)
-
-        elif "allOf" in prop:
-            combined_fields = {}
-            for sub_schema in prop["allOf"]:
-                model = jsonschema_to_pydantic(sub_schema, definitions)
-                combined_fields.update(model.__annotations__)
-            return create_model("CombinedModel", **combined_fields)
-
-        elif "anyOf" in prop:
-            unioned_types = tuple(
-                convert_type(sub_schema) for sub_schema in prop["anyOf"]
-            )
-            return Union[unioned_types]
-        elif prop == {} or "type" not in prop:
-            return Any
-        else:
-            raise ValueError(f"Unsupported schema: {prop}")
-
-    fields: dict[str, Any] = {}
-    required_fields = schema.get("required", [])
-
-    for name, prop in schema.get("properties", {}).items():
-        pydantic_type = convert_type(prop)
-        field_kwargs = {}
-        if "default" in prop:
-            field_kwargs["default"] = prop["default"]
-        if name not in required_fields:
-            # Note that we do not make this optional. This is due to a limitation in Pydantic/Python.
-            # If we convert the Optional type back to json schema, it is represented as type | None.
-            # pydantic_type = Optional[pydantic_type]
-
-            if "default" not in field_kwargs:
-                field_kwargs["default"] = None
-        if "description" in prop:
-            field_kwargs["description"] = prop["description"]
-        if "title" in prop:
-            field_kwargs["title"] = prop["title"]
-
-        fields[name] = (pydantic_type, Field(**field_kwargs))
-
-    convert_type(schema.get("properties", {}).get("choices", {}))
-
-    model = create_model(title, **fields)
-    if description:
-        model.__doc__ = description
-    return model