exdrf 0.0.1.dev0__py3-none-any.whl

exdrf/field_types/ref_o2m.py

@@ -0,0 +1,36 @@
+from typing import TYPE_CHECKING, Any, Optional
+
+from attrs import define, field
+
+from exdrf.constants import FIELD_TYPE_REF_ONE_TO_MANY
+from exdrf.field_types.ref_base import RefBaseField
+
+if TYPE_CHECKING:
+    from exdrf.resource import ExResource
+
+
+@define
+class RefOneToManyField(RefBaseField):
+    """This type of field is created by OneToMany relations.
+
+    In this type of relation there is one item of the present resource
+    that is related to many items of the related resource. Expect the foreign
+    key to be in the *related* resource.
+
+    It is asserted that in this case the `is_list` attribute is set to
+    `True`.
+    """
+
+    type_name: str = field(default=FIELD_TYPE_REF_ONE_TO_MANY)
+    is_list: bool = field(default=True)
+    subordinate: bool = field(default=False)
+    bridge: Optional["ExResource"] = field(default=None)
+
+    def field_properties(self, explicit: bool = False) -> dict[str, Any]:
+        result = super().field_properties(explicit)
+        if self.subordinate or explicit:
+            result["subordinate"] = self.subordinate
+        return result
+
+    def __repr__(self) -> str:
+        return f"O2M({self.ref.name})"

exdrf/field_types/ref_o2o.py

@@ -0,0 +1,32 @@
+from typing import Any
+
+from attrs import define, field
+
+from exdrf.constants import FIELD_TYPE_REF_ONE_TO_ONE
+from exdrf.field_types.ref_base import RefBaseField
+
+
+@define
+class RefOneToOneField(RefBaseField):
+    """This type of field is created by OneToOne relations.
+
+    In this type of relation there is one item of the present resource
+    that is related to one item of the related resource. The foreign key mey
+    be in either the present, in the related resource but *not in both*.
+
+    It is asserted that in this case the `is_list` attribute is set to
+    `False`.
+    """
+
+    type_name: str = field(default=FIELD_TYPE_REF_ONE_TO_ONE)
+    is_list: bool = field(default=False)
+    subordinate: bool = field(default=False)
+
+    def field_properties(self, explicit: bool = False) -> dict[str, Any]:
+        result = super().field_properties(explicit)
+        if self.subordinate or explicit:
+            result["subordinate"] = self.subordinate
+        return result
+
+    def __repr__(self) -> str:
+        return f"O2O({self.ref.name})"

exdrf/field_types/sort_field.py

@@ -0,0 +1,18 @@
+from typing import TYPE_CHECKING, List
+
+from attrs import define, field
+
+from exdrf.constants import FIELD_TYPE_SORT
+from exdrf.field import ExField
+
+if TYPE_CHECKING:
+    from exdrf.dataset import ExDataset
+    from exdrf.resource import ExResource
+
+
+@define
+class SortField(ExField):
+    type_name: str = field(default=FIELD_TYPE_SORT)
+
+    def extra_ref(self, d_set: "ExDataset") -> List["ExResource"]:
+        return [d_set["SortItem"]]

exdrf/field_types/str_field.py

