refactor: move IntegerField to pydantic (#1759)

Integrated pydantic logic to IntegerField.
All tests pass (apart from 5 console ones not related to modifications)
Fixed a few issued:
- examples should enable Any type, not only strings
- descriptor was broken during the merge of two kinds

Author: BmnQuentin

frictionless/fields/array_descriptor.py

@@ -0,0 +1,65 @@
+"""base_field_descriptor.py provides the base Pydantic model for all field descriptors"""
+
+from __future__ import annotations
+
+from pydantic import BaseModel, Field as PydanticField, model_validator
+from typing import Any, Dict, List, Optional
+from typing_extensions import Self
+
+
+class BaseFieldDescriptor(BaseModel):
+    """Data model of a (unspecialised) field descriptor"""
+
+    name: str
+    """
+    The field descriptor MUST contain a name property.
+    """
+
+    title: Optional[str] = None
+    """
+    A human readable label or title for the field
+    """
+
+    description: Optional[str] = None
+    """
+    A description for this field e.g. "The recipient of the funds"
+    """
+
+    missing_values: Optional[List[str]] = PydanticField(
+        default=None, alias="missingValues"
+    )
+    """
+    A list of field values to consider as null values
+    """
+
+    example: Optional[Any] = None
+    """
+    An example of a value for the field.
+    """
+
+    @model_validator(mode="before")
+    @classmethod
+    def compat(cls, data: Dict[str, Any]) -> Dict[str, Any]:
+        # Backward compatibility for field.format
+
+        format_ = data.get("format")
+        if format_:
+            if format_.startswith("fmt:"):
+                data["format"] = format_[4:]
+
+        return data
+
+    @model_validator(mode="after")
+    def validate_example(self) -> Self:
+        """Validate that the example value can be converted using read_value() if available"""
+        if self.example is not None:
+            if hasattr(self, "read_value"):
+                read_value_method = getattr(self, "read_value")
+                result = read_value_method(self.example)
+                if result is None:
+                    raise ValueError(
+                        f'example value "{self.example}" for field "{self.name}" is not valid'
+                    )
+
+        return self
+

frictionless/fields/base_field_descriptor.py

@@ -1,8 +1,9 @@
+from __future__ import annotations
 from ..schema.field import Field
 
-
 class BooleanField(Field):
     ### TEMP Only required for Metadata compatibility
     ### This is required because "metadata_import" makes a distinction based
     ### on the "type" property (`is_typed_class`)
     type = "boolean"
+    

frictionless/fields/boolean.py

@@ -0,0 +1,50 @@
+from typing import Any, ClassVar, List, Literal, Optional
+
+from pydantic import Field as PydanticField, AliasChoices
+
+from .. import settings
+from .base_field_descriptor import BaseFieldDescriptor
+from .field_constraints import BaseConstraints
+
+class BooleanFieldDescriptor(BaseFieldDescriptor):
+    """The field contains boolean (true/false) data."""
+
+    type: ClassVar[Literal["boolean"]] = "boolean"
+
+    format: Optional[Literal["default"]] = None
+    constraints: Optional[BaseConstraints[bool]] = None
+
+    true_values: Optional[List[str]] = PydanticField(
+        default=settings.DEFAULT_TRUE_VALUES,
+        alias="trueValues",
+        validation_alias=AliasChoices("trueValues", "true_values"),
+    )
+    """
+    Values to be interpreted as "true" for boolean fields
+    """
+
+    false_values: Optional[List[str]] = PydanticField(
+        default=settings.DEFAULT_FALSE_VALUES,
+        alias="falseValues",
+        validation_alias=AliasChoices("falseValues", "false_values"),
+    )
+    """
+    Values to be interpreted as "false" for boolean fields
+    """
+
+    def read_value(self, cell: Any) -> Optional[bool]:
+        if isinstance(cell, bool):
+            return cell
+
+        if isinstance(cell, str):
+            if self.true_values and cell in self.true_values:
+                return True
+            if self.false_values and cell in self.false_values:
+                return False
+
+        return None
+
+    def write_value(self, cell: Optional[bool]) -> Optional[str]:
+        if self.true_values and self.false_values:
+            return self.true_values[0] if cell else self.false_values[0]
+        return None

frictionless/fields/boolean_descriptor.py

@@ -1,15 +1,8 @@
 from __future__ import annotations
 
-from datetime import date, datetime
-from typing import Any
-
 import attrs
-
-from .. import settings
-from ..platform import platform
 from ..schema import Field
 
-
 @attrs.define(kw_only=True, repr=False)
 class DateField(Field):
     type = "date"
@@ -21,49 +14,3 @@ class DateField(Field):
         "enum",
     ]
 
-    # Read
-
-    # TODO: use different value_readers based on format (see string)
-    def create_value_reader(self):
-        # Create reader
-        def value_reader(cell: Any):
-            if isinstance(cell, datetime):
-                value_time = cell.time()
-                if (
-                    value_time.hour == 0
-                    and value_time.minute == 0
-                    and value_time.second == 0
-                ):
-                    return datetime(cell.year, cell.month, cell.day).date()
-                else:
-                    return None
-            if isinstance(cell, date):
-                return cell
-            if not isinstance(cell, str):
-                return None
-            try:
-                if self.format == "default":
-                    cell = datetime.strptime(cell, settings.DEFAULT_DATE_PATTERN).date()
-                elif self.format == "any":
-                    cell = platform.dateutil_parser.parse(cell).date()
-                else:
-                    cell = datetime.strptime(cell, self.format).date()
-            except Exception:
-                return None
-            return cell
-
-        return value_reader
-
-    # Write
-
-    def create_value_writer(self):
-        # Create format
-        format = self.format
-        if format == settings.DEFAULT_FIELD_FORMAT:
-            format = settings.DEFAULT_DATE_PATTERN
-
-        # Create writer
-        def value_writer(cell: Any):
-            return cell.strftime(format)
-
-        return value_writer

frictionless/fields/date.py

@@ -0,0 +1,53 @@
+import datetime
+from typing import Any, Literal, Optional
+
+
+from .. import settings
+from .base_field_descriptor import BaseFieldDescriptor
+from .field_constraints import ValueConstraints
+
+
+class DateFieldDescriptor(BaseFieldDescriptor):
+    """The field contains a date without a time."""
+
+    type: Literal["date"] = "date"
+    format: Optional[str] = None
+    constraints: Optional[ValueConstraints[str]] = None
+
+    def read_value(self, cell: Any) -> Optional[datetime.date]:
+        from datetime import date, datetime
+        from ..platform import platform
+
+        if isinstance(cell, datetime):
+            value_time = cell.time()
+            if (
+                value_time.hour == 0
+                and value_time.minute == 0
+                and value_time.second == 0
+            ):
+                return datetime(cell.year, cell.month, cell.day).date()
+            else:
+                return None
+        if isinstance(cell, date):
+            return cell
+        if not isinstance(cell, str):
+            return None
+        try:
+            format_value = self.format or "default"
+            if format_value == "default":
+                cell = datetime.strptime(cell, settings.DEFAULT_DATE_PATTERN).date()
+            elif format_value == "any":
+                cell = platform.dateutil_parser.parse(cell).date()
+            else:
+                cell = datetime.strptime(cell, format_value).date()
+        except Exception:
+            return None
+        return cell
+
+    def write_value(self, cell: Optional[datetime.date]) -> Optional[str]:
+        if cell is None:
+            return None
+        format_value = self.format or "default"
+        if format_value == settings.DEFAULT_FIELD_FORMAT:
+            format_value = settings.DEFAULT_DATE_PATTERN
+        return cell.strftime(format_value)