From b290e500bf5c6b6364c727ea22a2fdce4d9e4a0a Mon Sep 17 00:00:00 2001 From: Maxim V4S Date: Sat, 7 Sep 2024 11:34:55 +0300 Subject: [PATCH] fix: remove types parsing it's implemented in core parameters --- qualibrate_runner/api/routes/submit.py | 8 +- qualibrate_runner/core/types_parsing.py | 220 ------------------------ 2 files changed, 2 insertions(+), 226 deletions(-) delete mode 100644 qualibrate_runner/core/types_parsing.py diff --git a/qualibrate_runner/api/routes/submit.py b/qualibrate_runner/api/routes/submit.py index 3373768..52b7570 100644 --- a/qualibrate_runner/api/routes/submit.py +++ b/qualibrate_runner/api/routes/submit.py @@ -22,7 +22,6 @@ run_workflow, validate_input_parameters, ) -from qualibrate_runner.core.types_parsing import types_conversion submit_router = APIRouter(prefix="/submit") @@ -44,13 +43,10 @@ def submit_node_run( status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail="Already running", ) - converted_parameters = types_conversion( - input_parameters, node.parameters_class.serialize() - ) validate_input_parameters( - cast(Type[BaseModel], node.parameters_class), converted_parameters + cast(Type[BaseModel], node.parameters_class), input_parameters ) - background_tasks.add_task(run_node, node, converted_parameters, state) + background_tasks.add_task(run_node, node, input_parameters, state) return f"Node job {node.name} is submitted" diff --git a/qualibrate_runner/core/types_parsing.py b/qualibrate_runner/core/types_parsing.py deleted file mode 100644 index fe448b6..0000000 --- a/qualibrate_runner/core/types_parsing.py +++ /dev/null @@ -1,220 +0,0 @@ -import sys - -if sys.version_info >= (3, 10): - from types import NoneType -else: - NoneType = type(None) -from typing import Any, Dict, List, Mapping, Optional, Type, Union - -NOT_NONE_BASIC_TYPES = Union[bool, int, float, str] -BASIC_TYPES = Union[NOT_NONE_BASIC_TYPES, NoneType] -LIST_TYPES = Union[List[bool], List[int], List[float], List[str]] -VALUE_TYPES_WITHOUT_REC = Union[BASIC_TYPES, LIST_TYPES] -INPUT_CONVERSION_TYPE = Union[ - VALUE_TYPES_WITHOUT_REC, Dict[str, "INPUT_CONVERSION_TYPE"] -] - - -def parse_bool(value: VALUE_TYPES_WITHOUT_REC) -> VALUE_TYPES_WITHOUT_REC: - if isinstance(value, bool): - return value - if isinstance(value, str): - if value.lower() == "true": - return True - if value.lower() == "false": - return False - return value - if isinstance(value, int): - return value != 0 - if isinstance(value, float): - return abs(value) > 1e-9 - return value - - -def parse_int(value: VALUE_TYPES_WITHOUT_REC) -> VALUE_TYPES_WITHOUT_REC: - if isinstance(value, bool): - return int(value) - if isinstance(value, int): - return value - if isinstance(value, str): - if value.isdigit() or ( - len(value) > 1 and value[0] == "-" and value[1:].isdigit() - ): - return int(value) - return value - if isinstance(value, float): - if value.is_integer(): - return int(value) - return value - return value - - -def parse_float(value: VALUE_TYPES_WITHOUT_REC) -> VALUE_TYPES_WITHOUT_REC: - if isinstance(value, float): - return value - if isinstance(value, int): - return float(value) - if isinstance(value, str): - try: - return float(value) - except ValueError: - return value - return value - - -def parse_str(value: VALUE_TYPES_WITHOUT_REC) -> VALUE_TYPES_WITHOUT_REC: - if ( - isinstance(value, str) - and len(value) > 1 - and ( - (value.startswith('"') and value.endswith('"')) - or (value.startswith("'") and value.endswith("'")) - ) - ): - return value[1:-1] - return value - - -def parse_none(value: VALUE_TYPES_WITHOUT_REC) -> VALUE_TYPES_WITHOUT_REC: - if value is None or (isinstance(value, str) and not value): - return None - return value - - -BASIC_PARSERS = { - int: parse_int, - float: parse_float, - bool: parse_bool, - str: parse_str, - NoneType: parse_none, -} - -STR_TO_TYPE: Mapping[str, Type[BASIC_TYPES]] = { - "integer": int, - "number": float, - "boolean": bool, - "string": str, - "null": NoneType, -} - - -def parse_typed_list( - value: List[Any], item_type: Type[BASIC_TYPES] -) -> LIST_TYPES: - if len(value) == 0: - return value - parser = BASIC_PARSERS[item_type] - try: - return list(map(parser, value)) # type: ignore - except ValueError: - return value - - -def parse_list( - value: VALUE_TYPES_WITHOUT_REC, - item_type: Optional[Type[BASIC_TYPES]], -) -> VALUE_TYPES_WITHOUT_REC: - if isinstance(value, List): - if item_type is None: - return value - return parse_typed_list(value, item_type) - if isinstance(value, str): - stripped = value.strip() - if stripped.startswith("[") and stripped.endswith("]"): - stripped = stripped[1:-1] - splitted = list(map(str.strip, stripped.split(","))) - if item_type is None: - return splitted - return parse_typed_list(splitted, item_type) - return value - - -def types_conversion(value: Any, expected_type: Mapping[str, Any]) -> Any: - if isinstance(value, Mapping): - # has sub items - new = {} - for k, v in value.items(): - if k in expected_type: - new[k] = types_conversion(v, expected_type[k]) - else: - new[k] = v - return new - if "anyOf" in expected_type: - # suppose that only `Type | None` is possible - none = parse_none(value) - if none is None: - return None - expected_type_ = dict(expected_type) - expected_type_["type"] = expected_type_.pop("anyOf")[0]["type"] - return types_conversion(value, expected_type_) - if "type" in expected_type: - if expected_type.get("type") == "array": - # array - item_type: Optional[Type[BASIC_TYPES]] = ( - STR_TO_TYPE.get(expected_type["items"]["type"]) - if "items" in expected_type - else None - ) - return parse_list(value, item_type) - if expected_type.get("type") in STR_TO_TYPE.keys(): - expected = STR_TO_TYPE[expected_type["type"]] - parser = BASIC_PARSERS[expected] - return parser(value) - return value - - -if __name__ == "__main__": - types = { - "targets_name": { - "anyOf": [{"type": "string"}, {"type": "null"}], - "default": None, - "title": "Targets Name", - }, - "str_val": { - "anyOf": [{"type": "string"}, {"type": "null"}], - "default": "a", - "title": "Str Val", - }, - "list_str": { - "default": ["a", "b"], - "items": {"type": "string"}, - "title": "List Str", - "type": "array", - }, - "float_val": {"default": 1.1, "title": "Float Val", "type": "number"}, - "list_float": { - "default": ["a", "b"], - "items": {"type": "number"}, - "title": "List Float", - "type": "array", - }, - "int_val": {"default": 100, "title": "Int Val", "type": "integer"}, - "list_int": { - "default": ["a", "b"], - "items": {"type": "integer"}, - "title": "List Int", - "type": "array", - }, - "bool_val": {"default": False, "title": "Bool Val", "type": "boolean"}, - "list_bool": { - "default": ["a", "b"], - "items": {"type": "boolean"}, - "title": "List Bool", - "type": "array", - }, - "none_val": {"default": None, "title": "None Val", "type": "null"}, - } - types_conversion( - { - # "str_val": "aaa", - # "list_str": "[aa, bb]", - # "float_val": "1.2", - # "list_float": ["1.2","1.3"], - # "int_val": "-1111111", - # "list_int": [1,2,3], - # "bool_val": False, - "list_bool": "[1, 0, True, False, true, false, 1.1, 0.0]", - # "none_val": None - }, - types, - )