@@ -0,0 +1,77 @@
+from typing import Any, List, Optional, Tuple
+
+from attrs import define, field
+from pydantic import Field, field_validator
+
+from exdrf.constants import FIELD_TYPE_STRING
+from exdrf.field import ExField, FieldInfo
+
+
+@define
+class StrField(ExField):
+    """A field that stores strings.
+
+    Attributes:
+        multiline: Whether the string can span multiple lines.
+        min_length: The minimum length of the string.
+        max_length: The maximum length of the string.
+        enum_values: The list of predefined (named) values for the field. The
+            first element of the tuple is the value, the second element is the
+            display name.
+        no_dia_field: The name of the field that is used to store the value
+            of this field without diacritics.
+    """
+
+    type_name: str = field(default=FIELD_TYPE_STRING)
+
+    multiline: bool = field(default=False)
+    min_length: int = field(default=None)
+    max_length: int = field(default=None)
+    enum_values: List[Tuple[str, str]] = field(factory=list)
+
+    no_dia_field: Optional["ExField"] = field(default=None)
+
+    def __repr__(self) -> str:
+        return f"StrF({self.resource.name}.{self.name})"
+
+    def field_properties(self, explicit: bool = False) -> dict[str, Any]:
+        result = super().field_properties(explicit)
+        if self.multiline or explicit:
+            result["multiline"] = self.multiline
+        if self.min_length is not None or explicit:
+            result["min_length"] = self.min_length
+        if self.max_length is not None or explicit:
+            result["max_length"] = self.max_length
+        if self.enum_values or explicit:
+            result["enum_values"] = self.enum_values
+        return result
+
+
+class StrInfo(FieldInfo):
+    """Parser for information about a string field.
+
+    Attributes:
+        multiline: Whether the string can span multiple lines.
+        min_length: The minimum length of the string.
+        max_length: The maximum length of the string. Note that providing a
+            value for this attribute will override the derived value from the
+            database column (like `VARCHAR(255)`; see `field_from_sql_col()`
+            implementation).
+        enum_values: The list of predefined (named) values for the field. The
+            first element of the tuple is the value, the second element is the
+            display name.
+    """
+
+    multiline: Optional[bool] = None
+    min_length: Optional[int] = None
+    max_length: Optional[int] = None
+    enum_values: List[Tuple[str, str]] = Field(default_factory=list)
+
+    @field_validator("enum_values", mode="before")
+    @classmethod
+    def validate_enum_values(cls, v):
+        """Validate the enum values.
+
+        Accepts either a list of (int, str) tuples or an Enum class.
+        """
+        return cls.validate_enum_with_type(v, str)

exdrf/field_types/str_list.py

@@ -0,0 +1,18 @@
+from attrs import define, field
+
+from exdrf.constants import FIELD_TYPE_STRING_LIST
+from exdrf.field_types.str_field import StrField, StrInfo
+
+
+@define
+class StrListField(StrField):
+    """A field that stores list of strings."""
+
+    type_name: str = field(default=FIELD_TYPE_STRING_LIST)
+
+    def __repr__(self) -> str:
+        return f"SListF({self.resource.name}.{self.name})"
+
+
+class StrListInfo(StrInfo):
+    """Parser for information about a string-list field."""

exdrf/field_types/time_field.py

@@ -0,0 +1,49 @@
+from datetime import time
+from typing import Any, Optional
+
+from attrs import define, field
+
+from exdrf.constants import FIELD_TYPE_TIME
+from exdrf.field import ExField, FieldInfo
+
+
+@define
+class TimeField(ExField):
+    """A field that stores a time of day (without a date)
+
+    Attributes:
+        min: The minimum time that can be stored in the field.
+        max: The maximum time that can be stored in the field.
+        format: The format of the time string.
+    """
+
+    type_name: str = field(default=FIELD_TYPE_TIME)
+
+    min: time = field(default=None)
+    max: time = field(default=None)
+    format: str = field(default="HH:mm:ss")
+
+    def __repr__(self) -> str:
+        return f"TimeF({self.resource.name}.{self.name})"
+
+    def field_properties(self, explicit: bool = False) -> dict[str, Any]:
+        result = super().field_properties(explicit)
+        if self.min is not None or explicit:
+            result["min"] = self.min
+        if self.max is not None or explicit:
+            result["max"] = self.max
+        if self.format or explicit:
+            result["format"] = self.format
+        return result
+
+
+class TimeInfo(FieldInfo):
+    """Parser for information about a date-time field.
+
+    Attributes:
+        min: The minimum time that can be stored in the field.
+        max: The maximum time that can be stored in the field.
+    """
+
+    min: Optional[time] = None
+    max: Optional[time] = None