Schema sync functionnality inside FieldsInfo

Test passes, surprisingly.
No special effort has been made to support `header_case` option, or
"required" columns with `schema_sync`

Author: pierrecamilleri

frictionless/detector/detector.py

@@ -404,31 +404,30 @@ def detect_schema(
             schema.fields = fields  # type: ignore
 
         # Sync schema
-        if self.schema_sync:
-            if labels:
-                case_sensitive = options["header_case"]
+        if self.schema_sync and labels:
+            case_sensitive = options["header_case"]
 
-                if not case_sensitive:
-                    labels = [label.lower() for label in labels]
+            if not case_sensitive:
+                labels = [label.lower() for label in labels]
 
-                if len(labels) != len(set(labels)):
-                    note = '"schema_sync" requires unique labels in the header'
-                    raise FrictionlessException(note)
+            if len(labels) != len(set(labels)):
+                note = '"schema_sync" requires unique labels in the header'
+                raise FrictionlessException(note)
 
-                mapped_fields = self.map_schema_fields_by_name(
-                    schema.fields,
-                    case_sensitive,
-                )
+            mapped_fields = self.map_schema_fields_by_name(
+                schema.fields,
+                case_sensitive,
+            )
 
-                self.rearrange_schema_fields_given_labels(
-                    mapped_fields,
-                    schema,
-                    labels,
-                )
+            self.rearrange_schema_fields_given_labels(
+                mapped_fields,
+                schema,
+                labels,
+            )
 
-                self.add_missing_required_labels_to_schema_fields(
-                    mapped_fields, schema, labels, case_sensitive
-                )
+            self.add_missing_required_labels_to_schema_fields(
+                mapped_fields, schema, labels, case_sensitive
+            )
 
         # Patch schema
         if self.schema_patch:
@@ -460,8 +459,10 @@ def rearrange_schema_fields_given_labels(
         schema: Schema,
         labels: List[str],
     ):
-        """Rearrange fields according to the order of labels. All fields
-        missing from labels are dropped"""
+        """Rearrange fields according to the order of labels.
+        All fields missing from labels are dropped.
+        Any extra-field is filled in with a default `"type": "any"` field.
+        """
         schema.clear_fields()
 
         for name in labels:

frictionless/resources/table.py

@@ -263,7 +263,9 @@ def __open_lookup(self):
                     self.__lookup[source_name][source_key].add(cells)
 
     def __open_row_stream(self):
-        field_info = FieldsInfo(self.schema.fields)
+        fields_info = FieldsInfo(
+            self.schema.fields, self.labels, self.detector.schema_sync
+        )
 
         # Create state
         memory_unique: Dict[str, Any] = {}
@@ -296,7 +298,7 @@ def row_stream():
 
                 row = Row(
                     cells,
-                    field_info=field_info,
+                    fields_info=fields_info,
                     row_number=row_number,
                 )
 
@@ -378,9 +380,9 @@ def row_stream():
 
         if self.detector.schema_sync:
             # Missing required labels are not included in the
-            # field_info parameter used for row creation
+            # fields_info parameter used for row creation
             for field in self.schema.fields:
-                self.remove_missing_required_label_from_field_info(field, field_info)
+                self.remove_missing_required_label_from_field_info(field, fields_info)
 
         self.__row_stream = row_stream()
 
@@ -415,7 +417,9 @@ def label_is_missing(
     def primary_key_cells(self, row: Row, case_sensitive: bool) -> Tuple[Any, ...]:
         """Create a tuple containg all cells from a given row associated to primary
         keys"""
-        return tuple(row[label] for label in self.primary_key_labels(row, case_sensitive))
+        return tuple(
+            row[label] for label in self.primary_key_labels(row, case_sensitive)
+        )
 
     def primary_key_labels(
         self,
@@ -689,39 +693,63 @@ def __init__(self, field: Field, field_number: int):
 
 
 class FieldsInfo:
-    """Helper class to store additional data to a collection of fields
+    """Helper class for linking columns to schema fields.
+
+    It abstracts away the different ways of making this link. In particular, the
+    reference may be the schema (`detector.schema_sync = False`), or the labels
+    (`detector.schema_sync = True`).
 
     This class is not Public API, and should be used only in non-public
     interfaces.
     """
 
-    def __init__(self, fields: List[Field]):
-        self._fields: List[_FieldInfo] = [
-            _FieldInfo(field, i + 1) for i, field in enumerate(fields)
-        ]
+    def __init__(
+        self, fields: List[Field], labels: Optional[List[str]], schema_sync: bool
+    ):
+        if schema_sync and labels:
+            self._expected_fields: List[_FieldInfo] = []
+            if len(labels) != len(set(labels)):
+                note = '"schema_sync" requires unique labels in the header'
+                raise FrictionlessException(note)
+
+            for label_index, label in enumerate(labels):
+                try:
+                    field = next(f for f in fields if f.name == label)
+                except StopIteration:
+                    field = Field.from_descriptor({"name": label, "type": "any"})
+                self._expected_fields.append(_FieldInfo(field, label_index + 1))
+        else:
+            self._expected_fields = [
+                _FieldInfo(field, i + 1) for i, field in enumerate(fields)
+            ]
 
     def ls(self) -> List[str]:
-        """List all field names"""
-        return [fi.field.name for fi in self._fields]
+        """List all column names"""
+        return [fi.field.name for fi in self._expected_fields]
 
     def get(self, field_name: str) -> _FieldInfo:
         """Get a Field by its name
 
+        In case no field with field_name exists, the behavior depends on
+        the `detector.schema_sync` option:
+
         Raises:
-            ValueError: Field with name fieldname does not exist
+            ValueError
         """
         try:
-            return next(fi for fi in self._fields if fi.field.name == field_name)
+            return next(
+                fi for fi in self._expected_fields if fi.field.name == field_name
+            )
         except StopIteration:
-            raise ValueError(f"'{field_name}' is not in fields data")
+            raise ValueError(f"{field_name} is missing from expected fields")
 
     def get_copies(self) -> List[Field]:
         """Return field copies"""
-        return [fi.field.to_copy() for fi in self._fields]
+        return [fi.field.to_copy() for fi in self._expected_fields]
 
     def rm(self, field_name: str):
         try:
             i = self.ls().index(field_name)
-            del self._fields[i]
+            del self._expected_fields[i]
         except ValueError:
             raise ValueError(f"'{field_name}' is not in fields data")

frictionless/table/row.py

@@ -39,11 +39,11 @@ def __init__(
         self,
         cells: List[Any],
         *,
-        field_info: FieldsInfo,
+        fields_info: FieldsInfo,
         row_number: int,
     ):
         self.__cells = cells
-        self.__fields_info = field_info
+        self.__fields_info = fields_info
         self.__row_number = row_number
         self.__processed: bool = False
         self.__blank_cells: Dict[str, Any] = {}
@@ -65,7 +65,7 @@ def __repr__(self):
     def __setitem__(self, key: str, value: Any):
         try:
             field_number = self.__fields_info.get(key).field_number
-        except KeyError:
+        except ValueError:
             raise KeyError(f"Row does not have a field {key}")
         if len(self.__cells) < field_number:
             self.__cells.extend([None] * (field_number - len(self.__cells)))
@@ -87,7 +87,7 @@ def __contains__(self, key: object):
     def __reversed__(self):
         return reversed(self.__fields_info.ls())
 
-    def keys(self):
+    def keys(self):  # type: ignore
         return iter(self.__fields_info.ls())
 
     def values(self):  # type: ignore