deltafi 1.1.16__tar.gz → 2.0rc1705013410531__tar.gz

{deltafi-1.1.16 → deltafi-2.0rc1705013410531}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: deltafi
-Version: 1.1.16
+Version: 2.0rc1705013410531
 Summary: SDK for DeltaFi plugins and actions
 License: Apache License, Version 2.0
 Keywords: deltafi

deltafi-2.0rc1705013410531/deltafi/action.py

@@ -0,0 +1,131 @@
+#
+#    DeltaFi - Data transformation and enrichment platform
+#
+#    Copyright 2021-2023 DeltaFi Contributors <deltafi@deltafi.org>
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+from abc import ABC, abstractmethod
+from typing import Any, List
+
+from deltafi.actiontype import ActionType
+from deltafi.genericmodel import GenericModel
+from deltafi.domain import Context, DeltaFileMessage
+from deltafi.input import EgressInput, TransformInput
+from deltafi.result import *
+from pydantic import BaseModel
+
+
+class Action(ABC):
+    def __init__(self, action_type: ActionType, description: str, valid_result_types: tuple):
+        self.action_type = action_type
+        self.description = description
+        self.valid_result_types = valid_result_types
+        self.action_execution = None
+
+    @abstractmethod
+    def build_input(self, context: Context, delta_file_message: DeltaFileMessage):
+        pass
+
+    def collect(self, action_inputs: List[Any]):
+        raise RuntimeError(f"Collect is not supported for {self.__class__.__name__}")
+
+    @abstractmethod
+    def execute(self, context: Context, action_input: Any, params: BaseModel):
+        pass
+
+    def execute_action(self, event):
+        if event.delta_file_messages is None or not len(event.delta_file_messages):
+            raise RuntimeError(f"Received event with no delta file messages for did {event.context.did}")
+
+        if event.context.collect is not None:
+            result = self.execute(event.context, self.collect([self.build_input(event.context, delta_file_message)
+                                                               for delta_file_message in event.delta_file_messages]),
+                                  self.param_class().model_validate(event.params))
+        else:
+            result = self.execute(event.context, self.build_input(event.context, event.delta_file_messages[0]),
+                                  self.param_class().model_validate(event.params))
+
+        self.validate_type(result)
+        return result
+
+    @staticmethod
+    def param_class( ):
+        """Factory method to create and return an empty GenericModel instance.
+
+        Returns
+        -------
+        GenericModel
+            an empty GenericModel instance
+        """
+        return GenericModel
+
+    def validate_type(self, result):
+        if not isinstance(result, self.valid_result_types):
+            raise ValueError(f"{self.__class__.__name__} must return one of "
+                             f"{[result_type.__name__ for result_type in self.valid_result_types]} "
+                             f"but a {result.__class__.__name__} was returned")
+
+
+class EgressAction(Action, ABC):
+    def __init__(self, description: str):
+        super().__init__(ActionType.EGRESS, description, (EgressResult, ErrorResult, FilterResult))
+
+    def build_input(self, context: Context, delta_file_message: DeltaFileMessage):
+        return EgressInput(content=delta_file_message.content_list[0], metadata=delta_file_message.metadata)
+
+    @abstractmethod
+    def egress(self, context: Context, params: BaseModel, egress_input: EgressInput):
+        pass
+
+    def execute(self, context: Context, egress_input: EgressInput, params: BaseModel):
+        return self.egress(context, params, egress_input)
+
+
+class TimedIngressAction(Action, ABC):
+    def __init__(self, description: str):
+        super().__init__(ActionType.TIMED_INGRESS, description, (IngressResult, ErrorResult))
+
+    def build_input(self, context: Context, delta_file_message: DeltaFileMessage):
+        return None
+
+    @abstractmethod
+    def ingress(self, context: Context, params: BaseModel):
+        pass
+
+    def execute(self, context: Context, input_placeholder: Any, params: BaseModel):
+        return self.ingress(context, params)
+
+
+class TransformAction(Action, ABC):
+    def __init__(self, description: str):
+        super().__init__(ActionType.TRANSFORM, description, (TransformResult, ErrorResult, FilterResult))
+
+    def build_input(self, context: Context, delta_file_message: DeltaFileMessage):
+        return TransformInput(content=delta_file_message.content_list, metadata=delta_file_message.metadata)
+
+    def collect(self, transform_inputs: List[TransformInput]):
+        all_content = []
+        all_metadata = {}
+        for transform_input in transform_inputs:
+            all_content += transform_input.content
+            all_metadata.update(transform_input.metadata)
+        return TransformInput(content=all_content, metadata=all_metadata)
+
+    @abstractmethod
+    def transform(self, context: Context, params: BaseModel, transform_input: TransformInput):
+        pass
+
+    def execute(self, context: Context, transform_input: TransformInput, params: BaseModel):
+        return self.transform(context, params, transform_input)

