WIP attempt

Author: pierrecamilleri

frictionless/detector/detector.py

@@ -328,7 +328,7 @@ def detect_schema(
 
             # Handle name/empty
             for index, name in enumerate(names):
-                names[index] = name or f"field{index+1}"
+                names[index] = name or f"field{index + 1}"
 
             # Deduplicate names
             if len(names) != len(set(names)):
@@ -386,6 +386,7 @@ def detect_schema(
                         if not is_field_missing_value:
                             _, notes = runner["field"].read_cell(source)
                             runner["score"] += 1 if not notes else -1
+
                         if max_score[index] > 0 and runner["score"] >= (
                             max_score[index] * self.field_confidence
                         ):

frictionless/fields/geojson.py

@@ -18,7 +18,7 @@ def format(self):
 
     # TODO: use different value_readers based on format (see string)
     def create_value_reader(self):
-        validator_for = platform.jsonschema.field_descriptor_validators.validator_for  # type: ignore
+        validator_for = platform.jsonschema_validators.validator_for  # type: ignore
         validators = {  # type: ignore
             "default": validator_for(settings.GEOJSON_PROFILE)(settings.GEOJSON_PROFILE),
             "topojson": validator_for(settings.TOPOJSON_PROFILE)(

frictionless/metadata/metadata.py

@@ -413,7 +413,7 @@ def metadata_select_class(cls, type: Optional[str]) -> Type[Metadata]:
         return cls
 
     @classmethod
-    def metadata_select_property_class(cls, name: str) -> Optional[Type[Metadata]]:
+    def metadata_select_property_class(cls, name: str) -> Optional[type]:
         """Defines the class to use with a given property's metadata
 
         Complex properties are likely to have their own python class,

frictionless/schema/field.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import re
+from copy import deepcopy
 from functools import partial
 from typing import (
     TYPE_CHECKING,
@@ -55,6 +56,7 @@
     YearFieldDescriptor,
     YearmonthFieldDescriptor,
 )
+from ..metadata import Metadata
 
 if TYPE_CHECKING:
     from . import types
@@ -150,7 +152,7 @@ def read_cell(self, cell: Any):
         return cell_reader(cell)
 
     def create_cell_reader(self) -> types.ICellReader:
-        value_reader = self.create_value_reader()
+        value_reader = self.value_read_writer.create_value_reader()
 
         # Create missing values
         missing_values = self.missing_values
@@ -272,7 +274,11 @@ def value_writer(cell: Any):
     }
 
     @classmethod
-    def from_descriptor(cls, source: Union[Dict[str, Any], FieldDescriptor]):
+    def from_descriptor(cls, source: Union[Dict[str, Any], FieldDescriptor, str]):
+        if isinstance(source, str):
+            # Read descriptor from file
+            source = Metadata.metadata_retrieve(source)
+
         if isinstance(source, dict):
             descriptor: FieldDescriptor = pydantic.TypeAdapter[FieldDescriptor](
                 FieldDescriptor
@@ -328,8 +334,37 @@ def from_descriptor(cls, source: Union[Dict[str, Any], FieldDescriptor]):
             descriptor=descriptor,
         )
 
-    def to_descriptor(self):
+    def to_descriptor(self) -> FieldDescriptor:
         if self.descriptor:
             return self.descriptor
         else:
-            return AnyFieldDescriptor(name=self.name)
+            raise Exception()
+
+    ## Temporary metadata methods compatibility to be able to cooperate with,
+    ## e.g. the Schema class which is still a Metadata child.
+    #########################################################################
+
+    def to_copy(self):
+        return deepcopy(self)
+
+    @classmethod
+    def metadata_import(cls, descriptor: Any, *args, **kwargs):
+        return cls.from_descriptor(descriptor)
+
+    @classmethod
+    def metadata_select_class(cls, _: Any):
+        return cls
+
+    @classmethod
+    def metadata_transform(cls, _: Any):
+        return None
+
+    @classmethod
+    def metadata_validate(cls, *args, **kwargs):
+        # TODO this one should actually be implemented for the Descriptor class
+        return ()
+
+    def to_descriptor_source(self, *args, **kwargs) -> FieldDescriptor:
+        # TODO should we support returning a source ? what is the use case for
+        # this ?
+        return self.to_descriptor()

frictionless/schema/schema.py

@@ -79,6 +79,7 @@ class Schema(Metadata, metaclass=Factory):
     """
 
     def __attrs_post_init__(self):
+        print(self.fields)
         for field in self.fields:
             field.schema = self
         super().__attrs_post_init__()
@@ -325,6 +326,8 @@ def to_summary(self) -> str:
 
     @classmethod
     def metadata_select_property_class(cls, name: str):
+        if name == "fields":
+            return Field
         return None
 
     # TODO: handle invalid structure

frictionless/table/row.py

@@ -223,7 +223,11 @@ def to_list(self, *, json: bool = False, types: Optional[List[str]] = None):
         return result
 
     def to_dict(
-        self, *, csv: bool = False, json: bool = False, types: Optional[List[str]] = None
+        self,
+        *,
+        csv: bool = False,
+        json: bool = False,
+        types: Optional[List[str]] = None,
     ) -> Dict[str, Any]:
         """
         Parameters: