exdrf 0.0.1.dev0__py3-none-any.whl

exdrf/field_types/bool_field.py

@@ -0,0 +1,47 @@
+from typing import Any, Optional
+
+from attrs import define, field
+
+from exdrf.constants import FIELD_TYPE_BOOL
+from exdrf.field import ExField, FieldInfo
+
+
+@define
+class BoolField(ExField):
+    """A field that stores boolean values.
+
+    This field is not expected to resize when in list view mode.
+
+    Attributes:
+        true_str: The string representation of the boolean value `True`.
+        false_str: The string representation of the boolean value `False`.
+    """
+
+    type_name: str = field(default=FIELD_TYPE_BOOL)
+    resizable: bool = field(default=False)
+
+    true_str: str = field(default="True")
+    false_str: str = field(default="False")
+
+    def __repr__(self) -> str:
+        return f"BoolF({self.resource.name}.{self.name})"
+
+    def field_properties(self, explicit: bool = False) -> dict[str, Any]:
+        result = super().field_properties(explicit)
+        if self.true_str or explicit:
+            result["true_str"] = self.true_str
+        if self.false_str or explicit:
+            result["false_str"] = self.false_str
+        return result
+
+
+class BoolInfo(FieldInfo):
+    """Parser for information about a boolean field.
+
+    Attributes:
+        true_str: The string representation of the boolean value `True`.
+        false_str: The string representation of the boolean value `False`.
+    """
+
+    true_str: Optional[str] = None
+    false_str: Optional[str] = None

exdrf/field_types/date_field.py

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

exdrf/field_types/date_time.py

@@ -0,0 +1,52 @@
+from datetime import datetime
+from typing import Any, Optional
+
+from attrs import define, field
+
+from exdrf.constants import FIELD_TYPE_DT
+from exdrf.field import ExField, FieldInfo
+
+# Sentinel date-time value used to represent an "unknown" date.
+UNKNOWN_DATETIME = datetime(1000, 2, 3, 4, 5, 6, 7)
+
+
+@define
+class DateTimeField(ExField):
+    """A field that stores moments in time.
+
+    Attributes:
+        min: The minimum date-time that can be stored in the field.
+        max: The maximum date-time that can be stored in the field.
+        format: The format of the date-time string.
+    """
+
+    type_name: str = field(default=FIELD_TYPE_DT)
+
+    min: datetime = field(default=None)
+    max: datetime = field(default=None)
+    format: str = field(default="DD-MM-YYYY HH:mm:ss")
+
+    def __repr__(self) -> str:
+        return f"DaTiF({self.resource.name}.{self.name})"
+
+    def field_properties(self, explicit: bool = False) -> dict[str, Any]:
+        result = super().field_properties(explicit)
+        if self.min or explicit:
+            result["min"] = self.min
+        if self.max or explicit:
+            result["max"] = self.max
+        if self.format or explicit:
+            result["format"] = self.format
+        return result
+
+
+class DateTimeInfo(FieldInfo):
+    """Parser for information about a date-time field.
+
+    Attributes:
+        min: The minimum date-time that can be stored in the field.
+        max: The maximum date-time that can be stored in the field.
+    """
+
+    min: Optional[datetime] = None
+    max: Optional[datetime] = None

exdrf/field_types/dur_field.py

@@ -0,0 +1,44 @@
+from typing import Any, Optional
+
+from attrs import define, field
+
+from exdrf.constants import FIELD_TYPE_DURATION
+from exdrf.field import ExField, FieldInfo
+
+
+@define
+class DurationField(ExField):
+    """A field that stores the duration of time.
+
+    Attributes:
+        min: The minimum duration that can be stored in the field.
+        max: The maximum duration that can be stored in the field.
+    """
+
+    type_name: str = field(default=FIELD_TYPE_DURATION)
+
+    min: float = field(default=None)
+    max: float = field(default=None)
+
+    def __repr__(self) -> str:
+        return f"DaTiF({self.resource.name}.{self.name})"
+
+    def field_properties(self, explicit: bool = False) -> dict[str, Any]:
+        result = super().field_properties(explicit)
+        if self.min or explicit:
+            result["min"] = self.min
+        if self.max or explicit:
+            result["max"] = self.max
+        return result
+
+
+class DurationInfo(FieldInfo):
+    """Parser for information about a time duration field.
+
+    Attributes:
+        min: The minimum duration that can be stored in the field.
+        max: The maximum duration that can be stored in the field.
+    """
+
+    min: Optional[float] = None
+    max: Optional[float] = None

exdrf/field_types/enum_field.py

