Refactor other fields to #1751

frictionless/fields/any_descriptor.py

@@ -0,0 +1,21 @@
+from typing import Any, Literal, Optional
+
+from .base_field_descriptor import BaseFieldDescriptor
+from .field_constraints import BaseConstraints
+
+
+class AnyFieldDescriptor(BaseFieldDescriptor):
+    """The field contains values of a unspecified or mixed type."""
+
+    type: Literal["any"] = "any"
+    format: Optional[Literal["default"]] = None
+    constraints: Optional[BaseConstraints[str]] = None
+
+    def read_value(self, cell: Any) -> Any:
+        # Any field accepts any value as-is
+        return cell
+
+    def write_value(self, cell: Any) -> Any:
+        # Any field returns the value as-is
+        return cell
+

frictionless/fields/array.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import json
 from typing import Any, Dict, Optional
 
 import attrs
@@ -55,34 +54,6 @@ def cell_reader(cell: Any):
 
         return cell_reader
 
-    def create_value_reader(self):
-        # Create reader
-        def value_reader(cell: Any):  # type: ignore
-            if not isinstance(cell, list):
-                if isinstance(cell, str):
-                    try:
-                        cell = json.loads(cell)
-                    except Exception:
-                        return None
-                    if not isinstance(cell, list):
-                        return None
-                elif isinstance(cell, tuple):
-                    cell = list(cell)  # type: ignore
-                else:
-                    return None
-            return cell  # type: ignore
-
-        return value_reader
-
-    # Write
-
-    def create_value_writer(self):
-        # Create writer
-        def value_writer(cell: Any):
-            return json.dumps(cell)
-
-        return value_writer
-
     # Metadata
 
     metadata_profile_patch = {

frictionless/fields/array_descriptor.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+import json
+from typing import Any, Literal, Optional
+
+from pydantic import Field as PydanticField
+
+from .base_field_descriptor import BaseFieldDescriptor
+from .field_constraints import JSONConstraints
+
+
+class ArrayFieldDescriptor(BaseFieldDescriptor):
+    """The field contains a valid JSON array."""
+
+    type: Literal["array"] = "array"
+    format: Optional[Literal["default"]] = None
+    constraints: Optional[JSONConstraints] = None
+    # TODO: check later:
+    # arrayItem in Frictionless schemas is an unnamed field-like descriptor to prevent using a full FieldDescriptor with "name" (backward compatibility)
+    array_item: Optional[dict[str, Any]] = PydanticField(default=None, alias="arrayItem")
+
+    def read_value(self, cell: Any) -> Optional[list[Any]]:
+        if not isinstance(cell, list):
+            if isinstance(cell, str):
+                try:
+                    cell = json.loads(cell)
+                except Exception:
+                    return None
+                if not isinstance(cell, list):
+                    return None
+            elif isinstance(cell, tuple):
+                cell = list(cell)  # type: ignore[arg-type]
+            else:
+                return None
+        return cell  # type: ignore[return-value]
+
+    def write_value(self, cell: Any) -> str:
+        return json.dumps(cell)
+
+

frictionless/fields/datetime.py

@@ -1,12 +1,7 @@
 from __future__ import annotations
 
-from datetime import datetime
-from typing import Any
-
 import attrs
 
-from .. import settings
-from ..platform import platform
 from ..schema import Field
 
 
@@ -20,44 +15,3 @@ class DatetimeField(Field):
         "maximum",
         "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 not isinstance(cell, datetime):
-                if not isinstance(cell, str):
-                    return None
-                try:
-                    if self.format == "default":
-                        # Guard against shorter formats supported by dateutil
-                        assert cell[16] == ":"
-                        assert len(cell) >= 19
-                        cell = platform.dateutil_parser.isoparse(cell)
-                    elif self.format == "any":
-                        cell = platform.dateutil_parser.parse(cell)
-                    else:
-                        cell = datetime.strptime(cell, self.format)
-                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_DATETIME_PATTERN
-
-        # Create writer
-        def value_writer(cell: Any):
-            cell = cell.strftime(format)
-            cell = cell.replace("+0000", "Z")
-            return cell
-
-        return value_writer

frictionless/fields/datetime_descriptor.py

@@ -0,0 +1,44 @@
+import datetime
+from typing import Any, Literal, Optional
+
+from .. import settings
+from ..platform import platform
+from .base_field_descriptor import BaseFieldDescriptor
+from .field_constraints import ValueConstraints
+
+
+class DatetimeFieldDescriptor(BaseFieldDescriptor):
+    """The field contains a date with a time."""
+
+    type: Literal["datetime"] = "datetime"
+    format: Optional[str] = None
+    constraints: Optional[ValueConstraints[datetime.datetime]] = None
+
+    def read_value(self, cell: Any) -> Optional[datetime.datetime]:
+        if not isinstance(cell, datetime.datetime):
+            if not isinstance(cell, str):
+                return None
+            try:
+                format_value = self.format or "default"
+                if format_value == "default":
+                    # Guard against shorter formats supported by dateutil
+                    assert cell[16] == ":"
+                    assert len(cell) >= 19
+                    cell = platform.dateutil_parser.isoparse(cell)
+                elif format_value == "any":
+                    cell = platform.dateutil_parser.parse(cell)
+                else:
+                    cell = datetime.datetime.strptime(cell, format_value)
+            except Exception:
+                return None
+        return cell
+
+    def write_value(self, cell: Optional[datetime.datetime]) -> 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_DATETIME_PATTERN
+        result = cell.strftime(format_value)
+        result = result.replace("+0000", "Z")
+        return result

frictionless/fields/duration.py

@@ -1,11 +1,7 @@
 from __future__ import annotations
 
-import datetime
-from typing import Any
-
 import attrs
 
-from ..platform import platform
 from ..schema import Field
 
 
@@ -17,28 +13,3 @@ class DurationField(Field):
         "required",
         "enum",
     ]
-
-    # Read
-
-    def create_value_reader(self):
-        # Create reader
-        def value_reader(cell: Any):
-            if not isinstance(cell, (platform.isodate.Duration, datetime.timedelta)):  # type: ignore
-                if not isinstance(cell, str):
-                    return None
-                try:
-                    cell = platform.isodate.parse_duration(cell)  # type: ignore
-                except Exception:
-                    return None
-            return cell
-
-        return value_reader
-
-    # Write
-
-    def create_value_writer(self):
-        # Create writer
-        def value_writer(cell: Any):  # type: ignore
-            return platform.isodate.duration_isoformat(cell)  # type: ignore
-
-        return value_writer

frictionless/fields/duration_descriptor.py

@@ -0,0 +1,31 @@
+import datetime
+from typing import Any, Literal, Optional
+
+from ..platform import platform
+from .base_field_descriptor import BaseFieldDescriptor
+from .field_constraints import ValueConstraints
+
+
+class DurationFieldDescriptor(BaseFieldDescriptor):
+    """The field contains a duration of time."""
+
+    type: Literal["duration"] = "duration"
+    format: Optional[Literal["default"]] = None
+    constraints: Optional[ValueConstraints[str]] = None
+
+    def read_value(self, cell: Any) -> Any:
+        if not isinstance(cell, (platform.isodate.Duration, datetime.timedelta)):  # type: ignore
+            if not isinstance(cell, str):
+                return None
+            try:
+                cell = platform.isodate.parse_duration(cell)  # type: ignore
+            except Exception:
+                return None
+        return cell
+
+    def write_value(self, cell: Any) -> Optional[str]:
+        if cell is None:
+            return None
+        return platform.isodate.duration_isoformat(cell)  # type: ignore
+
+