{deltafi-1.1.16 → deltafi-2.0rc1705013410531}/deltafi/actiontype.py

@@ -22,11 +22,5 @@ from enum import Enum
 class ActionType(Enum):
     TIMED_INGRESS = "TIMED_INGRESS"
     TRANSFORM = "TRANSFORM"
-    LOAD = "LOAD"
-    DOMAIN = "DOMAIN"
-    ENRICH = "ENRICH"
-    FORMAT = "FORMAT"
-    VALIDATE = "VALIDATE"
     EGRESS = "EGRESS"
-    DELETE = "DELETE"
     UNKNOWN = "UNKNOWN"

deltafi-2.0rc1705013410531/deltafi/input.py

@@ -0,0 +1,52 @@
+#
+#    DeltaFi - Data transformation and enrichment platform
+#
+#    Copyright 2021-2023 DeltaFi Contributors <deltafi@deltafi.org>
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+from deltafi.domain import *
+from deltafi.exception import MissingMetadataException, ExpectedContentException
+
+class EgressInput(NamedTuple):
+    content: Content
+    metadata: dict
+
+
+class TransformInput(NamedTuple):
+    content: List[Content]
+    metadata: dict
+
+    def has_content(self) -> bool:
+        return len(self.content) > 0
+
+    def content_at(self, index: int) -> Content:
+        if len(self.content) < index + 1:
+            raise ExpectedContentException(index, len(self.content))
+        return self.content[index]
+
+    def first_content(self):
+        return self.content_at(0)
+
+    def get_metadata(self, key: str):
+        if key in self.metadata:
+            return self.metadata[key]
+        else:
+            raise MissingMetadataException(key)
+
+    def get_metadata_or_else(self, key: str, default: str) -> str:
+        if key in self.metadata:
+            return self.metadata[key]
+        else:
+            return default

{deltafi-1.1.16 → deltafi-2.0rc1705013410531}/deltafi/plugin.py

@@ -165,8 +165,6 @@ class Plugin(object):
             'name': self.action_name(action),
             'description': action.description,
             'type': action.action_type.name,
-            'requiresDomains': action.requires_domains,
-            'requiresEnrichments': action.requires_enrichments,
             'schema': action.param_class().model_json_schema()
         }
 

deltafi-2.0rc1705013410531/deltafi/result.py