@@ -0,0 +1,41 @@
+from typing import Any, List, Tuple
+
+from attrs import define, field
+from pydantic import Field
+
+from exdrf.constants import FIELD_TYPE_ENUM
+from exdrf.field import ExField, FieldInfo
+
+
+@define
+class EnumField(ExField):
+    """A field that stores moments in time.
+
+    Attributes:
+        enum_values: The list of possible values for the field. The first
+        element of the tuple is the value, the second element is the display
+        name.
+    """
+
+    type_name: str = field(default=FIELD_TYPE_ENUM)
+
+    enum_values: List[Tuple[str, str]] = field(factory=list)
+
+    def __repr__(self) -> str:
+        return f"EnumF({self.resource.name}.{self.name})"
+
+    def field_properties(self, explicit: bool = False) -> dict[str, Any]:
+        result = super().field_properties(explicit)
+        if self.enum_values or explicit:
+            result["enum_values"] = self.enum_values
+        return result
+
+
+class EnumInfo(FieldInfo):
+    """Parser for information about an enum field.
+
+    Attributes:
+        enum_values: The list of possible values for the field.
+    """
+
+    enum_values: List[str] = Field(default_factory=list)

exdrf/field_types/filter_field.py

@@ -0,0 +1,11 @@
+from attrs import define, field
+
+from exdrf.constants import FIELD_TYPE_FILTER
+from exdrf.field import ExField
+
+
+@define
+class FilterField(ExField):
+    """Field for filtering results."""
+
+    type_name: str = field(default=FIELD_TYPE_FILTER)

exdrf/field_types/float_field.py

