test

Author: BotellaA

src/opengeodeweb_back/routes/create/blueprint_create.py

@@ -29,7 +29,7 @@ def create_point() -> flask.Response:
     """Endpoint to create a single point in 3D space."""
     print(f"create_point : {flask.request=}", flush=True)
     utils_functions.validate_request(flask.request, create_point_json)
-    params = CreatePoint.from_dict(flask.request.get_json())
+    params = CreatePoint(**flask.request.get_json())
 
     # Create the point
     class_ = geode_functions.geode_object_class("PointSet3D")
@@ -56,7 +56,7 @@ def create_aoi() -> flask.Response:
     """Endpoint to create an Area of Interest (AOI) as an EdgedCurve3D."""
     print(f"create_aoi : {flask.request=}", flush=True)
     utils_functions.validate_request(flask.request, create_aoi_json)
-    params = CreateAoi.from_dict(flask.request.get_json())
+    params = CreateAoi(**flask.request.get_json())
 
     # Create the edged curve
     class_ = geode_functions.geode_object_class("EdgedCurve3D")
@@ -68,7 +68,7 @@ def create_aoi() -> flask.Response:
     vertex_indices: list[int] = []
     for point in params.points:
         vertex_id = builder.create_point(
-            opengeode.Point3D([point["x"], point["y"], params.z])
+            opengeode.Point3D([point.x, point.y, params.z])
         )
         vertex_indices.append(vertex_id)
 

src/opengeodeweb_back/routes/create/schemas/create_aoi.py

@@ -1,108 +1,18 @@
-from typing import Any, Optional, List, TypeVar, Callable, Type, cast
-
-
-T = TypeVar("T")
-
-
-def from_float(x: Any) -> float:
-    assert isinstance(x, (float, int)) and not isinstance(x, bool)
-    return float(x)
-
-
-def to_float(x: Any) -> float:
-    assert isinstance(x, (int, float))
-    return x
-
-
-def from_str(x: Any) -> str:
-    assert isinstance(x, str)
-    return x
-
-
-def from_none(x: Any) -> Any:
-    assert x is None
-    return x
-
-
-def from_union(fs, x):
-    for f in fs:
-        try:
-            return f(x)
-        except:
-            pass
-    assert False
-
-
-def from_list(f: Callable[[Any], T], x: Any) -> List[T]:
-    assert isinstance(x, list)
-    return [f(y) for y in x]
-
-
-def to_class(c: Type[T], x: Any) -> dict:
-    assert isinstance(x, c)
-    return cast(Any, x).to_dict()
+from dataclasses import dataclass
+from typing import List, Optional
 
 
+@dataclass
 class Point:
     x: float
     y: float
 
-    def __init__(self, x: float, y: float) -> None:
-        self.x = x
-        self.y = y
-
-    @staticmethod
-    def from_dict(obj: Any) -> "Point":
-        assert isinstance(obj, dict)
-        x = from_float(obj.get("x"))
-        y = from_float(obj.get("y"))
-        return Point(x, y)
-
-    def to_dict(self) -> dict:
-        result: dict = {}
-        result["x"] = to_float(self.x)
-        result["y"] = to_float(self.y)
-        return result
-
 
+@dataclass
 class CreateAoi:
-    id: Optional[str]
     name: str
     """Name of the AOI"""
 
     points: List[Point]
     z: float
-
-    def __init__(
-        self, id: Optional[str], name: str, points: List[Point], z: float
-    ) -> None:
-        self.id = id
-        self.name = name
-        self.points = points
-        self.z = z
-
-    @staticmethod
-    def from_dict(obj: Any) -> "CreateAoi":
-        assert isinstance(obj, dict)
-        id = from_union([from_str, from_none], obj.get("id"))
-        name = from_str(obj.get("name"))
-        points = from_list(Point.from_dict, obj.get("points"))
-        z = from_float(obj.get("z"))
-        return CreateAoi(id, name, points, z)
-
-    def to_dict(self) -> dict:
-        result: dict = {}
-        if self.id is not None:
-            result["id"] = from_union([from_str, from_none], self.id)
-        result["name"] = from_str(self.name)
-        result["points"] = from_list(lambda x: to_class(Point, x), self.points)
-        result["z"] = to_float(self.z)
-        return result
-
-
-def create_aoi_from_dict(s: Any) -> CreateAoi:
-    return CreateAoi.from_dict(s)
-
-
-def create_aoi_to_dict(x: CreateAoi) -> Any:
-    return to_class(CreateAoi, x)
+    id: Optional[str] = None

src/opengeodeweb_back/routes/create/schemas/create_point.py

@@ -1,63 +1,9 @@
-# type: ignore
-from typing import Any, TypeVar, Type, cast
-
-
-T = TypeVar("T")
-
-
-def from_str(x: Any) -> str:
-    assert isinstance(x, str)
-    return x
-
-
-def from_float(x: Any) -> float:
-    assert isinstance(x, (float, int)) and not isinstance(x, bool)
-    return float(x)
-
-
-def to_float(x: Any) -> float:
-    assert isinstance(x, (int, float))
-    return x
-
-
-def to_class(c: Type[T], x: Any) -> dict:
-    assert isinstance(x, c)
-    return cast(Any, x).to_dict()
+from dataclasses import dataclass
 
 
+@dataclass
 class CreatePoint:
     name: str
     x: float
     y: float
     z: float