@@ -0,0 +1,229 @@
+#
+#    DeltaFi - Data transformation and enrichment platform
+#
+#    Copyright 2021-2023 DeltaFi Contributors <deltafi@deltafi.org>
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+import abc
+from enum import Enum
+import uuid
+from typing import Dict, List
+
+from deltafi.domain import Content, Context
+from deltafi.metric import Metric
+
+ENDPOINT_TAG = "endpoint"
+FILES_OUT = "files_out"
+BYTES_OUT = "bytes_out"
+
+
+class Result:
+    __metaclass__ = abc.ABCMeta
+
+    def __init__(self, result_key, result_type, context):
+        self.result_key = result_key
+        self.result_type = result_type
+        self.metrics = []
+        self.context = context
+
+    @abc.abstractmethod
+    def response(self):
+        pass
+
+    def add_metric(self, metric: Metric):
+        self.metrics.append(metric)
+
+
+class EgressResult(Result):
+    def __init__(self, context: Context, destination: str, bytes_egressed: int):
+        super().__init__(None, 'EGRESS', context)
+        self.add_metric(Metric(FILES_OUT, 1, {ENDPOINT_TAG: destination}))
+        self.add_metric(Metric(BYTES_OUT, bytes_egressed, {ENDPOINT_TAG: destination}))
+
+    def response(self):
+        return None
+
+
+class ErrorResult(Result):
+    def __init__(self, context: Context, error_cause: str, error_context: str):
+        super().__init__('error', 'ERROR', context)
+        self.error_cause = error_cause
+        self.error_context = error_context
+        self.annotations = {}
+
+    def annotate(self, key: str, value: str):
+        self.annotations[key] = value
+        return self
+
+    def response(self):
+        return {
+            'cause': self.error_cause,
+            'context': self.error_context,
+            'annotations': self.annotations
+        }
+
+
+class FilterResult(Result):
+    def __init__(self, context: Context, filtered_cause: str, filtered_context: str=None):
+        super().__init__('filter', 'FILTER', context)
+        self.filtered_cause = filtered_cause
+        self.filtered_context = filtered_context
+        self.annotations = {}
+
+    def annotate(self, key: str, value: str):
+        self.annotations[key] = value
+        return self
+
+    def response(self):
+        return {
+            'message': self.filtered_cause,
+            'context': self.filtered_context,
+            'annotations': self.annotations
+        }
+
+
+class IngressResultItem:
+    def __init__(self, context: Context, filename: str):
+        self.context = context
+        self.filename = filename
+        self._did = str(uuid.uuid4())
+        self.content = []
+        self.metadata = {}
+
+    @property
+    def did(self):
+        return self._did
+
+    # content can be a single Content or a List[Content]
+    def add_content(self, content):
+        if content:
+            if type(content) == list:
+                self.content.extend(content)
+            else:
+                self.content.append(content)
+
+        return self
+
+    def save_string_content(self, string_data: str, name: str, media_type: str):
+        segment = self.context.content_service.put_str(self.context.did, string_data)
+        self.content.append(
+            Content(name=name, segments=[segment], media_type=media_type, content_service=self.context.content_service))
+        return self
+
+    def save_byte_content(self, byte_data: bytes, name: str, media_type: str):
+        segment = self.context.content_service.put_bytes(self.context.did, byte_data)
+        self.content.append(
+            Content(name=name, segments=[segment], media_type=media_type, content_service=self.context.content_service))
+        return self
+
+    def set_metadata(self, metadata: dict):
+        self.metadata = metadata
+        return self
+
+    def add_metadata(self, key: str, value: str):
+        self.metadata[key] = value
+        return self
+
+    def response(self):
+        return {
+            'did': self._did,
+            'filename': self.filename,
+            'metadata': self.metadata,
+            'content': [content.json() for content in self.content]
+        }
+
+
+class IngressStatusEnum(Enum):
+    HEALTHY = 'HEALTHY'
+    DEGRADED = 'DEGRADED'
+    UNHEALTHY = 'UNHEALTHY'
+
+
+class IngressResult(Result):
+    def __init__(self, context: Context):
+        super().__init__('ingress', 'INGRESS', context)
+        self.memo = None
+        self.execute_immediate = False
+        self.ingress_result_items = []
+        self.status = IngressStatusEnum.HEALTHY
+        self.statusMessage = None
+
+    def add_item(self, ingress_result_item: IngressResultItem):
+        self.ingress_result_items.append(ingress_result_item)
+        return self
+
+    def response(self):
+        return {
+            'memo': self.memo,
+            'executeImmediate': self.execute_immediate,
+            'ingressItems': [ingress_result_item.response() for ingress_result_item in self.ingress_result_items],
+            'status': self.status.value,
+            'statusMessage': self.statusMessage
+        }
+
+
+class TransformResult(Result):
+    def __init__(self, context: Context):
+        super().__init__('transform', 'TRANSFORM', context)
+        self.content = []
+        self.metadata = {}
+        self.annotations = {}
+        self.delete_metadata_keys = []
+
+    # content can be a single Content or a List[Content]
+    def add_content(self, content):
+        if content:
+            if type(content) == list:
+                self.content.extend(content)
+            else:
+                self.content.append(content)
+
+        return self
+
+    def save_string_content(self, string_data: str, name: str, media_type: str):
+        segment = self.context.content_service.put_str(self.context.did, string_data)
+        self.content.append(
+            Content(name=name, segments=[segment], media_type=media_type, content_service=self.context.content_service))
+        return self
+
+    def save_byte_content(self, byte_data: bytes, name: str, media_type: str):
+        segment = self.context.content_service.put_bytes(self.context.did, byte_data)
+        self.content.append(
+            Content(name=name, segments=[segment], media_type=media_type, content_service=self.context.content_service))
+        return self
+
+    def set_metadata(self, metadata: dict):
+        self.metadata = metadata
+        return self
+
+    def add_metadata(self, key: str, value: str):
+        self.metadata[key] = value
+        return self
+
+    def annotate(self, key: str, value: str):
+        self.annotations[key] = value
+        return self
+
+    def delete_metadata_key(self, key: str):
+        self.delete_metadata_keys.append(key)
+        return self
+
+    def response(self):
+        return {
+            'content': [content.json() for content in self.content],
+            'metadata': self.metadata,
+            'annotations': self.annotations,
+            'deleteMetadataKeys': self.delete_metadata_keys
+        }