@@ -0,0 +1,85 @@
+from typing import Any, List, Optional, Tuple
+
+from attrs import define, field
+from pydantic import Field, field_validator
+
+from exdrf.constants import FIELD_TYPE_FLOAT
+from exdrf.field import ExField, FieldInfo
+
+
+@define
+class FloatField(ExField):
+    """A field that stores real numbers.
+
+    Attributes:
+        min: The minimum value that can be stored in the field (inclusive).
+        max: The maximum value that can be stored in the field (inclusive).
+        precision: The number of digits that can be stored in the field.
+        scale: The number of digits to the right of the decimal point.
+        unit: The unit of measurement for the field.
+        unit_symbol: The symbol for the unit of measurement.
+        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.
+    """
+
+    type_name: str = field(default=FIELD_TYPE_FLOAT)
+
+    min: float = field(default=None)
+    max: float = field(default=None)
+    precision: int = field(default=2)
+    scale: int = field(default=1)
+    unit: str = field(default=None)
+    unit_symbol: str = field(default=None)
+    enum_values: List[Tuple[float, str]] = field(factory=list)
+
+    def __repr__(self) -> str:
+        return f"FloatF({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.precision is not None or explicit:
+            result["precision"] = self.precision
+        if self.scale is not None or explicit:
+            result["scale"] = self.scale
+        if self.unit or explicit:
+            result["unit"] = self.unit
+        if self.unit_symbol or explicit:
+            result["unit_symbol"] = self.unit_symbol
+        if self.enum_values or explicit:
+            result["enum_values"] = self.enum_values
+        return result
+
+
+class FloatInfo(FieldInfo):
+    """Parser for information about a real-number field.
+
+    Attributes:
+        min: The minimum value that can be stored in the field.
+        max: The maximum value that can be stored in the field.
+        precision: The number of digits that can be stored in the field.
+        scale: The number of digits to the right of the decimal point.
+        unit: The unit of measurement for the field.
+        unit_symbol: The symbol for the unit of measurement.
+    """
+
+    min: Optional[float] = None
+    max: Optional[float] = None
+    precision: Optional[int] = None
+    scale: Optional[int] = None
+    unit: Optional[str] = None
+    unit_symbol: Optional[str] = None
+    enum_values: List[Tuple[float, 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, float)

exdrf/field_types/float_list.py

@@ -0,0 +1,18 @@
+from attrs import define, field
+
+from exdrf.constants import FIELD_TYPE_FLOAT_LIST
+from exdrf.field_types.float_field import FloatField, FloatInfo
+
+
+@define
+class FloatListField(FloatField):
+    """A field that stores list of real numbers."""
+
+    type_name: str = field(default=FIELD_TYPE_FLOAT_LIST)
+
+    def __repr__(self) -> str:
+        return f"FloatListF({self.resource.name}.{self.name})"
+
+
+class FloatListInfo(FloatInfo):
+    """Parser for information about a real-numbers list field."""

exdrf/field_types/formatted.py

@@ -0,0 +1,39 @@
+from typing import Any, Literal, Optional
+
+from attrs import define, field
+
+from exdrf.constants import FIELD_TYPE_FORMATTED
+from exdrf.field import FieldInfo
+from exdrf.field_types.str_field import StrField
+
+
+@define
+class FormattedField(StrField):
+    """A field that stores strings that contain both text and markup.
+
+    Attributes:
+        format: The format of the string. Can be "json", "html", or "xml".
+    """
+
+    type_name: str = field(default=FIELD_TYPE_FORMATTED)
+
+    format: Literal["json", "html", "xml"] = field(default="json")
+
+    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.format or explicit:
+            result["format"] = self.format
+        return result
+
+
+class FormattedInfo(FieldInfo):
+    """Parser for information about a string field.
+
+    Attributes:
+        format: The format of the string. Can be "json", "html", or "xml".
+    """
+
+    format: Optional[Literal["json", "html", "xml"]] = None

exdrf/field_types/int_field.py

@@ -0,0 +1,70 @@
+from typing import Any, List, Optional, Tuple
+
+from attrs import define, field
+from pydantic import Field, field_validator
+
+from exdrf.constants import FIELD_TYPE_INTEGER
+from exdrf.field import ExField, FieldInfo
+
+
+@define
+class IntField(ExField):
+    """A field that stores integers.
+
+    Attributes:
+        min: The minimum integer that can be stored in the field (inclusive).
+        max: The maximum integer that can be stored in the field (inclusive).
+        unit: The unit of measurement for the field.
+        unit_symbol: The symbol for the unit of measurement.
+    """
+
+    type_name: str = field(default=FIELD_TYPE_INTEGER)
+
+    min: int = field(default=None)
+    max: int = field(default=None)
+    unit: str = field(default=None)
+    unit_symbol: str = field(default=None)
+    enum_values: List[Tuple[int, str]] = field(factory=list)
+
+    def __repr__(self) -> str:
+        return f"IntF({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.unit or explicit:
+            result["unit"] = self.unit
+        if self.unit_symbol or explicit:
+            result["unit_symbol"] = self.unit_symbol
+        if self.enum_values or explicit:
+            result["enum_values"] = self.enum_values
+        return result
+
+
+class IntInfo(FieldInfo):
+    """Parser for information about an integer field.
+
+    Attributes:
+        min: The minimum integer that can be stored in the field.
+        max: The maximum integer that can be stored in the field.
+        unit: The unit of measurement for the field.
+        unit_symbol: The symbol for the unit of measurement.
+    """
+
+    min: Optional[int] = None
+    max: Optional[int] = None
+    unit: Optional[str] = None
+    unit_symbol: Optional[str] = None
+    enum_values: List[Tuple[int, 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, int)

exdrf/field_types/int_list.py

@@ -0,0 +1,18 @@
+from attrs import define, field
+
+from exdrf.constants import FIELD_TYPE_INT_LIST
+from exdrf.field_types.int_field import IntField, IntInfo
+
+
+@define
+class IntListField(IntField):
+    """A field that stores a list of integers."""
+
+    type_name: str = field(default=FIELD_TYPE_INT_LIST)
+
+    def __repr__(self) -> str:
+        return f"IntListF({self.resource.name}.{self.name})"
+
+
+class IntListInfo(IntInfo):
+    """Parser for information about an integer-list field."""

exdrf/field_types/ref_base.py

@@ -0,0 +1,105 @@
+from typing import Any, List, Optional, Tuple
+
+from attrs import define, field
+from pydantic import Field, field_validator
+
+from exdrf.constants import RelType
+from exdrf.field import ExField, FieldInfo
+from exdrf.resource import ExResource
+
+
+@define
+class RefBaseField(ExField):
+    """Base class for resource relations.
+
+    Attributes:
+        ref: The related resource.
+        expect_lots: If true it indicates that the relation is expected to have
+            many items. This is only valid when the parent side is 'many'
+            (many-to-one or many-to-many relations from the parent's point of
+            view).
+        provides: indicates the concept that this field provides. This is
+            usually set at the resource level but can be overridden at the field
+            level.
+        depends_on: indicates the concepts that this field depends on. This is
+            usually set at the resource level but can be overridden at the field
+            level.
+        use_rel: When True on a non-bridge OneToMany relationship (from
+            SQLAlchemy ``relationship`` ``info``), Qt editor generation uses a
+            dedicated DrfRelated tab instead of an inline multi-select. Ignored
+            for other relation kinds.
+    """
+
+    ref: "ExResource" = field(default=None, repr=False)
+    expect_lots: bool = field(default=False)
+    provides: List[str] = field(factory=list)
+    depends_on: List[str] = field(factory=list)
+    use_rel: bool = field(default=False)
+
+    def field_properties(self, explicit: bool = False) -> dict[str, Any]:
+        result = super().field_properties(explicit)
+        result["ref"] = self.ref.name
+        if self.use_rel or explicit:
+            result["use_rel"] = self.use_rel
+        return result
+
+
+class RelExtraInfo(FieldInfo):
+    """Parser for information about a related resource.
+
+    Attributes:
+        direction: The direction of the relationship. Can be "OneToMany",
+            "ManyToOne", "OneToOne", or "ManyToMany".
+        subordinate: If true it indicates that the child resource is parented
+            into current resource through this relation. Child resources get
+            deleted when the parent is deleted and they should not be
+            independently managed at the top level. Instead, the widget for
+            this relation in the parent resource will be adapted to show an
+            editable list of children where the children are added and removed.
+            This is only valid when the parent side is 'one' (one-to-many or
+            one-to-one relations from the parent's point of view).
+        expect_lots: If true it indicates that the relation is expected to have
+            many items. This is only valid when the parent side is 'many'
+            (many-to-one or many-to-many relations from the parent's point of
+            view).
+        provides: indicates the concept that this field provides. This is
+            usually set at the resource level but can be overridden at the field
+            level.
+        depends_on: indicates the concepts that this field depends on. This is
+            usually set at the resource level but can be overridden at the field
+            level.
+        bridge: Even if the relation type is declared as OneToMany, the
+            other side is a junction table with extra attributes. The value is
+            the name of the resource on the other side.
+    """
+
+    direction: Optional[RelType] = None
+    subordinate: Optional[bool] = None
+    expect_lots: Optional[bool] = False
+    provides: List[str] = Field(default_factory=list)
+    depends_on: List[Tuple[str, str]] = Field(default_factory=list)
+    bridge: Optional[str] = None
+
+    @field_validator("provides", mode="before")
+    @classmethod
+    def parse_provides(cls, v):
+        if v is None:
+            return []
+        if isinstance(v, str):
+            return [item.strip() for item in v.split(",") if item.strip()]
+        return v
+
+    @field_validator("depends_on", mode="before")
+    @classmethod
+    def parse_depends_on(cls, v):
+        if v is None:
+            return []
+        if isinstance(v, str):
+            result = []
+            for part in v.split(","):
+                if not part.strip():
+                    continue
+                concept, target = part.strip().split(":", maxsplit=1)
+                result.append((concept.strip(), target.strip()))
+            return result
+        return v

exdrf/field_types/ref_m2m.py

@@ -0,0 +1,39 @@
+from typing import TYPE_CHECKING, Any
+
+from attrs import define, field
+
+from exdrf.constants import FIELD_TYPE_REF_MANY_TO_MANY
+from exdrf.field_types.ref_base import RefBaseField
+
+if TYPE_CHECKING:
+    from exdrf.resource import ExResource  # noqa: F401
+
+
+@define
+class RefManyToManyField(RefBaseField):
+    """This type of field is created by ManyToMany relations.
+
+    In this type of relation there are many items of the present resource that
+    are related to many items of the related resource. The relation is
+    implemented by a third resource that contains the foreign keys to both
+    resources and is referenced by the `ref_intermediate` attribute.
+
+    It is asserted that in this case the `is_list` attribute is set to `True`.
+
+    Attribute:
+        ref_intermediate: The intermediate resource that implements the
+            relation.
+    """
+
+    type_name: str = field(default=FIELD_TYPE_REF_MANY_TO_MANY)
+    is_list: bool = field(default=True)
+
+    ref_intermediate: "ExResource" = field(default=None, repr=False)
+
+    def field_properties(self, explicit: bool = False) -> dict[str, Any]:
+        result = super().field_properties(explicit)
+        result["ref_intermediate"] = self.ref_intermediate.name
+        return result
+
+    def __repr__(self) -> str:
+        return f"M2M({self.ref.name}, {self.ref_intermediate.name})"

exdrf/field_types/ref_m2o.py

@@ -0,0 +1,23 @@
+from attrs import define, field
+
+from exdrf.constants import FIELD_TYPE_REF_MANY_TO_ONE
+from exdrf.field_types.ref_base import RefBaseField
+
+
+@define
+class RefManyToOneField(RefBaseField):
+    """This type of field is created by ManyToOne relations.
+
+    In this type of relation there are many items of the present
+    resource that are related to one item of the related resource. Expect
+    the foreign key to be in the *present* resource.
+
+    It is asserted that in this case the `is_list` attribute is set to
+    `False`.
+    """
+
+    type_name: str = field(default=FIELD_TYPE_REF_MANY_TO_ONE)
+    is_list: bool = field(default=False)
+
+    def __repr__(self) -> str:
+        return f"M2O({self.ref.name})"