-
-    def __init__(self, name: str, x: float, y: float, z: float) -> None:
-        self.name = name
-        self.x = x
-        self.y = y
-        self.z = z
-
-    @staticmethod
-    def from_dict(obj: Any) -> "CreatePoint":
-        assert isinstance(obj, dict)
-        name = from_str(obj.get("name"))
-        x = from_float(obj.get("x"))
-        y = from_float(obj.get("y"))
-        z = from_float(obj.get("z"))
-        return CreatePoint(name, x, y, z)
-
-    def to_dict(self) -> dict:
-        result: dict = {}
-        result["name"] = from_str(self.name)
-        result["x"] = to_float(self.x)
-        result["y"] = to_float(self.y)
-        result["z"] = to_float(self.z)
-        return result
-
-
-def create_point_from_dict(s: Any) -> CreatePoint:
-    return CreatePoint.from_dict(s)
-
-
-def create_point_to_dict(x: CreatePoint) -> Any:
-    return to_class(CreatePoint, x)

src/opengeodeweb_back/routes/models/schemas/mesh_components.py

@@ -1,41 +1,6 @@
-# type: ignore
-from typing import Any, TypeVar, Type, cast
-
-
-T = TypeVar("T")
-
-
-def from_str(x: Any) -> str:
-    assert isinstance(x, str)
-    return x
-
-
-def to_class(c: Type[T], x: Any) -> dict:
-    assert isinstance(x, c)
-    return cast(Any, x).to_dict()
+from dataclasses import dataclass
 
 
+@dataclass
 class MeshComponents:
     id: str
-
-    def __init__(self, id: str) -> None:
-        self.id = id
-
-    @staticmethod
-    def from_dict(obj: Any) -> "MeshComponents":
-        assert isinstance(obj, dict)
-        id = from_str(obj.get("id"))
-        return MeshComponents(id)
-
-    def to_dict(self) -> dict:
-        result: dict = {}
-        result["id"] = from_str(self.id)
-        return result
-
-
-def mesh_components_from_dict(s: Any) -> MeshComponents:
-    return MeshComponents.from_dict(s)
-
-
-def mesh_components_to_dict(x: MeshComponents) -> Any:
-    return to_class(MeshComponents, x)

src/opengeodeweb_back/routes/models/schemas/vtm_component_indices.py

@@ -1,41 +1,6 @@
-# type: ignore
-from typing import Any, TypeVar, Type, cast
-
-
-T = TypeVar("T")
-
-
-def from_str(x: Any) -> str:
-    assert isinstance(x, str)
-    return x
-
-
-def to_class(c: Type[T], x: Any) -> dict:
-    assert isinstance(x, c)
-    return cast(Any, x).to_dict()
+from dataclasses import dataclass
 
 
+@dataclass
 class VtmComponentIndices:
     id: str
-
-    def __init__(self, id: str) -> None:
-        self.id = id
-
-    @staticmethod
-    def from_dict(obj: Any) -> "VtmComponentIndices":
-        assert isinstance(obj, dict)
-        id = from_str(obj.get("id"))
-        return VtmComponentIndices(id)
-
-    def to_dict(self) -> dict:
-        result: dict = {}
-        result["id"] = from_str(self.id)
-        return result
-
-
-def vtm_component_indices_from_dict(s: Any) -> VtmComponentIndices:
-    return VtmComponentIndices.from_dict(s)
-
-
-def vtm_component_indices_to_dict(x: VtmComponentIndices) -> Any:
-    return to_class(VtmComponentIndices, x)

src/opengeodeweb_back/routes/schemas/allowed_files.py

@@ -1,59 +1,7 @@
-# type: ignore
-from typing import Optional, Any, TypeVar, Type, cast
-
-
-T = TypeVar("T")
-
-
-def from_none(x: Any) -> Any:
-    assert x is None
-    return x
-
-
-def from_str(x: Any) -> str:
-    assert isinstance(x, str)
-    return x
-
-
-def from_union(fs, x):
-    for f in fs:
-        try:
-            return f(x)
-        except:
-            pass
-    assert False
-
-
-def to_class(c: Type[T], x: Any) -> dict:
-    assert isinstance(x, c)
-    return cast(Any, x).to_dict()
+from dataclasses import dataclass
+from typing import Optional
 
 
+@dataclass
 class AllowedFiles:
-    supported_feature: Optional[str]
-
-    def __init__(self, supported_feature: Optional[str]) -> None:
-        self.supported_feature = supported_feature
-
-    @staticmethod
-    def from_dict(obj: Any) -> "AllowedFiles":
-        assert isinstance(obj, dict)
-        supported_feature = from_union(
-            [from_none, from_str], obj.get("supported_feature")
-        )
-        return AllowedFiles(supported_feature)
-
-    def to_dict(self) -> dict:
-        result: dict = {}
-        result["supported_feature"] = from_union(
-            [from_none, from_str], self.supported_feature
-        )
-        return result
-
-
-def allowed_files_from_dict(s: Any) -> AllowedFiles:
-    return AllowedFiles.from_dict(s)
-
-
-def allowed_files_to_dict(x: AllowedFiles) -> Any:
-    return to_class(AllowedFiles, x)
+    supported_feature: Optional[str] = None