{deltafi-1.1.16 → deltafi-2.0rc1705013410531}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "deltafi"
-version = "1.1.16"
+version = "2.0rc1705013410531"
 description = "SDK for DeltaFi plugins and actions"
 authors = ["DeltaFi <deltafi@systolic.com>"]
 license = "Apache License, Version 2.0"

deltafi-1.1.16/deltafi/action.py

@@ -1,237 +0,0 @@
-#
-#    DeltaFi - Data transformation and enrichment platform
-#
-#    Copyright 2021-2023 DeltaFi Contributors <deltafi@deltafi.org>
-#
-#    Licensed under the Apache License, Version 2.0 (the "License");
-#    you may not use this file except in compliance with the License.
-#    You may obtain a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS,
-#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#    See the License for the specific language governing permissions and
-#    limitations under the License.
-#
-
-from abc import ABC, abstractmethod
-from typing import Any, List
-
-from deltafi.actiontype import ActionType
-from deltafi.genericmodel import GenericModel
-from deltafi.domain import Context, DeltaFileMessage
-from deltafi.input import DomainInput, EgressInput, EnrichInput, FormatInput, LoadInput, TransformInput, ValidateInput
-from deltafi.result import *
-from pydantic import BaseModel
-
-
-class Action(ABC):
-    def __init__(self, action_type: ActionType, description: str, requires_domains: List[str],
-                 requires_enrichments: List[str], valid_result_types: tuple):
-        self.action_type = action_type
-        self.description = description
-        self.requires_domains = requires_domains
-        self.requires_enrichments = requires_enrichments
-        self.valid_result_types = valid_result_types
-        self.action_execution = None
-
-    @abstractmethod
-    def build_input(self, context: Context, delta_file_message: DeltaFileMessage):
-        pass
-
-    def collect(self, action_inputs: List[Any]):
-        raise RuntimeError(f"Collect is not supported for {self.__class__.__name__}")
-
-    @abstractmethod
-    def execute(self, context: Context, action_input: Any, params: BaseModel):
-        pass
-
-    def execute_action(self, event):
-        if event.delta_file_messages is None or not len(event.delta_file_messages):
-            raise RuntimeError(f"Received event with no delta file messages for did {event.context.did}")
-
-        if event.context.collect is not None:
-            result = self.execute(event.context, self.collect([self.build_input(event.context, delta_file_message)
-                                                               for delta_file_message in event.delta_file_messages]),
-                                  self.param_class().model_validate(event.params))
-        else:
-            result = self.execute(event.context, self.build_input(event.context, event.delta_file_messages[0]),
-                                  self.param_class().model_validate(event.params))
-
-        self.validate_type(result)
-        return result
-
-    @staticmethod
-    def param_class( ):
-        """Factory method to create and return an empty GenericModel instance.
-
-        Returns
-        -------
-        GenericModel
-            an empty GenericModel instance
-        """
-        return GenericModel
-
-    def validate_type(self, result):
-        if not isinstance(result, self.valid_result_types):
-            raise ValueError(f"{self.__class__.__name__} must return one of "
-                             f"{[result_type.__name__ for result_type in self.valid_result_types]} "
-                             f"but a {result.__class__.__name__} was returned")
-
-
-class DomainAction(Action, ABC):
-    def __init__(self, description: str, requires_domains: List[str]):
-        super().__init__(ActionType.DOMAIN, description, requires_domains, [], (DomainResult, ErrorResult))
-
-    def build_input(self, context: Context, delta_file_message: DeltaFileMessage):
-        return DomainInput(content=delta_file_message.content_list, metadata=delta_file_message.metadata,
-                           domains={domain.name: domain for domain in delta_file_message.domains})
-
-    @abstractmethod
-    def domain(self, context: Context, params: BaseModel, domain_input: DomainInput):
-        pass
-
-    def execute(self, context: Context, domain_input: DomainInput, params: BaseModel):
-        return self.domain(context, params, domain_input)
-
-
-class EgressAction(Action, ABC):
-    def __init__(self, description: str):
-        super().__init__(ActionType.EGRESS, description, [], [], (EgressResult, ErrorResult, FilterResult))
-
-    def build_input(self, context: Context, delta_file_message: DeltaFileMessage):
-        return EgressInput(content=delta_file_message.content_list[0], metadata=delta_file_message.metadata)
-
-    @abstractmethod
-    def egress(self, context: Context, params: BaseModel, egress_input: EgressInput):
-        pass
-
-    def execute(self, context: Context, egress_input: EgressInput, params: BaseModel):
-        return self.egress(context, params, egress_input)
-
-
-class EnrichAction(Action, ABC):
-    def __init__(self, description: str, requires_domains: List[str], requires_enrichments: List[str]):
-        super().__init__(ActionType.ENRICH, description, requires_domains, requires_enrichments,
-                         (EnrichResult, ErrorResult))
-
-    def build_input(self, context: Context, delta_file_message: DeltaFileMessage):
-        return EnrichInput(content=delta_file_message.content_list, metadata=delta_file_message.metadata,
-                           domains={domain.name: domain for domain in delta_file_message.domains},
-                           enrichments={domain.name: domain for domain in delta_file_message.enrichments})
-
-    @abstractmethod
-    def enrich(self, context: Context, params: BaseModel, enrich_input: EnrichInput):
-        pass
-
-    def execute(self, context: Context, enrich_input: EnrichInput, params: BaseModel):
-        return self.enrich(context, params, enrich_input)
-
-
-class FormatAction(Action, ABC):
-    def __init__(self, description: str, requires_domains: List[str], requires_enrichments: List[str]):
-        super().__init__(ActionType.FORMAT, description, requires_domains, requires_enrichments,
-                         (FormatResult, FormatManyResult, ErrorResult, FilterResult))
-
-    def build_input(self, context: Context, delta_file_message: DeltaFileMessage):
-        return FormatInput(content=delta_file_message.content_list, metadata=delta_file_message.metadata,
-                           domains={domain.name: domain for domain in delta_file_message.domains},
-                           enrichments={domain.name: domain for domain in delta_file_message.enrichments})
-
-    def collect(self, format_inputs: List[FormatInput]):
-        all_content = []
-        all_metadata = {}
-        all_domains = {}
-        all_enrichments = {}
-        for format_input in format_inputs:
-            all_content += format_input.content
-            all_metadata.update(format_input.metadata)
-            all_domains.update(format_input.domains)
-            all_enrichments.update(format_input.enrichments)
-        return FormatInput(content=all_content, metadata=all_metadata, domains=all_domains, enrichments=all_enrichments)
-
-    @abstractmethod
-    def format(self, context: Context, params: BaseModel, format_input: FormatInput):
-        pass
-
-    def execute(self, context: Context, format_input: FormatInput, params: BaseModel):
-        return self.format(context, params, format_input)
-
-
-class LoadAction(Action, ABC):
-    def __init__(self, description: str):
-        super().__init__(ActionType.LOAD, description, [], [],
-                         (LoadResult, LoadManyResult, ErrorResult, FilterResult, ReinjectResult))
-
-    def build_input(self, context: Context, delta_file_message: DeltaFileMessage):
-        return LoadInput(content=delta_file_message.content_list, metadata=delta_file_message.metadata)
-
-    def collect(self, load_inputs: List[LoadInput]):
-        all_content = []
-        all_metadata = {}
-        for load_input in load_inputs:
-            all_content += load_input.content
-            all_metadata.update(load_input.metadata)
-        return LoadInput(content=all_content, metadata=all_metadata)
-
-    @abstractmethod
-    def load(self, context: Context, params: BaseModel, load_input: LoadInput):
-        pass
-
-    def execute(self, context: Context, load_input: LoadInput, params: BaseModel):
-        return self.load(context, params, load_input)
-
-
-class TimedIngressAction(Action, ABC):
-    def __init__(self, description: str):
-        super().__init__(ActionType.TIMED_INGRESS, description, [], [], (IngressResult, ErrorResult))
-
-    def build_input(self, context: Context, delta_file_message: DeltaFileMessage):
-        return None
-
-    @abstractmethod
-    def ingress(self, context: Context, params: BaseModel):
-        pass
-
-    def execute(self, context: Context, input_placeholder: Any, params: BaseModel):
-        return self.ingress(context, params)
-
-
-class TransformAction(Action, ABC):
-    def __init__(self, description: str):
-        super().__init__(ActionType.TRANSFORM, description, [], [], (TransformResult, ErrorResult, FilterResult, ReinjectResult))
-
-    def build_input(self, context: Context, delta_file_message: DeltaFileMessage):
-        return TransformInput(content=delta_file_message.content_list, metadata=delta_file_message.metadata)
-
-    def collect(self, transform_inputs: List[TransformInput]):
-        all_content = []
-        all_metadata = {}
-        for transform_input in transform_inputs:
-            all_content += transform_input.content
-            all_metadata.update(transform_input.metadata)
-        return TransformInput(content=all_content, metadata=all_metadata)
-
-    @abstractmethod
-    def transform(self, context: Context, params: BaseModel, transform_input: TransformInput):
-        pass
-
-    def execute(self, context: Context, transform_input: TransformInput, params: BaseModel):
-        return self.transform(context, params, transform_input)
-
-
-class ValidateAction(Action, ABC):
-    def __init__(self, description: str):
-        super().__init__(ActionType.VALIDATE, description, [], [], (ValidateResult, ErrorResult, FilterResult))
-
-    def build_input(self, context: Context, delta_file_message: DeltaFileMessage):
-        return ValidateInput(content=delta_file_message.content_list[0], metadata=delta_file_message.metadata)
-
-    @abstractmethod
-    def validate(self, context: Context, params: BaseModel, validate_input: ValidateInput):
-        pass
-
-    def execute(self, context: Context, validate_input: ValidateInput, params: BaseModel):
-        return self.validate(context, params, validate_input)