First attempt : separate descriptor from io logic

Author: pierrecamilleri

frictionless/detector/detector.py

@@ -10,7 +10,6 @@
 from .. import helpers, settings
 from ..dialect import Dialect
 from ..exception import FrictionlessException
-from ..fields import AnyField
 from ..metadata import Metadata
 from ..platform import platform
 from ..schema import Field, Schema
@@ -400,7 +399,7 @@ def detect_schema(
             # For not inferred fields we use the "any" type field as a default
             for index, name in enumerate(names):
                 if fields[index] is None:
-                    fields[index] = AnyField(name=name, schema=schema)  # type: ignore
+                    fields[index] = Field(name=name, schema=schema)  # type: ignore
             schema.fields = fields  # type: ignore
 
         # Sync schema

frictionless/fields/__init__.py

@@ -1,15 +1,16 @@
-from .any import AnyField as AnyField
-from .array import ArrayField as ArrayField
-from .boolean import BooleanField as BooleanField
-from .date import DateField as DateField
-from .datetime import DatetimeField as DatetimeField
-from .duration import DurationField as DurationField
-from .geojson import GeojsonField as GeojsonField
-from .geopoint import GeopointField as GeopointField
-from .integer import IntegerField as IntegerField
-from .number import NumberField as NumberField
-from .object import ObjectField as ObjectField
-from .string import StringField as StringField
-from .time import TimeField as TimeField
-from .year import YearField as YearField
-from .yearmonth import YearmonthField as YearmonthField
+from .any import AnyReadWriter as AnyReadWriter
+from .array import ArrayReadWriter as ArrayReadWriter
+from .boolean import BooleanReadWriter as BooleanReadWriter
+from .date import DateReadWriter as DateReadWriter
+from .datetime import DatetimeReadWriter as DatetimeReadWriter
+from .duration import DurationReadWriter as DurationReadWriter
+from .geojson import GeoJSONReadWriter as GeoJSONReadWriter
+from .geopoint import GeoPointReadWriter as GeoPointReadWriter
+from .integer import IntegerReadWriter as IntegerReadWriter
+from .list import ListReadWriter as ListReadWriter
+from .number import NumberReadWriter as NumberReadWriter
+from .object import ObjectReadWriter as ObjectReadWriter
+from .string import StringReadWriter as StringReadWriter
+from .time import TimeReadWriter as TimeReadWriter
+from .year import YearReadWriter as YearReadWriter
+from .yearmonth import YearmonthReadWriter as YearmonthReadWriter

frictionless/fields/any.py

@@ -1,15 +1,14 @@
 from __future__ import annotations
 
-import attrs
+from dataclasses import dataclass
 
-from ..schema import Field
+from .helpers import default_create_value_reader, default_create_value_writer
 
 
-@attrs.define(kw_only=True, repr=False)
-class AnyField(Field):
-    type = "any"
-    builtin = True
-    supported_constraints = [
-        "required",
-        "enum",
-    ]
+@dataclass
+class AnyReadWriter:
+    def create_value_reader(self):
+        return default_create_value_reader()
+
+    def create_value_writer(self):
+        return default_create_value_writer()

frictionless/fields/array.py

@@ -1,92 +1,65 @@
-from __future__ import annotations
-
-import json
-from typing import Any, Dict, Optional
-
-import attrs
-
-from ..schema import Field
-
-
-@attrs.define(kw_only=True, repr=False)
-class ArrayField(Field):
-    type = "array"
-    builtin = True
-    supported_constraints = [
-        "required",
-        "minLength",
-        "maxLength",
-        "enum",
-    ]
-
-    array_item: Optional[Dict[str, Any]] = attrs.field(factory=dict)
-    """
-    A dictionary that specifies the type and other constraints for the
-    data that will be read in this data type field.
-    """
-
-    # Read
-
-    def create_cell_reader(self):
-        default_reader = super().create_cell_reader()
-
-        # Create field
-        field_reader = None
-        if self.array_item:
-            descriptor = self.array_item.copy()
-            descriptor.pop("arrayItem", None)
-            descriptor.setdefault("name", self.name)
-            descriptor.setdefault("type", "any")
-            field = Field.from_descriptor(descriptor)
-            field_reader = field.create_cell_reader()
-
-        # Create reader
-        def cell_reader(cell: Any):
-            cell, notes = default_reader(cell)
-            if cell is not None and not notes and field_reader:
-                for index, item in enumerate(cell):
-                    item_cell, item_notes = field_reader(item)
-                    if item_notes:
-                        notes = notes or {}
-                        for name, note in item_notes.items():
-                            notes[name] = f"array item {note}"
-                    cell[index] = item_cell
-            return cell, notes
-
-        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 = {
-        "properties": {
-            "arrayItem": {"type": "object"},
-        }
-    }
+# from __future__ import annotations
+
+# import json
+# from dataclasses import dataclass
+# from typing import Any
+
+# from ..schema.field_descriptor import ArrayFieldDescriptor, FieldDescriptor
+from . import AnyReadWriter
+
+ArrayReadWriter = AnyReadWriter
+# @dataclass
+# class ArrayReadWriter:
+#     _descriptor: ArrayFieldDescriptor
+
+#     def create_cell_reader(self):
+#         # Create field
+#         field_reader = None
+
+#         if self._descriptor.arrayItem:
+#             item_descriptor = self._descriptor.arrayItem
+#             field = Fielditem_descriptor.from_descriptor(item_descriptor)
+#             field_reader = field.create_cell_reader()
+
+#         # Create reader
+#         def cell_reader(cell: Any):
+#             cell, notes = default_reader(cell)
+#             if cell is not None and not notes and field_reader:
+#                 for index, item in enumerate(cell):
+#                     item_cell, item_notes = field_reader(item)
+#                     if item_notes:
+#                         notes = notes or {}
+#                         for name, note in item_notes.items():
+#                             notes[name] = f"array item {note}"
+#                     cell[index] = item_cell
+#             return cell, notes
+
+#         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

frictionless/fields/boolean.py

@@ -1,42 +1,29 @@
 from __future__ import annotations
 
+from dataclasses import dataclass
 from typing import Any, Dict, List
 
-import attrs
-
 from .. import settings
-from ..schema import Field
-
+from .field_descriptor import BooleanFieldDescriptor
 
-@attrs.define(kw_only=True, repr=False)
-class BooleanField(Field):
-    type = "boolean"
-    builtin = True
-    supported_constraints = [
-        "required",
-        "enum",
-    ]
 
-    true_values: List[str] = attrs.field(factory=settings.DEFAULT_TRUE_VALUES.copy)
-    """
-    It defines the values to be read as true values while reading data. The default
-    true values are ["true", "True", "TRUE", "1"].
-    """
+@dataclass
+class BooleanReadWriter:
+    _descriptor: BooleanFieldDescriptor
 
-    false_values: List[str] = attrs.field(factory=settings.DEFAULT_FALSE_VALUES.copy)
-    """
-    It defines the values to be read as false values while reading data. The default
-    true values are ["false", "False", "FALSE", "0"].
-    """
+    def true_values(self) -> List[str]:
+        return self._descriptor.trueValues or settings.DEFAULT_TRUE_VALUES
 
-    # Read
+    def false_values(self) -> List[str]:
+        return self._descriptor.falseValues or settings.DEFAULT_FALSE_VALUES
 
     def create_value_reader(self):
         # Create mapping
         mapping: Dict[str, bool] = {}
-        for value in self.true_values:
+
+        for value in self.true_values():
             mapping[value] = True
-        for value in self.false_values:
+        for value in self.false_values():
             mapping[value] = False
 
         # Create reader
@@ -48,20 +35,8 @@ def value_reader(cell: Any):
 
         return value_reader
 
-    # Write
-
     def create_value_writer(self):
-        # Create writer
         def value_writer(cell: Any):
-            return self.true_values[0] if cell else self.false_values[0]
+            return self.true_values()[0] if cell else self.false_values()[0]
 
         return value_writer
-
-    # Metadata
-
-    metadata_profile_patch = {
-        "properties": {
-            "trueValues": {"type": "array", "items": {"type": "string"}},
-            "falseValues": {"type": "array", "items": {"type": "string"}},
-        }
-    }

frictionless/fields/date.py

@@ -1,27 +1,20 @@
 from __future__ import annotations
 
+from dataclasses import dataclass
 from datetime import date, datetime
 from typing import Any
 
-import attrs
-
 from .. import settings
 from ..platform import platform
-from ..schema import Field
+from .field_descriptor import DateFieldDescriptor
 
 
-@attrs.define(kw_only=True, repr=False)
-class DateField(Field):
-    type = "date"
-    builtin = True
-    supported_constraints = [
-        "required",
-        "minimum",
-        "maximum",
-        "enum",
-    ]
+@dataclass
+class DateReadWriter:
+    _descriptor: DateFieldDescriptor
 
-    # Read
+    def format(self):
+        return self._descriptor.format or settings.DEFAULT_FIELD_FORMAT
 
     # TODO: use different value_readers based on format (see string)
     def create_value_reader(self):
@@ -42,12 +35,12 @@ def value_reader(cell: Any):
             if not isinstance(cell, str):
                 return None
             try:
-                if self.format == "default":
+                if self.format() == "default":
                     cell = datetime.strptime(cell, settings.DEFAULT_DATE_PATTERN).date()
-                elif self.format == "any":
+                elif self.format() == "any":
                     cell = platform.dateutil_parser.parse(cell).date()
                 else:
-                    cell = datetime.strptime(cell, self.format).date()
+                    cell = datetime.strptime(cell, self.format()).date()
             except Exception:
                 return None
             return cell
@@ -58,7 +51,7 @@ def value_reader(cell: Any):
 
     def create_value_writer(self):
         # Create format
-        format = self.format
+        format = self.format()
         if format == settings.DEFAULT_FIELD_FORMAT:
             format = settings.DEFAULT_DATE_PATTERN