From 0e043648d1b862d2a3723bfe266b8b89551a9382 Mon Sep 17 00:00:00 2001 From: Ardt Klapwijk <59741981+ArdtK@users.noreply.github.com> Date: Tue, 23 Jul 2024 13:12:31 +0200 Subject: [PATCH 1/9] chore: first batch --- geolib/models/base_model.py | 18 +-- geolib/models/base_model_structure.py | 28 +--- .../models/dfoundations/dfoundations_model.py | 103 ++++----------- .../dfoundations/dfoundations_structures.py | 44 +++---- geolib/models/dfoundations/internal_soil.py | 67 +++------- geolib/models/dseries_parser.py | 124 ++++++------------ geolib/models/meta.py | 15 +-- geolib/models/utils.py | 19 +-- geolib/utils.py | 13 +- 9 files changed, 120 insertions(+), 311 deletions(-) diff --git a/geolib/models/base_model.py b/geolib/models/base_model.py index 48139160..2af44c3e 100644 --- a/geolib/models/base_model.py +++ b/geolib/models/base_model.py @@ -6,22 +6,13 @@ import abc import logging import os -from abc import abstractmethod, abstractproperty -from pathlib import Path, PosixPath, WindowsPath +from abc import abstractmethod +from pathlib import Path from subprocess import Popen, run -from types import CoroutineType from typing import List, Optional, Type, Union import requests -from pydantic import DirectoryPath, FilePath, HttpUrl, conlist - -from geolib._compat import IS_PYDANTIC_V2 - -if IS_PYDANTIC_V2: - from pydantic import ValidationError -else: - from pydantic.error_wrappers import ValidationError - +from pydantic import DirectoryPath, FilePath, HttpUrl, ValidationError from requests.auth import HTTPBasicAuth from geolib.errors import CalculationError @@ -153,7 +144,8 @@ def console_flags(self) -> List[str]: def console_flags_post(self) -> List[str]: return [] - @abstractproperty + @property + @abstractmethod def parser_provider_type(self) -> Type[BaseParserProvider]: """Returns the parser provider type of the current concrete class. diff --git a/geolib/models/base_model_structure.py b/geolib/models/base_model_structure.py index c6e50896..59420c2c 100644 --- a/geolib/models/base_model_structure.py +++ b/geolib/models/base_model_structure.py @@ -1,12 +1,6 @@ import abc -from math import isfinite -from pydantic import BaseModel - -from geolib._compat import IS_PYDANTIC_V2 - -if IS_PYDANTIC_V2: - from pydantic import ConfigDict +from pydantic import BaseModel, ConfigDict from .meta import MetaData from .validators import BaseValidator @@ -17,20 +11,12 @@ class BaseDataClass(BaseModel): """Base class for *all* pydantic classes in GEOLib.""" - if IS_PYDANTIC_V2: - model_config = ConfigDict( - validate_assignment=True, - arbitrary_types_allowed=True, - validate_default=True, - extra=settings.extra_fields, - ) - else: - - class Config: - validate_assignment = True - arbitrary_types_allowed = True - validate_all = True - extra = settings.extra_fields + model_config = ConfigDict( + validate_assignment=True, + arbitrary_types_allowed=True, + validate_default=True, + extra=settings.extra_fields, + ) class BaseModelStructure(BaseDataClass, abc.ABC): diff --git a/geolib/models/dfoundations/dfoundations_model.py b/geolib/models/dfoundations/dfoundations_model.py index 74b20f79..5f0a8669 100644 --- a/geolib/models/dfoundations/dfoundations_model.py +++ b/geolib/models/dfoundations/dfoundations_model.py @@ -1,21 +1,11 @@ import logging -from enum import Enum from pathlib import Path -from subprocess import CompletedProcess, run from typing import BinaryIO, List, Optional, Type, Union -from pydantic import FilePath +from pydantic import Field, FilePath +from typing_extensions import Annotated -from geolib._compat import IS_PYDANTIC_V2 - -if IS_PYDANTIC_V2: - from pydantic import Field - from typing_extensions import Annotated -else: - from pydantic import confloat, conint - -from geolib.geometry import Point -from geolib.models import BaseDataClass, BaseModel, BaseModelStructure +from geolib.models import BaseDataClass, BaseModel from geolib.models.internal import Bool from geolib.models.meta import CONSOLE_RUN_BATCH_FLAG from geolib.soils import Soil @@ -55,30 +45,14 @@ class ModelOptions(BaseDataClass): is_rigid: Bool = True # Transformation - if IS_PYDANTIC_V2: - max_allowed_settlement_lim_state_str: Annotated[float, Field(ge=0, le=100000)] = 0 - max_allowed_rel_rotation_lim_state_str: Annotated[ - int, Field(ge=1, le=10000) - ] = 100 - max_allowed_settlement_lim_state_serv: Annotated[ - float, Field(ge=0, le=100000) - ] = 0 - max_allowed_rel_rotation_lim_state_serv: Annotated[ - int, Field(ge=1, le=10000) - ] = 300 - # Factors - factor_xi3: Optional[Annotated[float, Field(ge=0.01, le=10)]] = None - factor_xi4: Optional[Annotated[float, Field(ge=0.01, le=10)]] = None - ea_gem: Optional[Annotated[float, Field(ge=1)]] = None - else: - max_allowed_settlement_lim_state_str: confloat(ge=0, le=100000) = 0 - max_allowed_rel_rotation_lim_state_str: conint(ge=1, le=10000) = 100 - max_allowed_settlement_lim_state_serv: confloat(ge=0, le=100000) = 0 - max_allowed_rel_rotation_lim_state_serv: conint(ge=1, le=10000) = 300 - # Factors - factor_xi3: Optional[confloat(ge=0.01, le=10)] = None - factor_xi4: Optional[confloat(ge=0.01, le=10)] = None - ea_gem: Optional[confloat(ge=1)] = None + max_allowed_settlement_lim_state_str: Annotated[float, Field(ge=0, le=100000)] = 0 + max_allowed_rel_rotation_lim_state_str: Annotated[int, Field(ge=1, le=10000)] = 100 + max_allowed_settlement_lim_state_serv: Annotated[float, Field(ge=0, le=100000)] = 0 + max_allowed_rel_rotation_lim_state_serv: Annotated[int, Field(ge=1, le=10000)] = 300 + # Factors + factor_xi3: Optional[Annotated[float, Field(ge=0.01, le=10)]] = None + factor_xi4: Optional[Annotated[float, Field(ge=0.01, le=10)]] = None + ea_gem: Optional[Annotated[float, Field(ge=1)]] = None # Combined Model Options is_suppress_qc_reduction: Bool = False @@ -90,10 +64,7 @@ class ModelOptions(BaseDataClass): use_extra_almere_rules: Bool = False def _to_internal(self): - if IS_PYDANTIC_V2: - return InternalModelOptions(**self.model_dump()) - else: - return InternalModelOptions(**self.dict()) + return InternalModelOptions(**self.model_dump()) @classmethod def model_type(cls): @@ -101,16 +72,10 @@ def model_type(cls): class BearingPilesModel(ModelOptions): - if IS_PYDANTIC_V2: - factor_gamma_b: Optional[Annotated[float, Field(ge=1, le=100)]] = None - factor_gamma_s: Optional[Annotated[float, Field(ge=1, le=100)]] = None - factor_gamma_fnk: Optional[Annotated[float, Field(ge=-100, le=100)]] = None - area: Optional[Annotated[float, Field(ge=0, le=100000)]] = None - else: - factor_gamma_b: Optional[confloat(ge=1, le=100)] = None - factor_gamma_s: Optional[confloat(ge=1, le=100)] = None - factor_gamma_fnk: Optional[confloat(ge=-100, le=100)] = None - area: Optional[confloat(ge=0, le=100000)] = None + factor_gamma_b: Optional[Annotated[float, Field(ge=1, le=100)]] = None + factor_gamma_s: Optional[Annotated[float, Field(ge=1, le=100)]] = None + factor_gamma_fnk: Optional[Annotated[float, Field(ge=-100, le=100)]] = None + area: Optional[Annotated[float, Field(ge=0, le=100000)]] = None @classmethod def model_type(cls): @@ -118,24 +83,14 @@ def model_type(cls): class TensionPilesModel(ModelOptions): - if IS_PYDANTIC_V2: - unit_weight_water: Annotated[float, Field(ge=0.01, le=20)] = 9.81 - use_compaction: Bool = False - surcharge: Annotated[float, Field(ge=0, le=1e7)] = 0 - use_piezometric_levels: Bool = True - - factor_gamma_var: Optional[Annotated[float, Field(ge=0.01, le=100)]] = None - factor_gamma_st: Optional[Annotated[float, Field(ge=0.01, le=100)]] = None - factor_gamma_gamma: Optional[Annotated[float, Field(ge=0.01, le=100)]] = None - else: - unit_weight_water: confloat(ge=0.01, le=20) = 9.81 - use_compaction: Bool = False - surcharge: confloat(ge=0, le=1e7) = 0 - use_piezometric_levels: Bool = True - - factor_gamma_var: Optional[confloat(ge=0.01, le=100)] = None - factor_gamma_st: Optional[confloat(ge=0.01, le=100)] = None - factor_gamma_gamma: Optional[confloat(ge=0.01, le=100)] = None + unit_weight_water: Annotated[float, Field(ge=0.01, le=20)] = 9.81 + use_compaction: Bool = False + surcharge: Annotated[float, Field(ge=0, le=1e7)] = 0 + use_piezometric_levels: Bool = True + + factor_gamma_var: Optional[Annotated[float, Field(ge=0.01, le=100)]] = None + factor_gamma_st: Optional[Annotated[float, Field(ge=0.01, le=100)]] = None + factor_gamma_gamma: Optional[Annotated[float, Field(ge=0.01, le=100)]] = None @classmethod def model_type(cls): @@ -170,10 +125,7 @@ class CalculationOptions(BaseDataClass): trajectory_interval: float = 0.50 def _to_internal(self): - if IS_PYDANTIC_V2: - fields = self.model_dump(exclude=["calculationtype"]) - else: - fields = self.dict(exclude={"calculationtype"}) + fields = self.model_dump(exclude=["calculationtype"]) return PreliminaryDesign(**fields) @@ -214,10 +166,7 @@ def input(self): return self.datastructure.input_data def serialize(self, filename: Union[FilePath, BinaryIO]): - if IS_PYDANTIC_V2: - serializer = DFoundationsInputSerializer(ds=self.datastructure.model_dump()) - else: - serializer = DFoundationsInputSerializer(ds=self.datastructure.dict()) + serializer = DFoundationsInputSerializer(ds=self.datastructure.model_dump()) serializer.write(filename) if isinstance(filename, Path): diff --git a/geolib/models/dfoundations/dfoundations_structures.py b/geolib/models/dfoundations/dfoundations_structures.py index 5641efc6..b5c7f527 100644 --- a/geolib/models/dfoundations/dfoundations_structures.py +++ b/geolib/models/dfoundations/dfoundations_structures.py @@ -3,7 +3,6 @@ import re from typing import Any, Dict, List, Tuple -from geolib._compat import IS_PYDANTIC_V2 from geolib.models.dseries_parser import ( DSerieListGroupNextStructure, DSerieParser, @@ -76,36 +75,26 @@ def parse_text(cls, text): Returns: DSerieStructure: Parsed structure. """ - if IS_PYDANTIC_V2: - - def split_line(text: str) -> List[str]: - parts = [] - for part in re.split(" |\t", text.strip()): - if part == "": - continue - if part.isdigit(): - parts.append(int(part)) - else: - try: - parts.append(float(part)) - except ValueError: - parts.append(part) - return parts - else: - - def split_line(text: str) -> List[str]: - parts = re.split(" |\t", text.strip()) - return list(filter(lambda part: part != "", parts)) + def split_line(text: str) -> List[str]: + parts = [] + for part in re.split(" |\t", text.strip()): + if part == "": + continue + if part.isdigit(): + parts.append(int(part)) + else: + try: + parts.append(float(part)) + except ValueError: + parts.append(part) + return parts table_text = list(DSerieParser.parse_list_group(text).values())[0] table_data = list(DSerieParser.parse_list_group(table_text).values()) if len(table_data) == 0: values_dict_list = table_data - if IS_PYDANTIC_V2: - collection_property_name = list(cls.model_fields.items())[0][0] - else: - collection_property_name = list(cls.__fields__.items())[0][0] + collection_property_name = list(cls.model_fields.items())[0][0] return cls(**{collection_property_name: values_dict_list}) else: # Expected two groups (column_indication and data) @@ -114,10 +103,7 @@ def split_line(text: str) -> List[str]: dict(zip(keys, values)) for values in map(split_line, table_data[1].split("\n")) ] - if IS_PYDANTIC_V2: - collection_property_name = list(cls.model_fields.items())[0][0] - else: - collection_property_name = list(cls.__fields__.items())[0][0] + collection_property_name = list(cls.model_fields.items())[0][0] return cls(**{collection_property_name: values_dict_list}) diff --git a/geolib/models/dfoundations/internal_soil.py b/geolib/models/dfoundations/internal_soil.py index dc115ce8..6a3d4b2c 100644 --- a/geolib/models/dfoundations/internal_soil.py +++ b/geolib/models/dfoundations/internal_soil.py @@ -3,13 +3,8 @@ from pathlib import Path from typing import List -from geolib._compat import IS_PYDANTIC_V2 - -if IS_PYDANTIC_V2: - from pydantic import Field, StringConstraints - from typing_extensions import Annotated -else: - from pydantic import confloat, constr +from pydantic import Field, StringConstraints +from typing_extensions import Annotated from geolib.models.dseries_parser import DSeriesUnmappedNameProperties from geolib.models.internal import Bool @@ -35,51 +30,29 @@ class MaxConeResistType(IntEnum): class Soil(DSeriesUnmappedNameProperties): - if IS_PYDANTIC_V2: - name: Annotated[str, StringConstraints(min_length=1, max_length=25)] - soilcolor: int = 10871211 # could be color - soilsoiltype: SoilTypeNl = SoilTypeNl.SAND - soilgamdry: Annotated[float, Field(ge=0.0, le=100)] = 20.00 - soilgamwet: Annotated[float, Field(ge=0.0, le=100)] = 20.00 - soilinitialvoidratio: Annotated[float, Field(ge=0.0, le=20.0)] = 0.001001 - soildiameterd50: Annotated[float, Field(ge=0.0, le=1000.0)] = 0.20000 - soilminvoidratio: Annotated[float, Field(ge=0.0, le=1.0)] = 0.400 - soilmaxvoidratio: Annotated[float, Field(ge=0.0, le=1.0)] = 0.800 - soilcohesion: Annotated[float, Field(ge=0.0, le=1000.0)] = 30.00 - soilphi: Annotated[float, Field(ge=0.0, le=89.0)] - soilcu: Annotated[float, Field(ge=0.0, le=1000.0)] = 0.00 - soilmaxconeresisttype: MaxConeResistType = MaxConeResistType.STANDARD - soilmaxconeresist: Annotated[float, Field(ge=0.0, le=1000000.0)] = 0.00 - soilusetension: Bool = Bool.TRUE - soilca: Annotated[float, Field(ge=0.0, le=10.0)] = 0.0040000 - soilccindex: Annotated[float, Field(ge=0.0, le=20.0)] = 0.1260000 - else: - name: constr(min_length=1, max_length=25) - soilcolor: int = 10871211 # could be color - soilsoiltype: SoilTypeNl = SoilTypeNl.SAND - soilgamdry: confloat(ge=0.0, le=100) = 20.00 - soilgamwet: confloat(ge=0.0, le=100) = 20.00 - soilinitialvoidratio: confloat(ge=0.0, le=20.0) = 0.001001 - soildiameterd50: confloat(ge=0.0, le=1000.0) = 0.20000 - soilminvoidratio: confloat(ge=0.0, le=1.0) = 0.400 - soilmaxvoidratio: confloat(ge=0.0, le=1.0) = 0.800 - soilcohesion: confloat(ge=0.0, le=1000.0) = 30.00 - soilphi: confloat(ge=0.0, le=89.0) - soilcu: confloat(ge=0.0, le=1000.0) = 0.00 - soilmaxconeresisttype: MaxConeResistType = MaxConeResistType.STANDARD - soilmaxconeresist: confloat(ge=0.0, le=1000000.0) = 0.00 - soilusetension: Bool = Bool.TRUE - soilca: confloat(ge=0.0, le=10.0) = 0.0040000 - soilccindex: confloat(ge=0.0, le=20.0) = 0.1260000 + name: Annotated[str, StringConstraints(min_length=1, max_length=25)] + soilcolor: int = 10871211 # could be color + soilsoiltype: SoilTypeNl = SoilTypeNl.SAND + soilgamdry: Annotated[float, Field(ge=0.0, le=100)] = 20.00 + soilgamwet: Annotated[float, Field(ge=0.0, le=100)] = 20.00 + soilinitialvoidratio: Annotated[float, Field(ge=0.0, le=20.0)] = 0.001001 + soildiameterd50: Annotated[float, Field(ge=0.0, le=1000.0)] = 0.20000 + soilminvoidratio: Annotated[float, Field(ge=0.0, le=1.0)] = 0.400 + soilmaxvoidratio: Annotated[float, Field(ge=0.0, le=1.0)] = 0.800 + soilcohesion: Annotated[float, Field(ge=0.0, le=1000.0)] = 30.00 + soilphi: Annotated[float, Field(ge=0.0, le=89.0)] + soilcu: Annotated[float, Field(ge=0.0, le=1000.0)] = 0.00 + soilmaxconeresisttype: MaxConeResistType = MaxConeResistType.STANDARD + soilmaxconeresist: Annotated[float, Field(ge=0.0, le=1000000.0)] = 0.00 + soilusetension: Bool = Bool.TRUE + soilca: Annotated[float, Field(ge=0.0, le=10.0)] = 0.0040000 + soilccindex: Annotated[float, Field(ge=0.0, le=20.0)] = 0.1260000 def __init__(self, *args, **kwargs): if "name" not in kwargs: name = None for key, value in kwargs.items(): - if IS_PYDANTIC_V2: - fields = self.model_fields - else: - fields = self.__fields__ + fields = self.model_fields if key not in fields: name = key + value break diff --git a/geolib/models/dseries_parser.py b/geolib/models/dseries_parser.py index 6ac6238e..af491503 100644 --- a/geolib/models/dseries_parser.py +++ b/geolib/models/dseries_parser.py @@ -4,33 +4,20 @@ import logging import re import shlex -from abc import abstractclassmethod, abstractmethod +from abc import abstractmethod from itertools import groupby from math import isfinite -from typing import ( - Dict, - Iterable, - List, - Tuple, - Type, - Union, - _GenericAlias, - _SpecialForm, - get_type_hints, -) +from typing import Dict, Iterable, List, Tuple, Type, Union, get_type_hints from pydantic import FilePath -from geolib._compat import IS_PYDANTIC_V2 from geolib.errors import ParserError from geolib.models import BaseDataClass as DataClass from geolib.models.base_model_structure import BaseModelStructure - -from .parsers import BaseParser -from .utils import ( +from geolib.models.parsers import BaseParser +from geolib.models.utils import ( get_args, get_filtered_type_hints, - get_required_class_field, is_list, is_union, unpack_if_union, @@ -168,10 +155,7 @@ def get_structure_required_fields(cls) -> List[Tuple[str, Type]]: return get_filtered_type_hints(cls) def dict(_, *args, **kwargs): - if IS_PYDANTIC_V2: - data = super().model_dump(*args, **kwargs) - else: - data = super().dict(*args, **kwargs) + data = super().model_dump(*args, **kwargs) for __, value in data.items(): if isinstance(value, float) and not isfinite(value): raise ValueError( @@ -207,6 +191,7 @@ class DSerieListGroupNextStructure(DSeriesStructure): of the first element should be ignored by the child parser. """ + @property @abstractclassmethod def group_delimiter(cls) -> str: raise NotImplementedError("Implement in derived classes.") @@ -229,10 +214,7 @@ def parse_text(cls, text: str): else: if not len(elements) == num_elements: raise ParserError(f"Error in parsing in number of elements for {cls}") - if IS_PYDANTIC_V2: - collection_property_name = list(cls.model_fields.items())[0][0] - else: - collection_property_name = list(cls.__fields__.items())[0][0] + collection_property_name = list(cls.model_fields.items())[0][0] return cls(**{collection_property_name: elements}) @@ -333,37 +315,28 @@ def parse_text(cls, text): Returns: DSerieStructure: Parsed structure. """ - if IS_PYDANTIC_V2: - # Changed this code to keep the type of the parsed data. This is needed for the - # tests to pass. Assert does not do type coercion, so asser '7' == 7 will fail. - def split_line(text: str) -> List[str]: - parts = [] - for part in re.split("[ \t]", text.strip()): - if part == "": - continue - if part.isdigit(): - parts.append(int(part)) - else: - try: - parts.append(float(part)) - except ValueError: - parts.append(part) - return parts - - else: - def split_line(text: str) -> List[str]: - parts = re.split("[ \t]", text.strip()) - return list(filter(lambda part: part != "", parts)) + # Changed this code to keep the type of the parsed data. This is needed for the + # tests to pass. Assert does not do type coercion, so asser '7' == 7 will fail. + def split_line(text: str) -> List[str]: + parts = [] + for part in re.split("[ \t]", text.strip()): + if part == "": + continue + if part.isdigit(): + parts.append(int(part)) + else: + try: + parts.append(float(part)) + except ValueError: + parts.append(part) + return parts table_text = list(DSerieParser.parse_list_group(text).values())[0] table_data = list(DSerieParser.parse_list_group(table_text).values()) if len(table_data) == 0: values_dict_list = table_data - if IS_PYDANTIC_V2: - collection_property_name = list(cls.model_fields.items())[0][0] - else: - collection_property_name = list(cls.__fields__.items())[0][0] + collection_property_name = list(cls.model_fields.items())[0][0] return cls(**{collection_property_name: values_dict_list}) else: # Expected two groups (column_indication and data) @@ -374,10 +347,7 @@ def split_line(text: str) -> List[str]: dict(zip(keys, values)) for values in map(split_line, table_data[1].split("\n")) ] - if IS_PYDANTIC_V2: - collection_property_name = list(cls.model_fields.items())[0][0] - else: - collection_property_name = list(cls.__fields__.items())[0][0] + collection_property_name = list(cls.model_fields.items())[0][0] return cls(**{collection_property_name: values_dict_list}) @@ -651,22 +621,13 @@ def get_property_key_value(cls, text: str, expected_property: str) -> Tuple[str, class DSerieVersion(DSeriesInlineMappedProperties): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) - if IS_PYDANTIC_V2: - for k, v in self.model_dump().items(): - if self.model_fields.get(k).get_default() != v: - logger.warning( - """The version of the input file is unsupported. - Check the documentation on how to prevent this warning in the future.""" - ) - return - else: - for k, v in self.dict().items(): - if self.__fields__.get(k).get_default() != v: - logger.warning( - """The version of the input file is unsupported. - Check the documentation on how to prevent this warning in the future.""" - ) - return + for k, v in self.model_dump().items(): + if self.model_fields.get(k).get_default() != v: + logger.warning( + """The version of the input file is unsupported. + Check the documentation on how to prevent this warning in the future.""" + ) + return class DSeriesInlineReversedProperties(DSeriesInlineProperties): @@ -1153,10 +1114,7 @@ def parse_collection_type( @classmethod def parse_text_lines(cls, lines: List[str]) -> Tuple[DSeriesStructure, int]: # Get class types - if IS_PYDANTIC_V2: - collection_property_name = list(cls.model_fields.items())[0][0] - else: - collection_property_name = list(cls.__fields__.items())[0][0] + collection_property_name = list(cls.model_fields.items())[0][0] structure_type = get_field_collection_type(cls, 0) # Parse elements. number_of_structures = cls.get_number_of_structures(lines) @@ -1528,18 +1486,12 @@ def get_field_collection_type(class_type: Type, field_idx: int) -> Type: Returns: Type: The class for the items in the collection. """ - if IS_PYDANTIC_V2: - from typing import get_args - - list_type = list(class_type.model_fields.items())[field_idx][1] - if not get_args(list_type.annotation): - return list_type.annotation - return get_args(list_type.annotation)[0] - else: - list_type = list(class_type.__fields__.items())[field_idx][1] - if not list_type.sub_fields: - return list_type.outer_type_ - return list_type.sub_fields[0].outer_type_ + from typing import get_args + + list_type = list(class_type.model_fields.items())[field_idx][1] + if not get_args(list_type.annotation): + return list_type.annotation + return get_args(list_type.annotation)[0] def is_structure_collection(field: Type) -> bool: diff --git a/geolib/models/meta.py b/geolib/models/meta.py index b57d98c1..9f07589a 100644 --- a/geolib/models/meta.py +++ b/geolib/models/meta.py @@ -15,13 +15,7 @@ from typing import Optional from pydantic import AnyHttpUrl, DirectoryPath - -from geolib._compat import IS_PYDANTIC_V2 - -if IS_PYDANTIC_V2: - from pydantic_settings import BaseSettings, SettingsConfigDict -else: - from pydantic import BaseSettings +from pydantic_settings import BaseSettings, SettingsConfigDict from geolib import __version__ as version @@ -68,9 +62,4 @@ class MetaData(BaseSettings): # of input/output fields. We don't support any other value than "forbid"! extra_fields: str = "forbid" # can be "ignore", "allow" or "forbid" - if IS_PYDANTIC_V2: - model_config = SettingsConfigDict(env_file="geolib.env") - else: - - class Config: - env_file = "geolib.env" + model_config = SettingsConfigDict(env_file="geolib.env") diff --git a/geolib/models/utils.py b/geolib/models/utils.py index 7f2fb1cd..ee8dceb1 100644 --- a/geolib/models/utils.py +++ b/geolib/models/utils.py @@ -3,8 +3,6 @@ from typing import get_args as get_args from typing import get_type_hints -from geolib._compat import IS_PYDANTIC_V2 - def unpack_if_union(tp): if is_union(tp): @@ -46,15 +44,8 @@ def get_required_class_field(class_type: Type) -> List[Tuple[str, Type]]: Returns: List[Tuple[str, Type]]: [description] """ - if IS_PYDANTIC_V2: - return [ - (field_name, field) - for field_name, field in class_type.model_fields.items() - if field.is_required() and not field_name.startswith("__") - ] - else: - return [ - (field_name, field) - for field_name, field in class_type.__fields__.items() - if field.required and not field_name.startswith("__") - ] + return [ + (field_name, field) + for field_name, field in class_type.model_fields.items() + if field.is_required() and not field_name.startswith("__") + ] diff --git a/geolib/utils.py b/geolib/utils.py index b30ae820..0e04e4fd 100644 --- a/geolib/utils.py +++ b/geolib/utils.py @@ -7,14 +7,8 @@ import re from collections import namedtuple from pathlib import Path -from typing import Any -from ._compat import IS_PYDANTIC_V2 - -if IS_PYDANTIC_V2: - from pydantic import field_validator -else: - from pydantic import validator +from pydantic import field_validator _CAMEL_TO_SNAKE_PATTERN = re.compile(r"(? Date: Tue, 23 Jul 2024 13:21:56 +0200 Subject: [PATCH 2/9] chore: second batch --- geolib/models/dfoundations/internal.py | 544 ++++++++----------------- geolib/models/dfoundations/piles.py | 311 ++++---------- geolib/models/dfoundations/profiles.py | 16 +- geolib/models/dseries_parser.py | 2 +- 4 files changed, 259 insertions(+), 614 deletions(-) diff --git a/geolib/models/dfoundations/internal.py b/geolib/models/dfoundations/internal.py index d0d056a1..c692594d 100644 --- a/geolib/models/dfoundations/internal.py +++ b/geolib/models/dfoundations/internal.py @@ -1,17 +1,14 @@ import logging -from enum import Enum, IntEnum +from enum import IntEnum from inspect import cleandoc -from typing import Any, Dict, List, Optional, Tuple, Type, Union +from typing import Dict, List, Optional, Union -from pydantic.types import PositiveInt, confloat, conint, constr +from pydantic import Field, StringConstraints +from pydantic.types import PositiveInt +from typing_extensions import Annotated -from geolib._compat import IS_PYDANTIC_V2 from geolib.models import BaseDataClass -from geolib.models.base_model_structure import BaseModelStructure from geolib.models.dseries_parser import ( - DSerieListStructure, - DSerieMatrixStructure, - DSerieOldTableStructure, DSeriesInlineMappedProperties, DSeriesInlineProperties, DSeriesNoParseSubStructure, @@ -32,10 +29,6 @@ ) from .internal_soil import Soil -if IS_PYDANTIC_V2: - from pydantic import Field, StringConstraints - from typing_extensions import Annotated - logger = logging.getLogger(__name__) @@ -116,163 +109,83 @@ class PileShape(IntEnum): class TypesBearingPiles(DSeriesNoParseSubStructure): - if IS_PYDANTIC_V2: - pile_name: str = "" - pile_type: PileType = PileType.PREFABRICATED_CONCRETE_PILE - pile_type_for_execution_factor_sand_gravel: Optional[PileType] = None - execution_factor_sand_gravel: Optional[Annotated[float, Field(ge=0, le=9)]] = None - pile_type_for_execution_factor_clay_loam_peat: Optional[ - PileTypeForClayLoamPeat - ] = None - execution_factor_clay_loam_peat: Optional[ - Annotated[float, Field(ge=0, le=9)] - ] = None - pile_type_for_pile_class_factor: Optional[PileType] = None - pile_class_factor: Optional[Annotated[float, Field(ge=0, le=9)]] = None - pile_type_for_load_settlement_curve: Optional[LoadSettlementCurve] = None - material: Optional[PileMaterial] = None - elasticity_modulus: Optional[Annotated[float, Field(ge=0, le=1e25)]] = None - slip_layer: BearingPileSlipLayer = BearingPileSlipLayer.NONE - characteristic_adhesion: Optional[Annotated[float, Field(ge=0, le=1000)]] = None - shape: PileShape = PileShape.RECTANGULAR_PILE - base_width: Optional[Annotated[float, Field(ge=0, le=100)]] = None - base_length: Optional[Annotated[float, Field(ge=0, le=100)]] = None - diameter: Optional[Annotated[float, Field(ge=0, le=100)]] = None - base_diameter: Optional[Annotated[float, Field(ge=0, le=100)]] = None - pile_diameter: Optional[Annotated[float, Field(ge=0, le=100)]] = None - base_height: Optional[Annotated[float, Field(ge=0, le=100)]] = None - base_width_v: Optional[Annotated[float, Field(ge=0, le=100)]] = None - base_length_v: Optional[Annotated[float, Field(ge=0, le=100)]] = None - shaft_width: Optional[Annotated[float, Field(ge=0, le=100)]] = None - shaft_length: Optional[Annotated[float, Field(ge=0, le=100)]] = None - increase_in_diameter: Optional[Annotated[float, Field(ge=0, le=100)]] = None - external_diameter: Optional[Annotated[float, Field(ge=0, le=100)]] = None - internal_diameter: Optional[Annotated[float, Field(ge=0, le=100)]] = None - height_h_shape: Optional[Annotated[float, Field(ge=0, le=100)]] = None - width_h_shape: Optional[Annotated[float, Field(ge=0, le=100)]] = None - thickness_web: Optional[Annotated[float, Field(ge=0, le=100)]] = None - thickness_flange: Optional[Annotated[float, Field(ge=0, le=100)]] = None - overrule_pile_tip_shape_factor: Bool = Bool.FALSE - pile_tip_shape_factor: Optional[Annotated[float, Field(ge=0, le=10)]] = None - overrule_pile_tip_cross_section_factors: Bool = Bool.FALSE - pile_tip_cross_section_factor: Optional[ - Annotated[float, Field(ge=0, le=10)] - ] = None - use_pre_2016: Bool = Bool.FALSE - user_defined_pile_type_as_prefab: Bool = Bool.FALSE - use_manual_reduction_for_qc: Bool = Bool.FALSE - reduction_percentage_qc: Annotated[float, Field(ge=25, le=100)] = 25 - is_user_defined: Bool = Bool.TRUE - else: - pile_name: str = "" - pile_type: PileType = PileType.PREFABRICATED_CONCRETE_PILE - pile_type_for_execution_factor_sand_gravel: Optional[PileType] - execution_factor_sand_gravel: Optional[confloat(ge=0, le=9)] - pile_type_for_execution_factor_clay_loam_peat: Optional[PileTypeForClayLoamPeat] - execution_factor_clay_loam_peat: Optional[confloat(ge=0, le=9)] - pile_type_for_pile_class_factor: Optional[PileType] - pile_class_factor: Optional[confloat(ge=0, le=9)] - pile_type_for_load_settlement_curve: Optional[LoadSettlementCurve] - material: Optional[PileMaterial] - elasticity_modulus: Optional[confloat(ge=0, le=1e25)] - slip_layer: BearingPileSlipLayer = BearingPileSlipLayer.NONE - characteristic_adhesion: Optional[confloat(ge=0, le=1000)] - shape: PileShape = PileShape.RECTANGULAR_PILE - base_width: Optional[confloat(ge=0, le=100)] - base_length: Optional[confloat(ge=0, le=100)] - diameter: Optional[confloat(ge=0, le=100)] - base_diameter: Optional[confloat(ge=0, le=100)] - pile_diameter: Optional[confloat(ge=0, le=100)] - base_height: Optional[confloat(ge=0, le=100)] - base_width_v: Optional[confloat(ge=0, le=100)] - base_length_v: Optional[confloat(ge=0, le=100)] - shaft_width: Optional[confloat(ge=0, le=100)] - shaft_length: Optional[confloat(ge=0, le=100)] - increase_in_diameter: Optional[confloat(ge=0, le=100)] - external_diameter: Optional[confloat(ge=0, le=100)] - internal_diameter: Optional[confloat(ge=0, le=100)] - height_h_shape: Optional[confloat(ge=0, le=100)] - width_h_shape: Optional[confloat(ge=0, le=100)] - thickness_web: Optional[confloat(ge=0, le=100)] - thickness_flange: Optional[confloat(ge=0, le=100)] - overrule_pile_tip_shape_factor: Bool = Bool.FALSE - pile_tip_shape_factor: Optional[confloat(ge=0, le=10)] - overrule_pile_tip_cross_section_factors: Bool = Bool.FALSE - pile_tip_cross_section_factor: Optional[confloat(ge=0, le=10)] - use_pre_2016: Bool = Bool.FALSE - user_defined_pile_type_as_prefab: Bool = Bool.FALSE - use_manual_reduction_for_qc: Bool = Bool.FALSE - reduction_percentage_qc: confloat(ge=25, le=100) = 25 - is_user_defined: Bool = Bool.TRUE + pile_name: str = "" + pile_type: PileType = PileType.PREFABRICATED_CONCRETE_PILE + pile_type_for_execution_factor_sand_gravel: Optional[PileType] = None + execution_factor_sand_gravel: Optional[Annotated[float, Field(ge=0, le=9)]] = None + pile_type_for_execution_factor_clay_loam_peat: Optional[ + PileTypeForClayLoamPeat + ] = None + execution_factor_clay_loam_peat: Optional[Annotated[float, Field(ge=0, le=9)]] = None + pile_type_for_pile_class_factor: Optional[PileType] = None + pile_class_factor: Optional[Annotated[float, Field(ge=0, le=9)]] = None + pile_type_for_load_settlement_curve: Optional[LoadSettlementCurve] = None + material: Optional[PileMaterial] = None + elasticity_modulus: Optional[Annotated[float, Field(ge=0, le=1e25)]] = None + slip_layer: BearingPileSlipLayer = BearingPileSlipLayer.NONE + characteristic_adhesion: Optional[Annotated[float, Field(ge=0, le=1000)]] = None + shape: PileShape = PileShape.RECTANGULAR_PILE + base_width: Optional[Annotated[float, Field(ge=0, le=100)]] = None + base_length: Optional[Annotated[float, Field(ge=0, le=100)]] = None + diameter: Optional[Annotated[float, Field(ge=0, le=100)]] = None + base_diameter: Optional[Annotated[float, Field(ge=0, le=100)]] = None + pile_diameter: Optional[Annotated[float, Field(ge=0, le=100)]] = None + base_height: Optional[Annotated[float, Field(ge=0, le=100)]] = None + base_width_v: Optional[Annotated[float, Field(ge=0, le=100)]] = None + base_length_v: Optional[Annotated[float, Field(ge=0, le=100)]] = None + shaft_width: Optional[Annotated[float, Field(ge=0, le=100)]] = None + shaft_length: Optional[Annotated[float, Field(ge=0, le=100)]] = None + increase_in_diameter: Optional[Annotated[float, Field(ge=0, le=100)]] = None + external_diameter: Optional[Annotated[float, Field(ge=0, le=100)]] = None + internal_diameter: Optional[Annotated[float, Field(ge=0, le=100)]] = None + height_h_shape: Optional[Annotated[float, Field(ge=0, le=100)]] = None + width_h_shape: Optional[Annotated[float, Field(ge=0, le=100)]] = None + thickness_web: Optional[Annotated[float, Field(ge=0, le=100)]] = None + thickness_flange: Optional[Annotated[float, Field(ge=0, le=100)]] = None + overrule_pile_tip_shape_factor: Bool = Bool.FALSE + pile_tip_shape_factor: Optional[Annotated[float, Field(ge=0, le=10)]] = None + overrule_pile_tip_cross_section_factors: Bool = Bool.FALSE + pile_tip_cross_section_factor: Optional[Annotated[float, Field(ge=0, le=10)]] = None + use_pre_2016: Bool = Bool.FALSE + user_defined_pile_type_as_prefab: Bool = Bool.FALSE + use_manual_reduction_for_qc: Bool = Bool.FALSE + reduction_percentage_qc: Annotated[float, Field(ge=25, le=100)] = 25 + is_user_defined: Bool = Bool.TRUE class TypesTensionPiles(DSeriesNoParseSubStructure): - if IS_PYDANTIC_V2: - pile_name: str = "" - pile_type: PileType = PileType.PREFABRICATED_CONCRETE_PILE - pile_type_for_execution_factor_sand_gravel: Optional[PileType] = None - execution_factor_sand_gravel: Optional[Annotated[float, Field(ge=0, le=9)]] = None - pile_type_for_execution_factor_clay_loam_peat: Optional[ - PileTypeForClayLoamPeat - ] = None - execution_factor_clay_loam_peat: Optional[ - Annotated[float, Field(ge=0, le=9)] - ] = None - material: Optional[PileMaterial] = None - unit_weight_pile: Optional[Annotated[float, Field(ge=0, le=1000)]] = None - elasticity_modulus: Optional[Annotated[float, Field(ge=0, le=1e25)]] = None - shape: PileShape = PileShape.RECTANGULAR_PILE - base_width: Optional[Annotated[float, Field(ge=0, le=100)]] = None - base_length: Optional[Annotated[float, Field(ge=0, le=100)]] = None - diameter: Optional[Annotated[float, Field(ge=0, le=100)]] = None - base_diameter: Optional[Annotated[float, Field(ge=0, le=100)]] = None - pile_diameter: Optional[Annotated[float, Field(ge=0, le=100)]] = None - base_height: Optional[Annotated[float, Field(ge=0, le=100)]] = None - base_width_v: Optional[Annotated[float, Field(ge=0, le=100)]] = None - base_length_v: Optional[Annotated[float, Field(ge=0, le=100)]] = None - shaft_width: Optional[Annotated[float, Field(ge=0, le=100)]] = None - shaft_length: Optional[Annotated[float, Field(ge=0, le=100)]] = None - increase_in_diameter: Optional[Annotated[float, Field(ge=0, le=100)]] = None - external_diameter: Optional[Annotated[float, Field(ge=0, le=100)]] = None - internal_diameter: Optional[Annotated[float, Field(ge=0, le=100)]] = None - height_h_shape: Optional[Annotated[float, Field(ge=0, le=100)]] = None - width_h_shape: Optional[Annotated[float, Field(ge=0, le=100)]] = None - thickness_web: Optional[Annotated[float, Field(ge=0, le=100)]] = None - thickness_flange: Optional[Annotated[float, Field(ge=0, le=100)]] = None - circumference: Optional[Annotated[float, Field(ge=0, le=100)]] = None - cross_section: Optional[Annotated[float, Field(ge=0, le=100)]] = None - is_user_defined: Bool = Bool.TRUE - else: - pile_name: str = "" - pile_type: PileType = PileType.PREFABRICATED_CONCRETE_PILE - pile_type_for_execution_factor_sand_gravel: Optional[PileType] - execution_factor_sand_gravel: Optional[confloat(ge=0, le=9)] - pile_type_for_execution_factor_clay_loam_peat: Optional[PileTypeForClayLoamPeat] - execution_factor_clay_loam_peat: Optional[confloat(ge=0, le=9)] - material: Optional[PileMaterial] - unit_weight_pile: Optional[confloat(ge=0, le=1000)] - elasticity_modulus: Optional[confloat(ge=0, le=1e25)] - shape: PileShape = PileShape.RECTANGULAR_PILE - base_width: Optional[confloat(ge=0, le=100)] - base_length: Optional[confloat(ge=0, le=100)] - diameter: Optional[confloat(ge=0, le=100)] - base_diameter: Optional[confloat(ge=0, le=100)] - pile_diameter: Optional[confloat(ge=0, le=100)] - base_height: Optional[confloat(ge=0, le=100)] - base_width_v: Optional[confloat(ge=0, le=100)] - base_length_v: Optional[confloat(ge=0, le=100)] - shaft_width: Optional[confloat(ge=0, le=100)] - shaft_length: Optional[confloat(ge=0, le=100)] - increase_in_diameter: Optional[confloat(ge=0, le=100)] - external_diameter: Optional[confloat(ge=0, le=100)] - internal_diameter: Optional[confloat(ge=0, le=100)] - height_h_shape: Optional[confloat(ge=0, le=100)] - width_h_shape: Optional[confloat(ge=0, le=100)] - thickness_web: Optional[confloat(ge=0, le=100)] - thickness_flange: Optional[confloat(ge=0, le=100)] - circumference: Optional[confloat(ge=0, le=100)] - cross_section: Optional[confloat(ge=0, le=100)] - is_user_defined: Bool = Bool.TRUE + pile_name: str = "" + pile_type: PileType = PileType.PREFABRICATED_CONCRETE_PILE + pile_type_for_execution_factor_sand_gravel: Optional[PileType] = None + execution_factor_sand_gravel: Optional[Annotated[float, Field(ge=0, le=9)]] = None + pile_type_for_execution_factor_clay_loam_peat: Optional[ + PileTypeForClayLoamPeat + ] = None + execution_factor_clay_loam_peat: Optional[Annotated[float, Field(ge=0, le=9)]] = None + material: Optional[PileMaterial] = None + unit_weight_pile: Optional[Annotated[float, Field(ge=0, le=1000)]] = None + elasticity_modulus: Optional[Annotated[float, Field(ge=0, le=1e25)]] = None + shape: PileShape = PileShape.RECTANGULAR_PILE + base_width: Optional[Annotated[float, Field(ge=0, le=100)]] = None + base_length: Optional[Annotated[float, Field(ge=0, le=100)]] = None + diameter: Optional[Annotated[float, Field(ge=0, le=100)]] = None + base_diameter: Optional[Annotated[float, Field(ge=0, le=100)]] = None + pile_diameter: Optional[Annotated[float, Field(ge=0, le=100)]] = None + base_height: Optional[Annotated[float, Field(ge=0, le=100)]] = None + base_width_v: Optional[Annotated[float, Field(ge=0, le=100)]] = None + base_length_v: Optional[Annotated[float, Field(ge=0, le=100)]] = None + shaft_width: Optional[Annotated[float, Field(ge=0, le=100)]] = None + shaft_length: Optional[Annotated[float, Field(ge=0, le=100)]] = None + increase_in_diameter: Optional[Annotated[float, Field(ge=0, le=100)]] = None + external_diameter: Optional[Annotated[float, Field(ge=0, le=100)]] = None + internal_diameter: Optional[Annotated[float, Field(ge=0, le=100)]] = None + height_h_shape: Optional[Annotated[float, Field(ge=0, le=100)]] = None + width_h_shape: Optional[Annotated[float, Field(ge=0, le=100)]] = None + thickness_web: Optional[Annotated[float, Field(ge=0, le=100)]] = None + thickness_flange: Optional[Annotated[float, Field(ge=0, le=100)]] = None + circumference: Optional[Annotated[float, Field(ge=0, le=100)]] = None + cross_section: Optional[Annotated[float, Field(ge=0, le=100)]] = None + is_user_defined: Bool = Bool.TRUE class SoilCollection(DSeriesStructureCollection): @@ -373,49 +286,27 @@ def __eq__(self, other): class PositionBearingPile(InternalPile): - if IS_PYDANTIC_V2: - index: PositiveInt = 1 - x_coordinate: Annotated[float, Field(ge=-10000000, le=100000000)] - y_coordinate: Annotated[float, Field(ge=-10000000, le=100000000)] - pile_head_level: Annotated[float, Field(ge=-1000, le=1000)] - surcharge: Annotated[float, Field(ge=0, le=100000)] - limit_state_str: Annotated[float, Field(ge=0, le=100000)] - limit_state_service: Annotated[float, Field(ge=0, le=100000)] - pile_name: Annotated[str, StringConstraints(min_length=1, max_length=100)] - else: - index: PositiveInt = 1 - x_coordinate: confloat(ge=-10000000, le=100000000) - y_coordinate: confloat(ge=-10000000, le=100000000) - pile_head_level: confloat(ge=-1000, le=1000) - surcharge: confloat(ge=0, le=100000) - limit_state_str: confloat(ge=0, le=100000) - limit_state_service: confloat(ge=0, le=100000) - pile_name: constr(min_length=1, max_length=100) + index: PositiveInt = 1 + x_coordinate: Annotated[float, Field(ge=-10000000, le=100000000)] + y_coordinate: Annotated[float, Field(ge=-10000000, le=100000000)] + pile_head_level: Annotated[float, Field(ge=-1000, le=1000)] + surcharge: Annotated[float, Field(ge=0, le=100000)] + limit_state_str: Annotated[float, Field(ge=0, le=100000)] + limit_state_service: Annotated[float, Field(ge=0, le=100000)] + pile_name: Annotated[str, StringConstraints(min_length=1, max_length=100)] class PositionTensionPile(InternalPile): - if IS_PYDANTIC_V2: - index: PositiveInt = 1 - x_coordinate: Annotated[float, Field(ge=-10000000, le=100000000)] - y_coordinate: Annotated[float, Field(ge=-10000000, le=100000000)] - pile_head_level: Annotated[float, Field(ge=-1000, le=1000)] - use_alternating_loads: Bool - max_force: Annotated[float, Field(ge=-100000, le=100000)] - min_force: Annotated[float, Field(ge=-100000, le=100000)] - limit_state_str: Annotated[float, Field(ge=0, le=100000)] - limit_state_service: Annotated[float, Field(ge=0, le=100000)] - pile_name: Annotated[str, StringConstraints(min_length=1, max_length=100)] - else: - index: PositiveInt = 1 - x_coordinate: confloat(ge=-10000000, le=100000000) - y_coordinate: confloat(ge=-10000000, le=100000000) - pile_head_level: confloat(ge=-1000, le=1000) - use_alternating_loads: Bool - max_force: confloat(ge=-100000, le=100000) - min_force: confloat(ge=-100000, le=100000) - limit_state_str: confloat(ge=0, le=100000) - limit_state_service: confloat(ge=0, le=100000) - pile_name: constr(min_length=1, max_length=100) + index: PositiveInt = 1 + x_coordinate: Annotated[float, Field(ge=-10000000, le=100000000)] + y_coordinate: Annotated[float, Field(ge=-10000000, le=100000000)] + pile_head_level: Annotated[float, Field(ge=-1000, le=1000)] + use_alternating_loads: Bool + max_force: Annotated[float, Field(ge=-100000, le=100000)] + min_force: Annotated[float, Field(ge=-100000, le=100000)] + limit_state_str: Annotated[float, Field(ge=0, le=100000)] + limit_state_service: Annotated[float, Field(ge=0, le=100000)] + pile_name: Annotated[str, StringConstraints(min_length=1, max_length=100)] class PositionsBearingPiles(DSeriesNoParseSubStructure): @@ -542,66 +433,32 @@ class CalculationOptions(DSeriesNoParseSubStructure): is_rigid: Bool = Bool.TRUE # Transformation - if IS_PYDANTIC_V2: - max_allowed_settlement_lim_state_str: Annotated[float, Field(ge=0, le=100000)] = 0 - max_allowed_rel_rotation_lim_state_str: Annotated[ - int, Field(ge=1, le=10000) - ] = 100 - max_allowed_settlement_lim_state_serv: Annotated[ - float, Field(ge=0, le=100000) - ] = 0 - max_allowed_rel_rotation_lim_state_serv: Annotated[ - int, Field(ge=1, le=10000) - ] = 300 - else: - max_allowed_settlement_lim_state_str: confloat(ge=0, le=100000) = 0 - max_allowed_rel_rotation_lim_state_str: conint(ge=1, le=10000) = 100 - max_allowed_settlement_lim_state_serv: confloat(ge=0, le=100000) = 0 - max_allowed_rel_rotation_lim_state_serv: conint(ge=1, le=10000) = 300 + max_allowed_settlement_lim_state_str: Annotated[float, Field(ge=0, le=100000)] = 0 + max_allowed_rel_rotation_lim_state_str: Annotated[int, Field(ge=1, le=10000)] = 100 + max_allowed_settlement_lim_state_serv: Annotated[float, Field(ge=0, le=100000)] = 0 + max_allowed_rel_rotation_lim_state_serv: Annotated[int, Field(ge=1, le=10000)] = 300 # Overrule parameters Bearing Piles - if IS_PYDANTIC_V2: - is_xi3_overruled: Bool = Bool.FALSE - factor_xi3: Optional[Annotated[float, Field(ge=0.01, le=10)]] = 2 - is_xi4_overruled: Bool = Bool.FALSE - factor_xi4: Optional[Annotated[float, Field(ge=0.01, le=10)]] = 2 - is_gamma_b_overruled: Bool = Bool.FALSE - factor_gamma_b: Optional[Annotated[float, Field(ge=1, le=100)]] = 2 - is_gamma_s_overruled: Bool = Bool.FALSE - factor_gamma_s: Optional[Annotated[float, Field(ge=1, le=100)]] = 2 - is_gamma_fnk_overruled: Bool = Bool.FALSE - factor_gamma_fnk: Optional[Annotated[float, Field(ge=-100, le=100)]] = 2 - is_area_overruled: Bool = Bool.FALSE - area: Optional[Annotated[float, Field(ge=0, le=100000)]] = 1000 - is_qbmax_overruled: Bool = Bool.FALSE - qbmax: Optional[Annotated[float, Field(ge=0, le=100)]] = 15 - is_qcza_low_overruled: Bool = Bool.FALSE - qcza_low: Optional[Annotated[float, Field(ge=0, le=100)]] = 12 - is_qcza_high_overruled: Bool = Bool.FALSE - qcza_high: Optional[Annotated[float, Field(ge=0, le=100)]] = 15 - is_ea_gem_overruled: Bool = Bool.FALSE - ea_gem: Optional[Annotated[float, Field(ge=1)]] = 100000 - else: - is_xi3_overruled: Bool = Bool.FALSE - factor_xi3: Optional[confloat(ge=0.01, le=10)] = 2 - is_xi4_overruled: Bool = Bool.FALSE - factor_xi4: Optional[confloat(ge=0.01, le=10)] = 2 - is_gamma_b_overruled: Bool = Bool.FALSE - factor_gamma_b: Optional[confloat(ge=1, le=100)] = 2 - is_gamma_s_overruled: Bool = Bool.FALSE - factor_gamma_s: Optional[confloat(ge=1, le=100)] = 2 - is_gamma_fnk_overruled: Bool = Bool.FALSE - factor_gamma_fnk: Optional[confloat(ge=-100, le=100)] = 2 - is_area_overruled: Bool = Bool.FALSE - area: Optional[confloat(ge=0, le=100000)] = 1000 - is_qbmax_overruled: Bool = Bool.FALSE - qbmax: Optional[confloat(ge=0, le=100)] = 15 - is_qcza_low_overruled: Bool = Bool.FALSE - qcza_low: Optional[confloat(ge=0, le=100)] = 12 - is_qcza_high_overruled: Bool = Bool.FALSE - qcza_high: Optional[confloat(ge=0, le=100)] = 15 - is_ea_gem_overruled: Bool = Bool.FALSE - ea_gem: Optional[confloat(ge=1)] = 100000 + is_xi3_overruled: Bool = Bool.FALSE + factor_xi3: Optional[Annotated[float, Field(ge=0.01, le=10)]] = 2 + is_xi4_overruled: Bool = Bool.FALSE + factor_xi4: Optional[Annotated[float, Field(ge=0.01, le=10)]] = 2 + is_gamma_b_overruled: Bool = Bool.FALSE + factor_gamma_b: Optional[Annotated[float, Field(ge=1, le=100)]] = 2 + is_gamma_s_overruled: Bool = Bool.FALSE + factor_gamma_s: Optional[Annotated[float, Field(ge=1, le=100)]] = 2 + is_gamma_fnk_overruled: Bool = Bool.FALSE + factor_gamma_fnk: Optional[Annotated[float, Field(ge=-100, le=100)]] = 2 + is_area_overruled: Bool = Bool.FALSE + area: Optional[Annotated[float, Field(ge=0, le=100000)]] = 1000 + is_qbmax_overruled: Bool = Bool.FALSE + qbmax: Optional[Annotated[float, Field(ge=0, le=100)]] = 15 + is_qcza_low_overruled: Bool = Bool.FALSE + qcza_low: Optional[Annotated[float, Field(ge=0, le=100)]] = 12 + is_qcza_high_overruled: Bool = Bool.FALSE + qcza_high: Optional[Annotated[float, Field(ge=0, le=100)]] = 15 + is_ea_gem_overruled: Bool = Bool.FALSE + ea_gem: Optional[Annotated[float, Field(ge=1)]] = 100000 # Model options combined is_suppress_qc_reduction: Bool = Bool.FALSE @@ -613,66 +470,35 @@ class CalculationOptions(DSeriesNoParseSubStructure): use_extra_almere_rules: Bool = Bool.FALSE # Overrule parameters Shallow foundations - if IS_PYDANTIC_V2: - is_gamma_g_str_overruled: Bool = Bool.FALSE - factor_gamma_g_str: Optional[Annotated[float, Field(ge=0.01, le=100)]] = 1.0 - is_gamma_coh_overruled: Bool = Bool.FALSE - factor_gamma_coh: Optional[Annotated[float, Field(ge=0.01, le=100)]] = 1.0 - is_gamma_phi_overruled: Bool = Bool.FALSE - factor_gamma_phi: Optional[Annotated[float, Field(ge=0.01, le=100)]] = 1.0 - is_gamma_fundr_overruled: Bool = Bool.FALSE - factor_gamma_fundr: Optional[Annotated[float, Field(ge=0.01, le=100)]] = 1.0 - is_gamma_g_sls_overruled: Bool = Bool.FALSE - factor_gamma_g_sls: Optional[Annotated[float, Field(ge=0.01, le=100)]] = 1.0 - is_gamma_cc_overruled: Bool = Bool.FALSE - factor_gamma_cc: Optional[Annotated[float, Field(ge=0.01, le=100)]] = 1.0 - is_gamma_ca_overruled: Bool = Bool.FALSE - factor_gamma_ca: Optional[Annotated[float, Field(ge=0.01, le=100)]] = 1.0 - is_keep_length_constant: Bool = Bool.FALSE - use_5_percent_limit: Bool = Bool.FALSE - load_factor_between_limit_1_and_2: Annotated[float, Field(ge=0.5, le=1)] = 0.833 - else: - is_gamma_g_str_overruled: Bool = Bool.FALSE - factor_gamma_g_str: Optional[confloat(ge=0.01, le=100)] = 1.0 - is_gamma_coh_overruled: Bool = Bool.FALSE - factor_gamma_coh: Optional[confloat(ge=0.01, le=100)] = 1.0 - is_gamma_phi_overruled: Bool = Bool.FALSE - factor_gamma_phi: Optional[confloat(ge=0.01, le=100)] = 1.0 - is_gamma_fundr_overruled: Bool = Bool.FALSE - factor_gamma_fundr: Optional[confloat(ge=0.01, le=100)] = 1.0 - is_gamma_g_sls_overruled: Bool = Bool.FALSE - factor_gamma_g_sls: Optional[confloat(ge=0.01, le=100)] = 1.0 - is_gamma_cc_overruled: Bool = Bool.FALSE - factor_gamma_cc: Optional[confloat(ge=0.01, le=100)] = 1.0 - is_gamma_ca_overruled: Bool = Bool.FALSE - factor_gamma_ca: Optional[confloat(ge=0.01, le=100)] = 1.0 - is_keep_length_constant: Bool = Bool.FALSE - use_5_percent_limit: Bool = Bool.FALSE - load_factor_between_limit_1_and_2: confloat(ge=0.5, le=1) = 0.833 + is_gamma_g_str_overruled: Bool = Bool.FALSE + factor_gamma_g_str: Optional[Annotated[float, Field(ge=0.01, le=100)]] = 1.0 + is_gamma_coh_overruled: Bool = Bool.FALSE + factor_gamma_coh: Optional[Annotated[float, Field(ge=0.01, le=100)]] = 1.0 + is_gamma_phi_overruled: Bool = Bool.FALSE + factor_gamma_phi: Optional[Annotated[float, Field(ge=0.01, le=100)]] = 1.0 + is_gamma_fundr_overruled: Bool = Bool.FALSE + factor_gamma_fundr: Optional[Annotated[float, Field(ge=0.01, le=100)]] = 1.0 + is_gamma_g_sls_overruled: Bool = Bool.FALSE + factor_gamma_g_sls: Optional[Annotated[float, Field(ge=0.01, le=100)]] = 1.0 + is_gamma_cc_overruled: Bool = Bool.FALSE + factor_gamma_cc: Optional[Annotated[float, Field(ge=0.01, le=100)]] = 1.0 + is_gamma_ca_overruled: Bool = Bool.FALSE + factor_gamma_ca: Optional[Annotated[float, Field(ge=0.01, le=100)]] = 1.0 + is_keep_length_constant: Bool = Bool.FALSE + use_5_percent_limit: Bool = Bool.FALSE + load_factor_between_limit_1_and_2: Annotated[float, Field(ge=0.5, le=1)] = 0.833 # Overrule parameters Tension Piles - if IS_PYDANTIC_V2: - unit_weight_water: Annotated[float, Field(ge=0.01, le=20)] = 9.81 - use_compaction: Bool = Bool.FALSE - is_gamma_var_overruled: Bool = Bool.FALSE - factor_gamma_var: Optional[Annotated[float, Field(ge=0.01, le=100)]] = 1.0 - is_gamma_st_overruled: Bool = Bool.FALSE - factor_gamma_st: Optional[Annotated[float, Field(ge=0.01, le=100)]] = 1.0 - is_gamma_gamma_overruled: Bool = Bool.FALSE - factor_gamma_gamma: Optional[Annotated[float, Field(ge=0.01, le=100)]] = 1.0 - surcharge: Annotated[float, Field(ge=0, le=1e7)] = 0 - use_piezometric_levels: Bool = Bool.TRUE - else: - unit_weight_water: confloat(ge=0.01, le=20) = 9.81 - use_compaction: Bool = Bool.FALSE - is_gamma_var_overruled: Bool = Bool.FALSE - factor_gamma_var: Optional[confloat(ge=0.01, le=100)] = 1.0 - is_gamma_st_overruled: Bool = Bool.FALSE - factor_gamma_st: Optional[confloat(ge=0.01, le=100)] = 1.0 - is_gamma_gamma_overruled: Bool = Bool.FALSE - factor_gamma_gamma: Optional[confloat(ge=0.01, le=100)] = 1.0 - surcharge: confloat(ge=0, le=1e7) = 0 - use_piezometric_levels: Bool = Bool.TRUE + unit_weight_water: Annotated[float, Field(ge=0.01, le=20)] = 9.81 + use_compaction: Bool = Bool.FALSE + is_gamma_var_overruled: Bool = Bool.FALSE + factor_gamma_var: Optional[Annotated[float, Field(ge=0.01, le=100)]] = 1.0 + is_gamma_st_overruled: Bool = Bool.FALSE + factor_gamma_st: Optional[Annotated[float, Field(ge=0.01, le=100)]] = 1.0 + is_gamma_gamma_overruled: Bool = Bool.FALSE + factor_gamma_gamma: Optional[Annotated[float, Field(ge=0.01, le=100)]] = 1.0 + surcharge: Annotated[float, Field(ge=0, le=1e7)] = 0 + use_piezometric_levels: Bool = Bool.TRUE def __init__(self, *args, **kwargs): """If defaults are overriden, update @@ -683,10 +509,7 @@ def __init__(self, *args, **kwargs): if value is None: continue # Nones will be passed by default settings toggle_field = self.find_toggle(field) - if IS_PYDANTIC_V2: - fields = self.model_fields - else: - fields = self.__fields__ + fields = self.model_fields if toggle_field in fields: toggles[toggle_field] = Bool.TRUE kwargs.update(toggles) @@ -916,24 +739,14 @@ class DFoundationsGlobalNenResults(DFoundationsInlineProperties): class DFoundationsVerificationResults(DSeriesStructure): - if IS_PYDANTIC_V2: - global_nen_results: Optional[DFoundationsGlobalNenResults] = None - demands_nen__en: Optional[str] = None - nen_pile_results: Optional[DFoundationsNenPileResults] = None - - verification_results_tp_load__settlement_curve_1b: Optional[str] = None - verification_results_tp_1a: Optional[str] = None - verification_results_tp_1b2: Optional[str] = None - verification_results_tp_load__settlement_curve_2: Optional[str] = None - else: - global_nen_results: Optional[DFoundationsGlobalNenResults] - demands_nen__en: Optional[str] - nen_pile_results: Optional[DFoundationsNenPileResults] - - verification_results_tp_load__settlement_curve_1b: Optional[str] - verification_results_tp_1a: Optional[str] - verification_results_tp_1b2: Optional[str] - verification_results_tp_load__settlement_curve_2: Optional[str] + global_nen_results: Optional[DFoundationsGlobalNenResults] = None + demands_nen__en: Optional[str] = None + nen_pile_results: Optional[DFoundationsNenPileResults] = None + + verification_results_tp_load__settlement_curve_1b: Optional[str] = None + verification_results_tp_1a: Optional[str] = None + verification_results_tp_1b2: Optional[str] = None + verification_results_tp_load__settlement_curve_2: Optional[str] = None # endregion @@ -959,40 +772,23 @@ class DFoundationsCalculationWarnings(DSeriesTreeStructure): class DFoundationsDumpfileOutputStructure(DSeriesStructure): - if IS_PYDANTIC_V2: - results_at_cpt_test_level: Optional[str] = None - verification_results: Optional[DFoundationsVerificationResults] = None - - calculation_parameters_tension_piles: Optional[str] = None - verification_results_tp: Optional[DFoundationsVerificationResults] = None - - footnote_warnings: Optional[str] = None - preliminary_design_results: Optional[str] = None - verification_results_sf: Optional[str] = None - verification_results_tp_1b2: Optional[str] = None - verification_design_results: Optional[str] = None - calculation_warnings: Optional[DFoundationsCalculationWarnings] = None - else: - results_at_cpt_test_level: Optional[str] - verification_results: Optional[DFoundationsVerificationResults] - - calculation_parameters_tension_piles: Optional[str] - verification_results_tp: Optional[DFoundationsVerificationResults] - - footnote_warnings: Optional[str] - preliminary_design_results: Optional[str] - verification_results_sf: Optional[str] - verification_results_tp_1b2: Optional[str] - verification_design_results: Optional[str] - calculation_warnings: Optional[DFoundationsCalculationWarnings] + results_at_cpt_test_level: Optional[str] = None + verification_results: Optional[DFoundationsVerificationResults] = None + + calculation_parameters_tension_piles: Optional[str] = None + verification_results_tp: Optional[DFoundationsVerificationResults] = None + + footnote_warnings: Optional[str] = None + preliminary_design_results: Optional[str] = None + verification_results_sf: Optional[str] = None + verification_results_tp_1b2: Optional[str] = None + verification_design_results: Optional[str] = None + calculation_warnings: Optional[DFoundationsCalculationWarnings] = None class DFoundationsStructure(DSeriesStructure): input_data: DFoundationsInputStructure = DFoundationsInputStructure() - if IS_PYDANTIC_V2: - dumpfile_output: Optional[DFoundationsDumpfileOutputStructure] = None - else: - dumpfile_output: Optional[DFoundationsDumpfileOutputStructure] + dumpfile_output: Optional[DFoundationsDumpfileOutputStructure] = None class DFoundationsDumpStructure(DSeriesStructure): diff --git a/geolib/models/dfoundations/piles.py b/geolib/models/dfoundations/piles.py index c073805f..53212afd 100644 --- a/geolib/models/dfoundations/piles.py +++ b/geolib/models/dfoundations/piles.py @@ -4,9 +4,10 @@ from enum import Enum from typing import Optional -from pydantic.types import PositiveInt, confloat, constr +from pydantic import Field, StringConstraints +from pydantic.types import PositiveInt +from typing_extensions import Annotated -from geolib._compat import IS_PYDANTIC_V2 from geolib.geometry import Point from geolib.models import BaseDataClass @@ -23,26 +24,15 @@ TypesTensionPiles, ) -if IS_PYDANTIC_V2: - from pydantic import Field, StringConstraints - from typing_extensions import Annotated - class PileLocation(BaseDataClass): """Base Class for Pile location.""" - if IS_PYDANTIC_V2: - pile_name: Annotated[str, StringConstraints(min_length=0, max_length=100)] = "" - point: Point - pile_head_level: Annotated[float, Field(ge=-1000, le=1000)] - limit_state_str: Annotated[float, Field(ge=0, le=100000)] - limit_state_service: Annotated[float, Field(ge=0, le=100000)] - else: - pile_name: constr(min_length=0, max_length=100) = "" - point: Point - pile_head_level: confloat(ge=-1000, le=1000) - limit_state_str: confloat(ge=0, le=100000) - limit_state_service: confloat(ge=0, le=100000) + pile_name: Annotated[str, StringConstraints(min_length=0, max_length=100)] = "" + point: Point + pile_head_level: Annotated[float, Field(ge=-1000, le=1000)] + limit_state_str: Annotated[float, Field(ge=0, le=100000)] + limit_state_service: Annotated[float, Field(ge=0, le=100000)] def _to_internal(self, index: PositiveInt): return { @@ -59,10 +49,7 @@ def _to_internal(self, index: PositiveInt): class BearingPileLocation(PileLocation): """Inherits :class:`~geolib.models.dfoundations.piles.PileLocation`.""" - if IS_PYDANTIC_V2: - surcharge: Annotated[float, Field(ge=0, le=100000)] - else: - surcharge: confloat(ge=0, le=100000) + surcharge: Annotated[float, Field(ge=0, le=100000)] def _to_internal(self, index: PositiveInt): pile_location = super()._to_internal(index) @@ -73,12 +60,8 @@ class TensionPileLocation(PileLocation): """Inherits :class:`~geolib.models.dfoundations.piles.PileLocation`.""" use_alternating_loads: bool - if IS_PYDANTIC_V2: - max_force: Annotated[float, Field(ge=-100000, le=100000)] - min_force: Annotated[float, Field(ge=-100000, le=100000)] - else: - max_force: confloat(ge=-100000, le=100000) - min_force: confloat(ge=-100000, le=100000) + max_force: Annotated[float, Field(ge=-100000, le=100000)] + min_force: Annotated[float, Field(ge=-100000, le=100000)] def _to_internal(self, index: PositiveInt): pile_location = super()._to_internal(index) @@ -109,49 +92,28 @@ class Pile(BaseDataClass): pile_name: str pile_type: BasePileType - if IS_PYDANTIC_V2: - pile_class_factor_shaft_sand_gravel: Annotated[float, Field(ge=0, le=9)] - pile_class_factor_shaft_clay_loam_peat: Optional[ - Annotated[float, Field(ge=0, le=9)] - ] = None - preset_pile_class_factor_shaft_clay_loam_peat: BasePileTypeForClayLoamPeat - elasticity_modulus: Annotated[float, Field(ge=0, le=1e25)] - else: - pile_class_factor_shaft_sand_gravel: confloat(ge=0, le=9) - pile_class_factor_shaft_clay_loam_peat: Optional[confloat(ge=0, le=9)] - preset_pile_class_factor_shaft_clay_loam_peat: BasePileTypeForClayLoamPeat - elasticity_modulus: confloat(ge=0, le=1e25) + pile_class_factor_shaft_sand_gravel: Annotated[float, Field(ge=0, le=9)] + pile_class_factor_shaft_clay_loam_peat: Optional[ + Annotated[float, Field(ge=0, le=9)] + ] = None + preset_pile_class_factor_shaft_clay_loam_peat: BasePileTypeForClayLoamPeat + elasticity_modulus: Annotated[float, Field(ge=0, le=1e25)] class BearingPile(Pile): """Inherits :class:`~geolib.models.dfoundations.piles.Pile`.""" - if IS_PYDANTIC_V2: - pile_class_factor_tip: Annotated[float, Field(ge=0, le=9)] - load_settlement_curve: LoadSettlementCurve - user_defined_pile_type_as_prefab: bool - use_manual_reduction_for_qc: bool - reduction_percentage_qc: Annotated[float, Field(ge=25, le=100)] = 25 - characteristic_adhesion: Annotated[float, Field(ge=0, le=1000)] - - overrule_pile_tip_shape_factor: bool - pile_tip_shape_factor: Optional[Annotated[float, Field(ge=0, le=10)]] = None - overrule_pile_tip_cross_section_factors: bool - pile_tip_cross_section_factor: Optional[ - Annotated[float, Field(ge=0, le=10)] - ] = None - else: - pile_class_factor_tip: confloat(ge=0, le=9) - load_settlement_curve: LoadSettlementCurve - user_defined_pile_type_as_prefab: bool - use_manual_reduction_for_qc: bool - reduction_percentage_qc: confloat(ge=25, le=100) = 25 - characteristic_adhesion: confloat(ge=0, le=1000) - - overrule_pile_tip_shape_factor: bool - pile_tip_shape_factor: Optional[confloat(ge=0, le=10)] - overrule_pile_tip_cross_section_factors: bool - pile_tip_cross_section_factor: Optional[confloat(ge=0, le=10)] + pile_class_factor_tip: Annotated[float, Field(ge=0, le=9)] + load_settlement_curve: LoadSettlementCurve + user_defined_pile_type_as_prefab: bool + use_manual_reduction_for_qc: bool + reduction_percentage_qc: Annotated[float, Field(ge=25, le=100)] = 25 + characteristic_adhesion: Annotated[float, Field(ge=0, le=1000)] + + overrule_pile_tip_shape_factor: bool + pile_tip_shape_factor: Optional[Annotated[float, Field(ge=0, le=10)]] = None + overrule_pile_tip_cross_section_factors: bool + pile_tip_cross_section_factor: Optional[Annotated[float, Field(ge=0, le=10)]] = None def _to_internal(self): return TypesBearingPiles( @@ -187,10 +149,7 @@ def _to_internal(self): class TensionPile(Pile): """Inherits :class:`~geolib.models.dfoundations.piles.Pile`.""" - if IS_PYDANTIC_V2: - unit_weight_pile: Annotated[float, Field(ge=0, le=1000)] - else: - unit_weight_pile: confloat(ge=0, le=1000) + unit_weight_pile: Annotated[float, Field(ge=0, le=1000)] def _to_internal(self): return TypesTensionPiles( @@ -210,10 +169,7 @@ def _to_internal(self): class BearingRoundPile(BearingPile): """Inherits :class:`~geolib.models.dfoundations.piles.BearingPile`.""" - if IS_PYDANTIC_V2: - diameter: Annotated[float, Field(ge=0, le=100)] - else: - diameter: confloat(ge=0, le=100) + diameter: Annotated[float, Field(ge=0, le=100)] def _to_internal(self): types_bearing_pile = super()._to_internal() @@ -225,10 +181,7 @@ def _to_internal(self): class TensionRoundPile(TensionPile): """Inherits :class:`~geolib.models.dfoundations.piles.TensionPile`.""" - if IS_PYDANTIC_V2: - diameter: Annotated[float, Field(ge=0, le=100)] - else: - diameter: confloat(ge=0, le=100) + diameter: Annotated[float, Field(ge=0, le=100)] def _to_internal(self): types_tension_pile = super()._to_internal() @@ -240,12 +193,8 @@ def _to_internal(self): class BearingRectangularPile(BearingPile): """Inherits :class:`~geolib.models.dfoundations.piles.BearingPile`.""" - if IS_PYDANTIC_V2: - base_width: Annotated[float, Field(ge=0, le=100)] - base_length: Annotated[float, Field(ge=0, le=100)] - else: - base_width: confloat(ge=0, le=100) - base_length: confloat(ge=0, le=100) + base_width: Annotated[float, Field(ge=0, le=100)] + base_length: Annotated[float, Field(ge=0, le=100)] def _to_internal(self): types_bearing_pile = super()._to_internal() @@ -258,12 +207,8 @@ def _to_internal(self): class TensionRectangularPile(TensionPile): """Inherits :class:`~geolib.models.dfoundations.piles.TensionPile`.""" - if IS_PYDANTIC_V2: - base_width: Annotated[float, Field(ge=0, le=100)] - base_length: Annotated[float, Field(ge=0, le=100)] - else: - base_width: confloat(ge=0, le=100) - base_length: confloat(ge=0, le=100) + base_width: Annotated[float, Field(ge=0, le=100)] + base_length: Annotated[float, Field(ge=0, le=100)] def _to_internal(self): types_tension_pile = super()._to_internal() @@ -276,14 +221,9 @@ def _to_internal(self): class BearingRoundPileWithEnlargedBase(BearingPile): """Inherits :class:`~geolib.models.dfoundations.piles.BearingPile`.""" - if IS_PYDANTIC_V2: - base_diameter: Annotated[float, Field(ge=0, le=100)] - pile_diameter: Annotated[float, Field(ge=0, le=100)] - base_height: Annotated[float, Field(ge=0, le=100)] - else: - base_diameter: confloat(ge=0, le=100) - pile_diameter: confloat(ge=0, le=100) - base_height: confloat(ge=0, le=100) + base_diameter: Annotated[float, Field(ge=0, le=100)] + pile_diameter: Annotated[float, Field(ge=0, le=100)] + base_height: Annotated[float, Field(ge=0, le=100)] def _to_internal(self): types_bearing_pile = super()._to_internal() @@ -297,14 +237,9 @@ def _to_internal(self): class TensionRoundPileWithEnlargedBase(TensionPile): """Inherits :class:`~geolib.models.dfoundations.piles.TensionPile`.""" - if IS_PYDANTIC_V2: - base_diameter: Annotated[float, Field(ge=0, le=100)] - pile_diameter: Annotated[float, Field(ge=0, le=100)] - base_height: Annotated[float, Field(ge=0, le=100)] - else: - base_diameter: confloat(ge=0, le=100) - pile_diameter: confloat(ge=0, le=100) - base_height: confloat(ge=0, le=100) + base_diameter: Annotated[float, Field(ge=0, le=100)] + pile_diameter: Annotated[float, Field(ge=0, le=100)] + base_height: Annotated[float, Field(ge=0, le=100)] def _to_internal(self): types_tension_pile = super()._to_internal() @@ -318,18 +253,11 @@ def _to_internal(self): class BearingRectangularPileWithEnlargedBase(BearingPile): """Inherits :class:`~geolib.models.dfoundations.piles.BearingPile`.""" - if IS_PYDANTIC_V2: - base_width_v: Annotated[float, Field(ge=0, le=100)] - base_length_v: Annotated[float, Field(ge=0, le=100)] - base_height: Annotated[float, Field(ge=0, le=100)] - shaft_width: Annotated[float, Field(ge=0, le=100)] - shaft_length: Annotated[float, Field(ge=0, le=100)] - else: - base_width_v: confloat(ge=0, le=100) - base_length_v: confloat(ge=0, le=100) - base_height: confloat(ge=0, le=100) - shaft_width: confloat(ge=0, le=100) - shaft_length: confloat(ge=0, le=100) + base_width_v: Annotated[float, Field(ge=0, le=100)] + base_length_v: Annotated[float, Field(ge=0, le=100)] + base_height: Annotated[float, Field(ge=0, le=100)] + shaft_width: Annotated[float, Field(ge=0, le=100)] + shaft_length: Annotated[float, Field(ge=0, le=100)] def _to_internal(self): types_bearing_pile = super()._to_internal() @@ -345,18 +273,11 @@ def _to_internal(self): class TensionRectangularPileWithEnlargedBase(TensionPile): """Inherits :class:`~geolib.models.dfoundations.piles.TensionPile`.""" - if IS_PYDANTIC_V2: - base_width_v: Annotated[float, Field(ge=0, le=100)] - base_length_v: Annotated[float, Field(ge=0, le=100)] - base_height: Annotated[float, Field(ge=0, le=100)] - shaft_width: Annotated[float, Field(ge=0, le=100)] - shaft_length: Annotated[float, Field(ge=0, le=100)] - else: - base_width_v: confloat(ge=0, le=100) - base_length_v: confloat(ge=0, le=100) - base_height: confloat(ge=0, le=100) - shaft_width: confloat(ge=0, le=100) - shaft_length: confloat(ge=0, le=100) + base_width_v: Annotated[float, Field(ge=0, le=100)] + base_length_v: Annotated[float, Field(ge=0, le=100)] + base_height: Annotated[float, Field(ge=0, le=100)] + shaft_width: Annotated[float, Field(ge=0, le=100)] + shaft_length: Annotated[float, Field(ge=0, le=100)] def _to_internal(self): types_tension_pile = super()._to_internal() @@ -372,12 +293,8 @@ def _to_internal(self): class BearingRoundTaperedPile(BearingPile): """Inherits :class:`~geolib.models.dfoundations.piles.BearingPile`.""" - if IS_PYDANTIC_V2: - diameter_at_pile_tip: Annotated[float, Field(ge=0, le=100)] - increase_in_diameter: Annotated[float, Field(ge=0, le=100)] - else: - diameter_at_pile_tip: confloat(ge=0, le=100) - increase_in_diameter: confloat(ge=0, le=100) + diameter_at_pile_tip: Annotated[float, Field(ge=0, le=100)] + increase_in_diameter: Annotated[float, Field(ge=0, le=100)] def _to_internal(self): types_bearing_pile = super()._to_internal() @@ -390,12 +307,8 @@ def _to_internal(self): class TensionRoundTaperedPile(TensionPile): """Inherits :class:`~geolib.models.dfoundations.piles.TensionPile`.""" - if IS_PYDANTIC_V2: - diameter_at_pile_tip: Annotated[float, Field(ge=0, le=100)] - increase_in_diameter: Annotated[float, Field(ge=0, le=100)] - else: - diameter_at_pile_tip: confloat(ge=0, le=100) - increase_in_diameter: confloat(ge=0, le=100) + diameter_at_pile_tip: Annotated[float, Field(ge=0, le=100)] + increase_in_diameter: Annotated[float, Field(ge=0, le=100)] def _to_internal(self): types_tension_pile = super()._to_internal() @@ -408,12 +321,8 @@ def _to_internal(self): class BearingRoundHollowPileWithClosedBase(BearingPile): """Inherits :class:`~geolib.models.dfoundations.piles.BearingPile`.""" - if IS_PYDANTIC_V2: - external_diameter: Annotated[float, Field(ge=0, le=100)] - wall_thickness: Annotated[float, Field(ge=0, le=100)] - else: - external_diameter: confloat(ge=0, le=100) - wall_thickness: confloat(ge=0, le=100) + external_diameter: Annotated[float, Field(ge=0, le=100)] + wall_thickness: Annotated[float, Field(ge=0, le=100)] def _to_internal(self): types_bearing_pile = super()._to_internal() @@ -428,12 +337,8 @@ def _to_internal(self): class TensionRoundHollowPileWithClosedBase(TensionPile): """Inherits :class:`~geolib.models.dfoundations.piles.TensionPile`.""" - if IS_PYDANTIC_V2: - external_diameter: Annotated[float, Field(ge=0, le=100)] - wall_thickness: Annotated[float, Field(ge=0, le=100)] - else: - external_diameter: confloat(ge=0, le=100) - wall_thickness: confloat(ge=0, le=100) + external_diameter: Annotated[float, Field(ge=0, le=100)] + wall_thickness: Annotated[float, Field(ge=0, le=100)] def _to_internal(self): types_tension_pile = super()._to_internal() @@ -448,12 +353,8 @@ def _to_internal(self): class BearingRoundPileWithLostTip(BearingPile): """Inherits :class:`~geolib.models.dfoundations.piles.BearingPile`.""" - if IS_PYDANTIC_V2: - base_diameter: Annotated[float, Field(ge=0, le=100)] - pile_diameter: Annotated[float, Field(ge=0, le=100)] - else: - base_diameter: confloat(ge=0, le=100) - pile_diameter: confloat(ge=0, le=100) + base_diameter: Annotated[float, Field(ge=0, le=100)] + pile_diameter: Annotated[float, Field(ge=0, le=100)] def _to_internal(self): types_bearing_pile = super()._to_internal() @@ -466,12 +367,8 @@ def _to_internal(self): class TensionRoundPileWithLostTip(TensionPile): """Inherits :class:`~geolib.models.dfoundations.piles.TensionPile`.""" - if IS_PYDANTIC_V2: - base_diameter: Annotated[float, Field(ge=0, le=100)] - pile_diameter: Annotated[float, Field(ge=0, le=100)] - else: - base_diameter: confloat(ge=0, le=100) - pile_diameter: confloat(ge=0, le=100) + base_diameter: Annotated[float, Field(ge=0, le=100)] + pile_diameter: Annotated[float, Field(ge=0, le=100)] def _to_internal(self): types_tension_pile = super()._to_internal() @@ -484,14 +381,9 @@ def _to_internal(self): class BearingRoundPileWithInSituFormedBase(BearingPile): """Inherits :class:`~geolib.models.dfoundations.piles.BearingPile`.""" - if IS_PYDANTIC_V2: - base_diameter: Annotated[float, Field(ge=0, le=100)] - pile_diameter: Annotated[float, Field(ge=0, le=100)] - base_height: Annotated[float, Field(ge=0, le=100)] - else: - base_diameter: confloat(ge=0, le=100) - pile_diameter: confloat(ge=0, le=100) - base_height: confloat(ge=0, le=100) + base_diameter: Annotated[float, Field(ge=0, le=100)] + pile_diameter: Annotated[float, Field(ge=0, le=100)] + base_height: Annotated[float, Field(ge=0, le=100)] def _to_internal(self): types_bearing_pile = super()._to_internal() @@ -505,14 +397,9 @@ def _to_internal(self): class TensionRoundPileWithInSituFormedBase(TensionPile): """Inherits :class:`~geolib.models.dfoundations.piles.TensionPile`.""" - if IS_PYDANTIC_V2: - base_diameter: Annotated[float, Field(ge=0, le=100)] - pile_diameter: Annotated[float, Field(ge=0, le=100)] - base_height: Annotated[float, Field(ge=0, le=100)] - else: - base_diameter: confloat(ge=0, le=100) - pile_diameter: confloat(ge=0, le=100) - base_height: confloat(ge=0, le=100) + base_diameter: Annotated[float, Field(ge=0, le=100)] + pile_diameter: Annotated[float, Field(ge=0, le=100)] + base_height: Annotated[float, Field(ge=0, le=100)] def _to_internal(self): types_tension_pile = super()._to_internal() @@ -526,12 +413,8 @@ def _to_internal(self): class BearingSection(BearingPile): """Inherits :class:`~geolib.models.dfoundations.piles.BearingPile`.""" - if IS_PYDANTIC_V2: - base_width: Annotated[float, Field(ge=0, le=100)] - base_length: Annotated[float, Field(ge=0, le=100)] - else: - base_width: confloat(ge=0, le=100) - base_length: confloat(ge=0, le=100) + base_width: Annotated[float, Field(ge=0, le=100)] + base_length: Annotated[float, Field(ge=0, le=100)] def _to_internal(self): types_bearing_pile = super()._to_internal() @@ -544,12 +427,8 @@ def _to_internal(self): class TensionSection(TensionPile): """Inherits :class:`~geolib.models.dfoundations.piles.TensionPile`.""" - if IS_PYDANTIC_V2: - circumference: Annotated[float, Field(ge=0, le=100)] - cross_section: Annotated[float, Field(ge=0, le=100)] - else: - circumference: confloat(ge=0, le=100) - cross_section: confloat(ge=0, le=100) + circumference: Annotated[float, Field(ge=0, le=100)] + cross_section: Annotated[float, Field(ge=0, le=100)] def _to_internal(self): types_tension_pile = super()._to_internal() @@ -562,12 +441,8 @@ def _to_internal(self): class BearingRoundOpenEndedHollowPile(BearingPile): """Inherits :class:`~geolib.models.dfoundations.piles.BearingPile`.""" - if IS_PYDANTIC_V2: - external_diameter: Annotated[float, Field(ge=0, le=100)] - wall_thickness: Annotated[float, Field(ge=0, le=100)] - else: - external_diameter: confloat(ge=0, le=100) - wall_thickness: confloat(ge=0, le=100) + external_diameter: Annotated[float, Field(ge=0, le=100)] + wall_thickness: Annotated[float, Field(ge=0, le=100)] def _to_internal(self): types_bearing_pile = super()._to_internal() @@ -582,12 +457,8 @@ def _to_internal(self): class TensionRoundOpenEndedHollowPile(TensionPile): """Inherits :class:`~geolib.models.dfoundations.piles.TensionPile`.""" - if IS_PYDANTIC_V2: - external_diameter: Annotated[float, Field(ge=0, le=100)] - wall_thickness: Annotated[float, Field(ge=0, le=100)] - else: - external_diameter: confloat(ge=0, le=100) - wall_thickness: confloat(ge=0, le=100) + external_diameter: Annotated[float, Field(ge=0, le=100)] + wall_thickness: Annotated[float, Field(ge=0, le=100)] def _to_internal(self): types_tension_pile = super()._to_internal() @@ -602,16 +473,10 @@ def _to_internal(self): class BearingHShapedPile(BearingPile): """Inherits :class:`~geolib.models.dfoundations.piles.BearingPile`.""" - if IS_PYDANTIC_V2: - height_h_shape: Annotated[float, Field(ge=0, le=100)] - width_h_shape: Annotated[float, Field(ge=0, le=100)] - thickness_web: Annotated[float, Field(ge=0, le=100)] - thickness_flange: Annotated[float, Field(ge=0, le=100)] - else: - height_h_shape: confloat(ge=0, le=100) - width_h_shape: confloat(ge=0, le=100) - thickness_web: confloat(ge=0, le=100) - thickness_flange: confloat(ge=0, le=100) + height_h_shape: Annotated[float, Field(ge=0, le=100)] + width_h_shape: Annotated[float, Field(ge=0, le=100)] + thickness_web: Annotated[float, Field(ge=0, le=100)] + thickness_flange: Annotated[float, Field(ge=0, le=100)] def _to_internal(self): types_bearing_pile = super()._to_internal() @@ -626,16 +491,10 @@ def _to_internal(self): class TensionHShapedPile(TensionPile): """Inherits :class:`~geolib.models.dfoundations.piles.TensionPile`.""" - if IS_PYDANTIC_V2: - height_h_shape: Annotated[float, Field(ge=0, le=100)] - width_h_shape: Annotated[float, Field(ge=0, le=100)] - thickness_web: Annotated[float, Field(ge=0, le=100)] - thickness_flange: Annotated[float, Field(ge=0, le=100)] - else: - height_h_shape: confloat(ge=0, le=100) - width_h_shape: confloat(ge=0, le=100) - thickness_web: confloat(ge=0, le=100) - thickness_flange: confloat(ge=0, le=100) + height_h_shape: Annotated[float, Field(ge=0, le=100)] + width_h_shape: Annotated[float, Field(ge=0, le=100)] + thickness_web: Annotated[float, Field(ge=0, le=100)] + thickness_flange: Annotated[float, Field(ge=0, le=100)] def _to_internal(self): types_tension_pile = super()._to_internal() diff --git a/geolib/models/dfoundations/profiles.py b/geolib/models/dfoundations/profiles.py index 80ec298e..18e804fc 100644 --- a/geolib/models/dfoundations/profiles.py +++ b/geolib/models/dfoundations/profiles.py @@ -1,6 +1,5 @@ from typing import Any, Dict, List, Optional -from geolib._compat import IS_PYDANTIC_V2 from geolib.geometry.one import Point from geolib.models import BaseDataClass from geolib.models.internal import Bool @@ -50,10 +49,7 @@ def to_profile(self, method, **kwargs) -> "Profile": pass def _to_internal(self) -> InternalCPT: - if IS_PYDANTIC_V2: - kwargs = self.model_dump() - else: - kwargs = self.dict() + kwargs = self.model_dump() kwargs["measured_data"] = {"data": kwargs["measured_data"]} return InternalCPT(**kwargs) @@ -107,18 +103,12 @@ class Profile(BaseDataClass): layers: List[Dict[str, Any]] def _to_internal(self, matching_cpt) -> InternalProfile: - if IS_PYDANTIC_V2: - kwargs = self.model_dump(exclude={"cpt", "excavation", "location"}) - else: - kwargs = self.dict(exclude={"cpt", "excavation", "location"}) + kwargs = self.model_dump(exclude={"cpt", "excavation", "location"}) kwargs["matching_cpt"] = matching_cpt if self.excavation is not None: - if IS_PYDANTIC_V2: - kwargs.update(self.excavation.model_dump()) - else: - kwargs.update(self.excavation.dict()) + kwargs.update(self.excavation.model_dump()) kwargs["x_coordinate"] = self.location.x kwargs["y_coordinate"] = self.location.y diff --git a/geolib/models/dseries_parser.py b/geolib/models/dseries_parser.py index af491503..b288aaa4 100644 --- a/geolib/models/dseries_parser.py +++ b/geolib/models/dseries_parser.py @@ -192,7 +192,7 @@ class DSerieListGroupNextStructure(DSeriesStructure): """ @property - @abstractclassmethod + @abstractmethod def group_delimiter(cls) -> str: raise NotImplementedError("Implement in derived classes.") From 67b5c8aad987fcc2adb64d8c4bb561a437d207d1 Mon Sep 17 00:00:00 2001 From: Ardt Klapwijk <59741981+ArdtK@users.noreply.github.com> Date: Tue, 23 Jul 2024 13:30:00 +0200 Subject: [PATCH 3/9] chore: batch 3 --- .../models/dgeoflow/dgeoflow_parserprovider.py | 16 +++------------- 1 file changed, 3 insertions(+), 13 deletions(-) diff --git a/geolib/models/dgeoflow/dgeoflow_parserprovider.py b/geolib/models/dgeoflow/dgeoflow_parserprovider.py index 100cb8c5..59be75a7 100644 --- a/geolib/models/dgeoflow/dgeoflow_parserprovider.py +++ b/geolib/models/dgeoflow/dgeoflow_parserprovider.py @@ -1,12 +1,10 @@ import logging -from os import path, scandir -from typing import List, Tuple, Type, _GenericAlias, get_type_hints +from typing import List, Tuple, Type, _GenericAlias from zipfile import ZipFile from pydantic import DirectoryPath, FilePath from zipp import Path -from geolib._compat import IS_PYDANTIC_V2 from geolib.models.parsers import BaseParser, BaseParserProvider from geolib.models.utils import get_filtered_type_hints @@ -42,12 +40,7 @@ def parse(self, filepath: DirectoryPath) -> BaseModelStructure: fn = filepath / (fieldtype.structure_name() + ".json") if not fn.exists(): raise FileNotFoundError(f"Couldn't find required file at {fn}") - if IS_PYDANTIC_V2: - data_structure[field] = fieldtype.model_validate_json( - fn.open().read() - ) - else: - data_structure[field] = fieldtype.parse_raw(fn.open().read()) + data_structure[field] = fieldtype.model_validate_json(fn.open().read()) return self.structure(**data_structure) @@ -64,10 +57,7 @@ def __parse_folder(self, fieldtype, filepath: DirectoryPath) -> List: sorted_files = sorted(files, key=lambda x: x.name) for file in sorted_files: if fieldtype.structure_name() in file.name: - if IS_PYDANTIC_V2: - out.append(fieldtype.model_validate_json(file.open().read())) - else: - out.append(fieldtype.parse_raw(file.open().read())) + out.append(fieldtype.model_validate_json(file.open().read())) else: logger.debug(f"Didn't match {fieldtype} for {file}") if len(out) == 0: From 03d171aa3d745feb91af121b06b0f892ea78d127 Mon Sep 17 00:00:00 2001 From: Ardt Klapwijk <59741981+ArdtK@users.noreply.github.com> Date: Wed, 24 Jul 2024 11:43:09 +0200 Subject: [PATCH 4/9] chore: batch 4 --- geolib/models/dgeoflow/internal.py | 224 ++---- geolib/models/dgeoflow/serializer.py | 18 +- .../dsettlement/dsettlement_structures.py | 13 +- geolib/models/dsettlement/internal.py | 295 +++----- .../dsheetpiling/calculation_options.py | 46 +- .../models/dsheetpiling/dsheetpiling_model.py | 54 +- geolib/models/dsheetpiling/internal.py | 546 ++++---------- geolib/models/dsheetpiling/loads.py | 92 +-- geolib/models/dsheetpiling/profiles.py | 29 +- geolib/models/dsheetpiling/settings.py | 14 +- geolib/models/dsheetpiling/supports.py | 74 +- geolib/models/dsheetpiling/surface.py | 39 +- geolib/models/dsheetpiling/water_level.py | 8 +- geolib/models/dstability/analysis.py | 66 +- .../dstability/dstability_parserprovider.py | 14 +- .../models/dstability/dstability_validator.py | 6 +- geolib/models/dstability/internal.py | 712 +++++++----------- geolib/models/dstability/loads.py | 65 +- geolib/models/dstability/reinforcements.py | 47 +- geolib/models/dstability/serializer.py | 18 +- geolib/models/dstability/states.py | 31 +- geolib/service/main.py | 30 +- geolib/soils/soil.py | 62 +- geolib/soils/soil_utils.py | 7 +- 24 files changed, 759 insertions(+), 1751 deletions(-) diff --git a/geolib/models/dgeoflow/internal.py b/geolib/models/dgeoflow/internal.py index 02d04490..0974993e 100644 --- a/geolib/models/dgeoflow/internal.py +++ b/geolib/models/dgeoflow/internal.py @@ -9,13 +9,8 @@ from math import isfinite from typing import Dict, List, Optional, Set, Tuple, Union -from geolib._compat import IS_PYDANTIC_V2 - -if IS_PYDANTIC_V2: - from pydantic import ConfigDict, Field, field_validator, model_validator - from typing_extensions import Annotated -else: - from pydantic import conlist, root_validator, validator +from pydantic import ConfigDict, Field, field_validator, model_validator +from typing_extensions import Annotated from geolib import BaseModelStructure from geolib import __version__ as version @@ -29,15 +24,13 @@ class DGeoFlowBaseModelStructure(BaseModelStructure): def dict(_, *args, **kwargs): - if IS_PYDANTIC_V2: - data = super().model_dump(*args, **kwargs) - else: - data = super().dict(*args, **kwargs) + data = super().model_dump(*args, **kwargs) return { k: "NaN" if isinstance(v, float) and not isfinite(v) else v for k, v in data.items() } + def transform_id_to_str(value) -> str: if value is None: return None @@ -89,10 +82,7 @@ class PersistableSoilVisualization(DGeoFlowBaseModelStructure): PersistableShadingType: Optional[PersistableShadingTypeEnum] SoilId: Optional[str] - if IS_PYDANTIC_V2: - id_validator = field_validator("SoilId", mode="before")( - transform_id_to_str - ) + id_validator = field_validator("SoilId", mode="before")(transform_id_to_str) class SoilVisualisation(DGeoFlowBaseModelStructure): @@ -108,10 +98,9 @@ class PersistableSoilLayer(DGeoFlowBaseModelStructure): LayerId: Optional[str] = None SoilId: Optional[str] = None - if IS_PYDANTIC_V2: - id_validator = field_validator("LayerId", "SoilId", mode="before")( - transform_id_to_str - ) + id_validator = field_validator("LayerId", "SoilId", mode="before")( + transform_id_to_str + ) class SoilLayerCollection(DGeoFlowSubStructure): @@ -129,10 +118,7 @@ def structure_group(cls) -> str: Id: Optional[str] = None SoilLayers: List[PersistableSoilLayer] = [] - if IS_PYDANTIC_V2: - id_validator = field_validator("Id", mode="before")( - transform_id_to_str - ) + id_validator = field_validator("Id", mode="before")(transform_id_to_str) def add_soillayer(self, layer_id: str, soil_id: str) -> PersistableSoilLayer: psl = PersistableSoilLayer(LayerId=layer_id, SoilId=soil_id) @@ -157,10 +143,7 @@ class PersistableSoil(DGeoFlowBaseModelStructure): HorizontalPermeability: float = 0.001 VerticalPermeability: float = 0.001 - if IS_PYDANTIC_V2: - id_validator = field_validator("Id", mode="before")( - transform_id_to_str - ) + id_validator = field_validator("Id", mode="before")(transform_id_to_str) class SoilCollection(DGeoFlowSubStructure): @@ -394,14 +377,9 @@ def nltime(cls, date: Union[date, str]) -> date: date = datetime.strptime(date, "%Y-%m-%d").date() return date - if IS_PYDANTIC_V2: - nltime_validator = field_validator( - "Created", "Date", "LastModified", mode="before" - )(nltime) - else: - nltime_validator = validator( - "Created", "Date", "LastModified", pre=True, allow_reuse=True - )(nltime) + nltime_validator = field_validator("Created", "Date", "LastModified", mode="before")( + nltime + ) class PersistablePoint(DGeoFlowBaseModelStructure): @@ -413,15 +391,9 @@ class PersistableLayer(DGeoFlowBaseModelStructure): Id: Optional[str] = None Label: Optional[str] = None Notes: Optional[str] = None - if IS_PYDANTIC_V2: - Points: Annotated[List[PersistablePoint], Field(min_length=3)] - else: - Points: conlist(PersistablePoint, min_items=3) - - if IS_PYDANTIC_V2: - id_validator = field_validator("Id", mode="before")( - transform_id_to_str - ) + Points: Annotated[List[PersistablePoint], Field(min_length=3)] + + id_validator = field_validator("Id", mode="before")(transform_id_to_str) @classmethod def polygon_checks(cls, points): @@ -436,14 +408,7 @@ def polygon_checks(cls, points): # 4. does it intersect other polygons return points - if IS_PYDANTIC_V2: - polygon_checks_validator = field_validator("Points", mode="before")( - polygon_checks - ) - else: - polygon_checks_validator = validator("Points", pre=True, allow_reuse=True)( - polygon_checks - ) + polygon_checks_validator = field_validator("Points", mode="before")(polygon_checks) class Geometry(DGeoFlowSubStructure): @@ -461,10 +426,7 @@ def structure_name(cls) -> str: Id: Optional[str] = None Layers: List[PersistableLayer] = [] - if IS_PYDANTIC_V2: - id_validator = field_validator("Id", mode="before")( - transform_id_to_str - ) + id_validator = field_validator("Id", mode="before")(transform_id_to_str) def contains_point(self, point: Point) -> bool: """ @@ -530,16 +492,10 @@ class PersistableBoundaryCondition(DGeoFlowBaseModelStructure): Label: Optional[str] = None Notes: Optional[str] = None Id: Optional[str] = None - if IS_PYDANTIC_V2: - Points: Annotated[List[PersistablePoint], Field(min_length=2)] - else: - Points: conlist(PersistablePoint, min_items=2) + Points: Annotated[List[PersistablePoint], Field(min_length=2)] FixedHeadBoundaryConditionProperties: PersistableFixedHeadBoundaryConditionProperties - if IS_PYDANTIC_V2: - id_validator = field_validator("Id", mode="before")( - transform_id_to_str - ) + id_validator = field_validator("Id", mode="before")(transform_id_to_str) class BoundaryConditionCollection(DGeoFlowSubStructure): @@ -549,10 +505,7 @@ class BoundaryConditionCollection(DGeoFlowSubStructure): Id: Optional[str] = None BoundaryConditions: List[PersistableBoundaryCondition] = [] - if IS_PYDANTIC_V2: - id_validator = field_validator("Id", mode="before")( - transform_id_to_str - ) + id_validator = field_validator("Id", mode="before")(transform_id_to_str) @classmethod def structure_group(cls) -> str: @@ -637,10 +590,9 @@ class PersistableCalculation(DGeoFlowBaseModelStructure): MeshPropertiesId: Optional[str] = None ResultsId: Optional[str] = None - if IS_PYDANTIC_V2: - id_validator = field_validator( - "CriticalHeadId", "MeshPropertiesId", "ResultsId", mode="before" - )(transform_id_to_str) + id_validator = field_validator( + "CriticalHeadId", "MeshPropertiesId", "ResultsId", mode="before" + )(transform_id_to_str) class NodeResult(DGeoFlowBaseModelStructure): @@ -665,10 +617,7 @@ class GroundwaterFlowResult(DGeoFlowSubStructure): Elements: Optional[List[ElementResult]] = [] ContentVersion: Optional[str] = "2" - if IS_PYDANTIC_V2: - id_validator = field_validator("Id", mode="before")( - transform_id_to_str - ) + id_validator = field_validator("Id", mode="before")(transform_id_to_str) @classmethod def structure_group(cls) -> str: @@ -682,10 +631,7 @@ class PipeLengthResult(DGeoFlowSubStructure): PipeElements: Optional[List[PipeElementResult]] = [] ContentVersion: Optional[str] = "2" - if IS_PYDANTIC_V2: - id_validator = field_validator("Id", mode="before")( - transform_id_to_str - ) + id_validator = field_validator("Id", mode="before")(transform_id_to_str) @classmethod def structure_group(cls) -> str: @@ -700,10 +646,7 @@ class CriticalHeadResult(DGeoFlowSubStructure): PipeElements: Optional[List[PipeElementResult]] = [] ContentVersion: Optional[str] = "2" - if IS_PYDANTIC_V2: - id_validator = field_validator("Id", mode="before")( - transform_id_to_str - ) + id_validator = field_validator("Id", mode="before")(transform_id_to_str) @classmethod def structure_group(cls) -> str: @@ -725,10 +668,9 @@ class Scenario(DGeoFlowSubStructure): Stages: List[PersistableStage] = [] Calculations: List[PersistableCalculation] = [] - if IS_PYDANTIC_V2: - id_validator = field_validator("Id", "GeometryId", "SoilLayersId", mode="before")( - transform_id_to_str - ) + id_validator = field_validator("Id", "GeometryId", "SoilLayersId", mode="before")( + transform_id_to_str + ) @classmethod def structure_name(cls) -> str: @@ -764,10 +706,7 @@ class PersistableMeshProperties(DGeoFlowBaseModelStructure): Label: Optional[str] = None ElementSize: Optional[float] = 1 - if IS_PYDANTIC_V2: - id_validator = field_validator("LayerId", mode="before")( - transform_id_to_str - ) + id_validator = field_validator("LayerId", mode="before")(transform_id_to_str) class MeshProperty(DGeoFlowSubStructure): @@ -777,10 +716,7 @@ class MeshProperty(DGeoFlowSubStructure): Id: Optional[str] = None MeshProperties: Optional[List[PersistableMeshProperties]] = [] - if IS_PYDANTIC_V2: - id_validator = field_validator("Id", mode="before")( - transform_id_to_str - ) + id_validator = field_validator("Id", mode="before")(transform_id_to_str) @classmethod def structure_name(cls) -> str: @@ -855,13 +791,7 @@ class DGeoFlowStructure(BaseModelStructure): pipe_length_results: List[PipeLengthResult] = [] critical_head_results: List[CriticalHeadResult] = [] - if IS_PYDANTIC_V2: - model_config = ConfigDict(arbitrary_types_allowed=True, validate_assignment=True) - else: - - class Config: - arbitrary_types_allowed = True - validate_assignment = True + model_config = ConfigDict(arbitrary_types_allowed=True, validate_assignment=True) def get_result_substructure( self, calculation_type: CalculationTypeEnum @@ -874,73 +804,29 @@ def get_result_substructure( return result_types_mapping[calculation_type] - if IS_PYDANTIC_V2: - - @model_validator(mode="after") - def ensure_validity_foreign_keys(self): - def list_has_id(values, id): - for entry in values: - if entry.Id == id: - return True - return False - # print(self) - for _, scenario in enumerate(self.scenarios): - for _, stage in enumerate(scenario.Stages): - print(self.boundary_conditions[0]) - if not list_has_id( - self.boundary_conditions, stage.BoundaryConditionCollectionId - ): - raise ValueError("BoundaryConditionCollectionIds not linked!") - - if not list_has_id(self.geometries, scenario.GeometryId): - raise ValueError("GeometryIds not linked!") - if not list_has_id(self.soillayers, scenario.SoilLayersId): - raise ValueError("SoilLayersIds not linked!") - - return self - - else: - # TODO: these are the original validators, but they are double? - @root_validator(skip_on_failure=True, allow_reuse=True) - def ensure_validity_foreign_keys(cls, values): - stage_count = 0 - for i, scenario in enumerate(values.get("scenarios")): - for _, stage in enumerate(scenario.Stages): - if ( - stage.BoundaryConditionCollectionId - != values.get("boundary_conditions")[stage_count].Id - ): - raise ValueError("BoundaryConditionCollectionIds not linked!") - stage_count += 1 - - if scenario.GeometryId != values.get("geometries")[i].Id: - raise ValueError("GeometryIds not linked!") - if scenario.SoilLayersId != values.get("soillayers")[i].Id: - raise ValueError("SoilLayersIds not linked!") - return values - - @root_validator(skip_on_failure=True, allow_reuse=True) - def ensure_validity_foreign_keys(cls, values): - def list_has_id(values, id): - for entry in values: - if entry.Id == id: - return True - return False - - for _, scenario in enumerate(values.get("scenarios")): - for _, stage in enumerate(scenario.Stages): - if not list_has_id( - values.get("boundary_conditions"), - stage.BoundaryConditionCollectionId, - ): - raise ValueError("BoundaryConditionCollectionIds not linked!") - - if not list_has_id(values.get("geometries"), scenario.GeometryId): - raise ValueError("GeometryIds not linked!") - if not list_has_id(values.get("soillayers"), scenario.SoilLayersId): - raise ValueError("SoilLayersIds not linked!") + @model_validator(mode="after") + def ensure_validity_foreign_keys(self): + def list_has_id(values, id): + for entry in values: + if entry.Id == id: + return True + return False - return values + # print(self) + for _, scenario in enumerate(self.scenarios): + for _, stage in enumerate(scenario.Stages): + print(self.boundary_conditions[0]) + if not list_has_id( + self.boundary_conditions, stage.BoundaryConditionCollectionId + ): + raise ValueError("BoundaryConditionCollectionIds not linked!") + + if not list_has_id(self.geometries, scenario.GeometryId): + raise ValueError("GeometryIds not linked!") + if not list_has_id(self.soillayers, scenario.SoilLayersId): + raise ValueError("SoilLayersIds not linked!") + + return self def add_default_scenario( self, label: str, notes: str, unique_start_id: Optional[int] = None diff --git a/geolib/models/dgeoflow/serializer.py b/geolib/models/dgeoflow/serializer.py index cfa896bd..cc0bffb8 100644 --- a/geolib/models/dgeoflow/serializer.py +++ b/geolib/models/dgeoflow/serializer.py @@ -1,14 +1,10 @@ from abc import ABCMeta, abstractmethod -from datetime import datetime from io import BytesIO -from os import makedirs -from typing import Dict, List, Union, _GenericAlias, get_type_hints +from typing import Dict, Union, _GenericAlias from zipfile import ZIP_DEFLATED, ZipFile from pydantic import DirectoryPath, FilePath -from zipp import Path -from geolib._compat import IS_PYDANTIC_V2 from geolib.errors import NotConcreteError from geolib.models.serializers import BaseSerializer from geolib.models.utils import get_filtered_type_hints @@ -35,21 +31,13 @@ def serialize(self) -> Dict: for i, data in enumerate(getattr(self.ds, field)): suffix = f"_{i}" if i > 0 else "" fn = element_type.structure_name() + suffix + ".json" - if IS_PYDANTIC_V2: - serialized_datastructure[folder][fn] = data.model_dump_json( - indent=4 - ) - else: - serialized_datastructure[folder][fn] = data.json(indent=4) + serialized_datastructure[folder][fn] = data.model_dump_json(indent=4) # Otherwise it is a single .json in the root folder else: fn = fieldtype.structure_name() + ".json" data = getattr(self.ds, field) - if IS_PYDANTIC_V2: - serialized_datastructure[fn] = data.model_dump_json(indent=4) - else: - serialized_datastructure[fn] = data.json(indent=4) + serialized_datastructure[fn] = data.model_dump_json(indent=4) return serialized_datastructure diff --git a/geolib/models/dsettlement/dsettlement_structures.py b/geolib/models/dsettlement/dsettlement_structures.py index 5b7ab228..f4bdb95d 100644 --- a/geolib/models/dsettlement/dsettlement_structures.py +++ b/geolib/models/dsettlement/dsettlement_structures.py @@ -1,17 +1,11 @@ from __future__ import annotations import logging -from typing import Any, Dict, List, Tuple +from typing import Dict, List -from geolib._compat import IS_PYDANTIC_V2 from geolib.models.dseries_parser import ( - DSerieListGroupNextStructure, - DSerieParser, - DSeriesInlineProperties, DSeriesRepeatedGroupedProperties, DSeriesStructure, - get_line_property_key_value, - get_line_property_value, make_key, split_line_elements, strip_line_first_element, @@ -32,10 +26,7 @@ def __init__(self, *args, **kwargs): them. """ largs = list(args) - if IS_PYDANTIC_V2: - fields = self.model_fields - else: - fields = self.__fields__ + fields = self.model_fields for field, fieldtype in fields.items(): if len(largs) == 0: break diff --git a/geolib/models/dsettlement/internal.py b/geolib/models/dsettlement/internal.py index 640148bf..c6d27266 100644 --- a/geolib/models/dsettlement/internal.py +++ b/geolib/models/dsettlement/internal.py @@ -5,9 +5,10 @@ from operator import attrgetter from typing import Any, Dict, List, Optional, Tuple, Type, Union -from pydantic.types import PositiveInt, confloat, conint, conlist, constr +from pydantic import Field, StringConstraints +from pydantic.types import PositiveInt, conint +from typing_extensions import Annotated -from geolib._compat import IS_PYDANTIC_V2 from geolib.geometry.one import Point from geolib.models import BaseDataClass from geolib.models.base_model_structure import BaseModelStructure @@ -38,16 +39,11 @@ ) from geolib.models.internal import Bool from geolib.models.utils import get_required_class_field -from geolib.soils import DistributionType, HorizontalBehaviourType, Soil -from geolib.soils import StorageTypes as StorageTypes_external +from geolib.soils import DistributionType from geolib.utils import make_newline_validator from .drain_types import DrainGridType, DrainSchedule, DrainType -if IS_PYDANTIC_V2: - from pydantic import Field, StringConstraints - from typing_extensions import Annotated - logger = logging.getLogger(__name__) @@ -141,10 +137,7 @@ class Curve(DSeriesTreeStructure): """Curve is a Line consisting of two points (by reference).""" id: PositiveInt = 1 - if IS_PYDANTIC_V2: - points: Annotated[List[int], Field(min_length=2, max_length=2)] - else: - points: conlist(int, min_items=2, max_items=2) + points: Annotated[List[int], Field(min_length=2, max_length=2)] def __eq__(self, other: object) -> bool: """ @@ -198,10 +191,7 @@ def __getitem__(self, curve_id: int) -> Curve: class Boundary(DSeriesTreeStructure): - if IS_PYDANTIC_V2: - id: Annotated[int, Field(ge=0)] = 0 - else: - id: conint(ge=0) = 0 + id: Annotated[int, Field(ge=0)] = 0 curves: List[int] = [] def __eq__(self, other: object) -> bool: @@ -252,12 +242,8 @@ def __getitem__(self, boundary_id: int) -> Boundary: class Layer(DSeriesTreeStructure): id: PositiveInt = 1 material: str = "" # reference to soil name - if IS_PYDANTIC_V2: - piezo_top: Annotated[int, Field(ge=0, le=99)] = 0 # reference to head line - piezo_bottom: Annotated[int, Field(ge=0, le=99)] = 0 # reference to head line - else: - piezo_top: conint(ge=0, le=99) = 0 # reference to head line - piezo_bottom: conint(ge=0, le=99) = 0 # reference to head line + piezo_top: Annotated[int, Field(ge=0, le=99)] = 0 # reference to head line + piezo_bottom: Annotated[int, Field(ge=0, le=99)] = 0 # reference to head line boundary_top: int # reference to boundary boundary_bottom: int # reference to boundary @@ -380,10 +366,7 @@ def append_distribution_boundary(self, distribution_boundary: DistributionType): class PhreaticLine(DSeriesUnmappedNameProperties): - if IS_PYDANTIC_V2: - phreatic_line: Annotated[int, Field(ge=0, lt=99)] = 0 - else: - phreatic_line: conint(ge=0, lt=99) = 0 + phreatic_line: Annotated[int, Field(ge=0, lt=99)] = 0 class GeometryData(DSeriesStructure): @@ -500,35 +483,21 @@ class NonUniformLoad(BaseDataClass): class NonUniformLoads(DSeriesNoParseSubStructure): """Representation of [NON-UNIFORM LOADS] group.""" - if IS_PYDANTIC_V2: - loads: Dict[ - Annotated[str, StringConstraints(min_length=1, max_length=25)], NonUniformLoad - ] = {} - - def add_load( - self, - name: Annotated[str, StringConstraints(min_length=1, max_length=25)], - load: NonUniformLoad, - ) -> Optional[ValueError]: - if name in self.loads: - raise ValueError(f"Load with name '{name}' already exists.") - else: - self.loads[name] = load - self.loads = self.loads # trigger validation - return None - - else: - loads: Dict[constr(min_length=1, max_length=25), NonUniformLoad] = {} - - def add_load( - self, name: constr(min_length=1, max_length=25), load: NonUniformLoad - ) -> Optional[ValueError]: - if name in self.loads: - raise ValueError(f"Load with name '{name}' already exists.") - else: - self.loads[name] = load - self.loads = self.loads # trigger validation - return None + loads: Dict[ + Annotated[str, StringConstraints(min_length=1, max_length=25)], NonUniformLoad + ] = {} + + def add_load( + self, + name: Annotated[str, StringConstraints(min_length=1, max_length=25)], + load: NonUniformLoad, + ) -> Optional[ValueError]: + if name in self.loads: + raise ValueError(f"Load with name '{name}' already exists.") + else: + self.loads[name] = load + self.loads = self.loads # trigger validation + return None class WaterLoad(BaseDataClass): @@ -556,10 +525,7 @@ def add_waterload( class ResidualTimes(DSeriesNoParseSubStructure): """Representation of [RESIDUAL TIMES] group.""" - if IS_PYDANTIC_V2: - time_steps: List[Annotated[int, Field(ge=0)]] = [] - else: - time_steps: List[conint(ge=0)] = [] + time_steps: List[Annotated[int, Field(ge=0)]] = [] class Verticals(DSeriesNoParseSubStructure): @@ -626,50 +592,30 @@ class LoadValuesTank(BaseDataClass): class OtherLoad(BaseDataClass): load_type: TypeOtherLoads time: int = 0 - if IS_PYDANTIC_V2: - load_values_trapeziform: Optional[LoadValuesTrapeziform] = None - load_values_circular: Optional[LoadValuesCircular] = None - load_values_rectangular: Optional[LoadValuesRectangular] = None - load_values_uniform: Optional[LoadValuesUniform] = None - load_values_tank: Optional[LoadValuesTank] = None - else: - load_values_trapeziform: Optional[LoadValuesTrapeziform] - load_values_circular: Optional[LoadValuesCircular] - load_values_rectangular: Optional[LoadValuesRectangular] - load_values_uniform: Optional[LoadValuesUniform] - load_values_tank: Optional[LoadValuesTank] + load_values_trapeziform: Optional[LoadValuesTrapeziform] = None + load_values_circular: Optional[LoadValuesCircular] = None + load_values_rectangular: Optional[LoadValuesRectangular] = None + load_values_uniform: Optional[LoadValuesUniform] = None + load_values_tank: Optional[LoadValuesTank] = None class OtherLoads(DSeriesNoParseSubStructure): """Representation of [OTHER LOADS] group.""" - if IS_PYDANTIC_V2: - loads: Dict[ - Annotated[str, StringConstraints(min_length=1, max_length=25)], OtherLoad - ] = {} - - def add_load( - self, - name: Annotated[str, StringConstraints(min_length=1, max_length=25)], - load: OtherLoad, - ) -> Optional[ValueError]: - if name in self.loads: - raise ValueError(f"Load with name '{name}' already exists.") - else: - self.loads[name] = load - return None - - else: - loads: Dict[constr(min_length=1, max_length=25), OtherLoad] = {} - - def add_load( - self, name: constr(min_length=1, max_length=25), load: OtherLoad - ) -> Optional[ValueError]: - if name in self.loads: - raise ValueError(f"Load with name '{name}' already exists.") - else: - self.loads[name] = load - return None + loads: Dict[ + Annotated[str, StringConstraints(min_length=1, max_length=25)], OtherLoad + ] = {} + + def add_load( + self, + name: Annotated[str, StringConstraints(min_length=1, max_length=25)], + load: OtherLoad, + ) -> Optional[ValueError]: + if name in self.loads: + raise ValueError(f"Load with name '{name}' already exists.") + else: + self.loads[name] = load + return None class Dimension(IntEnum): @@ -749,14 +695,9 @@ class CalculationOptions(DSeriesNoParseSubStructure): use_end_time_for_fit: Bool = Bool.FALSE is_maintain_profile: Bool = Bool.FALSE maintain_profile_material_name: str = "Superelevation" - if IS_PYDANTIC_V2: - maintain_profile_time: Annotated[int, Field(ge=0, le=100000)] = 0 - maintain_profile_gamma_dry: Annotated[float, Field(ge=-100, le=100)] = 10 - maintain_profile_gamma_wet: Annotated[float, Field(ge=-100, le=100)] = 10 - else: - maintain_profile_time: conint(ge=0, le=100000) = 0 - maintain_profile_gamma_dry: confloat(ge=-100, le=100) = 10 - maintain_profile_gamma_wet: confloat(ge=-100, le=100) = 10 + maintain_profile_time: Annotated[int, Field(ge=0, le=100000)] = 0 + maintain_profile_gamma_dry: Annotated[float, Field(ge=-100, le=100)] = 10 + maintain_profile_gamma_wet: Annotated[float, Field(ge=-100, le=100)] = 10 dispersion_conditions_layer_boundaries_top: DispersionConditionLayerBoundary = ( DispersionConditionLayerBoundary.DRAINED ) @@ -765,36 +706,18 @@ class CalculationOptions(DSeriesNoParseSubStructure): ) stress_distribution_soil: StressDistributionSoil = StressDistributionSoil.BUISMAN stress_distribution_loads: StressDistributionLoads = StressDistributionLoads.SIMULATE - if IS_PYDANTIC_V2: - iteration_stop_criteria_submerging: Annotated[float, Field(ge=0.0, le=1.0)] = 0.0 - iteration_stop_criteria_submerging_layer_height: Annotated[ - float, Field(ge=0, le=99.999) - ] = 0 - maximum_iteration_steps_for_submerging: Annotated[int, Field(ge=1, le=100)] = 1 - iteration_stop_criteria_desired_profile: Annotated[float, Field(ge=0, le=1)] = 0.1 - load_column_width_imaginary_surface: Annotated[ - float, Field(ge=0.05, le=10000) - ] = 1 - load_column_width_non_uniform_loads: Annotated[ - float, Field(ge=0.05, le=10000) - ] = 1 - load_column_width_trapeziform_loads: Annotated[ - float, Field(ge=0.05, le=10000) - ] = 1 - end_of_consolidation: Annotated[int, Field(ge=1, le=100000)] = 100000 - number_of_subtime_steps: Annotated[int, Field(ge=1, le=100)] = 2 - reference_time: Annotated[float, Field(ge=0.001, le=1000000)] = 1 - else: - iteration_stop_criteria_submerging: confloat(ge=0.0, le=1.0) = 0.0 - iteration_stop_criteria_submerging_layer_height: confloat(ge=0, le=99.999) = 0 - maximum_iteration_steps_for_submerging: conint(ge=1, le=100) = 1 - iteration_stop_criteria_desired_profile: confloat(ge=0, le=1) = 0.1 - load_column_width_imaginary_surface: confloat(ge=0.05, le=10000) = 1 - load_column_width_non_uniform_loads: confloat(ge=0.05, le=10000) = 1 - load_column_width_trapeziform_loads: confloat(ge=0.05, le=10000) = 1 - end_of_consolidation: conint(ge=1, le=100000) = 100000 - number_of_subtime_steps: conint(ge=1, le=100) = 2 - reference_time: confloat(ge=0.001, le=1000000) = 1 + iteration_stop_criteria_submerging: Annotated[float, Field(ge=0.0, le=1.0)] = 0.0 + iteration_stop_criteria_submerging_layer_height: Annotated[ + float, Field(ge=0, le=99.999) + ] = 0 + maximum_iteration_steps_for_submerging: Annotated[int, Field(ge=1, le=100)] = 1 + iteration_stop_criteria_desired_profile: Annotated[float, Field(ge=0, le=1)] = 0.1 + load_column_width_imaginary_surface: Annotated[float, Field(ge=0.05, le=10000)] = 1 + load_column_width_non_uniform_loads: Annotated[float, Field(ge=0.05, le=10000)] = 1 + load_column_width_trapeziform_loads: Annotated[float, Field(ge=0.05, le=10000)] = 1 + end_of_consolidation: Annotated[int, Field(ge=1, le=100000)] = 100000 + number_of_subtime_steps: Annotated[int, Field(ge=1, le=100)] = 2 + reference_time: Annotated[float, Field(ge=0.001, le=1000000)] = 1 dissipation: Bool = Bool.FALSE x_coord_dissipation: float = 0.0 use_fit_factors: Bool = Bool.FALSE @@ -814,61 +737,33 @@ def set_imaginary_surface_options(cls, **kwargs): class VerticalDrain(DSeriesNoParseSubStructure): # geometry of drain drain_type: DrainType = DrainType.STRIP - if IS_PYDANTIC_V2: - range_from: Annotated[float, Field(ge=-10000000.000, le=10000000.000)] = 0 - range_to: Annotated[float, Field(ge=-10000000.000, le=10000000.000)] = 0 - bottom_position: Annotated[float, Field(ge=-10000000.000, le=10000000.000)] = 0 - center_to_center: Annotated[float, Field(ge=0.001, le=1000)] = 3 - width: Annotated[float, Field(ge=0.001, le=1000)] = 0.1 - diameter: Annotated[float, Field(ge=0.001, le=1000)] = 0.1 - thickness: Annotated[float, Field(ge=0.001, le=1000)] = 0.003 - else: - range_from: confloat(ge=-10000000.000, le=10000000.000) = 0 - range_to: confloat(ge=-10000000.000, le=10000000.000) = 0 - bottom_position: confloat(ge=-10000000.000, le=10000000.000) = 0 - center_to_center: confloat(ge=0.001, le=1000) = 3 - width: confloat(ge=0.001, le=1000) = 0.1 - diameter: confloat(ge=0.001, le=1000) = 0.1 - thickness: confloat(ge=0.001, le=1000) = 0.003 + range_from: Annotated[float, Field(ge=-10000000.000, le=10000000.000)] = 0 + range_to: Annotated[float, Field(ge=-10000000.000, le=10000000.000)] = 0 + bottom_position: Annotated[float, Field(ge=-10000000.000, le=10000000.000)] = 0 + center_to_center: Annotated[float, Field(ge=0.001, le=1000)] = 3 + width: Annotated[float, Field(ge=0.001, le=1000)] = 0.1 + diameter: Annotated[float, Field(ge=0.001, le=1000)] = 0.1 + thickness: Annotated[float, Field(ge=0.001, le=1000)] = 0.003 grid: DrainGridType = DrainGridType.UNDERDETERMINED # schedule schedule_type: DrainSchedule = DrainSchedule.OFF - if IS_PYDANTIC_V2: - begin_time: Annotated[float, Field(ge=0, le=100000)] = 0 - end_time: Annotated[float, Field(ge=0, le=100000)] = 0 - under_pressure_for_strips_and_columns: Annotated[ - float, Field(ge=0, le=100000) - ] = 35 - under_pressure_for_sand_wall: Annotated[float, Field(ge=0, le=100000)] = 35 - start_of_drainage: Annotated[float, Field(ge=0, le=100000)] = 0 - phreatic_level_in_drain: Annotated[ - float, Field(ge=-10000000.000, le=10000000.000) - ] = 0 - water_head_during_dewatering: Annotated[ - float, Field(ge=-10000000.000, le=10000000.000) - ] = 0 # relevant for strip and column - tube_pressure_during_dewatering: Annotated[ - float, Field(ge=-10000000.000, le=10000000.000) - ] = 0 # relevant for the sand wall - time: List[Annotated[float, Field(ge=0, le=100000)]] = [] - underpressure: List[Annotated[float, Field(ge=0, le=100000)]] = [] - water_level: List[Annotated[float, Field(ge=-10000000.000, le=10000000.000)]] = [] - else: - begin_time: confloat(ge=0, le=100000) = 0 - end_time: confloat(ge=0, le=100000) = 0 - under_pressure_for_strips_and_columns: confloat(ge=0, le=100000) = 35 - under_pressure_for_sand_wall: confloat(ge=0, le=100000) = 35 - start_of_drainage: confloat(ge=0, le=100000) = 0 - phreatic_level_in_drain: confloat(ge=-10000000.000, le=10000000.000) = 0 - water_head_during_dewatering: confloat( - ge=-10000000.000, le=10000000.000 - ) = 0 # relevant for strip and column - tube_pressure_during_dewatering: confloat( - ge=-10000000.000, le=10000000.000 - ) = 0 # relevant for the sand wall - time: List[confloat(ge=0, le=100000)] = [] - underpressure: List[confloat(ge=0, le=100000)] = [] - water_level: List[confloat(ge=-10000000.000, le=10000000.000)] = [] + begin_time: Annotated[float, Field(ge=0, le=100000)] = 0 + end_time: Annotated[float, Field(ge=0, le=100000)] = 0 + under_pressure_for_strips_and_columns: Annotated[float, Field(ge=0, le=100000)] = 35 + under_pressure_for_sand_wall: Annotated[float, Field(ge=0, le=100000)] = 35 + start_of_drainage: Annotated[float, Field(ge=0, le=100000)] = 0 + phreatic_level_in_drain: Annotated[ + float, Field(ge=-10000000.000, le=10000000.000) + ] = 0 + water_head_during_dewatering: Annotated[ + float, Field(ge=-10000000.000, le=10000000.000) + ] = 0 # relevant for strip and column + tube_pressure_during_dewatering: Annotated[ + float, Field(ge=-10000000.000, le=10000000.000) + ] = 0 # relevant for the sand wall + time: List[Annotated[float, Field(ge=0, le=100000)]] = [] + underpressure: List[Annotated[float, Field(ge=0, le=100000)]] = [] + water_level: List[Annotated[float, Field(ge=-10000000.000, le=10000000.000)]] = [] class InternalProbabilisticCalculationType(IntEnum): @@ -878,31 +773,21 @@ class InternalProbabilisticCalculationType(IntEnum): class FitOptions(DSeriesInlineMappedProperties): - if IS_PYDANTIC_V2: - fit_maximum_number_of_iterations: Annotated[int, Field(ge=0, le=100)] = 5 - fit_required_iteration_accuracy: Annotated[float, Field(ge=0, le=1)] = 0.0001 - fit_required_correlation_coefficient: Annotated[float, Field(ge=0, le=1)] = 0.99 - else: - fit_maximum_number_of_iterations: conint(ge=0, le=100) = 5 - fit_required_iteration_accuracy: confloat(ge=0, le=1) = 0.0001 - fit_required_correlation_coefficient: confloat(ge=0, le=1) = 0.99 + fit_maximum_number_of_iterations: Annotated[int, Field(ge=0, le=100)] = 5 + fit_required_iteration_accuracy: Annotated[float, Field(ge=0, le=1)] = 0.0001 + fit_required_correlation_coefficient: Annotated[float, Field(ge=0, le=1)] = 0.99 class FitCalculation(DSeriesInlineMappedProperties): is_fit_calculation: Bool = Bool.FALSE - fit_vertical_number: conint(ge=-1, le=1000) = 0 # index (zero-based) + fit_vertical_number: Annotated[int, Field(ge=-1, le=1000)] = 0 # index (zero-based) class ProbabilisticData(DSeriesInlineMappedProperties): reliability_x_co__ordinate: float = 0 - if IS_PYDANTIC_V2: - residual_settlement: Annotated[float, Field(ge=0, le=1000)] = 1 - maximum_drawings: Annotated[int, Field(ge=0, le=999999999)] = 100 - maximum_iterations: Annotated[int, Field(ge=1, le=50)] = 15 - else: - residual_settlement: confloat(ge=0, le=1000) = 1 - maximum_drawings: conint(ge=0, le=999999999) = 100 - maximum_iterations: conint(ge=1, le=50) = 15 + residual_settlement: Annotated[float, Field(ge=0, le=1000)] = 1 + maximum_drawings: Annotated[int, Field(ge=0, le=999999999)] = 100 + maximum_iterations: Annotated[int, Field(ge=1, le=50)] = 15 reliability_type: InternalProbabilisticCalculationType = ( InternalProbabilisticCalculationType.FOSMOrDeterministic ) diff --git a/geolib/models/dsheetpiling/calculation_options.py b/geolib/models/dsheetpiling/calculation_options.py index 1c7009b5..0d4f24d9 100644 --- a/geolib/models/dsheetpiling/calculation_options.py +++ b/geolib/models/dsheetpiling/calculation_options.py @@ -1,7 +1,9 @@ -from abc import ABCMeta, abstractmethod +from abc import ABCMeta from typing import Optional, Union -from geolib._compat import IS_PYDANTIC_V2 +from pydantic import Field +from typing_extensions import Annotated + from geolib.models import BaseDataClass from .settings import ( @@ -16,12 +18,6 @@ VerifyType, ) -if IS_PYDANTIC_V2: - from pydantic import Field - from typing_extensions import Annotated -else: - from pydantic.types import confloat, conint - class CalculationOptionsPerStage(BaseDataClass): """Calculation options are needed when a verification calculation is performed with method B. @@ -102,10 +98,7 @@ class OverallStabilityCalculationOptions(CalculationOptions): """ input_calculation_type: CalculationType = CalculationType.OVERALL_STABILITY - if IS_PYDANTIC_V2: - cur_stability_stage: Annotated[int, Field(ge=0)] = 0 - else: - cur_stability_stage: conint(ge=0) = 0 + cur_stability_stage: Annotated[int, Field(ge=0)] = 0 overall_stability_type: DesignType = DesignType.REPRESENTATIVE stability_eurocode_partial_factor_set: PartialFactorSetEC = PartialFactorSetEC.DA1SET1 stability_ec7_nl_partial_factor_set: PartialFactorSetEC7NADNL = ( @@ -129,10 +122,7 @@ class KranzAnchorStrengthCalculationOptions(CalculationOptions): input_calculation_type: CalculationType = ( CalculationType.CHARACTERISTIC_KRANZ_ANCHOR_STRENGTH ) - if IS_PYDANTIC_V2: - cur_anchor_force_stage: Annotated[int, Field(ge=0)] = 0 - else: - cur_anchor_force_stage: conint(ge=0) = 0 + cur_anchor_force_stage: Annotated[int, Field(ge=0)] = 0 class StandardCalculationOptions(CalculationOptions): @@ -173,19 +163,13 @@ class VerifyCalculationOptions(CalculationOptions): ec7_nl_overall_partial_factor_set: PartialFactorSetEC7NADNL = ( PartialFactorSetEC7NADNL.RC0 ) - if IS_PYDANTIC_V2: - ec7_nl_overall_anchor_factor: Annotated[float, Field(ge=0.001, le=1000)] = 1 - else: - ec7_nl_overall_anchor_factor: confloat(ge=0.001, le=1000) = 1 + ec7_nl_overall_anchor_factor: Annotated[float, Field(ge=0.001, le=1000)] = 1 ec7_nad_nl_overall_stability: bool = False ec7_be_overall_stability: bool = False nb_method: PartialFactorCalculationType = PartialFactorCalculationType.METHODA cur_method: PartialFactorCalculationType = PartialFactorCalculationType.METHODA cur_overall_partial_factor_set: PartialFactorSetCUR = PartialFactorSetCUR.CLASSI - if IS_PYDANTIC_V2: - cur_overall_anchor_factor: Annotated[float, Field(ge=0.001, le=1000)] = 1 - else: - cur_overall_anchor_factor: confloat(ge=0.001, le=1000) = 1 + cur_overall_anchor_factor: Annotated[float, Field(ge=0.001, le=1000)] = 1 cur_overall_stability: bool = False @property @@ -217,16 +201,10 @@ class DesignSheetpilingLengthCalculationOptions(CalculationOptions): """ input_calculation_type: CalculationType = CalculationType.DESIGN_SHEETPILING_LENGTH - if IS_PYDANTIC_V2: - design_stage: Annotated[int, Field(ge=0)] = 0 - design_pile_length_from: Annotated[float, Field(ge=1, le=100)] = 1 - design_pile_length_to: Annotated[float, Field(ge=1, le=100)] = 1 - design_pile_length_decrement: Annotated[float, Field(ge=0.01, le=10)] = 0.01 - else: - design_stage: conint(ge=0) = 0 - design_pile_length_from: confloat(ge=1, le=100) = 1 - design_pile_length_to: confloat(ge=1, le=100) = 1 - design_pile_length_decrement: confloat(ge=0.01, le=10) = 0.01 + design_stage: Annotated[int, Field(ge=0)] = 0 + design_pile_length_from: Annotated[float, Field(ge=1, le=100)] = 1 + design_pile_length_to: Annotated[float, Field(ge=1, le=100)] = 1 + design_pile_length_decrement: Annotated[float, Field(ge=0.01, le=10)] = 0.01 design_type: DesignType = DesignType.REPRESENTATIVE design_eurocode_partial_factor_set: PartialFactorSetEC = PartialFactorSetEC.DA1SET1 design_partial_factor_set_ec7_nad_nl: PartialFactorSetEC7NADNL = ( diff --git a/geolib/models/dsheetpiling/dsheetpiling_model.py b/geolib/models/dsheetpiling/dsheetpiling_model.py index 306872c5..b6effe2a 100644 --- a/geolib/models/dsheetpiling/dsheetpiling_model.py +++ b/geolib/models/dsheetpiling/dsheetpiling_model.py @@ -1,21 +1,16 @@ from abc import ABCMeta, abstractmethod from pathlib import Path -from subprocess import CompletedProcess, run -from typing import Any, BinaryIO, List, Optional, Type, Union +from typing import BinaryIO, List, Optional, Type, Union from pydantic import FilePath, PositiveFloat -from pydantic.types import confloat, conint -from geolib._compat import IS_PYDANTIC_V2 -from geolib.geometry import Point -from geolib.models import BaseDataClass, BaseModel, BaseModelStructure +from geolib.models import BaseDataClass, BaseModel from geolib.models.dsheetpiling.constructions import DiaphragmWall, Pile, Sheet from geolib.models.meta import CONSOLE_RUN_BATCH_FLAG from geolib.soils import Soil from .calculation_options import CalculationOptions, CalculationOptionsPerStage from .dsheetpiling_parserprovider import DSheetPilingParserProvider -from .internal import CalculationOptions as CalculationOptionsInternal from .internal import ( DSheetPilingDumpStructure, DSheetPilingOutputStructure, @@ -35,16 +30,10 @@ from .settings import ( CalculationType, CurveSettings, - DesignType, LateralEarthPressureMethod, LateralEarthPressureMethodStage, ModelType, PartialFactorCalculationType, - PartialFactorSetCUR, - PartialFactorSetEC, - PartialFactorSetEC7NADBE, - PartialFactorSetEC7NADNL, - PartialFactorSetVerifyEC, PassiveSide, Side, SinglePileLoadOptions, @@ -64,10 +53,7 @@ def model(self): raise NotImplementedError def to_internal(self): - if IS_PYDANTIC_V2: - return self.model_dump() - else: - return dict(self) + return self.model_dump() class SheetModelType(BaseModelType): @@ -164,22 +150,13 @@ def model_type(self) -> Union[str, ModelType]: return self.datastructure.input_data.model.model def serialize(self, filename: Union[FilePath, BinaryIO]): - if IS_PYDANTIC_V2: - ds = self.datastructure.input_data.model_dump() - ds.update( - { - "version": self.datastructure.input_data.version.model_dump(), - "version_externals": self.datastructure.input_data.version_externals.model_dump(), - } - ) - else: - ds = self.datastructure.input_data.dict() - ds.update( - { - "version": self.datastructure.input_data.version.dict(), - "version_externals": self.datastructure.input_data.version_externals.dict(), - } - ) + ds = self.datastructure.input_data.model_dump() + ds.update( + { + "version": self.datastructure.input_data.version.model_dump(), + "version_externals": self.datastructure.input_data.version_externals.model_dump(), + } + ) serializer = DSheetPilingInputSerializer(ds=ds) serializer.write(filename) if isinstance(filename, Path): @@ -308,14 +285,9 @@ def set_calculation_options(self, calculation_options: CalculationOptions) -> No raise ValueError( f"model should be of subtype CalculationOptions, received {calculation_options}" ) - if IS_PYDANTIC_V2: - self.datastructure.input_data.set_calculation_options( - **calculation_options.model_dump() - ) - else: - self.datastructure.input_data.set_calculation_options( - **dict(calculation_options) - ) + self.datastructure.input_data.set_calculation_options( + **calculation_options.model_dump() + ) def set_curve_settings( self, diff --git a/geolib/models/dsheetpiling/internal.py b/geolib/models/dsheetpiling/internal.py index ef30303f..b6849064 100644 --- a/geolib/models/dsheetpiling/internal.py +++ b/geolib/models/dsheetpiling/internal.py @@ -1,30 +1,20 @@ import logging import warnings -from abc import ABCMeta -from enum import Enum, IntEnum from inspect import cleandoc -from typing import Any, Dict, List, Optional, Set, Tuple, Union +from typing import Any, Dict, List, Optional, Set, Union -from geolib._compat import IS_PYDANTIC_V2 +from pydantic import Field, StringConstraints +from typing_extensions import Annotated -if IS_PYDANTIC_V2: - from pydantic import Field, StringConstraints - from typing_extensions import Annotated -else: - from pydantic import confloat, conint, conlist, constr - -import geolib.models.dsheetpiling.constructions as constructions from geolib.geometry import Point from geolib.models import BaseDataClass from geolib.models.dseries_parser import ( - DSerieListStructure, DSeriesInlineMappedProperties, DSeriesInlineReversedProperties, DSeriesNoParseSubStructure, DSeriesRepeatedGroupedProperties, DSeriesStructure, DSeriesStructureCollection, - DSeriesTableStructure, DSeriesUnmappedNameProperties, DSeriesWrappedTableStructure, DSerieVersion, @@ -84,7 +74,6 @@ PassiveSide, SheetPilingElementMaterialType, Side, - SinglePileLoadOptions, SoilTypeModulusSubgradeReaction, VerifyType, ) @@ -130,112 +119,53 @@ class VersionExternals(DSeriesInlineMappedProperties): class Soil(DSeriesUnmappedNameProperties): - if IS_PYDANTIC_V2: - name: Annotated[ - str, StringConstraints(min_length=1, max_length=25) - ] = "default soil" - soilcolor: int = 9764853 - soilsoiltype: SoilTypeModulusSubgradeReaction = ( - SoilTypeModulusSubgradeReaction.SAND - ) - soilgraintype: GrainType = GrainType.FINE - soilgamdry: Annotated[float, Field(ge=0, le=100)] = 0.01 - soilgamwet: Annotated[float, Field(ge=0, le=100)] = 0.01 - soilrelativedensity: Annotated[float, Field(ge=0, le=100)] = 0 - soilemodmenard: Annotated[float, Field(ge=0.01, le=1000000)] = 0.01 - soilcohesion: Annotated[float, Field(ge=0, le=1000000000)] = 0 - soilphi: Annotated[float, Field(ge=-89, le=89)] = 0 - soildelta: Annotated[float, Field(ge=-80, le=89)] = 0.00 - soilisdeltaangleautomaticallycalculated: bool = False - soilocr: Annotated[float, Field(ge=0, le=1000)] = 1.00 - soilpermeabkx: Annotated[float, Field(ge=0.00000000001, le=1000000)] = 0.0001 - soilstdcohesion: Annotated[float, Field(ge=0, le=100000000)] = 0.00 - soilstdphi: Annotated[float, Field(ge=0, le=100000000)] = 0.00 - soildistcohesion: DistributionType = DistributionType.NONE - soildistphi: DistributionType = DistributionType.NONE - soilla: Annotated[float, Field(ge=0, le=1000)] = 0 - soilln: Annotated[float, Field(ge=0, le=1000)] = 0.01 - soillp: Annotated[float, Field(ge=0, le=1000)] = 0.01 - soilusemenard: ModulusSubgradeReaction = ModulusSubgradeReaction.MANUAL - soilusebrinchhansen: EarthPressureCoefficients = EarthPressureCoefficients.MANUAL - soilshellfactor: Annotated[float, Field(ge=1, le=1000)] = 1.00 - soillambdatype: LambdaType = LambdaType.MANUAL - soillam1: Annotated[float, Field(ge=0, le=100)] = 50 - soillam2: Annotated[float, Field(ge=0, le=100)] = 80 - soillam3: Annotated[float, Field(ge=0, le=100)] = 90 - soilkb0: Annotated[float, Field(ge=0.01, le=10000000000)] = 1.00000e04 - soilkb1: Annotated[float, Field(ge=0.01, le=10000000000)] = 5.00000e00 - soilkb2: Annotated[float, Field(ge=0.01, le=10000000000)] = 1.00000e04 - soilkb3: Annotated[float, Field(ge=0.01, le=10000000000)] = 1.00000e04 - soilkb4: Annotated[float, Field(ge=0.01, le=10000000000)] = 1.00000e04 - soilko0: Annotated[float, Field(ge=0.01, le=10000000000)] = 1.00000e04 - soilko1: Annotated[float, Field(ge=0.01, le=10000000000)] = 5.00000e00 - soilko2: Annotated[float, Field(ge=0.01, le=10000000000)] = 1.00000e04 - soilko3: Annotated[float, Field(ge=0.01, le=10000000000)] = 1.00000e04 - soilko4: Annotated[float, Field(ge=0.01, le=10000000000)] = 1.00000e04 - soilcurkb1: Annotated[float, Field(ge=0.01, le=10000000000)] = 2.00000e03 - soilcurkb2: Annotated[float, Field(ge=0.01, le=10000000000)] = 8.00000e02 - soilcurkb3: Annotated[float, Field(ge=0.01, le=10000000000)] = 5.00000e02 - soilcurko1: Annotated[float, Field(ge=0.01, le=10000000000)] = 2.00000e03 - soilcurko2: Annotated[float, Field(ge=0.01, le=10000000000)] = 8.00000e02 - soilcurko3: Annotated[float, Field(ge=0.01, le=10000000000)] = 5.00000e02 - soilhorizontalbehaviourtype: HorizontalBehaviorType = ( - HorizontalBehaviorType.ELASTIC - ) - soilelasticity: float = 1.00000e03 # fixed value - soildefaultelasticity: int = 1 # fixed value - else: - name: constr(min_length=1, max_length=25) = "default soil" - soilcolor: int = 9764853 - soilsoiltype: SoilTypeModulusSubgradeReaction = ( - SoilTypeModulusSubgradeReaction.SAND - ) - soilgraintype: GrainType = GrainType.FINE - soilgamdry: confloat(ge=0, le=100) = 0.01 - soilgamwet: confloat(ge=0, le=100) = 0.01 - soilrelativedensity: confloat(ge=0, le=100) = 0 - soilemodmenard: confloat(ge=0.01, le=1000000) = 0.01 - soilcohesion: confloat(ge=0, le=1000000000) = 0 - soilphi: confloat(ge=-89, le=89) = 0 - soildelta: confloat(ge=-80, le=89) = 0.00 - soilisdeltaangleautomaticallycalculated: bool = False - soilocr: confloat(ge=0, le=1000) = 1.00 - soilpermeabkx: confloat(ge=0.00000000001, le=1000000) = 0.0001 - soilstdcohesion: confloat(ge=0, le=100000000) = 0.00 - soilstdphi: confloat(ge=0, le=100000000) = 0.00 - soildistcohesion: DistributionType = DistributionType.NONE - soildistphi: DistributionType = DistributionType.NONE - soilla: confloat(ge=0, le=1000) = 0 - soilln: confloat(ge=0, le=1000) = 0.01 - soillp: confloat(ge=0, le=1000) = 0.01 - soilusemenard: ModulusSubgradeReaction = ModulusSubgradeReaction.MANUAL - soilusebrinchhansen: EarthPressureCoefficients = EarthPressureCoefficients.MANUAL - soilshellfactor: confloat(ge=1, le=1000) = 1.00 - soillambdatype: LambdaType = LambdaType.MANUAL - soillam1: confloat(ge=0, le=100) = 50 - soillam2: confloat(ge=0, le=100) = 80 - soillam3: confloat(ge=0, le=100) = 90 - soilkb0: confloat(ge=0.01, le=10000000000) = 1.00000e04 - soilkb1: confloat(ge=0.01, le=10000000000) = 5.00000e00 - soilkb2: confloat(ge=0.01, le=10000000000) = 1.00000e04 - soilkb3: confloat(ge=0.01, le=10000000000) = 1.00000e04 - soilkb4: confloat(ge=0.01, le=10000000000) = 1.00000e04 - soilko0: confloat(ge=0.01, le=10000000000) = 1.00000e04 - soilko1: confloat(ge=0.01, le=10000000000) = 5.00000e00 - soilko2: confloat(ge=0.01, le=10000000000) = 1.00000e04 - soilko3: confloat(ge=0.01, le=10000000000) = 1.00000e04 - soilko4: confloat(ge=0.01, le=10000000000) = 1.00000e04 - soilcurkb1: confloat(ge=0.01, le=10000000000) = 2.00000e03 - soilcurkb2: confloat(ge=0.01, le=10000000000) = 8.00000e02 - soilcurkb3: confloat(ge=0.01, le=10000000000) = 5.00000e02 - soilcurko1: confloat(ge=0.01, le=10000000000) = 2.00000e03 - soilcurko2: confloat(ge=0.01, le=10000000000) = 8.00000e02 - soilcurko3: confloat(ge=0.01, le=10000000000) = 5.00000e02 - soilhorizontalbehaviourtype: HorizontalBehaviorType = ( - HorizontalBehaviorType.ELASTIC - ) - soilelasticity: float = 1.00000e03 # fixed value - soildefaultelasticity: int = 1 # fixed value + name: Annotated[str, StringConstraints(min_length=1, max_length=25)] = "default soil" + soilcolor: int = 9764853 + soilsoiltype: SoilTypeModulusSubgradeReaction = SoilTypeModulusSubgradeReaction.SAND + soilgraintype: GrainType = GrainType.FINE + soilgamdry: Annotated[float, Field(ge=0, le=100)] = 0.01 + soilgamwet: Annotated[float, Field(ge=0, le=100)] = 0.01 + soilrelativedensity: Annotated[float, Field(ge=0, le=100)] = 0 + soilemodmenard: Annotated[float, Field(ge=0.01, le=1000000)] = 0.01 + soilcohesion: Annotated[float, Field(ge=0, le=1000000000)] = 0 + soilphi: Annotated[float, Field(ge=-89, le=89)] = 0 + soildelta: Annotated[float, Field(ge=-80, le=89)] = 0.00 + soilisdeltaangleautomaticallycalculated: bool = False + soilocr: Annotated[float, Field(ge=0, le=1000)] = 1.00 + soilpermeabkx: Annotated[float, Field(ge=0.00000000001, le=1000000)] = 0.0001 + soilstdcohesion: Annotated[float, Field(ge=0, le=100000000)] = 0.00 + soilstdphi: Annotated[float, Field(ge=0, le=100000000)] = 0.00 + soildistcohesion: DistributionType = DistributionType.NONE + soildistphi: DistributionType = DistributionType.NONE + soilla: Annotated[float, Field(ge=0, le=1000)] = 0 + soilln: Annotated[float, Field(ge=0, le=1000)] = 0.01 + soillp: Annotated[float, Field(ge=0, le=1000)] = 0.01 + soilusemenard: ModulusSubgradeReaction = ModulusSubgradeReaction.MANUAL + soilusebrinchhansen: EarthPressureCoefficients = EarthPressureCoefficients.MANUAL + soilshellfactor: Annotated[float, Field(ge=1, le=1000)] = 1.00 + soillambdatype: LambdaType = LambdaType.MANUAL + soillam1: Annotated[float, Field(ge=0, le=100)] = 50 + soillam2: Annotated[float, Field(ge=0, le=100)] = 80 + soillam3: Annotated[float, Field(ge=0, le=100)] = 90 + soilkb0: Annotated[float, Field(ge=0.01, le=10000000000)] = 1.00000e04 + soilkb1: Annotated[float, Field(ge=0.01, le=10000000000)] = 5.00000e00 + soilkb2: Annotated[float, Field(ge=0.01, le=10000000000)] = 1.00000e04 + soilkb3: Annotated[float, Field(ge=0.01, le=10000000000)] = 1.00000e04 + soilkb4: Annotated[float, Field(ge=0.01, le=10000000000)] = 1.00000e04 + soilko0: Annotated[float, Field(ge=0.01, le=10000000000)] = 1.00000e04 + soilko1: Annotated[float, Field(ge=0.01, le=10000000000)] = 5.00000e00 + soilko2: Annotated[float, Field(ge=0.01, le=10000000000)] = 1.00000e04 + soilko3: Annotated[float, Field(ge=0.01, le=10000000000)] = 1.00000e04 + soilko4: Annotated[float, Field(ge=0.01, le=10000000000)] = 1.00000e04 + soilcurkb1: Annotated[float, Field(ge=0.01, le=10000000000)] = 2.00000e03 + soilcurkb2: Annotated[float, Field(ge=0.01, le=10000000000)] = 8.00000e02 + soilcurkb3: Annotated[float, Field(ge=0.01, le=10000000000)] = 5.00000e02 + soilcurko1: Annotated[float, Field(ge=0.01, le=10000000000)] = 2.00000e03 + soilcurko2: Annotated[float, Field(ge=0.01, le=10000000000)] = 8.00000e02 + soilcurko3: Annotated[float, Field(ge=0.01, le=10000000000)] = 5.00000e02 + soilhorizontalbehaviourtype: HorizontalBehaviorType = HorizontalBehaviorType.ELASTIC + soilelasticity: float = 1.00000e03 # fixed value + soildefaultelasticity: int = 1 # fixed value class SoilCollection(DSeriesStructureCollection): @@ -276,20 +206,14 @@ class SoilLayer(DSeriesNoParseSubStructure): class SoilProfile(DSeriesNoParseSubStructure): - if IS_PYDANTIC_V2: - name: Annotated[str, StringConstraints(min_length=1, max_length=25)] - else: - name: constr(min_length=1, max_length=25) + name: Annotated[str, StringConstraints(min_length=1, max_length=25)] layers: List[SoilLayer] coordinate: Point class SoilProfiles(DSeriesNoParseSubStructure): soil_profiles: List[SoilProfile] = [] - if IS_PYDANTIC_V2: - curve_number: Annotated[int, Field(ge=1, le=4)] = 3 - else: - curve_number: conint(ge=1, le=4) = 3 + curve_number: Annotated[int, Field(ge=1, le=4)] = 3 use_unloading_reloading_curve: bool = False modulus_reaction_type: int = ModulusReactionType.SECANT.value @@ -313,16 +237,10 @@ class CalculationOptions(DSeriesStructure): # available when c, phi , delta is selected for as a model calcautolambdason: bool = True # design sheet pile length calculation - if IS_PYDANTIC_V2: - designstage: Annotated[int, Field(ge=0)] = 0 - designpilelengthfrom: Annotated[float, Field(ge=1, le=100)] = 1 - designpilelengthto: Annotated[float, Field(ge=1, le=100)] = 1 - designpilelengthdecrement: Annotated[float, Field(ge=0.01, le=10)] = 0.01 - else: - designstage: conint(ge=0) = 0 - designpilelengthfrom: confloat(ge=1, le=100) = 1 - designpilelengthto: confloat(ge=1, le=100) = 1 - designpilelengthdecrement: confloat(ge=0.01, le=10) = 0.01 + designstage: Annotated[int, Field(ge=0)] = 0 + designpilelengthfrom: Annotated[float, Field(ge=1, le=100)] = 1 + designpilelengthto: Annotated[float, Field(ge=1, le=100)] = 1 + designpilelengthdecrement: Annotated[float, Field(ge=0.01, le=10)] = 0.01 designpilelengthnew: int = 1 # fixed value designtype: DesignType = DesignType.REPRESENTATIVE designeurocodepartialfactorset: PartialFactorSetEC = PartialFactorSetEC.DA1SET1 @@ -343,31 +261,19 @@ class CalculationOptions(DSeriesStructure): eurocodeoverallstability: bool = False ec7nlmethod: PartialFactorCalculationType = PartialFactorCalculationType.METHODA ec7nloverallpartialfactorset: PartialFactorSetEC7NADNL = PartialFactorSetEC7NADNL.RC0 - if IS_PYDANTIC_V2: - ec7nloverallanchorfactor: Annotated[float, Field(ge=0.001, le=1000)] = 1 - else: - ec7nloverallanchorfactor: confloat(ge=0.001, le=1000) = 1 + ec7nloverallanchorfactor: Annotated[float, Field(ge=0.001, le=1000)] = 1 ec7nadnloverallstability: bool = False ec7beoverallstability: bool = False ec7bemethod: PartialFactorCalculationType = PartialFactorCalculationType.METHODA nbmethod: PartialFactorCalculationType = PartialFactorCalculationType.METHODA curmethod: PartialFactorCalculationType = PartialFactorCalculationType.METHODA curoverallpartialfactorset: PartialFactorSetCUR = PartialFactorSetCUR.CLASSI - if IS_PYDANTIC_V2: - curoverallanchorfactor: Annotated[float, Field(ge=0.001, le=1000)] = 1 - else: - curoverallanchorfactor: confloat(ge=0.001, le=1000) = 1 + curoverallanchorfactor: Annotated[float, Field(ge=0.001, le=1000)] = 1 curoverallstability: bool = False - if IS_PYDANTIC_V2: - # Characteristic Kranz Anchor Strength calculation - curanchorforcestage: Annotated[int, Field(ge=0)] = 0 - # Overall stability calculation - curstabilitystage: Annotated[int, Field(ge=0)] = 0 - else: - # Characteristic Kranz Anchor Strength calculation - curanchorforcestage: conint(ge=0) = 0 - # Overall stability calculation - curstabilitystage: conint(ge=0) = 0 + # Characteristic Kranz Anchor Strength calculation + curanchorforcestage: Annotated[int, Field(ge=0)] = 0 + # Overall stability calculation + curstabilitystage: Annotated[int, Field(ge=0)] = 0 overallstabilitytype: DesignType = DesignType.REPRESENTATIVE stabilityexport: bool = False stabilityeurocodepartialfactorset: PartialFactorSetEC = PartialFactorSetEC.DA1SET1 @@ -400,108 +306,61 @@ class CalculationOptions(DSeriesStructure): class SheetPileElement(DSeriesUnmappedNameProperties): - if IS_PYDANTIC_V2: - name: Annotated[ - str, StringConstraints(min_length=1, max_length=50) - ] = _DEFAULT_SHEET_PILING_ELEMENT_NAME - sheetpilingelementmaterialtype: SheetPilingElementMaterialType = ( - SheetPilingElementMaterialType.Steel - ) - sheetpilingelementei: Annotated[float, Field(ge=0.001, le=1e12)] = 100000 - sheetpilingelementwidth: Annotated[float, Field(ge=0, le=1000)] = 1 - sheetpilingelementlevel: Annotated[float, Field(ge=-10000, le=10000)] = -10 - sheetpilingelementheight: Annotated[int, Field(ge=10, le=100000)] = 400 - sheetpilingpilewidth: Annotated[float, Field(ge=0, le=100000)] = 0 - sheetpilingelementsectionarea: Annotated[int, Field(ge=10, le=100000)] = 170 - sheetpilingelementresistingmoment: Annotated[int, Field(ge=0, le=100000)] = 0 - sheetpilingelementreductionfactorei: Annotated[float, Field(ge=0.01, le=10)] = 1 - sheetpilingelementnote: Annotated[ - str, StringConstraints(min_length=0, max_length=20) - ] = "" - sheetpilingelementmaxcharacteristicmoment: Annotated[ - float, Field(ge=0, le=100000) - ] = 0 - sheetpilingelementmaxplasticcharacteristicmoment: Annotated[ - float, Field(ge=0, le=100000) - ] = 0 - sheetpilingelementkmod: Annotated[float, Field(ge=0.01, le=1)] = 0.01 - sheetpilingelementmaterialfactor: Annotated[float, Field(ge=0.01, le=10)] = 0.01 - ssheetpilingelementreductionfactormaxmoment: Annotated[ - float, Field(ge=0.01, le=10) - ] = 1 - diaphragmwallissymmetric: Annotated[int, Field(ge=0, le=1)] = 0 - diaphragmwallposeielastoplastic1: Annotated[float, Field(ge=0, le=100000)] = 0 - diaphragmwallnegeielastoplastic1: Annotated[float, Field(ge=0, le=100000)] = 0 - diaphragmwallposmomelastic: Annotated[ - float, Field(ge=0, le=1000000000000) - ] = 100000 - diaphragmwallnegmomelastic: Annotated[float, Field(ge=0, le=100000)] = 0 - diaphragmwallposmomplastic: Annotated[float, Field(ge=0, le=100000)] = 0 - diaphragmwallnegmomplastic: Annotated[float, Field(ge=0, le=100000)] = 0 - diaphragmwallposeielastoplastic2: Annotated[float, Field(ge=0, le=100000)] = 0 - diaphragmwallposmomelastoplastic: Annotated[float, Field(ge=0, le=100000)] = 0 - diaphragmwallnegeielastoplastic2: Annotated[float, Field(ge=0, le=100000)] = 0 - diaphragmwallnegmomelastoplastic: Annotated[float, Field(ge=0, le=100000)] = 0 - woodensheetpilingelemente: Annotated[ - float, Field(ge=0.001, le=1000000000000) - ] = 100000 - woodensheetpilingelementcharacflexuralstrength: Annotated[ - float, Field(ge=0, le=100000) - ] = 0 - woodensheetpilingelementksys: Annotated[float, Field(ge=0.01, le=10)] = 1.15 - woodensheetpilingelementkdef: Annotated[float, Field(ge=0.01, le=10)] = 1 - woodensheetpilingelementpsi2eff: Annotated[float, Field(ge=0, le=10)] = 1 - woodensheetpilingelementmaterialfactor: Annotated[ - float, Field(ge=0.01, le=10) - ] = 1.3 - woodensheetpilingelementkmodfshort: Annotated[float, Field(ge=0.01, le=10)] = 0.65 - woodensheetpilingelementkmodflong: Annotated[float, Field(ge=0.01, le=10)] = 0.5 - woodensheetpilingelementkmode: Annotated[float, Field(ge=0.01, le=10)] = 0.8 - else: - name: constr(min_length=1, max_length=50) = _DEFAULT_SHEET_PILING_ELEMENT_NAME - sheetpilingelementmaterialtype: SheetPilingElementMaterialType = ( - SheetPilingElementMaterialType.Steel - ) - sheetpilingelementei: confloat(ge=0.001, le=1e12) = 100000 - sheetpilingelementwidth: confloat(ge=0, le=1000) = 1 - sheetpilingelementlevel: confloat(ge=-10000, le=10000) = -10 - sheetpilingelementheight: conint(ge=10, le=100000) = 400 - sheetpilingpilewidth: confloat(ge=0, le=100000) = 0 - sheetpilingelementsectionarea: conint(ge=10, le=100000) = 170 - sheetpilingelementresistingmoment: conint(ge=0, le=100000) = 0 - sheetpilingelementreductionfactorei: confloat(ge=0.01, le=10) = 1 - sheetpilingelementnote: constr(min_length=0, max_length=20) = "" - sheetpilingelementmaxcharacteristicmoment: confloat(ge=0, le=100000) = 0 - sheetpilingelementmaxplasticcharacteristicmoment: confloat(ge=0, le=100000) = 0 - sheetpilingelementkmod: confloat(ge=0.01, le=1) = 0.01 - sheetpilingelementmaterialfactor: confloat(ge=0.01, le=10) = 0.01 - ssheetpilingelementreductionfactormaxmoment: confloat(ge=0.01, le=10) = 1 - diaphragmwallissymmetric: conint(ge=0, le=1) = 0 - diaphragmwallposeielastoplastic1: confloat(ge=0, le=100000) = 0 - diaphragmwallnegeielastoplastic1: confloat(ge=0, le=100000) = 0 - diaphragmwallposmomelastic: confloat(ge=0, le=1000000000000) = 100000 - diaphragmwallnegmomelastic: confloat(ge=0, le=100000) = 0 - diaphragmwallposmomplastic: confloat(ge=0, le=100000) = 0 - diaphragmwallnegmomplastic: confloat(ge=0, le=100000) = 0 - diaphragmwallposeielastoplastic2: confloat(ge=0, le=100000) = 0 - diaphragmwallposmomelastoplastic: confloat(ge=0, le=100000) = 0 - diaphragmwallnegeielastoplastic2: confloat(ge=0, le=100000) = 0 - diaphragmwallnegmomelastoplastic: confloat(ge=0, le=100000) = 0 - woodensheetpilingelemente: confloat(ge=0.001, le=1000000000000) = 100000 - woodensheetpilingelementcharacflexuralstrength: confloat(ge=0, le=100000) = 0 - woodensheetpilingelementksys: confloat(ge=0.01, le=10) = 1.15 - woodensheetpilingelementkdef: confloat(ge=0.01, le=10) = 1 - woodensheetpilingelementpsi2eff: confloat(ge=0, le=10) = 1 - woodensheetpilingelementmaterialfactor: confloat(ge=0.01, le=10) = 1.3 - woodensheetpilingelementkmodfshort: confloat(ge=0.01, le=10) = 0.65 - woodensheetpilingelementkmodflong: confloat(ge=0.01, le=10) = 0.5 - woodensheetpilingelementkmode: confloat(ge=0.01, le=10) = 0.8 + name: Annotated[ + str, StringConstraints(min_length=1, max_length=50) + ] = _DEFAULT_SHEET_PILING_ELEMENT_NAME + sheetpilingelementmaterialtype: SheetPilingElementMaterialType = ( + SheetPilingElementMaterialType.Steel + ) + sheetpilingelementei: Annotated[float, Field(ge=0.001, le=1e12)] = 100000 + sheetpilingelementwidth: Annotated[float, Field(ge=0, le=1000)] = 1 + sheetpilingelementlevel: Annotated[float, Field(ge=-10000, le=10000)] = -10 + sheetpilingelementheight: Annotated[int, Field(ge=10, le=100000)] = 400 + sheetpilingpilewidth: Annotated[float, Field(ge=0, le=100000)] = 0 + sheetpilingelementsectionarea: Annotated[int, Field(ge=10, le=100000)] = 170 + sheetpilingelementresistingmoment: Annotated[int, Field(ge=0, le=100000)] = 0 + sheetpilingelementreductionfactorei: Annotated[float, Field(ge=0.01, le=10)] = 1 + sheetpilingelementnote: Annotated[ + str, StringConstraints(min_length=0, max_length=20) + ] = "" + sheetpilingelementmaxcharacteristicmoment: Annotated[ + float, Field(ge=0, le=100000) + ] = 0 + sheetpilingelementmaxplasticcharacteristicmoment: Annotated[ + float, Field(ge=0, le=100000) + ] = 0 + sheetpilingelementkmod: Annotated[float, Field(ge=0.01, le=1)] = 0.01 + sheetpilingelementmaterialfactor: Annotated[float, Field(ge=0.01, le=10)] = 0.01 + ssheetpilingelementreductionfactormaxmoment: Annotated[ + float, Field(ge=0.01, le=10) + ] = 1 + diaphragmwallissymmetric: Annotated[int, Field(ge=0, le=1)] = 0 + diaphragmwallposeielastoplastic1: Annotated[float, Field(ge=0, le=100000)] = 0 + diaphragmwallnegeielastoplastic1: Annotated[float, Field(ge=0, le=100000)] = 0 + diaphragmwallposmomelastic: Annotated[float, Field(ge=0, le=1000000000000)] = 100000 + diaphragmwallnegmomelastic: Annotated[float, Field(ge=0, le=100000)] = 0 + diaphragmwallposmomplastic: Annotated[float, Field(ge=0, le=100000)] = 0 + diaphragmwallnegmomplastic: Annotated[float, Field(ge=0, le=100000)] = 0 + diaphragmwallposeielastoplastic2: Annotated[float, Field(ge=0, le=100000)] = 0 + diaphragmwallposmomelastoplastic: Annotated[float, Field(ge=0, le=100000)] = 0 + diaphragmwallnegeielastoplastic2: Annotated[float, Field(ge=0, le=100000)] = 0 + diaphragmwallnegmomelastoplastic: Annotated[float, Field(ge=0, le=100000)] = 0 + woodensheetpilingelemente: Annotated[ + float, Field(ge=0.001, le=1000000000000) + ] = 100000 + woodensheetpilingelementcharacflexuralstrength: Annotated[ + float, Field(ge=0, le=100000) + ] = 0 + woodensheetpilingelementksys: Annotated[float, Field(ge=0.01, le=10)] = 1.15 + woodensheetpilingelementkdef: Annotated[float, Field(ge=0.01, le=10)] = 1 + woodensheetpilingelementpsi2eff: Annotated[float, Field(ge=0, le=10)] = 1 + woodensheetpilingelementmaterialfactor: Annotated[float, Field(ge=0.01, le=10)] = 1.3 + woodensheetpilingelementkmodfshort: Annotated[float, Field(ge=0.01, le=10)] = 0.65 + woodensheetpilingelementkmodflong: Annotated[float, Field(ge=0.01, le=10)] = 0.5 + woodensheetpilingelementkmode: Annotated[float, Field(ge=0.01, le=10)] = 0.8 def __init__(self, *args, **kwargs) -> "SheetPileElement": - if IS_PYDANTIC_V2: - default_dict = dict(self.model_fields) - else: - default_dict = dict(self.__fields__) + default_dict = dict(self.model_fields) for field, value in kwargs.items(): if value is None: kwargs[field] = default_dict[field].default @@ -560,39 +419,23 @@ def update_arguments_if_invalid_input(self) -> None: class SheetPiling(DSeriesStructureCollection): - if IS_PYDANTIC_V2: - sheetpiling: Annotated[List[SheetPileElement], Field(min_length=1)] = [ - SheetPileElement() - ] - leveltopsheetpiling: Annotated[float, Field(ge=-10000, le=10000)] = 0.0 - lengthsheetpiling: Annotated[float, Field(gt=0)] = 10 - else: - sheetpiling: conlist(SheetPileElement, min_items=1) = [SheetPileElement()] - leveltopsheetpiling: confloat(ge=-10000, le=10000) = 0.0 - lengthsheetpiling: confloat(gt=0) = 10 + sheetpiling: Annotated[List[SheetPileElement], Field(min_length=1)] = [ + SheetPileElement() + ] + leveltopsheetpiling: Annotated[float, Field(ge=-10000, le=10000)] = 0.0 + lengthsheetpiling: Annotated[float, Field(gt=0)] = 10 class Anchor(DSheetpilingTableEntry): - if IS_PYDANTIC_V2: - name: Annotated[str, StringConstraints(min_length=1, max_length=50)] - level: float = 0 - e_modulus: Annotated[float, Field(gt=0)] = 2.1e8 - cross_section: Optional[Annotated[float, Field(gt=0)]] = 1e-3 - wall_height_kranz: Optional[Annotated[float, Field(ge=0)]] = 0.00 - length: Optional[Annotated[float, Field(gt=0)]] = 1 - angle: Optional[float] = 0.00 - yield_force: Optional[Annotated[float, Field(ge=0)]] = 0.00 - side: Side = Side.RIGHT - else: - name: constr(min_length=1, max_length=50) - level: float = 0 - e_modulus: confloat(gt=0) = 2.1e8 - cross_section: Optional[confloat(gt=0)] = 1e-3 - wall_height_kranz: Optional[confloat(ge=0)] = 0.00 - length: Optional[confloat(gt=0)] = 1 - angle: Optional[float] = 0.00 - yield_force: Optional[confloat(ge=0)] = 0.00 - side: Side = Side.RIGHT + name: Annotated[str, StringConstraints(min_length=1, max_length=50)] + level: float = 0 + e_modulus: Annotated[float, Field(gt=0)] = 2.1e8 + cross_section: Optional[Annotated[float, Field(gt=0)]] = 1e-3 + wall_height_kranz: Optional[Annotated[float, Field(ge=0)]] = 0.00 + length: Optional[Annotated[float, Field(gt=0)]] = 1 + angle: Optional[float] = 0.00 + yield_force: Optional[Annotated[float, Field(ge=0)]] = 0.00 + side: Side = Side.RIGHT class Anchors(DSheetpilingUnwrappedTable): @@ -610,31 +453,18 @@ class AnchorOrStrutPresstressReference(BaseDataClass): prestress.""" name: str - if IS_PYDANTIC_V2: - pre_stress: Annotated[float, Field(ge=0)] = _DEFAULT_PRE_STRESS - else: - pre_stress: confloat(ge=0) = _DEFAULT_PRE_STRESS + pre_stress: Annotated[float, Field(ge=0)] = _DEFAULT_PRE_STRESS class Strut(DSheetpilingTableEntry): - if IS_PYDANTIC_V2: - name: Annotated[str, StringConstraints(min_length=1, max_length=50)] - level: float = 0 - e_modulus: Annotated[float, Field(gt=0)] = 2.1e8 - cross_section: Optional[Annotated[float, Field(gt=0)]] = 1e-4 - length: Optional[Annotated[float, Field(gt=0)]] = 1 - angle: Optional[float] = 0.00 - buckling_force: Optional[Annotated[float, Field(ge=0)]] = 0.00 - side: Side = Side.RIGHT - else: - name: constr(min_length=1, max_length=50) - level: float = 0 - e_modulus: confloat(gt=0) = 2.1e8 - cross_section: Optional[confloat(gt=0)] = 1e-4 - length: Optional[confloat(gt=0)] = 1 - angle: Optional[float] = 0.00 - buckling_force: Optional[confloat(ge=0)] = 0.00 - side: Side = Side.RIGHT + name: Annotated[str, StringConstraints(min_length=1, max_length=50)] + level: float = 0 + e_modulus: Annotated[float, Field(gt=0)] = 2.1e8 + cross_section: Optional[Annotated[float, Field(gt=0)]] = 1e-4 + length: Optional[Annotated[float, Field(gt=0)]] = 1 + angle: Optional[float] = 0.00 + buckling_force: Optional[Annotated[float, Field(ge=0)]] = 0.00 + side: Side = Side.RIGHT class Struts(DSheetpilingUnwrappedTable): @@ -648,10 +478,7 @@ def strut_names(self) -> Set[str]: class ConstructionStage(DSeriesUnmappedNameProperties): - if IS_PYDANTIC_V2: - name: Annotated[str, StringConstraints(min_length=1, max_length=50)] - else: - name: constr(min_length=1, max_length=50) + name: Annotated[str, StringConstraints(min_length=1, max_length=50)] displacement_top_sheet_piling: float = 0 passive_side: PassiveSide = PassiveSide.DSHEETPILING_DETERMINED method_left: LateralEarthPressureMethodStage = ( @@ -687,10 +514,7 @@ def stage_names(self) -> Set[str]: class WaterLevel(DSeriesNoParseSubStructure): - if IS_PYDANTIC_V2: - name: Annotated[str, StringConstraints(min_length=1, max_length=50)] - else: - name: constr(min_length=1, max_length=50) + name: Annotated[str, StringConstraints(min_length=1, max_length=50)] level: float distribution_type: DistributionType = DistributionType.NONE standard_deviation: float = 0.0 @@ -709,16 +533,10 @@ class StageOptions(DSeriesInlineMappedProperties): stagepartialfactorsetcur: PartialFactorSetCUR = PartialFactorSetCUR.UNKNOWN stageverify: int = 0 - if IS_PYDANTIC_V2: - stageanchorfactor: Annotated[float, Field(ge=0.001, le=1000)] = 1 - else: - stageanchorfactor: confloat(ge=0.001, le=1000) = 1 + stageanchorfactor: Annotated[float, Field(ge=0.001, le=1000)] = 1 stagepartialfactorsetec7nadnl: PartialFactorSetEC7NADNL = PartialFactorSetEC7NADNL.RC0 stageverifyec7nadnl: int = 0 - if IS_PYDANTIC_V2: - stageanchorfactorec7nadnl: Annotated[float, Field(ge=0.001, le=1000)] = 1 - else: - stageanchorfactorec7nadnl: confloat(ge=0.001, le=1000) = 1 + stageanchorfactorec7nadnl: Annotated[float, Field(ge=0.001, le=1000)] = 1 stageverifyec7nadbe: int = 0 @@ -729,10 +547,7 @@ class CalculationOptionsPerStage(DSeriesStructureCollection): class UniformLoad(DSeriesUnmappedNameProperties): - if IS_PYDANTIC_V2: - name: Annotated[str, StringConstraints(min_length=1, max_length=50)] - else: - name: constr(min_length=1, max_length=50) + name: Annotated[str, StringConstraints(min_length=1, max_length=50)] uniformloadleft: float uniformloadright: float uniformloadpermanent: LoadTypePermanentVariable = LoadTypePermanentVariable.PERMANENT @@ -759,10 +574,7 @@ class SurchargePoint(DSeriesInlineMappedProperties): class SurchargeLoad(DSheetpilingSurchargeLoad): - if IS_PYDANTIC_V2: - name: Annotated[str, StringConstraints(min_length=1, max_length=50)] - else: - name: constr(min_length=1, max_length=50) + name: Annotated[str, StringConstraints(min_length=1, max_length=50)] points: List[SurchargePoint] = [] surchargeloadpermanent: LoadTypePermanentVariable = ( LoadTypePermanentVariable.PERMANENT @@ -783,18 +595,11 @@ def load_names(self) -> Set[str]: class Surface(DSeriesNoParseSubStructure): # TODO determine structure - if IS_PYDANTIC_V2: - name: Annotated[str, StringConstraints(min_length=1, max_length=50)] - points: Annotated[List[Point], Field(min_length=1)] - points: Annotated[List[dict], Field(min_length=1)] - distribution_type: DistributionType = DistributionType.NONE - std: Annotated[float, Field(ge=0.0)] = 0.0 - else: - name: constr(min_length=1, max_length=50) - points: conlist(Point, min_items=1) - points: conlist(dict, min_items=1) - distribution_type: DistributionType = DistributionType.NONE - std: confloat(ge=0.0) = 0.0 + name: Annotated[str, StringConstraints(min_length=1, max_length=50)] + points: Annotated[List[Point], Field(min_length=1)] + points: Annotated[List[dict], Field(min_length=1)] + distribution_type: DistributionType = DistributionType.NONE + std: Annotated[float, Field(ge=0.0)] = 0.0 class Surfaces(DSeriesNoParseSubStructure): # TODO GroupList should be suitable? @@ -806,14 +611,9 @@ def surface_names(self) -> Set[str]: class HorizontalLineLoad(DSeriesNoParseSubStructure): - if IS_PYDANTIC_V2: - name: Annotated[str, StringConstraints(min_length=1, max_length=50)] - level: Annotated[float, Field(ge=-1e12, le=1e12)] = 0 - load: Annotated[float, Field(ge=-1e12, le=1e12)] = 100 - else: - name: constr(min_length=1, max_length=50) - level: confloat(ge=-1e12, le=1e12) = 0 - load: confloat(ge=-1e12, le=1e12) = 100 + name: Annotated[str, StringConstraints(min_length=1, max_length=50)] + level: Annotated[float, Field(ge=-1e12, le=1e12)] = 0 + load: Annotated[float, Field(ge=-1e12, le=1e12)] = 100 load_type: LoadTypeFavourableUnfavourable = ( LoadTypeFavourableUnfavourable.DSHEETPILING_DETERMINED ) @@ -825,14 +625,9 @@ class HorizontalLineLoads(DSeriesNoParseSubStructure): class Moment(DSeriesNoParseSubStructure): - if IS_PYDANTIC_V2: - name: Annotated[str, StringConstraints(min_length=1, max_length=50)] - level: Annotated[float, Field(ge=-1e12, le=1e12)] = 0 - load: Annotated[float, Field(ge=-1e12, le=1e12)] = 100 - else: - name: constr(min_length=1, max_length=50) - level: confloat(ge=-1e12, le=1e12) = 0 - load: confloat(ge=-1e12, le=1e12) = 100 + name: Annotated[str, StringConstraints(min_length=1, max_length=50)] + level: Annotated[float, Field(ge=-1e12, le=1e12)] = 0 + load: Annotated[float, Field(ge=-1e12, le=1e12)] = 100 load_type: LoadTypeFavourableUnfavourableMoment = ( LoadTypeFavourableUnfavourableMoment.FAVOURABLE ) @@ -844,18 +639,11 @@ class Moments(DSeriesNoParseSubStructure): class NormalForce(DSeriesNoParseSubStructure): - if IS_PYDANTIC_V2: - name: Annotated[str, StringConstraints(min_length=1, max_length=50)] - force_at_sheet_pile_top: Annotated[float, Field(ge=-1e12, le=1e12)] - force_at_surface_level_left_side: Annotated[float, Field(ge=-1e12, le=1e12)] - force_at_surface_level_right_side: Annotated[float, Field(ge=-1e12, le=1e12)] - force_at_sheet_pile_toe: Annotated[float, Field(ge=-1e12, le=1e12)] - else: - name: constr(min_length=1, max_length=50) - force_at_sheet_pile_top: confloat(ge=-1e12, le=1e12) - force_at_surface_level_left_side: confloat(ge=-1e12, le=1e12) - force_at_surface_level_right_side: confloat(ge=-1e12, le=1e12) - force_at_sheet_pile_toe: confloat(ge=-1e12, le=1e12) + name: Annotated[str, StringConstraints(min_length=1, max_length=50)] + force_at_sheet_pile_top: Annotated[float, Field(ge=-1e12, le=1e12)] + force_at_surface_level_left_side: Annotated[float, Field(ge=-1e12, le=1e12)] + force_at_surface_level_right_side: Annotated[float, Field(ge=-1e12, le=1e12)] + force_at_sheet_pile_toe: Annotated[float, Field(ge=-1e12, le=1e12)] load_type: LoadTypeFavourableUnfavourableMoment = ( LoadTypeFavourableUnfavourableMoment.FAVOURABLE ) @@ -869,16 +657,10 @@ class NormalForces(DSeriesNoParseSubStructure): class Support(DSeriesNoParseSubStructure): """Internal structure for spring and rigid supports.""" - if IS_PYDANTIC_V2: - name: Annotated[str, StringConstraints(min_length=1, max_length=50)] - level: float - rotational_stiffness: Annotated[float, Field(ge=0)] - translational_stiffness: Annotated[float, Field(ge=0)] - else: - name: constr(min_length=1, max_length=50) - level: float - rotational_stiffness: confloat(ge=0) - translational_stiffness: confloat(ge=0) + name: Annotated[str, StringConstraints(min_length=1, max_length=50)] + level: float + rotational_stiffness: Annotated[float, Field(ge=0)] + translational_stiffness: Annotated[float, Field(ge=0)] class SupportContainer(DSeriesNoParseSubStructure): diff --git a/geolib/models/dsheetpiling/loads.py b/geolib/models/dsheetpiling/loads.py index e5d380bd..67ad016b 100644 --- a/geolib/models/dsheetpiling/loads.py +++ b/geolib/models/dsheetpiling/loads.py @@ -1,15 +1,7 @@ -from abc import ABCMeta, abstractmethod -from typing import Optional +from typing import List -from geolib._compat import IS_PYDANTIC_V2 - -if IS_PYDANTIC_V2: - from typing import List - - from pydantic import Field, StringConstraints, field_validator - from typing_extensions import Annotated -else: - from pydantic import conlist, constr, validator +from pydantic import Field, StringConstraints, field_validator +from typing_extensions import Annotated from geolib.geometry import Point from geolib.models import BaseDataClass @@ -108,10 +100,7 @@ class UniformLoad(BaseDataClass): distribution_type_right: Distribution type of the right side. """ - if IS_PYDANTIC_V2: - name: Annotated[str, StringConstraints(min_length=1, max_length=50)] - else: - name: constr(min_length=1, max_length=50) + name: Annotated[str, StringConstraints(min_length=1, max_length=50)] left_load: float right_load: float verification_load_settings: VerificationLoadSettingsLoads = ( @@ -142,10 +131,7 @@ def to_internal(self) -> InternalUniformLoad: class Moment(BaseDataClass): """Moment Load.""" - if IS_PYDANTIC_V2: - name: Annotated[str, StringConstraints(min_length=1, max_length=50)] - else: - name: constr(min_length=1, max_length=50) + name: Annotated[str, StringConstraints(min_length=1, max_length=50)] level: float load: float verification_load_settings: VerificationLoadSettingsMomentNormalForce = ( @@ -153,16 +139,9 @@ class Moment(BaseDataClass): ) def to_internal(self) -> MomentInternal: - if IS_PYDANTIC_V2: - moment = MomentInternal( - **self.model_dump( - exclude_none=True, exclude=["verification_load_settings"] - ) - ) - else: - moment = MomentInternal( - **self.dict(exclude_none=True, exclude={"verification_load_settings"}) - ) + moment = MomentInternal( + **self.model_dump(exclude_none=True, exclude=["verification_load_settings"]) + ) moment.load_type = self.verification_load_settings.load_type moment.duration_type = self.verification_load_settings.duration_type return moment @@ -179,12 +158,8 @@ class SurchargeLoad(BaseDataClass): distribution_type: Distribution type. """ - if IS_PYDANTIC_V2: - name: Annotated[str, StringConstraints(min_length=1, max_length=50)] - points: Annotated[List[Point], Field(min_length=1)] - else: - name: constr(min_length=1, max_length=50) - points: conlist(Point, min_items=1) + name: Annotated[str, StringConstraints(min_length=1, max_length=50)] + points: Annotated[List[Point], Field(min_length=1)] verification_load_settings: VerificationLoadSettingsLoads = ( VerificationLoadSettingsLoads() ) @@ -202,14 +177,9 @@ def points_must_be_increasing_and_greater_or_equal_to_zero(cls, v): raise ValueError("x-coordinates must be strictly increasing") return v - if IS_PYDANTIC_V2: - point_validator = field_validator("points")( - points_must_be_increasing_and_greater_or_equal_to_zero - ) - else: - point_validator = validator("points")( - points_must_be_increasing_and_greater_or_equal_to_zero - ) + point_validator = field_validator("points")( + points_must_be_increasing_and_greater_or_equal_to_zero + ) def to_internal(self) -> InternalSurchargeLoad: surchargeload = InternalSurchargeLoad( @@ -235,10 +205,7 @@ def to_internal(self) -> InternalSurchargeLoad: class HorizontalLineLoad(BaseDataClass): """Horizontal Line Load.""" - if IS_PYDANTIC_V2: - name: Annotated[str, StringConstraints(min_length=1, max_length=50)] - else: - name: constr(min_length=1, max_length=50) + name: Annotated[str, StringConstraints(min_length=1, max_length=50)] level: float load: float verification_load_settings: VerificationLoadSettingsLoads = ( @@ -246,16 +213,9 @@ class HorizontalLineLoad(BaseDataClass): ) def to_internal(self) -> HorizontalLineLoadInternal: - if IS_PYDANTIC_V2: - horizontallineload = HorizontalLineLoadInternal( - **self.model_dump( - exclude_none=True, exclude=["verification_load_settings"] - ) - ) - else: - horizontallineload = HorizontalLineLoadInternal( - **self.dict(exclude_none=True, exclude={"verification_load_settings"}) - ) + horizontallineload = HorizontalLineLoadInternal( + **self.model_dump(exclude_none=True, exclude=["verification_load_settings"]) + ) horizontallineload.load_type = self.verification_load_settings.load_type horizontallineload.duration_type = self.verification_load_settings.duration_type return horizontallineload @@ -264,10 +224,7 @@ def to_internal(self) -> HorizontalLineLoadInternal: class NormalForce(BaseDataClass): """Normal Force Load.""" - if IS_PYDANTIC_V2: - name: Annotated[str, StringConstraints(min_length=1, max_length=50)] - else: - name: constr(min_length=1, max_length=50) + name: Annotated[str, StringConstraints(min_length=1, max_length=50)] force_at_sheet_pile_top: float force_at_surface_level_left_side: float force_at_surface_level_right_side: float @@ -277,16 +234,9 @@ class NormalForce(BaseDataClass): ) def to_internal(self) -> NormalForceInternal: - if IS_PYDANTIC_V2: - normalforce = NormalForceInternal( - **self.model_dump( - exclude_none=True, exclude=["verification_load_settings"] - ) - ) - else: - normalforce = NormalForceInternal( - **self.dict(exclude_none=True, exclude={"verification_load_settings"}) - ) + normalforce = NormalForceInternal( + **self.model_dump(exclude_none=True, exclude=["verification_load_settings"]) + ) normalforce.load_type = self.verification_load_settings.load_type normalforce.duration_type = self.verification_load_settings.duration_type return normalforce diff --git a/geolib/models/dsheetpiling/profiles.py b/geolib/models/dsheetpiling/profiles.py index 49b43230..aabf85a4 100644 --- a/geolib/models/dsheetpiling/profiles.py +++ b/geolib/models/dsheetpiling/profiles.py @@ -6,17 +6,11 @@ from typing import List -from geolib._compat import IS_PYDANTIC_V2 - -if IS_PYDANTIC_V2: - from pydantic import Field, field_validator - from typing_extensions import Annotated -else: - from pydantic import conlist, validator +from pydantic import Field, field_validator +from typing_extensions import Annotated from geolib.geometry.one import Point from geolib.models import BaseDataClass -from geolib.soils import Soil from .internal import SoilProfile as InternalSoilProfile @@ -52,10 +46,7 @@ class SoilProfile(BaseDataClass): """D-Sheetpiling Profile.""" name: str - if IS_PYDANTIC_V2: - layers: Annotated[List[SoilLayer], Field(min_length=1)] - else: - layers: conlist(SoilLayer, min_items=1) + layers: Annotated[List[SoilLayer], Field(min_length=1)] coordinate: Point = Point(x=0, y=0) @classmethod @@ -67,15 +58,9 @@ def top_of_layers_must_be_decreasing(cls, v): ) return v - if IS_PYDANTIC_V2: - top_of_layer_validator = field_validator( - "layers", - )(top_of_layers_must_be_decreasing) - else: - top_of_layer_validator = validator("layers")(top_of_layers_must_be_decreasing) + top_of_layer_validator = field_validator( + "layers", + )(top_of_layers_must_be_decreasing) def to_internal(self) -> InternalSoilProfile: - if IS_PYDANTIC_V2: - return InternalSoilProfile(**self.model_dump(exclude_none=True)) - else: - return InternalSoilProfile(**self.dict(exclude_none=True)) + return InternalSoilProfile(**self.model_dump(exclude_none=True)) diff --git a/geolib/models/dsheetpiling/settings.py b/geolib/models/dsheetpiling/settings.py index f58d16b3..91fb1d25 100644 --- a/geolib/models/dsheetpiling/settings.py +++ b/geolib/models/dsheetpiling/settings.py @@ -1,12 +1,7 @@ from enum import Enum, IntEnum -from geolib._compat import IS_PYDANTIC_V2 - -if IS_PYDANTIC_V2: - from pydantic import Field - from typing_extensions import Annotated -else: - from pydantic import conint +from pydantic import Field +from typing_extensions import Annotated from geolib.models import BaseDataClass @@ -212,10 +207,7 @@ class ModulusReactionType(Enum): class CurveSettings(BaseDataClass): modulus_reaction_type: ModulusReactionType = ModulusReactionType.SECANT use_unloading_reloading_curve: bool = False - if IS_PYDANTIC_V2: - curve_number: Annotated[int, Field(ge=1, le=4)] = 3 - else: - curve_number: conint(ge=1, le=4) = 3 + curve_number: Annotated[int, Field(ge=1, le=4)] = 3 class LoadTypeFavourableUnfavourable(IntEnum): diff --git a/geolib/models/dsheetpiling/supports.py b/geolib/models/dsheetpiling/supports.py index fd85f6ce..e8f955b1 100644 --- a/geolib/models/dsheetpiling/supports.py +++ b/geolib/models/dsheetpiling/supports.py @@ -1,13 +1,8 @@ from enum import IntEnum from typing import Optional -from geolib._compat import IS_PYDANTIC_V2 - -if IS_PYDANTIC_V2: - from pydantic import Field, PositiveFloat, StringConstraints - from typing_extensions import Annotated -else: - from pydantic import PositiveFloat, confloat, constr +from pydantic import Field, PositiveFloat, StringConstraints +from typing_extensions import Annotated from geolib.models import BaseDataClass @@ -32,30 +27,18 @@ class Anchor(BaseDataClass): side: Side of the anchor [Side] """ - if IS_PYDANTIC_V2: - name: Annotated[str, StringConstraints(min_length=1, max_length=50)] - else: - name: constr(min_length=1, max_length=50) + name: Annotated[str, StringConstraints(min_length=1, max_length=50)] level: float e_modulus: Optional[PositiveFloat] = None cross_section: Optional[PositiveFloat] = None - if IS_PYDANTIC_V2: - wall_height_kranz: Optional[Annotated[float, Field(ge=0)]] = None - else: - wall_height_kranz: Optional[confloat(ge=0)] = None + wall_height_kranz: Optional[Annotated[float, Field(ge=0)]] = None length: Optional[PositiveFloat] = None angle: Optional[float] = None side: Side = Side.RIGHT - if IS_PYDANTIC_V2: - yield_force: Optional[Annotated[float, Field(ge=0)]] = None - else: - yield_force: Optional[confloat(ge=0)] = None + yield_force: Optional[Annotated[float, Field(ge=0)]] = None def to_internal(self) -> InternalAnchor: - if IS_PYDANTIC_V2: - return InternalAnchor(**self.model_dump(exclude_none=True)) - else: - return InternalAnchor(**self.dict(exclude_none=True)) + return InternalAnchor(**self.model_dump(exclude_none=True)) class Strut(BaseDataClass): @@ -73,31 +56,20 @@ class Strut(BaseDataClass): pre_compression: Pre-compressions [kN/m'] """ - if IS_PYDANTIC_V2: - name: Annotated[str, StringConstraints(min_length=1, max_length=50)] - else: - name: constr(min_length=1, max_length=50) + name: Annotated[str, StringConstraints(min_length=1, max_length=50)] level: float e_modulus: Optional[PositiveFloat] = None cross_section: Optional[PositiveFloat] = None length: Optional[PositiveFloat] = None angle: Optional[float] = None - if IS_PYDANTIC_V2: - buckling_force: Optional[Annotated[float, Field(ge=0)]] = None - else: - buckling_force: Optional[confloat(ge=0)] = None + buckling_force: Optional[Annotated[float, Field(ge=0)]] = None side: Side = Side.RIGHT pre_compression: Optional[PositiveFloat] = None def to_internal(self) -> InternalStrut: - if IS_PYDANTIC_V2: - return InternalStrut( - **self.model_dump(exclude_none=True, exclude={"pre_compression"}) - ) - else: - return InternalStrut( - **self.dict(exclude_none=True, exclude={"pre_compression"}) - ) + return InternalStrut( + **self.model_dump(exclude_none=True, exclude={"pre_compression"}) + ) class SupportType(IntEnum): @@ -109,31 +81,19 @@ class SupportType(IntEnum): class SpringSupport(BaseDataClass): """Spring support.""" - if IS_PYDANTIC_V2: - name: Annotated[str, StringConstraints(min_length=1, max_length=50)] - level: float - rotational_stiffness: Annotated[float, Field(ge=0)] - translational_stiffness: Annotated[float, Field(ge=0)] - else: - name: constr(min_length=1, max_length=50) - level: float - rotational_stiffness: confloat(ge=0) - translational_stiffness: confloat(ge=0) + name: Annotated[str, StringConstraints(min_length=1, max_length=50)] + level: float + rotational_stiffness: Annotated[float, Field(ge=0)] + translational_stiffness: Annotated[float, Field(ge=0)] def to_internal(self) -> InternalSupport: - if IS_PYDANTIC_V2: - return InternalSupport(**self.model_dump()) - else: - return InternalSupport(**self.dict()) + return InternalSupport(**self.model_dump()) class RigidSupport(BaseDataClass): """Rigid support.""" - if IS_PYDANTIC_V2: - name: Annotated[str, StringConstraints(min_length=1, max_length=50)] - else: - name: constr(min_length=1, max_length=50) + name: Annotated[str, StringConstraints(min_length=1, max_length=50)] level: float support_type: SupportType diff --git a/geolib/models/dsheetpiling/surface.py b/geolib/models/dsheetpiling/surface.py index 40d27d81..edd2d81c 100644 --- a/geolib/models/dsheetpiling/surface.py +++ b/geolib/models/dsheetpiling/surface.py @@ -1,12 +1,7 @@ from typing import List, Optional -from geolib._compat import IS_PYDANTIC_V2 - -if IS_PYDANTIC_V2: - from pydantic import Field, StringConstraints, field_validator - from typing_extensions import Annotated -else: - from pydantic import confloat, conlist, constr, validator +from pydantic import Field, StringConstraints, field_validator +from typing_extensions import Annotated from geolib.geometry import Point from geolib.models import BaseDataClass @@ -25,16 +20,10 @@ class Surface(BaseDataClass): std: Standard deviation of the distribution type. """ - if IS_PYDANTIC_V2: - name: Annotated[str, StringConstraints(min_length=1, max_length=50)] - points: Annotated[List[Point], Field(min_length=1)] - distribution_type: Optional[DistributionType] = None - std: Optional[Annotated[float, Field(ge=0.0)]] = None - else: - name: constr(min_length=1, max_length=50) - points: conlist(Point, min_items=1) - distribution_type: Optional[DistributionType] = None - std: Optional[confloat(ge=0.0)] = None + name: Annotated[str, StringConstraints(min_length=1, max_length=50)] + points: Annotated[List[Point], Field(min_length=1)] + distribution_type: Optional[DistributionType] = None + std: Optional[Annotated[float, Field(ge=0.0)]] = None @classmethod def points_must_be_increasing_and_greater_or_equal_to_zero(cls, v): @@ -51,20 +40,12 @@ def points_must_be_increasing_and_greater_or_equal_to_zero(cls, v): raise ValueError("x-coordinates must be strictly increasing") return v - if IS_PYDANTIC_V2: - points_validator = field_validator("points")( - points_must_be_increasing_and_greater_or_equal_to_zero - ) - else: - points_validator = validator("points")( - points_must_be_increasing_and_greater_or_equal_to_zero - ) + points_validator = field_validator("points")( + points_must_be_increasing_and_greater_or_equal_to_zero + ) def to_internal(self) -> InternalSurface: - if IS_PYDANTIC_V2: - kwargs = self.model_dump(exclude_none=True, exclude=["points"]) - else: - kwargs = self.dict(exclude_none=True, exclude={"points"}) + kwargs = self.model_dump(exclude_none=True, exclude=["points"]) kwargs["points"] = [ {"Nr": i, "X-coord": p.x, "Value": p.z} for i, p in enumerate(self.points, start=1) diff --git a/geolib/models/dsheetpiling/water_level.py b/geolib/models/dsheetpiling/water_level.py index 6786b25d..64117958 100644 --- a/geolib/models/dsheetpiling/water_level.py +++ b/geolib/models/dsheetpiling/water_level.py @@ -1,6 +1,3 @@ -from typing import Optional - -from geolib._compat import IS_PYDANTIC_V2 from geolib.models import BaseDataClass from .internal import WaterLevel as InternalWaterLevel @@ -14,7 +11,4 @@ class WaterLevel(BaseDataClass): standard_deviation: float = 0.0 def to_internal(self) -> InternalWaterLevel: - if IS_PYDANTIC_V2: - return InternalWaterLevel(**self.model_dump(exclude_none=True)) - else: - return InternalWaterLevel(**self.dict(exclude_none=True)) + return InternalWaterLevel(**self.model_dump(exclude_none=True)) diff --git a/geolib/models/dstability/analysis.py b/geolib/models/dstability/analysis.py index 27c67a82..db494f87 100644 --- a/geolib/models/dstability/analysis.py +++ b/geolib/models/dstability/analysis.py @@ -1,14 +1,8 @@ import abc -from enum import Enum -from typing import Dict, List, Optional, Type, Union +from typing import List -from geolib._compat import IS_PYDANTIC_V2 - -if IS_PYDANTIC_V2: - from pydantic import Field, PositiveInt - from typing_extensions import Annotated -else: - from pydantic import PositiveInt, confloat +from pydantic import Field, PositiveInt +from typing_extensions import Annotated from geolib.models import BaseDataClass @@ -63,10 +57,7 @@ class DStabilityCircle(DStabilityObject): """ center: Point - if IS_PYDANTIC_V2: - radius: Annotated[float, Field(gt=0)] - else: - radius: confloat(gt=0) + radius: Annotated[float, Field(gt=0)] def _to_internal_datastructure(self) -> PersistableCircle: return PersistableCircle( @@ -87,10 +78,7 @@ class DStabilitySearchGrid(DStabilityObject): bottom_left: Point number_of_points_in_x: PositiveInt number_of_points_in_z: PositiveInt - if IS_PYDANTIC_V2: - space: Annotated[float, Field(gt=0)] - else: - space: confloat(gt=0) + space: Annotated[float, Field(gt=0)] def _to_internal_datastructure(self) -> PersistableSearchGrid: return PersistableSearchGrid( @@ -112,14 +100,9 @@ class DStabilitySearchArea(DStabilityObject): width (float): Width of the search area """ - if IS_PYDANTIC_V2: - height: Annotated[float, Field(gt=0)] - top_left: Point - width: Annotated[float, Field(gt=0)] - else: - height: confloat(gt=0) - top_left: Point - width: confloat(gt=0) + height: Annotated[float, Field(gt=0)] + top_left: Point + width: Annotated[float, Field(gt=0)] def _to_internal_datastructure(self) -> PersistableSearchArea: return PersistableSearchArea( @@ -155,17 +138,9 @@ class DStabilitySlipPlaneConstraints(DStabilityObject): x_left_zone_b: float = 0.0 def _to_internal_datastructure(self) -> PersistableSlipPlaneConstraints: - if IS_PYDANTIC_V2: - data = { - **{ - snake_to_camel(name): value - for name, value in self.model_dump().items() - } - } - else: - data = { - **{snake_to_camel(name): value for name, value in self.dict().items()} - } + data = { + **{snake_to_camel(name): value for name, value in self.model_dump().items()} + } return PersistableSlipPlaneConstraints(**data) @@ -183,17 +158,9 @@ class DStabilityGeneticSlipPlaneConstraints(DStabilityObject): minimum_thrust_line_percentage_inside_slices: float = 0.0 def _to_internal_datastructure(self) -> PersistableGeneticSlipPlaneConstraints: - if IS_PYDANTIC_V2: - data = { - **{ - snake_to_camel(name): value - for name, value in self.model_dump().items() - } - } - else: - data = { - **{snake_to_camel(name): value for name, value in self.dict().items()} - } + data = { + **{snake_to_camel(name): value for name, value in self.model_dump().items()} + } return PersistableGeneticSlipPlaneConstraints(**data) @@ -231,10 +198,7 @@ class DStabilityBishopBruteForceAnalysisMethod(DStabilityAnalysisMethod): ) bottom_tangent_line_z: float number_of_tangent_lines: PositiveInt - if IS_PYDANTIC_V2: - space_tangent_lines: Annotated[float, Field(gt=0)] # type: ignore - else: - space_tangent_lines: confloat(gt=0) # type: ignore + space_tangent_lines: Annotated[float, Field(gt=0)] # type: ignore def _to_internal_datastructure(self) -> PersistableBishopBruteForceSettings: return PersistableBishopBruteForceSettings( diff --git a/geolib/models/dstability/dstability_parserprovider.py b/geolib/models/dstability/dstability_parserprovider.py index 5f9a0dea..2f0c415e 100644 --- a/geolib/models/dstability/dstability_parserprovider.py +++ b/geolib/models/dstability/dstability_parserprovider.py @@ -1,12 +1,10 @@ import logging -from os import path, scandir -from typing import List, Tuple, Type, _GenericAlias, get_type_hints +from typing import List, Tuple, Type, _GenericAlias from zipfile import ZipFile from pydantic import DirectoryPath, FilePath from zipp import Path -from geolib._compat import IS_PYDANTIC_V2 from geolib.models.parsers import BaseParser, BaseParserProvider from geolib.models.utils import get_filtered_type_hints @@ -42,10 +40,7 @@ def parse(self, filepath: DirectoryPath) -> BaseModelStructure: fn = filepath / (fieldtype.structure_name() + ".json") if not fn.exists(): raise FileNotFoundError(f"Couldn't find required file at {fn}") - if IS_PYDANTIC_V2: - ds[field] = fieldtype.model_validate_json(fn.open().read()) - else: - ds[field] = fieldtype.parse_raw(fn.open().read()) + ds[field] = fieldtype.model_validate_json(fn.open().read()) return self.structure(**ds) @@ -63,10 +58,7 @@ def __parse_folder(self, fieldtype, filepath: DirectoryPath) -> List: sorted_files = sorted(files, key=lambda x: x.name) for file in sorted_files: if fieldtype.structure_name() in file.name: - if IS_PYDANTIC_V2: - out.append(fieldtype.model_validate_json(file.open().read())) - else: - out.append(fieldtype.parse_raw(file.open().read())) + out.append(fieldtype.model_validate_json(file.open().read())) else: logger.debug(f"Didn't match {fieldtype} for {file}") diff --git a/geolib/models/dstability/dstability_validator.py b/geolib/models/dstability/dstability_validator.py index effb9c40..6b265ee1 100644 --- a/geolib/models/dstability/dstability_validator.py +++ b/geolib/models/dstability/dstability_validator.py @@ -1,7 +1,6 @@ import logging from typing import Set -from geolib._compat import IS_PYDANTIC_V2 from geolib.models.validators import BaseValidator logger = logging.getLogger(__name__) @@ -23,10 +22,7 @@ def is_valid_stages(self) -> bool: lengths_set = set() valid = True - if IS_PYDANTIC_V2: - model_dump = self.ds.model_dump() - else: - model_dump = self.ds.dict() + model_dump = self.ds.model_dump() for key, value in ( (k, v) for k, v in model_dump.items() diff --git a/geolib/models/dstability/internal.py b/geolib/models/dstability/internal.py index 0f94637e..ff660427 100644 --- a/geolib/models/dstability/internal.py +++ b/geolib/models/dstability/internal.py @@ -9,14 +9,8 @@ from math import isfinite from typing import Dict, List, Optional, Set, Tuple, Union -from geolib._compat import IS_PYDANTIC_V2 - -if IS_PYDANTIC_V2: - from pydantic import Field, ValidationError, field_validator, model_validator - from typing_extensions import Annotated -else: - from pydantic import conlist, root_validator, validator - from pydantic.error_wrappers import ValidationError +from pydantic import Field, ValidationError, field_validator, model_validator +from typing_extensions import Annotated from geolib import __version__ as version from geolib.geometry import Point @@ -29,10 +23,7 @@ class DStabilityBaseModelStructure(BaseModelStructure): def dict(_, *args, **kwargs): - if IS_PYDANTIC_V2: - data = super().model_dump(*args, **kwargs) - else: - data = super().dict(*args, **kwargs) + data = super().model_dump(*args, **kwargs) return { k: "NaN" if isinstance(v, float) and not isfinite(v) else v for k, v in data.items() @@ -87,21 +78,16 @@ class PersistablePoint(DStabilityBaseModelStructure): class PersistableHeadLine(DStabilityBaseModelStructure): - if IS_PYDANTIC_V2: - Id: Optional[str] = None - else: - Id: Optional[str] + Id: Optional[str] = None Label: Optional[str] = "" Notes: Optional[str] = "" Points: Optional[List[Optional[PersistablePoint]]] = None - if IS_PYDANTIC_V2: - - @field_validator("Id", mode="before") - def transform_id_to_str(cls, value) -> str: - if value is None: - return None - return str(value) + @field_validator("Id", mode="before") + def transform_id_to_str(cls, value) -> str: + if value is None: + return None + return str(value) class PersistableReferenceLine(DStabilityBaseModelStructure): @@ -112,13 +98,11 @@ class PersistableReferenceLine(DStabilityBaseModelStructure): Points: Optional[List[Optional[PersistablePoint]]] = None TopHeadLineId: Optional[str] = None - if IS_PYDANTIC_V2: - - @field_validator("Id", "TopHeadLineId", "BottomHeadLineId", mode="before") - def transform_id_to_str(cls, value) -> str: - if value is None: - return None - return str(value) + @field_validator("Id", "TopHeadLineId", "BottomHeadLineId", mode="before") + def transform_id_to_str(cls, value) -> str: + if value is None: + return None + return str(value) class Waternet(DStabilitySubStructure): @@ -139,13 +123,11 @@ def structure_name(cls) -> str: ReferenceLines: List[PersistableReferenceLine] = [] UnitWeightWater: Optional[float] = 9.81 - if IS_PYDANTIC_V2: - - @field_validator("Id", "PhreaticLineId", mode="before") - def transform_id_to_str(cls, value) -> str: - if value is None: - return None - return str(value) + @field_validator("Id", "PhreaticLineId", mode="before") + def transform_id_to_str(cls, value) -> str: + if value is None: + return None + return str(value) def get_head_line(self, head_line_id: str) -> PersistableHeadLine: for head_line in self.HeadLines: @@ -273,13 +255,12 @@ class WaternetCreatorSettings(DStabilitySubStructure): UseDefaultOffsets: Optional[bool] = True WaterLevelHinterland: Optional[Union[float, str]] = "NaN" - if IS_PYDANTIC_V2: - field_validator("Id", "AquiferLayerId", mode="before") + field_validator("Id", "AquiferLayerId", mode="before") - def transform_id_to_str(cls, value) -> str: - if value is None: - return None - return str(value) + def transform_id_to_str(cls, value) -> str: + if value is None: + return None + return str(value) @classmethod def structure_group(cls) -> str: @@ -318,13 +299,11 @@ class PersistableStateLinePoint(DStabilityBaseModelStructure): Notes: Optional[str] = "" X: Optional[float] = None - if IS_PYDANTIC_V2: - - @field_validator("Id", mode="before") - def transform_id_to_str(cls, value) -> str: - if value is None: - return None - return str(value) + @field_validator("Id", mode="before") + def transform_id_to_str(cls, value) -> str: + if value is None: + return None + return str(value) class PersistableStateLine(DStabilityBaseModelStructure): @@ -341,13 +320,11 @@ class PersistableStatePoint(DStabilityBaseModelStructure): Point: Optional[PersistablePoint] = None Stress: Optional[PersistableStress] = None - if IS_PYDANTIC_V2: - - @field_validator("Id", "LayerId", mode="before") - def transform_id_to_str(cls, value) -> str: - if value is None: - return None - return str(value) + @field_validator("Id", "LayerId", mode="before") + def transform_id_to_str(cls, value) -> str: + if value is None: + return None + return str(value) class State(DStabilitySubStructure): @@ -366,13 +343,11 @@ def structure_group(cls) -> str: StateLines: List[PersistableStateLine] = [] StatePoints: List[PersistableStatePoint] = [] - if IS_PYDANTIC_V2: - - @field_validator("Id", mode="before") - def transform_id_to_str(cls, value) -> str: - if value is None: - return None - return str(value) + @field_validator("Id", mode="before") + def transform_id_to_str(cls, value) -> str: + if value is None: + return None + return str(value) def add_state_point(self, state_point: PersistableStatePoint) -> None: self.StatePoints.append(state_point) @@ -403,17 +378,15 @@ class PersistableStateCorrelation(DStabilityBaseModelStructure): CorrelatedStateIds: Optional[List[Optional[str]]] = None IsFullyCorrelated: Optional[bool] = None - if IS_PYDANTIC_V2: - - @field_validator("CorrelatedStateIds", mode="before") - def transform_id_to_str(cls, values) -> str: - out = [] - for value in values: - if value is None: - out.append(None) - else: - out.append(str(value)) - return out + @field_validator("CorrelatedStateIds", mode="before") + def transform_id_to_str(cls, values) -> str: + out = [] + for value in values: + if value is None: + out.append(None) + else: + out.append(str(value)) + return out class StateCorrelation(DStabilitySubStructure): @@ -431,13 +404,11 @@ def structure_group(cls) -> str: Id: Optional[str] = None StateCorrelations: Optional[List[Optional[PersistableStateCorrelation]]] = [] - if IS_PYDANTIC_V2: - - @field_validator("Id", mode="before") - def transform_id_to_str(cls, value) -> str: - if value is None: - return None - return str(value) + @field_validator("Id", mode="before") + def transform_id_to_str(cls, value) -> str: + if value is None: + return None + return str(value) def add_state_correlation( self, state_correlation: PersistableStateCorrelation @@ -469,23 +440,21 @@ def structure_group(cls) -> str: WaternetCreatorSettingsId: Optional[str] = None WaternetId: Optional[str] = None - if IS_PYDANTIC_V2: - - @field_validator( - "DecorationsId", - "GeometryId", - "Id", - "LoadsId", - "ReinforcementsId", - "SoilLayersId", - "StateId", - "WaternetId", - mode="before", - ) - def transform_id_to_str(cls, value) -> str: - if value is None: - return None - return str(value) + @field_validator( + "DecorationsId", + "GeometryId", + "Id", + "LoadsId", + "ReinforcementsId", + "SoilLayersId", + "StateId", + "WaternetId", + mode="before", + ) + def transform_id_to_str(cls, value) -> str: + if value is None: + return None + return str(value) class PersistableCalculation(DStabilityBaseModelStructure): @@ -495,13 +464,11 @@ class PersistableCalculation(DStabilityBaseModelStructure): ResultId: Optional[str] = None CalculationSettingsId: Optional[str] = None - if IS_PYDANTIC_V2: - - @field_validator("Id", "ResultId", "CalculationSettingsId", mode="before") - def transform_id_to_str(cls, value) -> str: - if value is None: - return None - return str(value) + @field_validator("Id", "ResultId", "CalculationSettingsId", mode="before") + def transform_id_to_str(cls, value) -> str: + if value is None: + return None + return str(value) class Scenario(DStabilitySubStructure): @@ -522,13 +489,11 @@ def structure_group(cls) -> str: Label: Optional[str] = "" Notes: Optional[str] = "" - if IS_PYDANTIC_V2: - - @field_validator("Id", mode="before") - def transform_id_to_str(cls, value) -> str: - if value is None: - return None - return str(value) + @field_validator("Id", mode="before") + def transform_id_to_str(cls, value) -> str: + if value is None: + return None + return str(value) class PersistableShadingTypeEnum(Enum): @@ -550,13 +515,11 @@ class PersistableSoilVisualization(DStabilityBaseModelStructure): PersistableShadingType: Optional[PersistableShadingTypeEnum] SoilId: Optional[str] = None - if IS_PYDANTIC_V2: - - @field_validator("SoilId", mode="before") - def transform_id_to_str(cls, value) -> str: - if value is None: - return None - return str(value) + @field_validator("SoilId", mode="before") + def transform_id_to_str(cls, value) -> str: + if value is None: + return None + return str(value) class SoilVisualisation(DStabilityBaseModelStructure): @@ -572,13 +535,11 @@ class PersistableSoilLayer(DStabilityBaseModelStructure): LayerId: Optional[str] = None SoilId: Optional[str] = None - if IS_PYDANTIC_V2: - - @field_validator("LayerId", "SoilId", mode="before") - def transform_id_to_str(cls, value) -> str: - if value is None: - return None - return str(value) + @field_validator("LayerId", "SoilId", mode="before") + def transform_id_to_str(cls, value) -> str: + if value is None: + return None + return str(value) class SoilLayerCollection(DStabilitySubStructure): @@ -596,13 +557,11 @@ def structure_group(cls) -> str: Id: Optional[str] = None SoilLayers: List[PersistableSoilLayer] = [] - if IS_PYDANTIC_V2: - - @field_validator("Id", mode="before") - def transform_id_to_str(cls, value) -> str: - if value is None: - return None - return str(value) + @field_validator("Id", mode="before") + def transform_id_to_str(cls, value) -> str: + if value is None: + return None + return str(value) def add_soillayer(self, layer_id: str, soil_id: str) -> PersistableSoilLayer: psl = PersistableSoilLayer(LayerId=layer_id, SoilId=soil_id) @@ -622,17 +581,15 @@ def get_ids(self, exclude_soil_layer_id: Optional[int]) -> Set[str]: class PersistableSoilCorrelation(DStabilityBaseModelStructure): CorrelatedSoilIds: Optional[List[str]] = None - if IS_PYDANTIC_V2: - - @field_validator("CorrelatedSoilIds", mode="before") - def transform_id_to_str(cls, values) -> str: - out = [] - for value in values: - if value is None: - out.append(None) - else: - out.append(str(value)) - return out + @field_validator("CorrelatedSoilIds", mode="before") + def transform_id_to_str(cls, values) -> str: + out = [] + for value in values: + if value is None: + out.append(None) + else: + out.append(str(value)) + return out class SoilCorrelation(DStabilitySubStructure): @@ -773,13 +730,11 @@ class PersistableSoil(DStabilityBaseModelStructure): VolumetricWeightBelowPhreaticLevel: float = 0.0 SuTable: PersistableSuTable = PersistableSuTable() - if IS_PYDANTIC_V2: - - @field_validator("Id", mode="before") - def transform_id_to_str(cls, value) -> str: - if value is None: - return None - return str(value) + @field_validator("Id", mode="before") + def transform_id_to_str(cls, value) -> str: + if value is None: + return None + return str(value) class SoilCollection(DStabilitySubStructure): @@ -1133,13 +1088,11 @@ class Reinforcements(DStabilitySubStructure): Geotextiles: List[PersistableGeotextile] = [] Nails: List[PersistableNail] = [] - if IS_PYDANTIC_V2: - - @field_validator("Id", mode="before") - def transform_id_to_str(cls, value) -> str: - if value is None: - return None - return str(value) + @field_validator("Id", mode="before") + def transform_id_to_str(cls, value) -> str: + if value is None: + return None + return str(value) def add_reinforcement( self, reinforcement: "DStabilityReinforcement" @@ -1177,14 +1130,9 @@ def nltime(cls, date: Union[date, str]) -> date: date = datetime.strptime(date, "%Y-%m-%d").date() return date - if IS_PYDANTIC_V2: - nltime_validator = field_validator( - "Created", "Date", "LastModified", mode="before" - )(nltime) - else: - nltime_validator = validator( - "Created", "Date", "LastModified", pre=True, allow_reuse=True - )(nltime) + nltime_validator = field_validator("Created", "Date", "LastModified", mode="before")( + nltime + ) class PersistableBondStress(DStabilityBaseModelStructure): @@ -1199,13 +1147,11 @@ class PersistableNailPropertiesForSoil(DStabilityBaseModelStructure): RheologicalCoefficient: Optional[float] = None SoilId: Optional[str] = None - if IS_PYDANTIC_V2: - - @field_validator("SoilId", mode="before") - def transform_id_to_str(cls, value) -> str: - if value is None: - return None - return str(value) + @field_validator("SoilId", mode="before") + def transform_id_to_str(cls, value) -> str: + if value is None: + return None + return str(value) class NailProperties(DStabilitySubStructure): @@ -1225,13 +1171,11 @@ class PersistableConsolidation(DStabilityBaseModelStructure): Degree: Optional[float] = None LayerId: Optional[str] = None - if IS_PYDANTIC_V2: - - @field_validator("LayerId", mode="before") - def transform_id_to_str(cls, value) -> str: - if value is None: - return None - return str(value) + @field_validator("LayerId", mode="before") + def transform_id_to_str(cls, value) -> str: + if value is None: + return None + return str(value) class PersistableEarthquake(DStabilityBaseModelStructure): @@ -1248,13 +1192,11 @@ class PersistableLayerLoad(DStabilityBaseModelStructure): Consolidations: Optional[List[Optional[PersistableConsolidation]]] = [] LayerId: Optional[str] = None - if IS_PYDANTIC_V2: - - @field_validator("LayerId", mode="before") - def transform_id_to_str(cls, value) -> str: - if value is None: - return None - return str(value) + @field_validator("LayerId", mode="before") + def transform_id_to_str(cls, value) -> str: + if value is None: + return None + return str(value) class PersistableLineLoad(DStabilityBaseModelStructure): @@ -1300,13 +1242,11 @@ class Loads(DStabilitySubStructure): Trees: Optional[List[Optional[PersistableTree]]] = [] UniformLoads: Optional[List[Optional[PersistableUniformLoad]]] = [] - if IS_PYDANTIC_V2: - - @field_validator("Id", mode="before") - def transform_id_to_str(cls, value) -> str: - if value is None: - return None - return str(value) + @field_validator("Id", mode="before") + def transform_id_to_str(cls, value) -> str: + if value is None: + return None + return str(value) def add_load( self, load: "DStabilityLoad", consolidations: List["Consolidation"] @@ -1347,18 +1287,13 @@ class PersistableLayer(DStabilityBaseModelStructure): Id: Optional[str] = None Label: Optional[str] = "" Notes: Optional[str] = "" - if IS_PYDANTIC_V2: - Points: Annotated[List[PersistablePoint], Field(min_length=3)] - else: - Points: conlist(PersistablePoint, min_items=3) + Points: Annotated[List[PersistablePoint], Field(min_length=3)] - if IS_PYDANTIC_V2: - - @field_validator("Id", mode="before") - def transform_id_to_str(cls, value) -> str: - if value is None: - return None - return str(value) + @field_validator("Id", mode="before") + def transform_id_to_str(cls, value) -> str: + if value is None: + return None + return str(value) @classmethod def polygon_checks(cls, points): @@ -1373,12 +1308,7 @@ def polygon_checks(cls, points): # 4. does it intersect other polygons return points - if IS_PYDANTIC_V2: - polygon_chack_validator = field_validator("Points", mode="before")(polygon_checks) - else: - polygon_chack_validator = validator("Points", pre=True, allow_reuse=True)( - polygon_checks - ) + polygon_chack_validator = field_validator("Points", mode="before")(polygon_checks) class Geometry(DStabilitySubStructure): @@ -1392,13 +1322,11 @@ def structure_group(cls) -> str: Id: Optional[str] = None Layers: List[PersistableLayer] = [] - if IS_PYDANTIC_V2: - - @field_validator("Id", mode="before") - def transform_id_to_str(cls, value) -> str: - if value is None: - return None - return str(value) + @field_validator("Id", mode="before") + def transform_id_to_str(cls, value) -> str: + if value is None: + return None + return str(value) def contains_point(self, point: Point) -> bool: """ @@ -1462,13 +1390,11 @@ class PersistableElevation(DStabilityBaseModelStructure): Notes: Optional[str] = "" Points: Optional[List[Optional[PersistablePoint]]] = None - if IS_PYDANTIC_V2: - - @field_validator("AddedLayerId", mode="before") - def transform_id_to_str(cls, value) -> str: - if value is None: - return None - return str(value) + @field_validator("AddedLayerId", mode="before") + def transform_id_to_str(cls, value) -> str: + if value is None: + return None + return str(value) class PersistableExcavation(DStabilityBaseModelStructure): @@ -1485,13 +1411,11 @@ class Decorations(DStabilitySubStructure): Excavations: Optional[List[Optional[PersistableExcavation]]] = [] Id: Optional[str] = None - if IS_PYDANTIC_V2: - - @field_validator("Id", mode="before") - def transform_id_to_str(cls, value) -> str: - if value is None: - return None - return str(value) + @field_validator("Id", mode="before") + def transform_id_to_str(cls, value) -> str: + if value is None: + return None + return str(value) def add_excavation(self, excavation: PersistableExcavation): self.Excavations.append(excavation) @@ -1667,13 +1591,11 @@ class CalculationSettings(DStabilitySubStructure): PersistableUpliftVanParticleSwarmSettings ] = PersistableUpliftVanParticleSwarmSettings() - if IS_PYDANTIC_V2: - - @field_validator("Id", mode="before") - def transform_id_to_str(cls, value) -> str: - if value is None: - return None - return str(value) + @field_validator("Id", mode="before") + def transform_id_to_str(cls, value) -> str: + if value is None: + return None + return str(value) def set_bishop(self, bishop_settings: PersistableBishopSettings) -> None: self.Bishop = bishop_settings @@ -1764,13 +1686,11 @@ class BishopBruteForceResult(DStabilitySubStructure): ResultThreshold: Optional[float] = None SlipPlaneResults: Optional[list] = None - if IS_PYDANTIC_V2: - - @field_validator("Id", mode="before") - def transform_id_to_str(cls, value) -> str: - if value is None: - return None - return str(value) + @field_validator("Id", mode="before") + def transform_id_to_str(cls, value) -> str: + if value is None: + return None + return str(value) @classmethod def structure_group(cls) -> str: @@ -1795,13 +1715,11 @@ class PersistableSoilContribution(DStabilityBaseModelStructure): UncorrelatedAlpha: Optional[float] = None Value: Optional[float] = None - if IS_PYDANTIC_V2: - - @field_validator("SoilId", mode="before") - def transform_id_to_str(cls, value) -> str: - if value is None: - return None - return str(value) + @field_validator("SoilId", mode="before") + def transform_id_to_str(cls, value) -> str: + if value is None: + return None + return str(value) class PersistableCalculationContribution(DStabilityBaseModelStructure): @@ -1811,13 +1729,11 @@ class PersistableCalculationContribution(DStabilityBaseModelStructure): UncorrelatedAlpha: Optional[float] = None Value: Optional[float] = None - if IS_PYDANTIC_V2: - - @field_validator("CalculationId", mode="before") - def transform_id_to_str(cls, value) -> str: - if value is None: - return None - return str(value) + @field_validator("CalculationId", mode="before") + def transform_id_to_str(cls, value) -> str: + if value is None: + return None + return str(value) class PersistableStateLinePointContribution(DStabilityBaseModelStructure): @@ -1827,13 +1743,11 @@ class PersistableStateLinePointContribution(DStabilityBaseModelStructure): UncorrelatedAlpha: Optional[float] = None Value: Optional[float] = None - if IS_PYDANTIC_V2: - - @field_validator("StateLinePointId", mode="before") - def transform_id_to_str(cls, value) -> str: - if value is None: - return None - return str(value) + @field_validator("StateLinePointId", mode="before") + def transform_id_to_str(cls, value) -> str: + if value is None: + return None + return str(value) class PersistableStatePointContribution(DStabilityBaseModelStructure): @@ -1843,13 +1757,11 @@ class PersistableStatePointContribution(DStabilityBaseModelStructure): UncorrelatedAlpha: Optional[float] = None Value: Optional[float] = None - if IS_PYDANTIC_V2: - - @field_validator("StatePointId", mode="before") - def transform_id_to_str(cls, value) -> str: - if value is None: - return None - return str(value) + @field_validator("StatePointId", mode="before") + def transform_id_to_str(cls, value) -> str: + if value is None: + return None + return str(value) class BishopReliabilityResult(DStabilitySubStructure): @@ -1870,13 +1782,11 @@ class BishopReliabilityResult(DStabilitySubStructure): List[Optional[PersistableStatePointContribution]] ] = None - if IS_PYDANTIC_V2: - - @field_validator("Id", mode="before") - def transform_id_to_str(cls, value) -> str: - if value is None: - return None - return str(value) + @field_validator("Id", mode="before") + def transform_id_to_str(cls, value) -> str: + if value is None: + return None + return str(value) @classmethod def structure_group(cls) -> str: @@ -1914,13 +1824,11 @@ class BishopBruteForceReliabilityResult(DStabilitySubStructure): ResultThreshold: Optional[float] = None SlipPlaneResults: Optional[list] = None - if IS_PYDANTIC_V2: - - @field_validator("Id", mode="before") - def transform_id_to_str(cls, value) -> str: - if value is None: - return None - return str(value) + @field_validator("Id", mode="before") + def transform_id_to_str(cls, value) -> str: + if value is None: + return None + return str(value) @classmethod def structure_group(cls) -> str: @@ -1945,13 +1853,11 @@ class BishopResult(DStabilitySubStructure): Points: Optional[List[Optional[PersistablePoint]]] = None Slices: Optional[List[Optional[PersistableSlice]]] = None - if IS_PYDANTIC_V2: - - @field_validator("Id", mode="before") - def transform_id_to_str(cls, value) -> str: - if value is None: - return None - return str(value) + @field_validator("Id", mode="before") + def transform_id_to_str(cls, value) -> str: + if value is None: + return None + return str(value) @classmethod def structure_group(cls) -> str: @@ -2027,13 +1933,11 @@ class SpencerGeneticAlgorithmResult(DStabilitySubStructure): ResultThreshold: Optional[float] = None SlipPlaneResults: Optional[list] = None - if IS_PYDANTIC_V2: - - @field_validator("Id", mode="before") - def transform_id_to_str(cls, value) -> str: - if value is None: - return None - return str(value) + @field_validator("Id", mode="before") + def transform_id_to_str(cls, value) -> str: + if value is None: + return None + return str(value) @classmethod def structure_group(cls) -> str: @@ -2069,13 +1973,11 @@ class SpencerReliabilityResult(DStabilitySubStructure): List[Optional[PersistableStatePointContribution]] ] = None - if IS_PYDANTIC_V2: - - @field_validator("Id", mode="before") - def transform_id_to_str(cls, value) -> str: - if value is None: - return None - return str(value) + @field_validator("Id", mode="before") + def transform_id_to_str(cls, value) -> str: + if value is None: + return None + return str(value) @classmethod def structure_group(cls) -> str: @@ -2111,13 +2013,11 @@ class SpencerGeneticAlgorithmReliabilityResult(DStabilitySubStructure): List[Optional[PersistableStatePointContribution]] ] = None - if IS_PYDANTIC_V2: - - @field_validator("Id", mode="before") - def transform_id_to_str(cls, value) -> str: - if value is None: - return None - return str(value) + @field_validator("Id", mode="before") + def transform_id_to_str(cls, value) -> str: + if value is None: + return None + return str(value) @classmethod def structure_group(cls) -> str: @@ -2142,13 +2042,11 @@ class SpencerResult(DStabilitySubStructure): Slices: Optional[List[Optional[PersistableSpencerSlice]]] = None SlipPlane: Optional[List[Optional[PersistablePoint]]] = None - if IS_PYDANTIC_V2: - - @field_validator("Id", mode="before") - def transform_id_to_str(cls, value) -> str: - if value is None: - return None - return str(value) + @field_validator("Id", mode="before") + def transform_id_to_str(cls, value) -> str: + if value is None: + return None + return str(value) @classmethod def structure_group(cls) -> str: @@ -2177,13 +2075,11 @@ class UpliftVanParticleSwarmResult(DStabilitySubStructure): ResultThreshold: Optional[float] = None SlipPlaneResults: Optional[list] = None - if IS_PYDANTIC_V2: - - @field_validator("Id", mode="before") - def transform_id_to_str(cls, value) -> str: - if value is None: - return None - return str(value) + @field_validator("Id", mode="before") + def transform_id_to_str(cls, value) -> str: + if value is None: + return None + return str(value) @classmethod def structure_group(cls) -> str: @@ -2225,13 +2121,11 @@ class UpliftVanReliabilityResult(DStabilitySubStructure): ] = None TangentLine: Optional[float] = None - if IS_PYDANTIC_V2: - - @field_validator("Id", mode="before") - def transform_id_to_str(cls, value) -> str: - if value is None: - return None - return str(value) + @field_validator("Id", mode="before") + def transform_id_to_str(cls, value) -> str: + if value is None: + return None + return str(value) @classmethod def structure_group(cls) -> str: @@ -2275,13 +2169,11 @@ class UpliftVanParticleSwarmReliabilityResult(DStabilitySubStructure): ] = None TangentLine: Optional[float] = None - if IS_PYDANTIC_V2: - - @field_validator("Id", mode="before") - def transform_id_to_str(cls, value) -> str: - if value is None: - return None - return str(value) + @field_validator("Id", mode="before") + def transform_id_to_str(cls, value) -> str: + if value is None: + return None + return str(value) @classmethod def structure_group(cls) -> str: @@ -2312,13 +2204,11 @@ class UpliftVanResult(DStabilitySubStructure): Slices: Optional[List[Optional[PersistableSlice]]] = None TangentLine: Optional[float] = None - if IS_PYDANTIC_V2: - - @field_validator("Id", mode="before") - def transform_id_to_str(cls, value) -> str: - if value is None: - return None - return str(value) + @field_validator("Id", mode="before") + def transform_id_to_str(cls, value) -> str: + if value is None: + return None + return str(value) @classmethod def structure_group(cls) -> str: @@ -2442,90 +2332,42 @@ class DStabilityStructure(BaseModelStructure): bishop_reliability_results: List[BishopReliabilityResult] = [] bishop_bruteforce_reliability_results: List[BishopBruteForceReliabilityResult] = [] - if IS_PYDANTIC_V2: - - @model_validator(mode="after") - def ensure_validity_foreign_keys(self): - def list_has_id(values, id): - for entry in values: - if entry.Id == id: - return True - return False - - for _, scenario in enumerate(self.scenarios): - for _, stage in enumerate(scenario.Stages): - if not list_has_id(self.decorations, stage.DecorationsId): - raise ValueError("DecorationsIds not linked!") - if not list_has_id(self.geometries, stage.GeometryId): - raise ValueError("GeometryIds not linked!") - if not list_has_id(self.loads, stage.LoadsId): - raise ValueError("LoadsIds not linked!") - if not list_has_id(self.reinforcements, stage.ReinforcementsId): - raise ValueError("ReinforcementsIds not linked!") - if not list_has_id(self.soillayers, stage.SoilLayersId): - raise ValueError("SoilLayersIds not linked!") - if not list_has_id(self.states, stage.StateId): - raise ValueError("StateIds not linked!") - if not list_has_id(self.statecorrelations, stage.StateCorrelationsId): - raise ValueError("StateCorrelationsIds not linked!") - if not list_has_id( - self.waternetcreatorsettings, stage.WaternetCreatorSettingsId - ): - raise ValueError("WaternetCreatorSettingsIds not linked!") - if not list_has_id(self.waternets, stage.WaternetId): - raise ValueError("WaternetIds not linked!") - for _, calculation in enumerate(scenario.Calculations): - if not list_has_id( - self.calculationsettings, calculation.CalculationSettingsId - ): - raise ValueError("CalculationSettingsIds not linked!") - return self - - else: - - @root_validator(skip_on_failure=True, allow_reuse=True) - def ensure_validity_foreign_keys(cls, values): - def list_has_id(values, id): - for entry in values: - if entry.Id == id: - return True - return False + @model_validator(mode="after") + def ensure_validity_foreign_keys(self): + def list_has_id(values, id): + for entry in values: + if entry.Id == id: + return True + return False - for _, scenario in enumerate(values.get("scenarios")): - for _, stage in enumerate(scenario.Stages): - if not list_has_id(values.get("decorations"), stage.DecorationsId): - raise ValueError("DecorationsIds not linked!") - if not list_has_id(values.get("geometries"), stage.GeometryId): - raise ValueError("GeometryIds not linked!") - if not list_has_id(values.get("loads"), stage.LoadsId): - raise ValueError("LoadsIds not linked!") - if not list_has_id( - values.get("reinforcements"), stage.ReinforcementsId - ): - raise ValueError("ReinforcementsIds not linked!") - if not list_has_id(values.get("soillayers"), stage.SoilLayersId): - raise ValueError("SoilLayersIds not linked!") - if not list_has_id(values.get("states"), stage.StateId): - raise ValueError("StateIds not linked!") - if not list_has_id( - values.get("statecorrelations"), stage.StateCorrelationsId - ): - raise ValueError("StateCorrelationsIds not linked!") - if not list_has_id( - values.get("waternetcreatorsettings"), - stage.WaternetCreatorSettingsId, - ): - raise ValueError("WaternetCreatorSettingsIds not linked!") - if not list_has_id(values.get("waternets"), stage.WaternetId): - raise ValueError("WaternetIds not linked!") - for _, calculation in enumerate(scenario.Calculations): - if not list_has_id( - values.get("calculationsettings"), - calculation.CalculationSettingsId, - ): - raise ValueError("CalculationSettingsIds not linked!") - - return values + for _, scenario in enumerate(self.scenarios): + for _, stage in enumerate(scenario.Stages): + if not list_has_id(self.decorations, stage.DecorationsId): + raise ValueError("DecorationsIds not linked!") + if not list_has_id(self.geometries, stage.GeometryId): + raise ValueError("GeometryIds not linked!") + if not list_has_id(self.loads, stage.LoadsId): + raise ValueError("LoadsIds not linked!") + if not list_has_id(self.reinforcements, stage.ReinforcementsId): + raise ValueError("ReinforcementsIds not linked!") + if not list_has_id(self.soillayers, stage.SoilLayersId): + raise ValueError("SoilLayersIds not linked!") + if not list_has_id(self.states, stage.StateId): + raise ValueError("StateIds not linked!") + if not list_has_id(self.statecorrelations, stage.StateCorrelationsId): + raise ValueError("StateCorrelationsIds not linked!") + if not list_has_id( + self.waternetcreatorsettings, stage.WaternetCreatorSettingsId + ): + raise ValueError("WaternetCreatorSettingsIds not linked!") + if not list_has_id(self.waternets, stage.WaternetId): + raise ValueError("WaternetIds not linked!") + for _, calculation in enumerate(scenario.Calculations): + if not list_has_id( + self.calculationsettings, calculation.CalculationSettingsId + ): + raise ValueError("CalculationSettingsIds not linked!") + return self def add_default_scenario( self, label: str, notes: str, unique_start_id: Optional[int] = None diff --git a/geolib/models/dstability/loads.py b/geolib/models/dstability/loads.py index 97540c65..a1a5ce2a 100644 --- a/geolib/models/dstability/loads.py +++ b/geolib/models/dstability/loads.py @@ -2,15 +2,10 @@ This module handles the four types of loads in DStability. """ import abc -from typing import List, Optional +from typing import Optional -from geolib._compat import IS_PYDANTIC_V2 - -if IS_PYDANTIC_V2: - from pydantic import Field, model_validator - from typing_extensions import Annotated -else: - from pydantic import NoneStr, confloat, validator +from pydantic import Field, model_validator +from typing_extensions import Annotated from geolib.models import BaseDataClass @@ -27,10 +22,7 @@ class DStabilityLoad(BaseDataClass): """Base Class for Loads.""" - if IS_PYDANTIC_V2: - label: Optional[str] = None - else: - label: NoneStr + label: Optional[str] = None @abc.abstractmethod def to_internal_datastructure(self): @@ -38,10 +30,7 @@ def to_internal_datastructure(self): class Consolidation(BaseDataClass): - if IS_PYDANTIC_V2: - degree: Annotated[float, Field(ge=0, le=100)] = 100 - else: - degree: confloat(ge=0, le=100) = 100 + degree: Annotated[float, Field(ge=0, le=100)] = 100 layer_id: int def to_internal_datastructure(self) -> PersistableConsolidation: @@ -53,29 +42,16 @@ class UniformLoad(DStabilityLoad): start: float end: float - if IS_PYDANTIC_V2: - magnitude: Annotated[float, Field(ge=0)] - angle_of_distribution: Annotated[float, Field(ge=0, le=90)] - - @model_validator(mode="after") - def end_greater_than_start(self): - if self.end <= self.start: - raise ValueError( - f"End {self.end} should be greater than start ({self.start})" - ) - return self - - else: - magnitude: confloat(ge=0) - angle_of_distribution: confloat(ge=0, le=90) - - @validator("end") - def end_greater_than_start(cls, v, values): - if v <= values["start"]: - raise ValueError( - f"End {v} should be greater than start ({values['start']})" - ) - return v + magnitude: Annotated[float, Field(ge=0)] + angle_of_distribution: Annotated[float, Field(ge=0, le=90)] + + @model_validator(mode="after") + def end_greater_than_start(self): + if self.end <= self.start: + raise ValueError( + f"End {self.end} should be greater than start ({self.start})" + ) + return self def to_internal_datastructure(self) -> PersistableUniformLoad: return PersistableUniformLoad( @@ -91,14 +67,9 @@ class LineLoad(DStabilityLoad): """DStability Lineload.""" location: Point - if IS_PYDANTIC_V2: - angle: Annotated[float, Field(ge=-360, le=360)] - magnitude: Annotated[float, Field(ge=0)] - angle_of_distribution: Annotated[float, Field(ge=0, le=90)] - else: - angle: confloat(ge=-360, le=360) - magnitude: confloat(ge=0) - angle_of_distribution: confloat(ge=0, le=90) + angle: Annotated[float, Field(ge=-360, le=360)] + magnitude: Annotated[float, Field(ge=0)] + angle_of_distribution: Annotated[float, Field(ge=0, le=90)] def to_internal_datastructure(self) -> PersistableLineLoad: return PersistableLineLoad( diff --git a/geolib/models/dstability/reinforcements.py b/geolib/models/dstability/reinforcements.py index 42bc260a..149e7f3f 100644 --- a/geolib/models/dstability/reinforcements.py +++ b/geolib/models/dstability/reinforcements.py @@ -3,17 +3,10 @@ """ import abc -from typing import List, Tuple +from typing import List, Optional, Tuple -from geolib._compat import IS_PYDANTIC_V2 - -if IS_PYDANTIC_V2: - from typing import Optional - - from pydantic import Field - from typing_extensions import Annotated -else: - from pydantic import NoneStr, confloat +from pydantic import Field +from typing_extensions import Annotated from geolib.models import BaseDataClass @@ -31,10 +24,7 @@ class DStabilityReinforcement(BaseDataClass, metaclass=abc.ABCMeta): """Base Class for Reinforcements.""" - if IS_PYDANTIC_V2: - label: Optional[str] = None - else: - label: NoneStr = None + label: Optional[str] = None @abc.abstractmethod def _to_internal_datastructure(self): @@ -47,21 +37,13 @@ class Nail(DStabilityReinforcement): location: Point # TODO x, z must be below ground level direction: float = 0.0 horizontal_spacing: float = 0.0 - if IS_PYDANTIC_V2: - length: Annotated[float, Field(gt=0)] = 3.0 - diameter: Annotated[float, Field(gt=0)] = 0.1 - grout_diameter: Annotated[float, Field(gt=0)] = 0.1 - else: - length: confloat(gt=0) = 3.0 - diameter: confloat(gt=0) = 0.1 - grout_diameter: confloat(gt=0) = 0.1 + length: Annotated[float, Field(gt=0)] = 3.0 + diameter: Annotated[float, Field(gt=0)] = 0.1 + grout_diameter: Annotated[float, Field(gt=0)] = 0.1 critical_angle: float = 0.0 max_pull_force: float = 0.0 plastic_moment: float = 0.0 - if IS_PYDANTIC_V2: - bending_stiffness: Annotated[float, Field(gt=0)] = 0.1 - else: - bending_stiffness: confloat(gt=0) = 0.1 + bending_stiffness: Annotated[float, Field(gt=0)] = 0.1 use_facing: bool = False use_lateral_stress: bool = ( False # TODO set on wether or not lateralstresses are provided? @@ -73,10 +55,7 @@ class Nail(DStabilityReinforcement): shear_stresses: List[Tuple[float, float]] = [] def _to_internal_datastructure(self) -> PersistableNail: - if IS_PYDANTIC_V2: - model_dump = self.model_dump() - else: - model_dump = self.dict() + model_dump = self.model_dump() data = { **{ snake_to_camel(name): value @@ -115,12 +94,8 @@ class Geotextile(DStabilityReinforcement): start: Point end: Point - if IS_PYDANTIC_V2: - effective_tensile_strength: Annotated[float, Field(gt=0)] - reduction_area: Annotated[float, Field(gt=0)] - else: - effective_tensile_strength: confloat(gt=0) - reduction_area: confloat(gt=0) + effective_tensile_strength: Annotated[float, Field(gt=0)] + reduction_area: Annotated[float, Field(gt=0)] def _to_internal_datastructure(self) -> PersistableForbiddenLine: return PersistableGeotextile( diff --git a/geolib/models/dstability/serializer.py b/geolib/models/dstability/serializer.py index 3fd02344..3874508e 100644 --- a/geolib/models/dstability/serializer.py +++ b/geolib/models/dstability/serializer.py @@ -1,14 +1,10 @@ from abc import ABCMeta, abstractmethod -from datetime import datetime from io import BytesIO -from os import makedirs -from typing import Dict, List, Union, _GenericAlias, get_type_hints +from typing import Dict, Union, _GenericAlias from zipfile import ZIP_DEFLATED, ZipFile from pydantic import DirectoryPath, FilePath -from zipp import Path -from geolib._compat import IS_PYDANTIC_V2 from geolib.errors import NotConcreteError from geolib.models.serializers import BaseSerializer from geolib.models.utils import get_filtered_type_hints @@ -35,21 +31,13 @@ def serialize(self) -> Dict: for i, data in enumerate(getattr(self.ds, field)): suffix = f"_{i}" if i > 0 else "" fn = element_type.structure_name() + suffix + ".json" - if IS_PYDANTIC_V2: - serialized_datastructure[folder][fn] = data.model_dump_json( - indent=4 - ) - else: - serialized_datastructure[folder][fn] = data.json(indent=4) + serialized_datastructure[folder][fn] = data.model_dump_json(indent=4) # Otherwise its a single .json in the root folder else: fn = fieldtype.structure_name() + ".json" data = getattr(self.ds, field) - if IS_PYDANTIC_V2: - serialized_datastructure[fn] = data.model_dump_json(indent=4) - else: - serialized_datastructure[fn] = data.json(indent=4) + serialized_datastructure[fn] = data.model_dump_json(indent=4) return serialized_datastructure diff --git a/geolib/models/dstability/states.py b/geolib/models/dstability/states.py index 329797f3..8533e1ce 100644 --- a/geolib/models/dstability/states.py +++ b/geolib/models/dstability/states.py @@ -3,9 +3,7 @@ """ import abc -from typing import List, Tuple -from geolib._compat import IS_PYDANTIC_V2 from geolib.models import BaseDataClass from ...geometry.one import Point @@ -43,20 +41,11 @@ class DStabilityStress(DStabilityObject): ) state_type: InternalStateTypeEnum = InternalStateTypeEnum.POP - def _to_internal_datastructure(self) -> PersistableStress: - if IS_PYDANTIC_V2: - data = { - **{ - snake_to_camel(name): value - for name, value in self.model_dump().items() - } - } - else: - data = { - **{snake_to_camel(name): value for name, value in self.dict().items()} - } - data["PopStochasticParameter"] = data.pop("StochasticParameter") - return PersistableStress(**data) + +def _to_internal_datastructure(self) -> PersistableStress: + data = {**{snake_to_camel(name): value for name, value in self.model_dump().items()}} + data["PopStochasticParameter"] = data.pop("StochasticParameter") + return PersistableStress(**data) class DStabilityStatePoint(DStabilityObject): @@ -81,10 +70,7 @@ class DStabilityStatePoint(DStabilityObject): label: str = "" def _to_internal_datastructure(self) -> PersistableStatePoint: - if IS_PYDANTIC_V2: - model_dump = self.model_dump() - else: - model_dump = self.dict() + model_dump = self.model_dump() data = { **{ snake_to_camel(name): value @@ -109,10 +95,7 @@ class DStabilityStateLinePoint(DStabilityObject): x: float def _to_internal_datastructure(self) -> PersistableStateLinePoint: - if IS_PYDANTIC_V2: - model_dump = self.model_dump() - else: - model_dump = self.dict() + model_dump = self.model_dump() data = { **{ snake_to_camel(name): value diff --git a/geolib/service/main.py b/geolib/service/main.py index 8384b459..719d4bfc 100644 --- a/geolib/service/main.py +++ b/geolib/service/main.py @@ -2,23 +2,15 @@ import shutil import uuid from pathlib import Path, PosixPath, WindowsPath -from typing import Dict, List, Type, Union - -from geolib._compat import IS_PYDANTIC_V2 - -if IS_PYDANTIC_V2: - from pydantic import Field, ValidationError - from pydantic.deprecated import json as pydantic_json - from typing_extensions import Annotated -else: - from pydantic import json as pydantic_json - from pydantic import conlist - from pydantic.error_wrappers import ValidationError +from typing import List from fastapi import BackgroundTasks, Depends, FastAPI, HTTPException from fastapi.security import HTTPBasic, HTTPBasicCredentials +from pydantic import Field, ValidationError +from pydantic.deprecated import json as pydantic_json from starlette import status from starlette.responses import JSONResponse +from typing_extensions import Annotated from geolib.errors import CalculationError from geolib.models import ( @@ -43,16 +35,10 @@ # Models (types) are defined below, because they are used in the # signatures of the functions and they differ between Pydantic v1 and v2. -if IS_PYDANTIC_V2: - dsettlement_list = Annotated[List[DSettlementModel], Field(min_length=1)] - dfoundation_list = Annotated[List[DFoundationsModel], Field(min_length=1)] - dsheetpile_list = Annotated[List[DSheetPilingModel], Field(min_length=1)] - dstability_list = Annotated[List[DStabilityModel], Field(min_length=1)] -else: - dsettlement_list = conlist(DSettlementModel, min_items=1) - dfoundation_list = conlist(DFoundationsModel, min_items=1) - dsheetpile_list = conlist(DSheetPilingModel, min_items=1) - dstability_list = conlist(DStabilityModel, min_items=1) +dsettlement_list = Annotated[List[DSettlementModel], Field(min_length=1)] +dfoundation_list = Annotated[List[DFoundationsModel], Field(min_length=1)] +dsheetpile_list = Annotated[List[DSheetPilingModel], Field(min_length=1)] +dstability_list = Annotated[List[DStabilityModel], Field(min_length=1)] def get_current_username(credentials: HTTPBasicCredentials = Depends(security)): diff --git a/geolib/soils/soil.py b/geolib/soils/soil.py index d58cd134..8790e6b3 100644 --- a/geolib/soils/soil.py +++ b/geolib/soils/soil.py @@ -2,12 +2,7 @@ from math import isfinite from typing import List, Optional, Union -from geolib._compat import IS_PYDANTIC_V2 - -if IS_PYDANTIC_V2: - from pydantic import field_validator -else: - from pydantic import validator +from pydantic import field_validator from geolib.geometry.one import Point from geolib.models import BaseDataClass @@ -16,25 +11,13 @@ class SoilBaseModel(BaseDataClass): - if IS_PYDANTIC_V2: - - @field_validator("*") - def fail_on_infinite(cls, v, _): - if isinstance(v, float) and not isfinite(v): - raise ValueError( - "Only finite values are supported, don't use nan, -inf or inf." - ) - return v - - else: - - @validator("*") - def fail_on_infinite(cls, v, values, field): - if isinstance(v, float) and not isfinite(v): - raise ValueError( - "Only finite values are supported, don't use nan, -inf or inf." - ) - return v + @field_validator("*") + def fail_on_infinite(cls, v, _): + if isinstance(v, float) and not isfinite(v): + raise ValueError( + "Only finite values are supported, don't use nan, -inf or inf." + ) + return v class DistributionType(IntEnum): @@ -446,14 +429,12 @@ class Soil(SoilBaseModel): ] = SubgradeReactionParameters() shell_factor: Optional[float] = None - if IS_PYDANTIC_V2: - - @field_validator("id", mode="before") - @classmethod - def transform_id_to_str(cls, value) -> str: - if value is None: - return None - return str(value) + @field_validator("id", mode="before") + @classmethod + def transform_id_to_str(cls, value) -> str: + if value is None: + return None + return str(value) @staticmethod def set_stochastic_parameters(input_class: object): @@ -467,17 +448,11 @@ def set_stochastic_parameters(input_class: object): """ try: - if IS_PYDANTIC_V2: - class_dict = input_class.model_dump() - else: - class_dict = input_class.dict() + class_dict = input_class.model_dump() except AttributeError: return input_class - if IS_PYDANTIC_V2: - fields = input_class.model_fields - else: - fields = input_class.__fields__ + fields = input_class.model_fields for field in fields: parameter = fields[field] if isinstance(parameter.default, StochasticParameter): @@ -495,10 +470,7 @@ def set_all_stochastic_parameters(self): Returns: """ - if IS_PYDANTIC_V2: - fields = self.model_fields - else: - fields = self.__fields__ + fields = self.model_fields for field in fields: self.set_stochastic_parameters(self.__getattribute__(field)) diff --git a/geolib/soils/soil_utils.py b/geolib/soils/soil_utils.py index 4ff226a8..73168878 100644 --- a/geolib/soils/soil_utils.py +++ b/geolib/soils/soil_utils.py @@ -1,11 +1,6 @@ from struct import pack, unpack_from -from geolib._compat import IS_PYDANTIC_V2 - -if IS_PYDANTIC_V2: - from pydantic_extra_types.color import Color as PydanticColor -else: - from pydantic.color import Color as PydanticColor +from pydantic_extra_types.color import Color as PydanticColor class Color(PydanticColor): From 4de92313f656543a1bf9105009af88b710c175e4 Mon Sep 17 00:00:00 2001 From: Ardt Klapwijk <59741981+ArdtK@users.noreply.github.com> Date: Wed, 24 Jul 2024 12:07:59 +0200 Subject: [PATCH 5/9] chore: tests --- .../test_dfoundations_regression_suite.py | 12 +- .../test_dfoundations_structures.py | 11 +- .../models/dgeoflow/test_dgeoflow_internal.py | 8 +- .../dgeoflow/test_dgeoflow_parserprovider.py | 11 +- .../dsettlement/test_dsettlement_model.py | 51 ++----- .../test_dsettlement_regression_suite.py | 11 +- .../test_dsheetpiling_acceptance.py | 130 +++++------------- .../dsheetpiling/test_dsheetpiling_model.py | 45 +----- .../test_dsheetpiling_regression_suite.py | 17 +-- tests/models/dsheetpiling/test_profiles.py | 27 +--- tests/models/dsheetpiling/test_supports.py | 36 +---- tests/models/dsheetpiling/test_surfaces.py | 13 +- .../models/dstability/test_dstability_bugs.py | 6 +- .../dstability/test_dstability_geometry.py | 8 +- .../dstability/test_dstability_internal.py | 9 +- .../test_dstability_parserprovider.py | 13 +- tests/models/dstability/test_loads.py | 15 +- .../models/dstability/test_reinforcements.py | 8 +- tests/models/dstability/test_waternets.py | 13 -- tests/models/test_dseries_parser.py | 13 +- tests/service/test_service.py | 40 ++---- tests/soils/test_soil_bugs.py | 10 +- tests/soils/test_soils.py | 10 +- tests/test_utils.py | 9 +- 24 files changed, 104 insertions(+), 422 deletions(-) diff --git a/tests/models/dfoundations/test_dfoundations_regression_suite.py b/tests/models/dfoundations/test_dfoundations_regression_suite.py index 6f436126..358e72fe 100644 --- a/tests/models/dfoundations/test_dfoundations_regression_suite.py +++ b/tests/models/dfoundations/test_dfoundations_regression_suite.py @@ -1,9 +1,7 @@ from pathlib import Path import pytest -from teamcity import is_running_under_teamcity -from geolib._compat import IS_PYDANTIC_V2 from geolib.models import DFoundationsModel from tests.utils import TestUtils, only_teamcity @@ -50,10 +48,7 @@ def test_parse_output_benchmarks_dfoundations(self, test_file: Path): # Serialize to json for acceptance with open(output_test_file, "w") as io: - if IS_PYDANTIC_V2: - io.write(ds.model_dump_json(indent=4)) - else: - io.write(ds.output.json(indent=4)) + io.write(ds.model_dump_json(indent=4)) @pytest.mark.systemtest @only_teamcity @@ -77,10 +72,7 @@ def test_parse_output_tutorials_dfoundations(self, test_file: Path): # Serialize to json for acceptance with open(output_test_file, "w") as io: - if IS_PYDANTIC_V2: - io.write(ds.model_dump_json(indent=4)) - else: - io.write(ds.output.json(indent=4)) + io.write(ds.model_dump_json(indent=4)) @pytest.mark.unittest def test_regression_issue8(self): diff --git a/tests/models/dfoundations/test_dfoundations_structures.py b/tests/models/dfoundations/test_dfoundations_structures.py index be8ffc58..9e794a01 100644 --- a/tests/models/dfoundations/test_dfoundations_structures.py +++ b/tests/models/dfoundations/test_dfoundations_structures.py @@ -1,23 +1,16 @@ from contextlib import nullcontext as does_not_raise from random import choice, randint from string import ascii_lowercase -from typing import Dict, List, Type, Union, _GenericAlias +from typing import Dict, List, Type, Union import pytest - -from geolib._compat import IS_PYDANTIC_V2 - -if IS_PYDANTIC_V2: - from pydantic_core._pydantic_core import ValidationError -else: - from pydantic import ValidationError +from pydantic_core._pydantic_core import ValidationError from geolib.models.dfoundations.dfoundations_structures import ( DFoundationsCPTCollectionWrapper, DFoundationsEnumStructure, DFoundationsTableWrapper, ) -from geolib.models.dseries_parser import DSeriesTreeStructure class TestDFoundationsEnumStructure: diff --git a/tests/models/dgeoflow/test_dgeoflow_internal.py b/tests/models/dgeoflow/test_dgeoflow_internal.py index d8929492..51e74415 100644 --- a/tests/models/dgeoflow/test_dgeoflow_internal.py +++ b/tests/models/dgeoflow/test_dgeoflow_internal.py @@ -2,13 +2,7 @@ from pathlib import Path import pytest - -from geolib._compat import IS_PYDANTIC_V2 - -if IS_PYDANTIC_V2: - from pydantic_core._pydantic_core import ValidationError -else: - from pydantic import ValidationError +from pydantic_core._pydantic_core import ValidationError from geolib.models.dgeoflow import DGeoFlowModel from geolib.models.dgeoflow.internal import ( diff --git a/tests/models/dgeoflow/test_dgeoflow_parserprovider.py b/tests/models/dgeoflow/test_dgeoflow_parserprovider.py index 42d2bb06..fa7099a9 100644 --- a/tests/models/dgeoflow/test_dgeoflow_parserprovider.py +++ b/tests/models/dgeoflow/test_dgeoflow_parserprovider.py @@ -3,7 +3,6 @@ import pytest -from geolib._compat import IS_PYDANTIC_V2 from geolib.models.dgeoflow import DGeoFlowModel from geolib.models.dgeoflow.dgeoflow_parserprovider import ( DGeoFlowParser, @@ -41,10 +40,7 @@ def test_dgeoflow_parse_directory(self, dir_path: str): # 4. Verify final expectations. assert input_structure is not None - if IS_PYDANTIC_V2: - data = input_structure.model_dump_json(indent=4) - else: - data = input_structure.json(indent=4) + data = input_structure.model_dump_json(indent=4) with open(test_output_filepath / "dstability_parsed_input.json", "w") as io: io.write(data) @@ -65,10 +61,7 @@ def test_dgeoflow_parse_flox(self): # 4. Verify final expectations. assert input_structure is not None - if IS_PYDANTIC_V2: - data = input_structure.model_dump_json(indent=4) - else: - data = input_structure.json(indent=4) + data = input_structure.model_dump_json(indent=4) with open(test_output_dir / "dgeoflow_parsed_input_flox.json", "w") as io: io.write(data) diff --git a/tests/models/dsettlement/test_dsettlement_model.py b/tests/models/dsettlement/test_dsettlement_model.py index 04efe4ea..cd6764d6 100644 --- a/tests/models/dsettlement/test_dsettlement_model.py +++ b/tests/models/dsettlement/test_dsettlement_model.py @@ -1,31 +1,18 @@ -import logging import os -import pathlib from datetime import timedelta from io import BytesIO from pathlib import Path from typing import List -from warnings import warn - -from geolib._compat import IS_PYDANTIC_V2 - -if IS_PYDANTIC_V2: - from pydantic import ValidationError -else: - from pydantic.error_wrappers import ValidationError import pytest -from pydantic.color import Color -from teamcity import is_running_under_teamcity +from pydantic import ValidationError import geolib.models.dsettlement.loads as loads import geolib.soils as soil_external -from geolib.errors import CalculationError from geolib.geometry.one import Point from geolib.models import BaseModel -from geolib.models.dsettlement.drain_types import DrainGridType, DrainSchedule, DrainType +from geolib.models.dsettlement.drain_types import DrainGridType, DrainType from geolib.models.dsettlement.drains import ( - ScheduleValues, ScheduleValuesDetailedInput, ScheduleValuesOff, ScheduleValuesSimpleInput, @@ -42,7 +29,6 @@ Dimension, DispersionConditionLayerBoundary, DSeriePoint, - DSettlementOutputStructure, DSettlementStructure, GeometryData, InternalProbabilisticCalculationType, @@ -62,10 +48,8 @@ ) from geolib.soils import ( DistributionType, - IsotacheParameters, Soil, SoilClassificationParameters, - SoilWeightParameters, StateType, StochasticParameter, ) @@ -196,10 +180,7 @@ def test_parse_output(self): # Serialize to json for acceptance with open(output_test_file, "w") as io: - if IS_PYDANTIC_V2: - io.write(ds.output.model_dump_json(indent=4)) - else: - io.write(ds.output.json(indent=4)) + io.write(ds.output.model_dump_json(indent=4)) @pytest.mark.acceptance @only_teamcity @@ -299,10 +280,7 @@ def test_given_timedelta_lesser_than_zero_when_set_calculation_times_raises_valu ): # 1. Set up test data. test_model = DSettlementModel() - if IS_PYDANTIC_V2: - expected_mssg = "Input should be greater than or equal to 0" - else: - expected_mssg = "ensure this value is greater than or equal to 0" + expected_mssg = "Input should be greater than or equal to 0" # 2. Run and verify expectations with pytest.raises(ValueError, match=expected_mssg): @@ -367,21 +345,13 @@ def test_given_parsed_input_when_serialize_then_same_content(self, filename: Pat # 4.1. Verify final expectations. assert ds.datastructure, "No data has been generated." assert isinstance(ds.datastructure, DSettlementStructure) - if IS_PYDANTIC_V2: - input_datastructure = ds.datastructure.input_data.model_dump() - else: - input_datastructure = ds.datastructure.input_data.dict() + input_datastructure = ds.datastructure.input_data.model_dump() # 4.2. Read the generated data. assert output_test_file.is_file() - if IS_PYDANTIC_V2: - output_datastructure = ( - DSettlementModel().parse(output_test_file).input_data.model_dump() - ) - else: - output_datastructure = ( - DSettlementModel().parse(output_test_file).input_data.dict() - ) + output_datastructure = ( + DSettlementModel().parse(output_test_file).input_data.model_dump() + ) assert not ( input_datastructure is output_datastructure ), "Both references are the same." @@ -1057,10 +1027,7 @@ def test_add_soil_to_layer(self): # step 3: run test ds.add_soil(soil_input) # step 4: verify final expectations - if IS_PYDANTIC_V2: - model_dump = ds.input.soil_collection.soil[-1].model_dump() - else: - model_dump = ds.input.soil_collection.soil[-1].dict() + model_dump = ds.input.soil_collection.soil[-1].model_dump() assert model_dump["name"] == "MyNewSoil" assert model_dump["soilgamdry"] == 30 assert model_dump["soilgamwet"] == 20 diff --git a/tests/models/dsettlement/test_dsettlement_regression_suite.py b/tests/models/dsettlement/test_dsettlement_regression_suite.py index 47ddefe3..f0db8317 100644 --- a/tests/models/dsettlement/test_dsettlement_regression_suite.py +++ b/tests/models/dsettlement/test_dsettlement_regression_suite.py @@ -3,7 +3,6 @@ import pytest from teamcity import is_running_under_teamcity -from geolib._compat import IS_PYDANTIC_V2 from geolib.models import DSettlementModel from tests.utils import TestUtils, only_teamcity @@ -50,10 +49,7 @@ def test_parse_output_benchmarks_dsettlement(self, test_file): # Serialize to json for acceptance with open(output_test_file, "w") as io: - if IS_PYDANTIC_V2: - io.write(ds.model_dump_json(indent=4)) - else: - io.write(ds.output.json(indent=4)) + io.write(ds.model_dump_json(indent=4)) @pytest.mark.systemtest @only_teamcity @@ -77,7 +73,4 @@ def test_parse_output_tutorials_dsettlement(self, test_file: Path): # Serialize to json for acceptance with open(output_test_file, "w") as io: - if IS_PYDANTIC_V2: - io.write(ds.model_dump_json(indent=4)) - else: - io.write(ds.output.json(indent=4)) + io.write(ds.model_dump_json(indent=4)) diff --git a/tests/models/dsheetpiling/test_dsheetpiling_acceptance.py b/tests/models/dsheetpiling/test_dsheetpiling_acceptance.py index d69e6b39..e0ebf57f 100644 --- a/tests/models/dsheetpiling/test_dsheetpiling_acceptance.py +++ b/tests/models/dsheetpiling/test_dsheetpiling_acceptance.py @@ -3,25 +3,14 @@ from pathlib import Path import pytest - -from geolib._compat import IS_PYDANTIC_V2 - -if IS_PYDANTIC_V2: - from pydantic_extra_types.color import Color -else: - from pydantic.color import Color - -from teamcity import is_running_under_teamcity +from pydantic_extra_types.color import Color from geolib.geometry.one import Point -from geolib.models import BaseModel from geolib.models.dsheetpiling.calculation_options import ( - CalculationOptions, CalculationOptionsPerStage, DesignSheetpilingLengthCalculationOptions, KranzAnchorStrengthCalculationOptions, OverallStabilityCalculationOptions, - ReliabilityAnalysisCalculationOptions, StandardCalculationOptions, VerifyCalculationOptions, ) @@ -43,35 +32,21 @@ SinglePileModelType, WoodenSheetPileModelType, ) -from geolib.models.dsheetpiling.internal import ( - DSheetPilingDumpStructure, - DSheetPilingInputStructure, - DSheetPilingOutputStructure, - DSheetPilingStructure, - SurchargePoint, -) from geolib.models.dsheetpiling.loads import ( HorizontalLineLoad, - LoadTypeFavourableUnfavourable, - LoadTypePermanentVariable, Moment, NormalForce, SurchargeLoad, UniformLoad, - VerificationLoadSettingsLoads, - VerificationLoadSettingsMomentNormalForce, ) from geolib.models.dsheetpiling.profiles import SoilLayer, SoilProfile from geolib.models.dsheetpiling.settings import ( CalculationType, CurveSettings, DesignType, - DistributionType, LateralEarthPressureMethod, LateralEarthPressureMethodStage, - ModelType, ModulusReactionType, - ModulusSubgradeReaction, PartialFactorCalculationType, PartialFactorSetCUR, PartialFactorSetEC7NADNL, @@ -79,7 +54,6 @@ SheetPilingElementMaterialType, Side, SinglePileLoadOptions, - SoilTypeModulusSubgradeReaction, VerifyType, ) from geolib.models.dsheetpiling.supports import ( @@ -400,17 +374,12 @@ def test_run_sheet_model_acceptance_different_calculation_types( assert model.datastructure assert model.datastructure.is_valid with open("data" + output_test_file.name.split(".")[0] + ".json", "w") as outfile: - if IS_PYDANTIC_V2: - json.dump( - model.datastructure.model_dump(), - outfile, - ensure_ascii=False, - indent=4, - ) - else: - json.dump( - model.datastructure.dict(), outfile, ensure_ascii=False, indent=4 - ) + json.dump( + model.datastructure.model_dump(), + outfile, + ensure_ascii=False, + indent=4, + ) # 5. For OverallStabilityCalculationOptions a STI file should be present because StabilityExport is True if isinstance(calc_options, OverallStabilityCalculationOptions): @@ -670,17 +639,12 @@ def test_run_sheet_model_acceptance_multiple_stages(self, request): assert model.datastructure assert model.datastructure.is_valid with open("data" + output_test_file.name.split(".")[0] + ".json", "w") as outfile: - if IS_PYDANTIC_V2: - json.dump( - model.datastructure.model_dump(), - outfile, - ensure_ascii=False, - indent=4, - ) - else: - json.dump( - model.datastructure.dict(), outfile, ensure_ascii=False, indent=4 - ) + json.dump( + model.datastructure.model_dump(), + outfile, + ensure_ascii=False, + indent=4, + ) # @only_teamcity @pytest.mark.acceptance @@ -910,17 +874,12 @@ def test_acceptance_test_single_pile(self, request, modeltype): with open( "data" + output_test_file.name.split(".")[0] + ".json", "w" ) as outfile: - if IS_PYDANTIC_V2: - json.dump( - model.datastructure.model_dump(), - outfile, - ensure_ascii=False, - indent=4, - ) - else: - json.dump( - model.datastructure.dict(), outfile, ensure_ascii=False, indent=4 - ) + json.dump( + model.datastructure.model_dump(), + outfile, + ensure_ascii=False, + indent=4, + ) # @only_teamcity @pytest.mark.acceptance @@ -1227,17 +1186,12 @@ def test_run_sheet_model_acceptance_different_calculation_types_wooden_sheet_pil assert model.datastructure assert model.datastructure.is_valid with open("data" + output_test_file.name.split(".")[0] + ".json", "w") as outfile: - if IS_PYDANTIC_V2: - json.dump( - model.datastructure.model_dump(), - outfile, - ensure_ascii=False, - indent=4, - ) - else: - json.dump( - model.datastructure.dict(), outfile, ensure_ascii=False, indent=4 - ) + json.dump( + model.datastructure.model_dump(), + outfile, + ensure_ascii=False, + indent=4, + ) # @only_teamcity @pytest.mark.acceptance @@ -1555,17 +1509,12 @@ def test_run_sheet_model_acceptance_different_calculation_types_diaphragm_wall( assert model.datastructure assert model.datastructure.is_valid with open("data" + output_test_file.name.split(".")[0] + ".json", "w") as outfile: - if IS_PYDANTIC_V2: - json.dump( - model.datastructure.model_dump(), - outfile, - ensure_ascii=False, - indent=4, - ) - else: - json.dump( - model.datastructure.dict(), outfile, ensure_ascii=False, indent=4 - ) + json.dump( + model.datastructure.model_dump(), + outfile, + ensure_ascii=False, + indent=4, + ) # @only_teamcity @pytest.mark.acceptance @@ -1868,14 +1817,9 @@ def test_run_sheet_model_plastic_pile_acceptance_different_calculation_types( assert model.datastructure assert model.datastructure.is_valid with open("data" + output_test_file.name.split(".")[0] + ".json", "w") as outfile: - if IS_PYDANTIC_V2: - json.dump( - model.datastructure.model_dump(), - outfile, - ensure_ascii=False, - indent=4, - ) - else: - json.dump( - model.datastructure.dict(), outfile, ensure_ascii=False, indent=4 - ) + json.dump( + model.datastructure.model_dump(), + outfile, + ensure_ascii=False, + indent=4, + ) diff --git a/tests/models/dsheetpiling/test_dsheetpiling_model.py b/tests/models/dsheetpiling/test_dsheetpiling_model.py index 64048fa2..a6b964e5 100644 --- a/tests/models/dsheetpiling/test_dsheetpiling_model.py +++ b/tests/models/dsheetpiling/test_dsheetpiling_model.py @@ -2,24 +2,12 @@ import os from io import BytesIO from pathlib import Path -from typing import List, Type +from typing import Type import pytest -from teamcity import is_running_under_teamcity -from geolib._compat import IS_PYDANTIC_V2 from geolib.geometry.one import Point from geolib.models import BaseModel -from geolib.models.dsheetpiling.calculation_options import ( - CalculationOptions, - CalculationOptionsPerStage, - DesignSheetpilingLengthCalculationOptions, - KranzAnchorStrengthCalculationOptions, - OverallStabilityCalculationOptions, - ReliabilityAnalysisCalculationOptions, - StandardCalculationOptions, - VerifyCalculationOptions, -) from geolib.models.dsheetpiling.constructions import ( DiaphragmWall, DiaphragmWallProperties, @@ -38,7 +26,6 @@ from geolib.models.dsheetpiling.internal import ( DSheetPilingDumpStructure, DSheetPilingInputStructure, - DSheetPilingOutputStructure, DSheetPilingStructure, SurchargePoint, ) @@ -49,37 +36,19 @@ Moment, NormalForce, SurchargeLoad, - UniformLoad, VerificationLoadSettingsLoads, VerificationLoadSettingsMomentNormalForce, ) -from geolib.models.dsheetpiling.profiles import SoilLayer, SoilProfile from geolib.models.dsheetpiling.settings import ( - CalculationType, - CurveSettings, DistributionType, LateralEarthPressureMethod, LateralEarthPressureMethodStage, ModelType, - ModulusReactionType, - ModulusSubgradeReaction, - PartialFactorCalculationType, - PartialFactorSetEC7NADNL, PassiveSide, - SheetPilingElementMaterialType, Side, - VerifyType, -) -from geolib.models.dsheetpiling.supports import ( - Anchor, - RigidSupport, - SpringSupport, - Strut, - SupportType, ) -from geolib.models.dsheetpiling.surface import Surface -from geolib.models.dsheetpiling.water_level import WaterLevel -from geolib.soils import MohrCoulombParameters, Soil, SoilType +from geolib.models.dsheetpiling.supports import Anchor +from geolib.soils import Soil, SoilType from tests.utils import TestUtils, only_teamcity test_file_directory = "dsheetpiling/benchmarks" @@ -98,12 +67,8 @@ def model() -> DSheetPilingModel: def get_problem_description(ds_value, errors, od_value): - if IS_PYDANTIC_V2: - od_dict = od_value.model_dump() - ds_dict = ds_value.model_dump() - else: - od_dict = od_value.dict() - ds_dict = ds_value.dict() + od_dict = od_value.model_dump() + ds_dict = ds_value.model_dump() for key, value in ds_dict.items(): if key not in od_dict.keys(): errors.append(f"Input key {key} not present in output") diff --git a/tests/models/dsheetpiling/test_dsheetpiling_regression_suite.py b/tests/models/dsheetpiling/test_dsheetpiling_regression_suite.py index 5b78fbe2..c1009242 100644 --- a/tests/models/dsheetpiling/test_dsheetpiling_regression_suite.py +++ b/tests/models/dsheetpiling/test_dsheetpiling_regression_suite.py @@ -1,9 +1,7 @@ from pathlib import Path import pytest -from teamcity import is_running_under_teamcity -from geolib._compat import IS_PYDANTIC_V2 from geolib.models import DSheetPilingModel from tests.utils import TestUtils, only_teamcity @@ -58,10 +56,7 @@ def test_parse_output_benchmarks_dsheetpiling(self, test_file: Path): # Serialize to json for acceptance with open(output_test_file, "w") as io: - if IS_PYDANTIC_V2: - io.write(ds.output.model_dump_json(indent=4)) - else: - io.write(ds.output.json(indent=4)) + io.write(ds.output.model_dump_json(indent=4)) @pytest.mark.systemtest @only_teamcity @@ -87,10 +82,7 @@ def test_parse_output_complex_projects_dsheetpiling(self, test_file: Path): # Serialize to json for acceptance with open(output_test_file, "w") as io: - if IS_PYDANTIC_V2: - io.write(ds.output.model_dump_json(indent=4)) - else: - io.write(ds.output.json(indent=4)) + io.write(ds.output.model_dump_json(indent=4)) @pytest.mark.systemtest @only_teamcity @@ -114,7 +106,4 @@ def test_parse_output_tutorials_dsheetpiling(self, test_file: Path): # Serialize to json for acceptance with open(output_test_file, "w") as io: - if IS_PYDANTIC_V2: - io.write(ds.output.model_dump_json(indent=4)) - else: - io.write(ds.output.json(indent=4)) + io.write(ds.output.model_dump_json(indent=4)) diff --git a/tests/models/dsheetpiling/test_profiles.py b/tests/models/dsheetpiling/test_profiles.py index 532adf52..7f806279 100644 --- a/tests/models/dsheetpiling/test_profiles.py +++ b/tests/models/dsheetpiling/test_profiles.py @@ -2,13 +2,7 @@ from typing import Callable, List import pytest - -from geolib._compat import IS_PYDANTIC_V2 - -if IS_PYDANTIC_V2: - from pydantic import ValidationError -else: - from pydantic.error_wrappers import ValidationError +from pydantic import ValidationError from geolib.geometry.one import Point from geolib.models.dsheetpiling.dsheetpiling_model import DSheetPilingModel @@ -81,10 +75,7 @@ class TestCurveSettings: pytest.param( 0, pytest.raises( - ValidationError, - match=r"Input should be greater than or equal to 1" - if IS_PYDANTIC_V2 - else r"ensure this value is greater than or equal to 1", + ValidationError, match=r"Input should be greater than or equal to 1" ), id="Lower than allowed", ), @@ -95,10 +86,7 @@ class TestCurveSettings: pytest.param( 5, pytest.raises( - ValidationError, - match=r"Input should be less than or equal to 4" - if IS_PYDANTIC_V2 - else r"ensure this value is less than or equal to 4", + ValidationError, match=r"Input should be less than or equal to 4" ), id="Higher than allowed", ), @@ -187,9 +175,7 @@ class TestSoilProfile: [], pytest.raises( ValidationError, - match=r"List should have at least 1 item after validation" - if IS_PYDANTIC_V2 - else r"ensure this value has at least 1 items", + match=r"List should have at least 1 item after validation", ), id="No layers", ), @@ -289,10 +275,7 @@ def test_dsheetpilingmodel_add_profile_internal_soil_profiles_updated( assert internal.name == _PROFILE_TEST_NAME assert len(profile.layers) == len(internal.layers) for layer, internal_layer in zip(profile.layers, internal.layers): - if IS_PYDANTIC_V2: - assert layer.model_dump() == internal_layer.model_dump() - else: - assert layer.dict() == internal_layer.dict() + assert layer.model_dump() == internal_layer.model_dump() assert profile.coordinate.x == internal.coordinate.x assert profile.coordinate.y == internal.coordinate.y diff --git a/tests/models/dsheetpiling/test_supports.py b/tests/models/dsheetpiling/test_supports.py index 198f7476..45fe00b0 100644 --- a/tests/models/dsheetpiling/test_supports.py +++ b/tests/models/dsheetpiling/test_supports.py @@ -1,14 +1,7 @@ -from contextlib import nullcontext as does_not_raise from typing import Any import pytest - -from geolib._compat import IS_PYDANTIC_V2 - -if IS_PYDANTIC_V2: - from pydantic import ValidationError -else: - from pydantic.error_wrappers import ValidationError +from pydantic import ValidationError from geolib.models.dsheetpiling.dsheetpiling_model import DSheetPilingModel from geolib.models.dsheetpiling.internal import _DEFAULT_PRE_STRESS @@ -341,10 +334,7 @@ def test_intialization_spring_support( "name", "i" * 51, pytest.raises( - ValidationError, - match=r"String should have at most 50 characters" - if IS_PYDANTIC_V2 - else r"ensure this value has at most 50 characters", + ValidationError, match=r"String should have at most 50 characters" ), id="Name too long", ), @@ -352,10 +342,7 @@ def test_intialization_spring_support( "rotational_stiffness", -1, pytest.raises( - ValidationError, - match=r"Input should be greater than or equal to 0 " - if IS_PYDANTIC_V2 - else r"ensure this value is greater than or equal to 0", + ValidationError, match=r"Input should be greater than or equal to 0 " ), id="Name too long", ), @@ -363,10 +350,7 @@ def test_intialization_spring_support( "translational_stiffness", -1, pytest.raises( - ValidationError, - match=r"Input should be greater than or equal to 0 " - if IS_PYDANTIC_V2 - else r"ensure this value is greater than or equal to 0", + ValidationError, match=r"Input should be greater than or equal to 0 " ), id="Negative translational stiffness", ), @@ -524,22 +508,14 @@ def test_intialization_rigid_support( "name", "i" * 51, pytest.raises( - ValidationError, - match=r"String should have at most 50 characters" - if IS_PYDANTIC_V2 - else r"ensure this value has at most 50 characters", + ValidationError, match=r"String should have at most 50 characters" ), id="Name too long", ), pytest.param( "support_type", 5, - pytest.raises( - ValidationError, - match=r"Input should be 1, 2 or 3" - if IS_PYDANTIC_V2 - else r"value is not a valid enumeration member; permitted: 1, 2, 3", - ), + pytest.raises(ValidationError, match=r"Input should be 1, 2 or 3"), id="Name too long", ), ], diff --git a/tests/models/dsheetpiling/test_surfaces.py b/tests/models/dsheetpiling/test_surfaces.py index abed715b..ce72047b 100644 --- a/tests/models/dsheetpiling/test_surfaces.py +++ b/tests/models/dsheetpiling/test_surfaces.py @@ -2,13 +2,7 @@ from typing import Callable, List import pytest - -from geolib._compat import IS_PYDANTIC_V2 - -if IS_PYDANTIC_V2: - from pydantic import ValidationError -else: - from pydantic.error_wrappers import ValidationError +from pydantic import ValidationError from geolib.geometry.one import Point from geolib.models.dsheetpiling.dsheetpiling_model import DSheetPilingModel @@ -55,10 +49,7 @@ class TestSurfaces: pytest.param( [], pytest.raises( - ValidationError, - match=r" List should have at least 1 item" - if IS_PYDANTIC_V2 - else r"ensure this value has at least 1 items", + ValidationError, match=r" List should have at least 1 item" ), id="No points", ), diff --git a/tests/models/dstability/test_dstability_bugs.py b/tests/models/dstability/test_dstability_bugs.py index 2ddad234..84e19a4e 100644 --- a/tests/models/dstability/test_dstability_bugs.py +++ b/tests/models/dstability/test_dstability_bugs.py @@ -2,7 +2,6 @@ import pytest -from geolib._compat import IS_PYDANTIC_V2 from geolib.geometry import Point from geolib.models import DStabilityModel from geolib.models.dstability.analysis import ( @@ -27,10 +26,7 @@ def test_nan_fields_become_string_in_json(self): ) dm.set_model(bishop_analysis_method, 0, 0) - if IS_PYDANTIC_V2: - data = dm.datastructure.model_dump_json() - else: - data = dm.datastructure.json() + data = dm.datastructure.model_dump_json() # Using `in` was very slow, hence the find assert data.find('"NaN"') != -1 # Assert that quoted NaNs are found assert data.find(" NaN") == -1 # Assert that an unquoted NaN isn't found diff --git a/tests/models/dstability/test_dstability_geometry.py b/tests/models/dstability/test_dstability_geometry.py index f015ae31..3a82e5ab 100644 --- a/tests/models/dstability/test_dstability_geometry.py +++ b/tests/models/dstability/test_dstability_geometry.py @@ -2,13 +2,7 @@ from pathlib import Path import pytest - -from geolib._compat import IS_PYDANTIC_V2 - -if IS_PYDANTIC_V2: - from pydantic import ValidationError -else: - from pydantic.error_wrappers import ValidationError +from pydantic import ValidationError from geolib.geometry import Point from geolib.models.dstability.dstability_model import DStabilityModel diff --git a/tests/models/dstability/test_dstability_internal.py b/tests/models/dstability/test_dstability_internal.py index c0934fee..3eccac6f 100644 --- a/tests/models/dstability/test_dstability_internal.py +++ b/tests/models/dstability/test_dstability_internal.py @@ -2,19 +2,12 @@ from pathlib import Path import pytest - -from geolib._compat import IS_PYDANTIC_V2 - -if IS_PYDANTIC_V2: - from pydantic_core._pydantic_core import ValidationError -else: - from pydantic import ValidationError +from pydantic_core._pydantic_core import ValidationError from geolib.models.dstability import DStabilityModel from geolib.models.dstability.internal import ( DStabilityStructure, ForeignKeys, - PersistableHeadLine, ProjectInfo, Waternet, ) diff --git a/tests/models/dstability/test_dstability_parserprovider.py b/tests/models/dstability/test_dstability_parserprovider.py index 504982f5..7b3aff44 100644 --- a/tests/models/dstability/test_dstability_parserprovider.py +++ b/tests/models/dstability/test_dstability_parserprovider.py @@ -3,12 +3,9 @@ import pytest -from geolib._compat import IS_PYDANTIC_V2 -from geolib.models import BaseModel from geolib.models.dstability import DStabilityModel from geolib.models.dstability.dstability_parserprovider import ( DStabilityParser, - DStabilityParserProvider, DStabilityZipParser, ) from geolib.models.dstability.serializer import ( @@ -54,10 +51,7 @@ def test_dstability_parse_directory(self, dir_path: str): # 4. Verify final expectations. assert input_structure is not None - if IS_PYDANTIC_V2: - data = input_structure.model_dump_json(indent=4) - else: - data = input_structure.json(indent=4) + data = input_structure.model_dump_json(indent=4) with open(test_output_file_path / "dstability_parsed_input.json", "w") as io: io.write(data) @@ -80,10 +74,7 @@ def test_dstability_zip_parser_stix(self): # 4. Verify final expectations. assert input_structure is not None - if IS_PYDANTIC_V2: - data = input_structure.model_dump_json(indent=4) - else: - data = input_structure.json(indent=4) + data = input_structure.model_dump_json(indent=4) with open(test_output_dir / "dstability_parsed_input_stix.json", "w") as io: io.write(data) diff --git a/tests/models/dstability/test_loads.py b/tests/models/dstability/test_loads.py index 6989d452..2450066f 100644 --- a/tests/models/dstability/test_loads.py +++ b/tests/models/dstability/test_loads.py @@ -1,13 +1,7 @@ from typing import List import pytest - -from geolib._compat import IS_PYDANTIC_V2 - -if IS_PYDANTIC_V2: - from pydantic_core._pydantic_core import ValidationError -else: - from pydantic import ValidationError +from pydantic_core._pydantic_core import ValidationError from geolib.geometry.one import Point from geolib.models.dstability.dstability_model import DStabilityModel @@ -18,7 +12,12 @@ PersistableTree, PersistableUniformLoad, ) -from geolib.models.dstability.loads import Consolidation, LineLoad, TreeLoad, UniformLoad +from geolib.models.dstability.loads import ( + Consolidation, + LineLoad, + TreeLoad, + UniformLoad, +) @pytest.fixture diff --git a/tests/models/dstability/test_reinforcements.py b/tests/models/dstability/test_reinforcements.py index 48af78cc..d51f0fe0 100644 --- a/tests/models/dstability/test_reinforcements.py +++ b/tests/models/dstability/test_reinforcements.py @@ -1,13 +1,7 @@ from itertools import product import pytest - -from geolib._compat import IS_PYDANTIC_V2 - -if IS_PYDANTIC_V2: - from pydantic_core._pydantic_core import ValidationError -else: - from pydantic import ValidationError +from pydantic_core._pydantic_core import ValidationError from geolib.geometry.one import Point from geolib.models.dstability.dstability_model import DStabilityModel diff --git a/tests/models/dstability/test_waternets.py b/tests/models/dstability/test_waternets.py index 633e46df..15601d14 100644 --- a/tests/models/dstability/test_waternets.py +++ b/tests/models/dstability/test_waternets.py @@ -1,20 +1,7 @@ import pytest -from geolib._compat import IS_PYDANTIC_V2 - -if IS_PYDANTIC_V2: - from pydantic import ValidationError -else: - from pydantic.error_wrappers import ValidationError - from geolib.geometry import Point from geolib.models.dstability.dstability_model import DStabilityModel -from geolib.models.dstability.internal import ( - PersistableHeadLine, - PersistablePoint, - PersistableReferenceLine, - Waternet, -) class TestDStabilityHeadLine: diff --git a/tests/models/test_dseries_parser.py b/tests/models/test_dseries_parser.py index ad854761..377d90fe 100644 --- a/tests/models/test_dseries_parser.py +++ b/tests/models/test_dseries_parser.py @@ -1,18 +1,9 @@ -import logging -import os from random import randint -from typing import Dict, List, Tuple, Type, _GenericAlias, get_type_hints +from typing import Dict, List, Tuple, Type import pytest +from pydantic_core._pydantic_core import ValidationError -from geolib._compat import IS_PYDANTIC_V2 - -if IS_PYDANTIC_V2: - from pydantic_core._pydantic_core import ValidationError -else: - from pydantic import ValidationError - -from geolib.models.base_model import BaseModel from geolib.models.dseries_parser import ( DSeriesInlineMappedProperties, DSeriesInlineProperties, diff --git a/tests/service/test_service.py b/tests/service/test_service.py index 81a4831a..fb57a2eb 100644 --- a/tests/service/test_service.py +++ b/tests/service/test_service.py @@ -1,14 +1,8 @@ from pathlib import Path, PosixPath, WindowsPath -from geolib._compat import IS_PYDANTIC_V2 - -if IS_PYDANTIC_V2: - from pydantic.deprecated import json as pydantic_json -else: - from pydantic import json as pydantic_json - import pytest from fastapi.testclient import TestClient +from pydantic.deprecated import json as pydantic_json from requests.auth import HTTPBasicAuth from geolib import BaseModelList, DFoundationsModel, DSettlementModel @@ -33,10 +27,7 @@ def test_read_main(): def test_post_calculate_empty_model_fails(): model = DFoundationsModel() - if IS_PYDANTIC_V2: - data = model.model_dump_json() - else: - data = model.json() + data = model.model_dump_json() response = client.post( "/calculate/dfoundationsmodel", @@ -55,10 +46,7 @@ def test_post_calculate(): benchmark_fn = input_folder / "bm1-1.sli" model.parse(benchmark_fn) - if IS_PYDANTIC_V2: - data = model.model_dump_json() - else: - data = model.json() + data = model.model_dump_json() response = client.post( "/calculate/dsettlementmodel", @@ -84,18 +72,11 @@ def test_post_calculate_many(): model.parse(benchmark_fn) ml.models.append(DSettlementModel(filename=Path("c.sli"))) - if IS_PYDANTIC_V2: - response = client.post( - "/calculate/dsettlementmodels", - data="[" + ",".join((model.model_dump_json() for model in ml.models)) + "]", - auth=HTTPBasicAuth("test", "test"), - ) - else: - response = client.post( - "/calculate/dsettlementmodels", - data="[" + ",".join((model.json() for model in ml.models)) + "]", - auth=HTTPBasicAuth("test", "test"), - ) + response = client.post( + "/calculate/dsettlementmodels", + data="[" + ",".join((model.model_dump_json() for model in ml.models)) + "]", + auth=HTTPBasicAuth("test", "test"), + ) assert response.status_code == 200 assert "models" in response.json() assert "errors" in response.json() @@ -113,7 +94,4 @@ def test_auth(): auth=HTTPBasicAuth("test", "test"), ) assert response.status_code == 422 - if IS_PYDANTIC_V2: - assert "List should have at least 1 item after validation" in response.text - else: - assert "field required" in response.text + assert "List should have at least 1 item after validation" in response.text diff --git a/tests/soils/test_soil_bugs.py b/tests/soils/test_soil_bugs.py index cdf8be74..a9aa6e84 100644 --- a/tests/soils/test_soil_bugs.py +++ b/tests/soils/test_soil_bugs.py @@ -1,13 +1,5 @@ import pytest - -from geolib._compat import IS_PYDANTIC_V2 - -if IS_PYDANTIC_V2: - from pydantic_core._pydantic_core import ValidationError -else: - from pydantic import ValidationError - -from teamcity import is_running_under_teamcity +from pydantic_core._pydantic_core import ValidationError from geolib.models.dfoundations.dfoundations_model import DFoundationsModel from geolib.soils import MohrCoulombParameters, Soil, SoilType diff --git a/tests/soils/test_soils.py b/tests/soils/test_soils.py index c3f9b716..ddbf8a4d 100644 --- a/tests/soils/test_soils.py +++ b/tests/soils/test_soils.py @@ -1,13 +1,5 @@ import pytest - -from geolib._compat import IS_PYDANTIC_V2 - -if IS_PYDANTIC_V2: - from pydantic_core._pydantic_core import ValidationError -else: - from pydantic import ValidationError - -from teamcity import is_running_under_teamcity +from pydantic_core._pydantic_core import ValidationError from geolib.soils import ( MohrCoulombParameters, diff --git a/tests/test_utils.py b/tests/test_utils.py index cb6ed2f2..21152e69 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -1,9 +1,7 @@ -from random import randint -from typing import Type, _GenericAlias, get_type_hints +from typing import Type import pytest -from geolib._compat import IS_PYDANTIC_V2 from geolib.models import BaseDataClass from geolib.models.utils import get_filtered_type_hints, get_required_class_field @@ -33,10 +31,7 @@ def test_given_class_when_get_required_class_field_then_only_valid_fields_return assert len(filtered_types) == 1 field_name, field_type = filtered_types[0] assert field_name == "regular_field" - if IS_PYDANTIC_V2: - assert field_type.annotation == int - else: - assert field_type.type_ == int + assert field_type.annotation == int @pytest.mark.unittest @pytest.mark.parametrize( From c81372c9d5449fef8c0989ecd4f11e94f0b383d3 Mon Sep 17 00:00:00 2001 From: Ardt Klapwijk <59741981+ArdtK@users.noreply.github.com> Date: Wed, 24 Jul 2024 12:08:21 +0200 Subject: [PATCH 6/9] chore: compat --- geolib/_compat.py | 3 --- 1 file changed, 3 deletions(-) delete mode 100644 geolib/_compat.py diff --git a/geolib/_compat.py b/geolib/_compat.py deleted file mode 100644 index 4009b827..00000000 --- a/geolib/_compat.py +++ /dev/null @@ -1,3 +0,0 @@ -from pydantic import VERSION as PYDANTIC_VERSION - -IS_PYDANTIC_V2 = PYDANTIC_VERSION.startswith("2.") From 28b09221aabd111706da90a6e6d55509424f814e Mon Sep 17 00:00:00 2001 From: Ardt Klapwijk <59741981+ArdtK@users.noreply.github.com> Date: Wed, 24 Jul 2024 12:13:04 +0200 Subject: [PATCH 7/9] chore: typing fixes --- .../models/dsettlement/dsettlement_model.py | 21 ++++++------------- geolib/models/dsettlement/internal.py | 5 ++--- 2 files changed, 8 insertions(+), 18 deletions(-) diff --git a/geolib/models/dsettlement/dsettlement_model.py b/geolib/models/dsettlement/dsettlement_model.py index f0c22482..c62bac07 100644 --- a/geolib/models/dsettlement/dsettlement_model.py +++ b/geolib/models/dsettlement/dsettlement_model.py @@ -1,16 +1,12 @@ import logging from datetime import timedelta -from operator import attrgetter from pathlib import Path -from subprocess import CompletedProcess, run -from typing import BinaryIO, List, Optional, Type, Union +from typing import Annotated, BinaryIO, List, Optional, Type, Union -from pydantic import FilePath, validate_arguments -from pydantic.types import PositiveInt, confloat, conint, constr +from pydantic import FilePath, StringConstraints from geolib.geometry import Point -from geolib.models import BaseDataClass, BaseModel, BaseModelStructure -from geolib.models.dsettlement.internal_soil import SoilInternal +from geolib.models import BaseModel from geolib.models.dsettlement.loads import ( CircularLoad, RectangularLoad, @@ -22,30 +18,25 @@ ProbabilisticCalculationType, ) from geolib.models.dsettlement.serializer import DSettlementInputSerializer -from geolib.models.meta import CONSOLE_RUN_BATCH_FLAG, MetaData +from geolib.models.meta import CONSOLE_RUN_BATCH_FLAG from geolib.soils import DistributionType from geolib.soils import Soil as Soil_Input from .drains import VerticalDrain from .dsettlement_parserprovider import DSettlementParserProvider from .internal import ( - Boundary, CalculationOptions, ConsolidationModel, - Curve, Dimension, DSeriePoint, DSettlementOutputStructure, DSettlementStructure, Layer, - Layers, Model, NonUniformLoad, NonUniformLoads, OtherLoads, - PiezoLines, PointForLoad, - Points, ResidualTimes, Results, SoilModel, @@ -410,7 +401,7 @@ def other_loads(self): def add_other_load( self, - name: constr(min_length=1, max_length=25), + name: Annotated[str, StringConstraints(min_length=1, max_length=25)], time: timedelta, point: Point, other_load: Union[ @@ -430,7 +421,7 @@ def non_uniform_loads(self): def add_non_uniform_load( self, - name: constr(min_length=1, max_length=25), + name: Annotated[str, StringConstraints(min_length=1, max_length=25)], points: List[Point], time_start: timedelta, gamma_dry: float, diff --git a/geolib/models/dsettlement/internal.py b/geolib/models/dsettlement/internal.py index c6d27266..08f540b8 100644 --- a/geolib/models/dsettlement/internal.py +++ b/geolib/models/dsettlement/internal.py @@ -3,15 +3,14 @@ from inspect import cleandoc from math import isclose from operator import attrgetter -from typing import Any, Dict, List, Optional, Tuple, Type, Union +from typing import Dict, List, Optional, Tuple, Type, Union from pydantic import Field, StringConstraints -from pydantic.types import PositiveInt, conint +from pydantic.types import PositiveInt from typing_extensions import Annotated from geolib.geometry.one import Point from geolib.models import BaseDataClass -from geolib.models.base_model_structure import BaseModelStructure from geolib.models.dseries_parser import ( DSerieListStructure, DSerieMatrixStructure, From 3dccaf391f223181aa41de84c89fb09922216d68 Mon Sep 17 00:00:00 2001 From: Ardt Klapwijk <59741981+ArdtK@users.noreply.github.com> Date: Mon, 12 Aug 2024 09:19:26 +0200 Subject: [PATCH 8/9] chore: fix bug --- geolib/models/dsettlement/loads.py | 2 -- geolib/models/dstability/states.py | 11 ++++++----- 2 files changed, 6 insertions(+), 7 deletions(-) diff --git a/geolib/models/dsettlement/loads.py b/geolib/models/dsettlement/loads.py index ef00696a..492186d4 100644 --- a/geolib/models/dsettlement/loads.py +++ b/geolib/models/dsettlement/loads.py @@ -2,8 +2,6 @@ from datetime import timedelta from typing import Optional -from pydantic import constr - from geolib.geometry import Point from geolib.models import BaseDataClass diff --git a/geolib/models/dstability/states.py b/geolib/models/dstability/states.py index 8533e1ce..68e4cba7 100644 --- a/geolib/models/dstability/states.py +++ b/geolib/models/dstability/states.py @@ -41,11 +41,12 @@ class DStabilityStress(DStabilityObject): ) state_type: InternalStateTypeEnum = InternalStateTypeEnum.POP - -def _to_internal_datastructure(self) -> PersistableStress: - data = {**{snake_to_camel(name): value for name, value in self.model_dump().items()}} - data["PopStochasticParameter"] = data.pop("StochasticParameter") - return PersistableStress(**data) + def _to_internal_datastructure(self) -> PersistableStress: + data = { + **{snake_to_camel(name): value for name, value in self.model_dump().items()} + } + data["PopStochasticParameter"] = data.pop("StochasticParameter") + return PersistableStress(**data) class DStabilityStatePoint(DStabilityObject): From abb47963a5a18c229b06de10c01ee170a26098b2 Mon Sep 17 00:00:00 2001 From: Ardt Klapwijk <59741981+ArdtK@users.noreply.github.com> Date: Mon, 12 Aug 2024 10:07:18 +0200 Subject: [PATCH 9/9] chore: fix merge issue --- geolib/models/base_model.py | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/geolib/models/base_model.py b/geolib/models/base_model.py index 71603558..8a527a14 100644 --- a/geolib/models/base_model.py +++ b/geolib/models/base_model.py @@ -12,7 +12,7 @@ from typing import List, Optional, Type, Union import requests -from pydantic import DirectoryPath, FilePath, HttpUrl, ValidationError +from pydantic import DirectoryPath, FilePath, HttpUrl, SerializeAsAny, ValidationError from requests.auth import HTTPBasicAuth from geolib.errors import CalculationError @@ -28,10 +28,7 @@ class BaseModel(BaseDataClass, abc.ABC): filename: Optional[Path] = None - if IS_PYDANTIC_V2: - datastructure: Optional[SerializeAsAny[BaseModelStructure]] = None - else: - datastructure: Optional[BaseModelStructure] = None + datastructure: Optional[SerializeAsAny[BaseModelStructure]] = None """ This is the base class for all models in GEOLib.