Remove field_info from Row class as well

Replace with CellHandler

Author: pierrecamilleri

frictionless/detector/detector.py

@@ -9,7 +9,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

frictionless/table/row.py

@@ -2,7 +2,7 @@
 
 from functools import cached_property
 from itertools import zip_longest
-from typing import Any, Dict, List, Optional
+from typing import Any, Callable, Dict, List, NamedTuple, Optional
 
 from .. import errors, helpers
 from ..platform import platform
@@ -13,6 +13,13 @@
 # We can consider adding row.header property to provide more comprehensive API
 
 
+class _CellHandler(NamedTuple):
+    field: Field
+    field_number: int
+    reader: Callable[..., Any]
+    writer: Callable[..., Any]
+
+
 # TODO: add types
 class Row(Dict[str, Any]):
     """Row representation
@@ -29,46 +36,34 @@ class Row(Dict[str, Any]):
 
     Parameters:
         cells (any[]): array of cells
-        field_info (dict): special field info structure
+        fields (Field[]): schema fields, in the order expected in the data
         row_number (int): row number from 1
     """
 
     def __init__(
         self,
         cells: List[Any],
         *,
-        field_info: Optional[Dict[str, Any]] = None,
-        fields: Optional[List[Field]] = None,
+        fields: List[Field],
         row_number: int,
     ):
-        if field_info is None and fields is None:
-            raise TypeError("Row requires either 'field_info' or 'fields'")
-        if field_info is not None and fields is not None:
-            raise TypeError("Row accepts 'field_info' or 'fields', not both")
-        if field_info is None:
-            field_info = self.__build_field_info(fields)  # type: ignore[arg-type]
         self.__cells = cells
-        self.__field_info = field_info
+        self.__field_copies: List[Field] = [field.to_copy() for field in fields]
+        self.__handlers: Dict[str, _CellHandler] = {
+            field.name: _CellHandler(
+                field=field,
+                field_number=field_number,
+                reader=field.create_cell_reader(),
+                writer=field.create_cell_writer(),
+            )
+            for field_number, field in enumerate(fields, start=1)
+        }
         self.__row_number = row_number
         self.__processed: bool = False
         self.__blank_cells: Dict[str, Any] = {}
         self.__error_cells: Dict[str, Any] = {}
         self.__errors: list[errors.RowError] = []
 
-    @staticmethod
-    def __build_field_info(fields: List[Field]) -> Dict[str, Any]:
-        info: Dict[str, Any] = {"names": [], "objects": [], "mapping": {}}
-        for field_number, field in enumerate(fields, start=1):
-            info["names"].append(field.name)
-            info["objects"].append(field.to_copy())
-            info["mapping"][field.name] = (
-                field,
-                field_number,
-                field.create_cell_reader(),
-                field.create_cell_writer(),
-            )
-        return info
-
     def __eq__(self, other: object):
         self.__process()
         return super().__eq__(other)
@@ -87,7 +82,7 @@ def __repr__(self):
 
     def __setitem__(self, key: str, value: Any):
         try:
-            _, field_number, _, _ = self.__field_info["mapping"][key]
+            field_number = self.__handlers[key].field_number
         except KeyError:
             raise KeyError(f"Row does not have a field {key}")
         if len(self.__cells) < field_number:
@@ -99,30 +94,30 @@ def __missing__(self, key: str):
         return self.__process(key)
 
     def __iter__(self):
-        return iter(self.__field_info["names"])
+        return iter(self.__handlers)
 
     def __len__(self):
-        return len(self.__field_info["names"])
+        return len(self.__handlers)
 
     def __contains__(self, key: object):
-        return key in self.__field_info["mapping"]
+        return key in self.__handlers
 
     def __reversed__(self):
-        return reversed(self.__field_info["names"])
+        return reversed(self.__handlers)
 
     def keys(self):
-        return iter(self.__field_info["names"])
+        return iter(self.__handlers)
 
     def values(self):  # type: ignore
-        for name in self.__field_info["names"]:
+        for name in self.__handlers:
             yield self[name]
 
     def items(self):  # type: ignore
-        for name in self.__field_info["names"]:
+        for name in self.__handlers:
             yield (name, self[name])
 
     def get(self, key: str, default: Optional[Any] = None):
-        if key not in self.__field_info["names"]:
+        if key not in self.__handlers:
             return default
         return self[key]
 
