scalable-pypeline 2.1.0__tar.gz → 2.1.1__tar.gz

{scalable-pypeline-2.1.0/scalable_pypeline.egg-info → scalable-pypeline-2.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: scalable-pypeline
-Version: 2.1.0
+Version: 2.1.1
 Summary: PypeLine - Python pipelines for the Real World
 Home-page: https://gitlab.com/bravos2/pypeline
 Author: Bravos Power Corporation

scalable-pypeline-2.1.1/pypeline/__init__.py

@@ -0,0 +1 @@
+__version__ = "2.1.1"

{scalable-pypeline-2.1.0 → scalable-pypeline-2.1.1}/pypeline/pipeline_settings_schema.py

@@ -32,11 +32,39 @@ def create_pipeline_settings_schema(pipeline_settings_schema_data):
             "float": fields.Float,
             "boolean": fields.Boolean,
             "datetime": fields.DateTime,
+            "array": fields.List,
+            "object": fields.Nested,
         }.get(data_type)
 
         if not field_type:
             raise ValidationError(f"Unsupported dataType `{data_type}` for `{key}`.")
 
+        # Handle array type
+        if data_type == "array":
+            element_type = config.get("elementType")
+            if not element_type:
+                raise ValidationError(f"`elementType` is required for array `{key}`.")
+            field_args["cls_or_instance"] = {
+                "string": fields.String,
+                "int": fields.Integer,
+                "float": fields.Float,
+                "boolean": fields.Boolean,
+                "datetime": fields.DateTime,
+            }.get(element_type)
+            if not field_args["cls_or_instance"]:
+                raise ValidationError(
+                    f"Unsupported elementType `{element_type}` for array `{key}`."
+                )
+
+        # Handle object type
+        if data_type == "object":
+            properties = config.get("properties")
+            if not properties:
+                raise ValidationError(f"`properties` is required for object `{key}`.")
+            # Recursively create a schema for the nested object
+            nested_schema = create_pipeline_settings_schema({"properties": properties})
+            field_args["schema"] = nested_schema
+
         # Handle range validation for numeric fields
         if data_type in ["int", "float"]:
             if "minimum" in config or "maximum" in config:
@@ -64,6 +92,97 @@ def create_pipeline_settings_schema(pipeline_settings_schema_data):
     return DynamicPipelineSettingsSchema()
 
 
+def create_pipeline_settings_schema(pipeline_settings_schema_data):
+    """
+    Dynamically create a schema to validate user data based on settings.
+
+    Args:
+        pipeline_settings_schema_data (dict): The settings schema data containing
+                                              field configurations.
+
+    Returns:
+        Schema: A dynamically created schema class for validating user data.
+    """
+
+    # Dictionary to store dynamically generated fields
+    schema_fields = {}
+
+    for key, config in pipeline_settings_schema_data["properties"].items():
+        data_type = config.get("dataType")
+        input_type = config.get("inputType")
+        field_args = {}
+
+        # Map dataType to Marshmallow field type
+        field_type = {
+            "string": fields.String,
+            "int": fields.Integer,
+            "float": fields.Float,
+            "boolean": fields.Boolean,
+            "datetime": fields.DateTime,
+            "array": fields.List,
+            "object": fields.Nested,
+        }.get(data_type)
+
+        if not field_type:
+            raise ValidationError(f"Unsupported dataType `{data_type}` for `{key}`.")
+
+        # Handle array type
+        if data_type == "array":
+            element_type = config.get("elementType")
+            if not element_type:
+                raise ValidationError(f"`elementType` is required for array `{key}`.")
+            field_args["cls_or_instance"] = {
+                "string": fields.String,
+                "int": fields.Integer,
+                "float": fields.Float,
+                "boolean": fields.Boolean,
+                "datetime": fields.DateTime,
+            }.get(element_type)
+            if not field_args["cls_or_instance"]:
+                raise ValidationError(
+                    f"Unsupported elementType `{element_type}` for array `{key}`."
+                )
+
+        # Handle object type
+        if data_type == "object":
+            properties = config.get("properties")
+            if not properties:
+                raise ValidationError(f"`properties` is required for object `{key}`.")
+            # Recursively create a schema for the nested object
+            nested_schema = create_pipeline_settings_schema({"properties": properties})
+            # Use the nested schema as the `nested` argument for fields.Nested
+            field_type = fields.Nested(nested_schema)
+
+        # Handle range validation for numeric fields
+        if data_type in ["int", "float"]:
+            if "minimum" in config or "maximum" in config:
+                field_args["validate"] = validate.Range(
+                    min=config.get("minimum"), max=config.get("maximum")
+                )
+
+        # Handle dropdown or radio input options
+        if input_type in ["dropdown", "radio"] and "options" in config:
+            allowed_values = [option["value"] for option in config["options"]]
+            field_args["validate"] = validate.OneOf(allowed_values)
+
+        # Mark the field as required if specified
+        if key in pipeline_settings_schema_data.get("required", []):
+            field_args["required"] = True
+
+        # Create the field and add to the schema fields dictionary
+        if data_type == "object":
+            schema_fields[key] = field_type
+        else:
+            schema_fields[key] = field_type(**field_args)
+
+    # Dynamically create a schema class with the generated fields
+    DynamicPipelineSettingsSchema = type(
+        "DynamicPipelineSettingsSchema", (Schema,), schema_fields
+    )
+
+    return DynamicPipelineSettingsSchema()
+
+
 class OptionSchema(Schema):
     label = fields.String(
         required=True,
@@ -103,13 +222,15 @@ def validate_min_max(data):
 class SettingSchema(Schema):
     dataType = fields.String(
         required=True,
-        validate=validate.OneOf(["string", "int", "float", "boolean", "datetime"]),
+        validate=validate.OneOf(
+            ["string", "int", "float", "boolean", "datetime", "array", "object"]
+        ),
         metadata={"description": "The underlying data type of the setting"},
     )
     inputType = fields.String(
         required=True,
         validate=validate.OneOf(
-            ["text", "dropdown", "radio", "checkbox", "searchable"]
+            ["text", "dropdown", "radio", "checkbox", "searchable", "custom"]
         ),
         metadata={"description": "The type of input UI element"},
     )
@@ -133,6 +254,17 @@ class SettingSchema(Schema):
     searchEndpoint = fields.String(
         metadata={"description": "Endpoint for searchable fields"}
     )
+    component = fields.String(
+        metadata={"description": "React component for custom input types"}
+    )
+    elementType = fields.String(
+        metadata={"description": "Element type for array data types"}
+    )
+    properties = fields.Dict(
+        keys=fields.String(),
+        values=fields.Nested(lambda: SettingSchema),
+        metadata={"description": "Properties for object data types"},
+    )
 
     class Meta:
         ordered = True
@@ -197,6 +329,57 @@ class SettingSchema(Schema):
                 field_name="searchEndpoint",
             )
 