@@ -140,23 +135,23 @@ def fields(self):
         Returns:
             Field[]: table schema fields
         """
-        return self.__field_info["objects"]
+        return self.__field_copies
 
     @cached_property
     def field_names(self) -> List[str]:
         """
         Returns:
             str[]: field names
         """
-        return self.__field_info["names"]
+        return list(self.__handlers)
 
     @cached_property
     def field_numbers(self):
         """
         Returns:
             str[]: field numbers
         """
-        return list(range(1, len(self.__field_info["names"]) + 1))
+        return list(range(1, len(self.__handlers) + 1))
 
     @cached_property
     def row_number(self) -> int:
@@ -227,22 +222,22 @@ def to_list(self, *, json: bool = False, types: Optional[List[str]] = None):
 
         # Prepare
         self.__process()
-        result = [self[name] for name in self.__field_info["names"]]
+        result = [self[name] for name in self.__handlers]
         if types is None and json:
             types = platform.frictionless_formats.JsonParser.supported_types
 
         # Convert
         if types is not None:
-            for index, field_mapping in enumerate(self.__field_info["mapping"].values()):
-                field, _, _, cell_writer = field_mapping
+            for index, handler in enumerate(self.__handlers.values()):
+                field = handler.field
                 # Here we can optimize performance if we use a types mapping
                 if field.type in types:
                     continue
                 # NOTE: Move somehow to be in the json plugin
                 if json is True and field.type == "number" and field.float_number:
                     continue
                 cell = result[index]
-                cell, _ = cell_writer(cell, ignore_missing=True)
+                cell, _ = handler.writer(cell, ignore_missing=True)
                 result[index] = cell
 
         # Return
@@ -261,20 +256,20 @@ def to_dict(
 
         # Prepare
         self.__process()
-        result = {name: self[name] for name in self.__field_info["names"]}
+        result = {name: self[name] for name in self.__handlers}
         if types is None and json:
             types = platform.frictionless_formats.JsonParser.supported_types
         if types is None and csv:
             types = platform.frictionless_formats.CsvParser.supported_types
 
         # Convert
         if types is not None:
-            for field_mapping in self.__field_info["mapping"].values():
-                field, _, _, cell_writer = field_mapping
+            for handler in self.__handlers.values():
+                field = handler.field
                 # Here we can optimize performance if we use a types mapping
                 if field.type not in types:
                     cell = result[field.name]
-                    cell, _ = cell_writer(cell, ignore_missing=True)
+                    cell, _ = handler.writer(cell, ignore_missing=True)
                     result[field.name] = cell
 
         # Return
@@ -294,31 +289,33 @@ def __process(self, key: Optional[str] = None):
         # Prepare context
         cells = self.__cells
         to_str = lambda v: str(v) if v is not None else ""  # type: ignore
-        fields = self.__field_info["objects"]
-        field_mapping = self.__field_info["mapping"]
-        iterator = zip_longest(field_mapping.values(), cells)
+        handlers = self.__handlers
         is_empty = not bool(super().__len__())
         if key:
             try:
-                field, field_number, cell_reader, cell_writer = self.__field_info[
-                    "mapping"
-                ][key]
+                handler = handlers[key]
             except KeyError:
                 raise KeyError(f"Row does not have a field {key}")
-            cell = cells[field_number - 1] if len(cells) >= field_number else None
-            iterator = zip([(field, field_number, cell_reader, cell_writer)], [cell])
+            cell = (
+                cells[handler.field_number - 1]
+                if len(cells) >= handler.field_number
+                else None
+            )
+            iterator = zip([handler], [cell])
+        else:
+            iterator = zip_longest(handlers.values(), cells)
 
         # Iterate cells
-        for field_mapping, source in iterator:
+        for handler, source in iterator:
             # Prepare context
-            if field_mapping is None:
+            if handler is None:
                 break
-            field, field_number, cell_reader, _ = field_mapping
+            field = handler.field
             if not is_empty and super().__contains__(field.name):
                 continue
 
             # Read cell
-            target, notes = cell_reader(source)
+            target, notes = handler.reader(source)
             type_note = notes.pop("type", None) if notes else None
             if target is None and not type_note:
                 self.__blank_cells[field.name] = source
@@ -333,7 +330,7 @@ def __process(self, key: Optional[str] = None):
                         row_number=self.__row_number,
                         cell=str(source),
                         field_name=field.name,
-                        field_number=field_number,
+                        field_number=handler.field_number,
                     )
                 )
 
@@ -347,7 +344,7 @@ def __process(self, key: Optional[str] = None):
                             row_number=self.__row_number,
                             cell=str(source),
                             field_name=field.name,
-                            field_number=field_number,
+                            field_number=handler.field_number,
                         )
                     )
 
@@ -357,10 +354,10 @@ def __process(self, key: Optional[str] = None):
                 return target
 
         # Extra cells
-        if len(fields) < len(cells):
-            start = len(fields) + 1
-            iterator = cells[len(fields) :]
-            for field_number, cell in enumerate(iterator, start=start):
+        n_fields = len(handlers)
+        if n_fields < len(cells):
+            start = n_fields + 1
+            for field_number, cell in enumerate(cells[n_fields:], start=start):
                 self.__errors.append(
                     errors.ExtraCellError(
                         note="",
@@ -373,24 +370,22 @@ def __process(self, key: Optional[str] = None):
                 )
 
         # Missing cells
-        if len(fields) > len(cells):
-            start = len(cells) + 1
-            iterator = fields[len(cells) :]
-            for field_number, field in enumerate(iterator, start=start):
-                if field is not None:
-                    self.__errors.append(
-                        errors.MissingCellError(
-                            note="",
-                            cells=list(map(to_str, cells)),  # type: ignore
-                            row_number=self.__row_number,
-                            cell="",
-                            field_name=field.name,
-                            field_number=field_number,
-                        )
+        if n_fields > len(cells):
+            missing_handlers = list(handlers.values())[len(cells) :]
+            for handler in missing_handlers:
+                self.__errors.append(
+                    errors.MissingCellError(
+                        note="",
+                        cells=list(map(to_str, cells)),  # type: ignore
+                        row_number=self.__row_number,
+                        cell="",
+                        field_name=handler.field.name,
+                        field_number=handler.field_number,
                     )
+                )
 
         # Blank row
-        if len(fields) == len(self.__blank_cells):
+        if n_fields == len(self.__blank_cells):
             self.__errors = [
                 errors.BlankRowError(
                     note="",