+    @validates_schema
+    def validate_custom_component(self, data, **kwargs):
+        """Ensure component is provided for custom input types."""
+        input_type = data.get("inputType")
+        component = data.get("component")
+
+        if input_type == "custom" and not component:
+            raise ValidationError(
+                "`component` is required for `custom` input types.",
+                field_name="component",
+            )
+        elif input_type != "custom" and component:
+            raise ValidationError(
+                "`component` is not allowed for non-custom input types.",
+                field_name="component",
+            )
+
+    @validates_schema
+    def validate_array_element_type(self, data, **kwargs):
+        """Ensure elementType is provided for array data types."""
+        data_type = data.get("dataType")
+        element_type = data.get("elementType")
+
+        if data_type == "array" and not element_type:
+            raise ValidationError(
+                "`elementType` is required for `array` data types.",
+                field_name="elementType",
+            )
+        elif data_type != "array" and element_type:
+            raise ValidationError(
+                "`elementType` is not allowed for non-array data types.",
+                field_name="elementType",
+            )
+
+    @validates_schema
+    def validate_object_properties(self, data, **kwargs):
+        """Ensure properties are provided for object data types."""
+        data_type = data.get("dataType")
+        properties = data.get("properties")
+
+        if data_type == "object" and not properties:
+            raise ValidationError(
+                "`properties` is required for `object` data types.",
+                field_name="properties",
+            )
+        elif data_type != "object" and properties:
+            raise ValidationError(
+                "`properties` is not allowed for non-object data types.",
+                field_name="properties",
+            )
+
 
 class PipelineSettingsSchema(Schema):
     properties = fields.Dict(
@@ -288,8 +471,8 @@ if __name__ == "__main__":
                 "dataType": "int",
                 "inputType": "text",
                 "label": "Parameter 2",
-                "minimum": 1,
-                "maximum": -1,
+                "minimum": -1,
+                "maximum": 1,
             },
             "param3": {
                 "dataType": "boolean",
@@ -322,6 +505,30 @@ if __name__ == "__main__":
                 "label": "Select Pipeline",
                 "searchEndpoint": "/api/pipelines",
             },
+            "param7": {
+                "dataType": "array",
+                "inputType": "text",
+                "label": "Array of Integers",
+                "elementType": "int",
+            },
+            "param8": {
+                "dataType": "object",
+                "inputType": "custom",
+                "label": "Custom Object",
+                "component": "CustomObjectComponent",
+                "properties": {
+                    "subParam1": {
+                        "dataType": "string",
+                        "inputType": "text",
+                        "label": "Sub Parameter 1",
+                    },
+                    "subParam2": {
+                        "dataType": "int",
+                        "inputType": "text",
+                        "label": "Sub Parameter 2",
+                    },
+                },
+            },
         },
         "required": ["param1", "param2", "param4"],
     }

{scalable-pypeline-2.1.0 → scalable-pypeline-2.1.1/scalable_pypeline.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: scalable-pypeline
-Version: 2.1.0
+Version: 2.1.1
 Summary: PypeLine - Python pipelines for the Real World
 Home-page: https://gitlab.com/bravos2/pypeline
 Author: Bravos Power Corporation

scalable-pypeline-2.1.0/pypeline/__init__.py

@@ -1 +0,0 @@
-__version__ = "2.1.0"