From 8fc19e59a93c88acee2317e7601669bff8ad5a9c Mon Sep 17 00:00:00 2001
From: Olivier <coen.olivier@gmail.com>
Date: Sat, 11 Apr 2026 15:23:35 +0200
Subject: [PATCH 01/22] create __init__.py and add filter for warning
 'UserWarning: Field name "schema" in "Resource" shadows an attribute in
 parent "BaseModel"'

---
 coordo-py/coordo/__init__.py | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 coordo-py/coordo/__init__.py

diff --git a/coordo-py/coordo/__init__.py b/coordo-py/coordo/__init__.py
new file mode 100644
index 0000000..a6cf95c
--- /dev/null
+++ b/coordo-py/coordo/__init__.py
@@ -0,0 +1,19 @@
+import warnings
+
+# ignore warnings due to shadowing of Pydantic's "schema" field in "Resource"
+REGEX_TO_IGNORE = (
+    'Field name "schema" in "Resource" shadows an attribute in parent "(Base)?Model"'
+)
+warnings.filterwarnings(
+    "ignore",
+    category=UserWarning,
+    module="dplib",
+    message=REGEX_TO_IGNORE,
+)
+
+warnings.filterwarnings(
+    "ignore",
+    category=UserWarning,
+    module="coordo",
+    message=REGEX_TO_IGNORE,
+)

From f004f9202ec4b8781d53ad73a593511f9bbdf889 Mon Sep 17 00:00:00 2001
From: Olivier <coen.olivier@gmail.com>
Date: Sun, 12 Apr 2026 19:07:32 +0200
Subject: [PATCH 02/22] implement functionnality to overwrite existing file

---
 coordo-py/coordo/__init__.py             | 14 ++++++
 coordo-py/coordo/cli.py                  |  9 ++--
 coordo-py/coordo/datapackage/package.py  | 56 +++++++++++++++++----
 coordo-py/coordo/datapackage/resource.py |  6 +++
 coordo-py/coordo/loaders/kobotoolbox.py  | 62 +++++++++++++++++++-----
 5 files changed, 122 insertions(+), 25 deletions(-)

diff --git a/coordo-py/coordo/__init__.py b/coordo-py/coordo/__init__.py
index a6cf95c..8926ded 100644
--- a/coordo-py/coordo/__init__.py
+++ b/coordo-py/coordo/__init__.py
@@ -1,4 +1,7 @@
 import warnings
+from enum import Enum
+from typing import Annotated
+import typer
 
 # ignore warnings due to shadowing of Pydantic's "schema" field in "Resource"
 REGEX_TO_IGNORE = (
@@ -17,3 +20,14 @@
     module="coordo",
     message=REGEX_TO_IGNORE,
 )
+
+
+class LoadingStrategy(str, Enum):
+    raise_error = "raise_error"
+    overwrite = "overwrite"
+    merge = "merge"
+    
+StrategyType = Annotated[
+    LoadingStrategy, 
+    typer.Option(help="Strategy to use in case of already existing resource")
+]
\ No newline at end of file
diff --git a/coordo-py/coordo/cli.py b/coordo-py/coordo/cli.py
index 2ff3bc5..bd02b86 100644
--- a/coordo-py/coordo/cli.py
+++ b/coordo-py/coordo/cli.py
@@ -7,7 +7,7 @@
 import typer
 from dplib.models.schema.foreignKey import ForeignKey, ForeignKeyReference
 
-from coordo import loaders
+from coordo import loaders, LoadingStrategy, StrategyType
 from coordo.datapackage import DataPackage
 from coordo.sql.builder import build_query
 
@@ -78,14 +78,16 @@ def static_files(filename):
 load = typer.Typer()
 
 
+
 @load.command()
 def kobotoolbox(
     xlsform: Path,
     xlsdata: Path,
     package: Path = typer.Option(help="Path to the package directory"),
+    strategy: StrategyType = LoadingStrategy.raise_error,
 ):
     dp = DataPackage.from_path(package)
-    loaders.kobotoolbox.load(dp, xlsform, xlsdata)
+    loaders.kobotoolbox.load(dp, xlsform, xlsdata, strategy)    
     dp.save()
 
 
@@ -93,10 +95,11 @@ def kobotoolbox(
 def file(
     path: Path,
     package: Path = typer.Option(".", help="Path to the package directory"),
+    strategy: StrategyType = LoadingStrategy.raise_error,
 ):
     dp = DataPackage.from_path(package)
     try:
-        loaders.file.load(dp, path)
+        loaders.file.load(dp, path, strategy)
     except ValueError as e:
         raise typer.BadParameter(
             f"{e} Add --overwrite if you wish to continue.", param_hint="path"
diff --git a/coordo-py/coordo/datapackage/package.py b/coordo-py/coordo/datapackage/package.py
index b405d28..5638280 100644
--- a/coordo-py/coordo/datapackage/package.py
+++ b/coordo-py/coordo/datapackage/package.py
@@ -22,6 +22,7 @@
 from dplib.plugins.sql.models import SqlSchema
 from pygeofilter.ast import AstType
 
+from coordo import LoadingStrategy
 from coordo.sql.builder import build_query, compile_query
 from coordo.sql.helpers import load_conn
 
@@ -91,26 +92,61 @@ def save(self):
         )
 
     def remove_resource(self, name: str) -> None:
+        """
+        Remove a resource from the package:
+        - for all other resources in the current datapackage, remove any foreign keys pointing to this resource.
+        - remove the file associated with the resource.
+        Args:
+            name (str): the name of the resource to remove
+        """
+        print(f"Removing resource {name} from DataPackage {self.name}")
         resource = self.get_resource(name=name)
+        # looping over all resources in the current datapackage, other than <resource>
         for res in self.resources:
             if res.name == name:
                 continue
-            sm = safe(res, "schema")
-            if sm.foreignKeys:
-                for fk in sm.foreignKeys:
-                    assert fk.reference.resource != name, (
-                        f"Can't remove the resource {name} : {res.name} have a foreign key pointing to this resource."
-                    )
+            
+            # getting the schema of the resource
+            res_schema = safe(res, "schema")
+            
+            # removing all foreign keys pointing to <resource>, if any
+            # we do it in two steps: first collect all keys to remove, then remove them
+            # so that we don't modify the list while iterating over it
+            if res_schema.foreignKeys:
+                foreign_keys_to_remove = []
+                for fk in res_schema.foreignKeys:
+                    if fk.reference.resource == name:
+                        foreign_keys_to_remove.append(fk)
+                for fk in foreign_keys_to_remove:
+                    res.remove_foreignkey(fk)
+                    
         if resource.path:
             path = handle_path(resource.path)
             Path(self._basepath / path).unlink()
         self.resources = [res for res in self.resources if res.name != name]
 
-    def add_resource(self, resource: Resource) -> None:
+    def add_resource(self, resource: Resource, strategy: LoadingStrategy) -> None:
+        """
+        Add a resource to the DataPackage.
+
+        Args:
+            resource (Resource): The resource to add.
+            strategy (LoadingStrategy): The strategy to use when a resource with the same name already exists.
+        """
+        print(f"Adding resource {resource.name} to DataPackage {self.name} with strategy={strategy.name}")
         if any(res.name == resource.name for res in self.resources):
-            raise ValueError(
-                f"A resource named {resource.name} already exists in package {self.name}."
-            )
+            if strategy == LoadingStrategy.overwrite:
+                self.remove_resource(resource.name)
+            elif strategy == LoadingStrategy.merge:
+                pass
+            elif strategy == LoadingStrategy.raise_error:
+                raise ValueError(
+                    f"A resource named {resource.name} already exists in package {self.name}."
+                )
+            else:
+                raise ValueError(
+                    f"Unknown strategy {strategy} for resource {resource.name}."
+                )
         resource._package = self
         self.resources.append(resource)
 
diff --git a/coordo-py/coordo/datapackage/resource.py b/coordo-py/coordo/datapackage/resource.py
index 67a3c32..d0162e3 100644
--- a/coordo-py/coordo/datapackage/resource.py
+++ b/coordo-py/coordo/datapackage/resource.py
@@ -68,6 +68,12 @@ def add_foreignkey(self, fk: ForeignKey) -> None:
                 f in field_names
             ), f"Resource {parent_resource.name} has no field named {f}"
         self.schema.foreignKeys.append(fk)
+    
+    def remove_foreignkey(self, fk: ForeignKey) -> None:
+        if fk not in self.schema.foreignKeys:
+            raise ValueError(f"Foreign key {fk} not found in resource {self.name}")
+        self.schema.foreignKeys.remove(fk)
+        
 
     @model_validator(mode="after")
     def check_data_or_path(self) -> Self:
diff --git a/coordo-py/coordo/loaders/kobotoolbox.py b/coordo-py/coordo/loaders/kobotoolbox.py
index 5898ab0..d992862 100644
--- a/coordo-py/coordo/loaders/kobotoolbox.py
+++ b/coordo-py/coordo/loaders/kobotoolbox.py
@@ -14,6 +14,7 @@
 from pyxform.xls2json import parse_file_to_json
 from shapely.geometry import Point
 
+from coordo import LoadingStrategy
 from coordo.datapackage import (
     DataPackage,
     Field,
@@ -134,11 +135,20 @@ def coords_to_point(coords):
         return Point(lon, lat, alt)
 
 
-def load(package: DataPackage, xlsform: Path, xlsdata: Path):
+def load(dp: DataPackage, xlsform: Path, xlsdata: Path, strategy: LoadingStrategy):
+    """
+    Loads a datapackage from an XLS form and XLS data file.
+    The xlsform is parsed with the pyxform.xls2json.parse_file_to_json function
+    while the xlsdata is parsed with pandas read_excel or read_csv functions.
+    """
+    # parse form from xlsform
+    print(f"Parsing form from {xlsform}")
     form = parse_file_to_json(str(xlsform))
     name = cast(str, form["id_string"].lower())
     main_resource = _create_resource(name)
-    _parse_form(package, form, main_resource)
+    _parse_form(dp, form, main_resource, strategy)
+
+    print(f"Parsing data from {xlsdata}")
     if xlsdata.suffix == ".xlsx":
         sheets_dict = pd.read_excel(xlsdata, sheet_name=None)
     elif xlsdata.suffix == ".csv":
@@ -153,9 +163,10 @@ def load(package: DataPackage, xlsform: Path, xlsdata: Path):
         }
     else:
         raise ValueError(f"Unsupported file format: {xlsdata}")
+
     for i, (sheet_name, sheet) in enumerate(sheets_dict.items()):
         table_name = main_resource.name if i == 0 else sheet_name.lower()
-        resource = next(r for r in package.resources if r.name == table_name)
+        resource = next(r for r in dp.resources if r.name == table_name)
         schema = safe(resource, "schema")
         sheet = (
             sheet.rename(
@@ -185,7 +196,7 @@ def load(package: DataPackage, xlsform: Path, xlsdata: Path):
 
         sheet = sheet[fields]
         sheet = sheet.replace({np.nan: None})
-        path = Path(package._basepath, table_name + ".parquet")
+        path = Path(dp._basepath, table_name + ".parquet")
         geo_cols = [f.name for f in schema.fields if f.type == "geojson"]
         if geo_cols:
             gdf = gpd.GeoDataFrame(sheet, geometry=geo_cols[0], crs="EPSG:4326")
@@ -200,7 +211,7 @@ def load(package: DataPackage, xlsform: Path, xlsdata: Path):
             sheet.to_parquet(path, index=False)
 
 
-def _create_resource(name) -> Resource:
+def _create_resource(name: str) -> Resource:
     return Resource(
         name=name,
         path=name + ".parquet",
@@ -211,20 +222,47 @@ def _create_resource(name) -> Resource:
     )
 
 
-def _parse_form(pkg: DataPackage, form, resource: Resource):
-    _parse_questions(pkg, form["children"], resource)
-    pkg.add_resource(resource)
+def _parse_form(pkg: DataPackage, form: dict[str, Any], resource: Resource, strategy: LoadingStrategy):
+    _parse_questions(pkg, form["children"], resource, strategy)
+    # print(resource)
+    pkg.add_resource(resource, strategy)
 
 
-def _parse_questions(pkg, questions: List[Dict[str, Any]], resource: Resource):
+def _parse_questions(
+    pkg: DataPackage, questions: List[Dict[str, Any]], resource: Resource, strategy: LoadingStrategy
+):
+    """
+    Parses questions (list of dictionaries) and adds them to the resource's schema.
+    Example of structure of questions:
+        [
+            {
+                'type': 'integer',
+                'name': '<name>',
+                'label': '<label>',
+                'bind': {'required': 'true', 'constraint': '. < 100', 'jr:constraintMsg': '<constraint message>'}
+            },
+            {
+                'type': 'group',
+                'name': '<name>',
+                'label': '<label>',
+                'control': {'appearance': 'field-list'},
+                'children': [
+                    {'type': 'text', 'name': 'name1', 'label': "Label1", ...},
+                    {'type': 'select one', 'name': 'name2', 'label': 'Label2', ...},
+                    {'type': 'integer', 'name': 'name3', 'label': 'Label233', ...}
+                ]
+            }
+        ]
+    For each question having a 'group' type, parses recursively the children questions.
+    """
     schema = safe(resource, "schema")
     for question in questions:
         qtype = question["type"]
         if qtype in METADATA_TYPES + IGNORE_TYPES:
-            print("Skipping :", qtype)
+            print("Skipping question type:", qtype)
             continue
         if qtype == "group":
-            _parse_questions(pkg, question["children"], resource)
+            _parse_questions(pkg, question["children"], resource, strategy)
             continue
         if qtype == "repeat":
             child_resource = _create_resource(question["name"].lower())
@@ -239,7 +277,7 @@ def _parse_questions(pkg, questions: List[Dict[str, Any]], resource: Resource):
                     ),
                 )
             ]
-            _parse_form(pkg, question, child_resource)
+            _parse_form(pkg, question, child_resource, strategy)
             continue
         if qtype in DP_FIELDS:
             kwargs = dict(name=question["name"], type=DP_FIELDS[qtype])

From 25f5b3334c0088b6684259ecc241d32d931a3f6d Mon Sep 17 00:00:00 2001
From: Olivier <coen.olivier@gmail.com>
Date: Mon, 13 Apr 2026 08:10:05 +0200
Subject: [PATCH 03/22] add parameter strategy to choose overwrite behavior +
 implement overwrite

---
 coordo-py/coordo/__init__.py            | 11 ++----
 coordo-py/coordo/cli.py                 |  7 ++--
 coordo-py/coordo/datapackage/package.py | 46 +++++++++++++++++++++----
 coordo-py/coordo/loaders/kobotoolbox.py | 29 +++++++++++++---
 4 files changed, 72 insertions(+), 21 deletions(-)

diff --git a/coordo-py/coordo/__init__.py b/coordo-py/coordo/__init__.py
index 8926ded..3602647 100644
--- a/coordo-py/coordo/__init__.py
+++ b/coordo-py/coordo/__init__.py
@@ -1,7 +1,6 @@
 import warnings
 from enum import Enum
-from typing import Annotated
-import typer
+
 
 # ignore warnings due to shadowing of Pydantic's "schema" field in "Resource"
 REGEX_TO_IGNORE = (
@@ -25,9 +24,5 @@
 class LoadingStrategy(str, Enum):
     raise_error = "raise_error"
     overwrite = "overwrite"
-    merge = "merge"
-    
-StrategyType = Annotated[
-    LoadingStrategy, 
-    typer.Option(help="Strategy to use in case of already existing resource")
-]
\ No newline at end of file
+    append = "append"
+    append_strict = "append_strict"
\ No newline at end of file
diff --git a/coordo-py/coordo/cli.py b/coordo-py/coordo/cli.py
index bd02b86..3b72de7 100644
--- a/coordo-py/coordo/cli.py
+++ b/coordo-py/coordo/cli.py
@@ -3,11 +3,12 @@
 
 import signal
 from pathlib import Path
+from typing import Annotated
 
 import typer
 from dplib.models.schema.foreignKey import ForeignKey, ForeignKeyReference
 
-from coordo import loaders, LoadingStrategy, StrategyType
+from coordo import loaders, LoadingStrategy
 from coordo.datapackage import DataPackage
 from coordo.sql.builder import build_query
 
@@ -84,7 +85,7 @@ def kobotoolbox(
     xlsform: Path,
     xlsdata: Path,
     package: Path = typer.Option(help="Path to the package directory"),
-    strategy: StrategyType = LoadingStrategy.raise_error,
+    strategy: Annotated[LoadingStrategy, typer.Option(help="Strategy to use in case of already existing resource")] = LoadingStrategy.raise_error,
 ):
     dp = DataPackage.from_path(package)
     loaders.kobotoolbox.load(dp, xlsform, xlsdata, strategy)    
@@ -95,7 +96,7 @@ def kobotoolbox(
 def file(
     path: Path,
     package: Path = typer.Option(".", help="Path to the package directory"),
-    strategy: StrategyType = LoadingStrategy.raise_error,
+    strategy: Annotated[LoadingStrategy, typer.Option(help="Strategy to use in case of already existing resource")] = LoadingStrategy.raise_error,
 ):
     dp = DataPackage.from_path(package)
     try:
diff --git a/coordo-py/coordo/datapackage/package.py b/coordo-py/coordo/datapackage/package.py
index 5638280..3c06782 100644
--- a/coordo-py/coordo/datapackage/package.py
+++ b/coordo-py/coordo/datapackage/package.py
@@ -41,6 +41,14 @@ def handle_path(path: str | list[str]) -> str:
     return path
 
 
+def check_resource_fields_match(res1: Resource, res2: Resource) -> None:
+    res1_field_names = [field.name for field in res1.schema.fields]
+    res2_field_names = [field.name for field in res2.schema.fields]
+    if set(res1_field_names) != set(res2_field_names):
+        raise ValueError(f"Field names do not match for resource {res1.name}: {sorted(res1_field_names)} != {sorted(res2_field_names)}")
+    
+
+
 class DataPackage(pydantic.BaseModel):
     id: Optional[str] = None
     name: str = pydantic.Field(pattern=r"^[a-z0-9._-]+$")
@@ -122,31 +130,55 @@ def remove_resource(self, name: str) -> None:
                     
         if resource.path:
             path = handle_path(resource.path)
-            Path(self._basepath / path).unlink()
+            try:
+                Path(self._basepath / path).unlink()
+            except FileNotFoundError:
+                raise FileNotFoundError(
+                    f"File not found: {path}. It was meant to be removed anyway but there may be an issue."
+                )
+                
         self.resources = [res for res in self.resources if res.name != name]
 
-    def add_resource(self, resource: Resource, strategy: LoadingStrategy) -> None:
+    def add_resource_following_strategy(self, resource: Resource, strategy: LoadingStrategy) -> None:
         """
-        Add a resource to the DataPackage.
+        Add a resource to the DataPackage according to the given strategy.
 
         Args:
             resource (Resource): The resource to add.
             strategy (LoadingStrategy): The strategy to use when a resource with the same name already exists.
         """
         print(f"Adding resource {resource.name} to DataPackage {self.name} with strategy={strategy.name}")
-        if any(res.name == resource.name for res in self.resources):
-            if strategy == LoadingStrategy.overwrite:
+        if any(res.name == resource.name for res in self.resources): # resource already exists
+            
+            if strategy == LoadingStrategy.overwrite: # remove and overwrite
                 self.remove_resource(resource.name)
-            elif strategy == LoadingStrategy.merge:
+                self.add_resource(resource)
+            
+            elif strategy == LoadingStrategy.append: # do nothing for now
                 pass
+                
+            elif strategy == LoadingStrategy.append_strict: # just check that fields match
+                current_resource = self.get_resource(resource.name)
+                check_resource_fields_match(current_resource, resource)
+                
             elif strategy == LoadingStrategy.raise_error:
                 raise ValueError(
                     f"A resource named {resource.name} already exists in package {self.name}."
                 )
+                
             else:
                 raise ValueError(
                     f"Unknown strategy {strategy} for resource {resource.name}."
                 )
+                
+        else: # resource does not exist, just add it
+            self.add_resource(resource)
+    
+    def add_resource(self, resource: Resource) -> None:
+        if any(res.name == resource.name for res in self.resources): # check, just in case
+            raise ValueError(
+                f"A resource named {resource.name} already exists in package {self.name}."
+            )
         resource._package = self
         self.resources.append(resource)
 
@@ -206,3 +238,5 @@ def read_resource(
             df[col] = df[col].apply(lambda x: x.tolist() if x is not None else None)
 
         return df
+
+    
\ No newline at end of file
diff --git a/coordo-py/coordo/loaders/kobotoolbox.py b/coordo-py/coordo/loaders/kobotoolbox.py
index d992862..374259a 100644
--- a/coordo-py/coordo/loaders/kobotoolbox.py
+++ b/coordo-py/coordo/loaders/kobotoolbox.py
@@ -146,13 +146,15 @@ def load(dp: DataPackage, xlsform: Path, xlsdata: Path, strategy: LoadingStrateg
     form = parse_file_to_json(str(xlsform))
     name = cast(str, form["id_string"].lower())
     main_resource = _create_resource(name)
+    
+    # parses questions from JSON form and add resources to the datapackage
     _parse_form(dp, form, main_resource, strategy)
-
+    
     print(f"Parsing data from {xlsdata}")
     if xlsdata.suffix == ".xlsx":
         sheets_dict = pd.read_excel(xlsdata, sheet_name=None)
     elif xlsdata.suffix == ".csv":
-        # I think this encoding is not the one from Kobo we should verify
+        # TODO: I think this encoding is not the one from Kobo we should verify
         sheets_dict = {
             name: pd.read_csv(
                 xlsdata,
@@ -163,8 +165,13 @@ def load(dp: DataPackage, xlsform: Path, xlsdata: Path, strategy: LoadingStrateg
         }
     else:
         raise ValueError(f"Unsupported file format: {xlsdata}")
+    
+    # determine append mode based on strategy
+    append_mode = strategy in [LoadingStrategy.append, LoadingStrategy.append_strict]
 
+    print("Processing sheets...")
     for i, (sheet_name, sheet) in enumerate(sheets_dict.items()):
+        
         table_name = main_resource.name if i == 0 else sheet_name.lower()
         resource = next(r for r in dp.resources if r.name == table_name)
         schema = safe(resource, "schema")
@@ -176,6 +183,7 @@ def load(dp: DataPackage, xlsform: Path, xlsdata: Path, strategy: LoadingStrateg
             .replace(np.nan, None)
         )
         sheet[PRIMARY_KEY] = sheet.index + 1
+        
         fields = []
         for field in schema.fields:
             if field.name in sheet.columns:
@@ -196,10 +204,18 @@ def load(dp: DataPackage, xlsform: Path, xlsdata: Path, strategy: LoadingStrateg
 
         sheet = sheet[fields]
         sheet = sheet.replace({np.nan: None})
+        
         path = Path(dp._basepath, table_name + ".parquet")
+        print(f"Saving {sheet_name!r} to {path}")
+        
         geo_cols = [f.name for f in schema.fields if f.type == "geojson"]
         if geo_cols:
             gdf = gpd.GeoDataFrame(sheet, geometry=geo_cols[0], crs="EPSG:4326")
+            
+            # if append_mode, try to read existing data and concatenate
+            if append_mode:
+                pass
+               
             gdf.to_parquet(
                 path,
                 schema_version="1.1.0",
@@ -208,8 +224,13 @@ def load(dp: DataPackage, xlsform: Path, xlsdata: Path, strategy: LoadingStrateg
                 geometry_encoding="WKB",  # We use this because duckdb can't open geoarrow as geometries
             )
         else:
+            
+            # if append_mode, try to read existing data and concatenate
+            if append_mode:
+                pass
+                
             sheet.to_parquet(path, index=False)
-
+    
 
 def _create_resource(name: str) -> Resource:
     return Resource(
@@ -225,7 +246,7 @@ def _create_resource(name: str) -> Resource:
 def _parse_form(pkg: DataPackage, form: dict[str, Any], resource: Resource, strategy: LoadingStrategy):
     _parse_questions(pkg, form["children"], resource, strategy)
     # print(resource)
-    pkg.add_resource(resource, strategy)
+    pkg.add_resource_following_strategy(resource, strategy)
 
 
 def _parse_questions(

From 93f3e2bc34e72c266299b052b451794b81d839f4 Mon Sep 17 00:00:00 2001
From: Olivier <coen.olivier@gmail.com>
Date: Mon, 13 Apr 2026 08:23:20 +0200
Subject: [PATCH 04/22] Update README.md

---
 coordo-py/README.md | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/coordo-py/README.md b/coordo-py/README.md
index 636a1c9..2e4e65b 100644
--- a/coordo-py/README.md
+++ b/coordo-py/README.md
@@ -90,3 +90,18 @@ FROM parents LEFT OUTER JOIN children ON parents.id = children.parent_id)
  SELECT anon_1.avg_1
 FROM anon_1
 ```
+
+
+## Development
+
+### Data types
+
+#### KoboToolbox
+
+For surveys, Kobotoolbox uses the standard XLSForm format.
+Briefly, each `xlsx` file contains 3 sheets:
+- `survey`
+- `choices`
+- `settings`
+
+All information can be found at https://support.kobotoolbox.org/edit_forms_excel.html

From 87ebb76e8e6b6d3f4fc3bb941dabff16f45d6694 Mon Sep 17 00:00:00 2001
From: Olivier <coen.olivier@gmail.com>
Date: Mon, 13 Apr 2026 08:38:36 +0200
Subject: [PATCH 05/22] add copyright

---
 coordo-py/coordo/__init__.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/coordo-py/coordo/__init__.py b/coordo-py/coordo/__init__.py
index 3602647..7f46c99 100644
--- a/coordo-py/coordo/__init__.py
+++ b/coordo-py/coordo/__init__.py
@@ -1,3 +1,6 @@
+# Copyright COORDONNÉES 2025, 2026
+# SPDX-License-Identifier: MPL-2.0
+
 import warnings
 from enum import Enum
 
@@ -25,4 +28,4 @@ class LoadingStrategy(str, Enum):
     raise_error = "raise_error"
     overwrite = "overwrite"
     append = "append"
-    append_strict = "append_strict"
\ No newline at end of file
+    append_strict = "append_strict"

From e4c70ad4a7c7079ff96afb7e4ec186b9a49c2b57 Mon Sep 17 00:00:00 2001
From: Olivier <coen.olivier@gmail.com>
Date: Mon, 13 Apr 2026 08:41:08 +0200
Subject: [PATCH 06/22] apply ruff

---
 coordo-py/coordo/cli.py                  | 13 ++++--
 coordo-py/coordo/datapackage/package.py  | 54 ++++++++++++++----------
 coordo-py/coordo/datapackage/resource.py | 11 +++--
 coordo-py/coordo/loaders/kobotoolbox.py  | 34 +++++++++------
 coordo-py/pyproject.toml                 |  8 +++-
 5 files changed, 72 insertions(+), 48 deletions(-)

diff --git a/coordo-py/coordo/cli.py b/coordo-py/coordo/cli.py
index 3b72de7..1fc12fb 100644
--- a/coordo-py/coordo/cli.py
+++ b/coordo-py/coordo/cli.py
@@ -79,16 +79,18 @@ def static_files(filename):
 load = typer.Typer()
 
 
-
 @load.command()
 def kobotoolbox(
     xlsform: Path,
     xlsdata: Path,
     package: Path = typer.Option(help="Path to the package directory"),
-    strategy: Annotated[LoadingStrategy, typer.Option(help="Strategy to use in case of already existing resource")] = LoadingStrategy.raise_error,
+    strategy: Annotated[
+        LoadingStrategy,
+        typer.Option(help="Strategy to use in case of already existing resource"),
+    ] = LoadingStrategy.raise_error,
 ):
     dp = DataPackage.from_path(package)
-    loaders.kobotoolbox.load(dp, xlsform, xlsdata, strategy)    
+    loaders.kobotoolbox.load(dp, xlsform, xlsdata, strategy)
     dp.save()
 
 
@@ -96,7 +98,10 @@ def kobotoolbox(
 def file(
     path: Path,
     package: Path = typer.Option(".", help="Path to the package directory"),
-    strategy: Annotated[LoadingStrategy, typer.Option(help="Strategy to use in case of already existing resource")] = LoadingStrategy.raise_error,
+    strategy: Annotated[
+        LoadingStrategy,
+        typer.Option(help="Strategy to use in case of already existing resource"),
+    ] = LoadingStrategy.raise_error,
 ):
     dp = DataPackage.from_path(package)
     try:
diff --git a/coordo-py/coordo/datapackage/package.py b/coordo-py/coordo/datapackage/package.py
index 3c06782..76cd18d 100644
--- a/coordo-py/coordo/datapackage/package.py
+++ b/coordo-py/coordo/datapackage/package.py
@@ -45,8 +45,9 @@ def check_resource_fields_match(res1: Resource, res2: Resource) -> None:
     res1_field_names = [field.name for field in res1.schema.fields]
     res2_field_names = [field.name for field in res2.schema.fields]
     if set(res1_field_names) != set(res2_field_names):
-        raise ValueError(f"Field names do not match for resource {res1.name}: {sorted(res1_field_names)} != {sorted(res2_field_names)}")
-    
+        raise ValueError(
+            f"Field names do not match for resource {res1.name}: {sorted(res1_field_names)} != {sorted(res2_field_names)}"
+        )
 
 
 class DataPackage(pydantic.BaseModel):
@@ -113,10 +114,10 @@ def remove_resource(self, name: str) -> None:
         for res in self.resources:
             if res.name == name:
                 continue
-            
+
             # getting the schema of the resource
             res_schema = safe(res, "schema")
-            
+
             # removing all foreign keys pointing to <resource>, if any
             # we do it in two steps: first collect all keys to remove, then remove them
             # so that we don't modify the list while iterating over it
@@ -127,7 +128,7 @@ def remove_resource(self, name: str) -> None:
                         foreign_keys_to_remove.append(fk)
                 for fk in foreign_keys_to_remove:
                     res.remove_foreignkey(fk)
-                    
+
         if resource.path:
             path = handle_path(resource.path)
             try:
@@ -136,10 +137,12 @@ def remove_resource(self, name: str) -> None:
                 raise FileNotFoundError(
                     f"File not found: {path}. It was meant to be removed anyway but there may be an issue."
                 )
-                
+
         self.resources = [res for res in self.resources if res.name != name]
 
-    def add_resource_following_strategy(self, resource: Resource, strategy: LoadingStrategy) -> None:
+    def add_resource_following_strategy(
+        self, resource: Resource, strategy: LoadingStrategy
+    ) -> None:
         """
         Add a resource to the DataPackage according to the given strategy.
 
@@ -147,35 +150,42 @@ def add_resource_following_strategy(self, resource: Resource, strategy: LoadingS
             resource (Resource): The resource to add.
             strategy (LoadingStrategy): The strategy to use when a resource with the same name already exists.
         """
-        print(f"Adding resource {resource.name} to DataPackage {self.name} with strategy={strategy.name}")
-        if any(res.name == resource.name for res in self.resources): # resource already exists
-            
-            if strategy == LoadingStrategy.overwrite: # remove and overwrite
+        print(
+            f"Adding resource {resource.name} to DataPackage {self.name} with strategy={strategy.name}"
+        )
+        if any(
+            res.name == resource.name for res in self.resources
+        ):  # resource already exists
+            if strategy == LoadingStrategy.overwrite:  # remove and overwrite
                 self.remove_resource(resource.name)
                 self.add_resource(resource)
-            
-            elif strategy == LoadingStrategy.append: # do nothing for now
+
+            elif strategy == LoadingStrategy.append:  # do nothing for now
                 pass
-                
-            elif strategy == LoadingStrategy.append_strict: # just check that fields match
+
+            elif (
+                strategy == LoadingStrategy.append_strict
+            ):  # just check that fields match
                 current_resource = self.get_resource(resource.name)
                 check_resource_fields_match(current_resource, resource)
-                
+
             elif strategy == LoadingStrategy.raise_error:
                 raise ValueError(
                     f"A resource named {resource.name} already exists in package {self.name}."
                 )
-                
+
             else:
                 raise ValueError(
                     f"Unknown strategy {strategy} for resource {resource.name}."
                 )
-                
-        else: # resource does not exist, just add it
+
+        else:  # resource does not exist, just add it
             self.add_resource(resource)
-    
+
     def add_resource(self, resource: Resource) -> None:
-        if any(res.name == resource.name for res in self.resources): # check, just in case
+        if any(
+            res.name == resource.name for res in self.resources
+        ):  # check, just in case
             raise ValueError(
                 f"A resource named {resource.name} already exists in package {self.name}."
             )
@@ -238,5 +248,3 @@ def read_resource(
             df[col] = df[col].apply(lambda x: x.tolist() if x is not None else None)
 
         return df
-
-    
\ No newline at end of file
diff --git a/coordo-py/coordo/datapackage/resource.py b/coordo-py/coordo/datapackage/resource.py
index d0162e3..33d4fc7 100644
--- a/coordo-py/coordo/datapackage/resource.py
+++ b/coordo-py/coordo/datapackage/resource.py
@@ -64,16 +64,15 @@ def add_foreignkey(self, fk: ForeignKey) -> None:
         )
         field_names = [f.name for f in parent_resource.schema.fields]
         for f in fk.reference.fields:
-            assert (
-                f in field_names
-            ), f"Resource {parent_resource.name} has no field named {f}"
+            assert f in field_names, (
+                f"Resource {parent_resource.name} has no field named {f}"
+            )
         self.schema.foreignKeys.append(fk)
-    
+
     def remove_foreignkey(self, fk: ForeignKey) -> None:
         if fk not in self.schema.foreignKeys:
             raise ValueError(f"Foreign key {fk} not found in resource {self.name}")
-        self.schema.foreignKeys.remove(fk)
-        
+        self.schema.foreignKeys.remove(fk)        
 
     @model_validator(mode="after")
     def check_data_or_path(self) -> Self:
diff --git a/coordo-py/coordo/loaders/kobotoolbox.py b/coordo-py/coordo/loaders/kobotoolbox.py
index 374259a..e2cbe7a 100644
--- a/coordo-py/coordo/loaders/kobotoolbox.py
+++ b/coordo-py/coordo/loaders/kobotoolbox.py
@@ -146,10 +146,10 @@ def load(dp: DataPackage, xlsform: Path, xlsdata: Path, strategy: LoadingStrateg
     form = parse_file_to_json(str(xlsform))
     name = cast(str, form["id_string"].lower())
     main_resource = _create_resource(name)
-    
+
     # parses questions from JSON form and add resources to the datapackage
     _parse_form(dp, form, main_resource, strategy)
-    
+
     print(f"Parsing data from {xlsdata}")
     if xlsdata.suffix == ".xlsx":
         sheets_dict = pd.read_excel(xlsdata, sheet_name=None)
@@ -165,13 +165,12 @@ def load(dp: DataPackage, xlsform: Path, xlsdata: Path, strategy: LoadingStrateg
         }
     else:
         raise ValueError(f"Unsupported file format: {xlsdata}")
-    
+
     # determine append mode based on strategy
     append_mode = strategy in [LoadingStrategy.append, LoadingStrategy.append_strict]
 
     print("Processing sheets...")
     for i, (sheet_name, sheet) in enumerate(sheets_dict.items()):
-        
         table_name = main_resource.name if i == 0 else sheet_name.lower()
         resource = next(r for r in dp.resources if r.name == table_name)
         schema = safe(resource, "schema")
@@ -183,7 +182,7 @@ def load(dp: DataPackage, xlsform: Path, xlsdata: Path, strategy: LoadingStrateg
             .replace(np.nan, None)
         )
         sheet[PRIMARY_KEY] = sheet.index + 1
-        
+
         fields = []
         for field in schema.fields:
             if field.name in sheet.columns:
@@ -204,18 +203,18 @@ def load(dp: DataPackage, xlsform: Path, xlsdata: Path, strategy: LoadingStrateg
 
         sheet = sheet[fields]
         sheet = sheet.replace({np.nan: None})
-        
+
         path = Path(dp._basepath, table_name + ".parquet")
         print(f"Saving {sheet_name!r} to {path}")
-        
+
         geo_cols = [f.name for f in schema.fields if f.type == "geojson"]
         if geo_cols:
             gdf = gpd.GeoDataFrame(sheet, geometry=geo_cols[0], crs="EPSG:4326")
-            
+
             # if append_mode, try to read existing data and concatenate
             if append_mode:
                 pass
-               
+
             gdf.to_parquet(
                 path,
                 schema_version="1.1.0",
@@ -224,13 +223,12 @@ def load(dp: DataPackage, xlsform: Path, xlsdata: Path, strategy: LoadingStrateg
                 geometry_encoding="WKB",  # We use this because duckdb can't open geoarrow as geometries
             )
         else:
-            
             # if append_mode, try to read existing data and concatenate
             if append_mode:
                 pass
-                
+
             sheet.to_parquet(path, index=False)
-    
+
 
 def _create_resource(name: str) -> Resource:
     return Resource(
@@ -243,14 +241,22 @@ def _create_resource(name: str) -> Resource:
     )
 
 
-def _parse_form(pkg: DataPackage, form: dict[str, Any], resource: Resource, strategy: LoadingStrategy):
+def _parse_form(
+    pkg: DataPackage,
+    form: dict[str, Any],
+    resource: Resource,
+    strategy: LoadingStrategy,
+):
     _parse_questions(pkg, form["children"], resource, strategy)
     # print(resource)
     pkg.add_resource_following_strategy(resource, strategy)
 
 
 def _parse_questions(
-    pkg: DataPackage, questions: List[Dict[str, Any]], resource: Resource, strategy: LoadingStrategy
+    pkg: DataPackage,
+    questions: List[Dict[str, Any]],
+    resource: Resource,
+    strategy: LoadingStrategy,
 ):
     """
     Parses questions (list of dictionaries) and adds them to the resource's schema.
diff --git a/coordo-py/pyproject.toml b/coordo-py/pyproject.toml
index 61b1534..d105112 100644
--- a/coordo-py/pyproject.toml
+++ b/coordo-py/pyproject.toml
@@ -30,5 +30,11 @@ coordo = "coordo.cli:app"
 
 [dependency-groups]
 dev = [
-    "ruff>=0.15.8",
+    "ruff>=0.15.8"
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest",
+    "ruff"
 ]

From 4c52975d8545f63b6a14722e62b7e0f5c04916d4 Mon Sep 17 00:00:00 2001
From: Olivier <coen.olivier@gmail.com>
Date: Tue, 14 Apr 2026 22:49:59 +0200
Subject: [PATCH 07/22] factorise loaders

---
 coordo-py/coordo/__init__.py                  |   7 -
 coordo-py/coordo/cli.py                       |  27 +-
 coordo-py/coordo/datapackage/__init__.py      |   3 +-
 coordo-py/coordo/datapackage/package.py       |  72 +++---
 coordo-py/coordo/loaders/__init__.py          |  10 +-
 coordo-py/coordo/loaders/file.py              |  26 --
 coordo-py/coordo/loaders/file_loader.py       |  38 +++
 .../{kobotoolbox.py => kobotoolbox_loader.py} | 244 +++++++++---------
 coordo-py/coordo/loaders/loader.py            |  39 +++
 9 files changed, 260 insertions(+), 206 deletions(-)
 delete mode 100644 coordo-py/coordo/loaders/file.py
 create mode 100644 coordo-py/coordo/loaders/file_loader.py
 rename coordo-py/coordo/loaders/{kobotoolbox.py => kobotoolbox_loader.py} (54%)
 create mode 100644 coordo-py/coordo/loaders/loader.py

diff --git a/coordo-py/coordo/__init__.py b/coordo-py/coordo/__init__.py
index 7f46c99..40c1185 100644
--- a/coordo-py/coordo/__init__.py
+++ b/coordo-py/coordo/__init__.py
@@ -2,7 +2,6 @@
 # SPDX-License-Identifier: MPL-2.0
 
 import warnings
-from enum import Enum
 
 
 # ignore warnings due to shadowing of Pydantic's "schema" field in "Resource"
@@ -23,9 +22,3 @@
     message=REGEX_TO_IGNORE,
 )
 
-
-class LoadingStrategy(str, Enum):
-    raise_error = "raise_error"
-    overwrite = "overwrite"
-    append = "append"
-    append_strict = "append_strict"
diff --git a/coordo-py/coordo/cli.py b/coordo-py/coordo/cli.py
index 1fc12fb..cb8adee 100644
--- a/coordo-py/coordo/cli.py
+++ b/coordo-py/coordo/cli.py
@@ -8,8 +8,8 @@
 import typer
 from dplib.models.schema.foreignKey import ForeignKey, ForeignKeyReference
 
-from coordo import loaders, LoadingStrategy
-from coordo.datapackage import DataPackage
+from coordo.loaders import KoboToolboxLoader, FileLoader
+from coordo.datapackage import DataPackage, ResourceExistsStrategy
 from coordo.sql.builder import build_query
 
 from .map import Map
@@ -85,32 +85,23 @@ def kobotoolbox(
     xlsdata: Path,
     package: Path = typer.Option(help="Path to the package directory"),
     strategy: Annotated[
-        LoadingStrategy,
+        ResourceExistsStrategy,
         typer.Option(help="Strategy to use in case of already existing resource"),
-    ] = LoadingStrategy.raise_error,
+    ] = ResourceExistsStrategy.raise_error,
 ):
-    dp = DataPackage.from_path(package)
-    loaders.kobotoolbox.load(dp, xlsform, xlsdata, strategy)
-    dp.save()
-
+    KoboToolboxLoader(package, xlsform, xlsdata, strategy).etl()
+    
 
 @load.command()
 def file(
     path: Path,
     package: Path = typer.Option(".", help="Path to the package directory"),
     strategy: Annotated[
-        LoadingStrategy,
+        ResourceExistsStrategy,
         typer.Option(help="Strategy to use in case of already existing resource"),
-    ] = LoadingStrategy.raise_error,
+    ] = ResourceExistsStrategy.raise_error,
 ):
-    dp = DataPackage.from_path(package)
-    try:
-        loaders.file.load(dp, path, strategy)
-    except ValueError as e:
-        raise typer.BadParameter(
-            f"{e} Add --overwrite if you wish to continue.", param_hint="path"
-        )
-    dp.save()
+    FileLoader(package, path, strategy).etl()
 
 
 app.add_typer(load, name="load")
diff --git a/coordo-py/coordo/datapackage/__init__.py b/coordo-py/coordo/datapackage/__init__.py
index b8b37a0..a535dd2 100644
--- a/coordo-py/coordo/datapackage/__init__.py
+++ b/coordo-py/coordo/datapackage/__init__.py
@@ -1,7 +1,7 @@
 # Copyright COORDONNÉES 2025, 2026
 # SPDX-License-Identifier: MPL-2.0
 
-from .package import DataPackage, Field, ForeignKeyReference
+from .package import DataPackage, Field, ForeignKeyReference, ResourceExistsStrategy
 from .resource import ForeignKey, Resource, Schema
 
 __all__ = [
@@ -11,4 +11,5 @@
     "Schema",
     "ForeignKey",
     "ForeignKeyReference",
+    "ResourceExistsStrategy"
 ]
diff --git a/coordo-py/coordo/datapackage/package.py b/coordo-py/coordo/datapackage/package.py
index 76cd18d..66a144c 100644
--- a/coordo-py/coordo/datapackage/package.py
+++ b/coordo-py/coordo/datapackage/package.py
@@ -3,6 +3,7 @@
 
 from pathlib import Path
 from typing import Iterable, Optional
+from enum import Enum
 
 import duckdb
 import geopandas as gpd
@@ -22,7 +23,6 @@
 from dplib.plugins.sql.models import SqlSchema
 from pygeofilter.ast import AstType
 
-from coordo import LoadingStrategy
 from coordo.sql.builder import build_query, compile_query
 from coordo.sql.helpers import load_conn
 
@@ -50,6 +50,13 @@ def check_resource_fields_match(res1: Resource, res2: Resource) -> None:
         )
 
 
+class ResourceExistsStrategy(str, Enum):
+    raise_error = "raise_error"
+    overwrite = "overwrite"
+    append = "append"
+    append_strict = "append_strict"
+
+
 class DataPackage(pydantic.BaseModel):
     id: Optional[str] = None
     name: str = pydantic.Field(pattern=r"^[a-z0-9._-]+$")
@@ -114,10 +121,8 @@ def remove_resource(self, name: str) -> None:
         for res in self.resources:
             if res.name == name:
                 continue
-
             # getting the schema of the resource
             res_schema = safe(res, "schema")
-
             # removing all foreign keys pointing to <resource>, if any
             # we do it in two steps: first collect all keys to remove, then remove them
             # so that we don't modify the list while iterating over it
@@ -134,14 +139,12 @@ def remove_resource(self, name: str) -> None:
             try:
                 Path(self._basepath / path).unlink()
             except FileNotFoundError:
-                raise FileNotFoundError(
-                    f"File not found: {path}. It was meant to be removed anyway but there may be an issue."
-                )
+                print(f"Could not remove {path}. File not found.")
 
         self.resources = [res for res in self.resources if res.name != name]
 
-    def add_resource_following_strategy(
-        self, resource: Resource, strategy: LoadingStrategy
+    def add_resource(
+        self, resource: Resource, strategy: ResourceExistsStrategy
     ) -> None:
         """
         Add a resource to the DataPackage according to the given strategy.
@@ -153,23 +156,24 @@ def add_resource_following_strategy(
         print(
             f"Adding resource {resource.name} to DataPackage {self.name} with strategy={strategy.name}"
         )
-        if any(
-            res.name == resource.name for res in self.resources
-        ):  # resource already exists
-            if strategy == LoadingStrategy.overwrite:  # remove and overwrite
+        if self.resource_exists(resource.name):
+            # resource already exists
+            
+            if strategy == ResourceExistsStrategy.overwrite:
+                # remove and overwrite
                 self.remove_resource(resource.name)
-                self.add_resource(resource)
+                self.append_resource_if_not_exists(resource)
 
-            elif strategy == LoadingStrategy.append:  # do nothing for now
-                pass
+            elif strategy == ResourceExistsStrategy.append:  # do nothing for now
+                self.append_resource_if_not_exists(resource)
 
-            elif (
-                strategy == LoadingStrategy.append_strict
-            ):  # just check that fields match
+            elif strategy == ResourceExistsStrategy.append_strict:
+                # just check that fields match
                 current_resource = self.get_resource(resource.name)
                 check_resource_fields_match(current_resource, resource)
+                self.append_resource_if_not_exists(resource)
 
-            elif strategy == LoadingStrategy.raise_error:
+            elif strategy == ResourceExistsStrategy.raise_error:
                 raise ValueError(
                     f"A resource named {resource.name} already exists in package {self.name}."
                 )
@@ -179,28 +183,30 @@ def add_resource_following_strategy(
                     f"Unknown strategy {strategy} for resource {resource.name}."
                 )
 
-        else:  # resource does not exist, just add it
-            self.add_resource(resource)
+        else:
+            # resource does not exist, just add it
+            self.append_resource_if_not_exists(resource)
 
-    def add_resource(self, resource: Resource) -> None:
-        if any(
-            res.name == resource.name for res in self.resources
-        ):  # check, just in case
-            raise ValueError(
-                f"A resource named {resource.name} already exists in package {self.name}."
-            )
-        resource._package = self
-        self.resources.append(resource)
+    def append_resource_if_not_exists(self, resource: Resource) -> None:
+        if self.resource_exists(resource.name):
+            print(f"A resource named {resource.name} already exists in package {self.name}.")
+        else:
+            resource._package = self
+            self.resources.append(resource)
 
     def get_resource(self, name: str) -> Resource:
-        resource = next(res for res in self.resources if res.name == name)
-        assert resource is not None, f"Resource {name} not found."
-        return resource
+        found_resources = [res for res in self.resources if res.name == name]
+        assert len(found_resources) <= 1, f"Multiple resources named {name} found."
+        assert len(found_resources) > 0, f"Resource {name} not found."
+        return found_resources[0]
 
     def write_resource(self, resource_name: str, it: Iterable[dict]):
         pass
         # resource = self.get_resource(name=resource_name)
         # schema = resource.get_schema()
+    
+    def resource_exists(self, name: str) -> bool:
+        return any(res.name == name for res in self.resources)
 
     def prepare_db(self) -> tuple[duckdb.DuckDBPyConnection, sa.MetaData]:
         conn = load_conn()
diff --git a/coordo-py/coordo/loaders/__init__.py b/coordo-py/coordo/loaders/__init__.py
index 39fbd71..6f359f2 100644
--- a/coordo-py/coordo/loaders/__init__.py
+++ b/coordo-py/coordo/loaders/__init__.py
@@ -1,6 +1,12 @@
 # Copyright COORDONNÉES 2025, 2026
 # SPDX-License-Identifier: MPL-2.0
 
-from . import file, kobotoolbox
+from .kobotoolbox_loader import KoboToolboxLoader
+from .file_loader import FileLoader
+
+
+__all__ = [
+    "KoboToolboxLoader", 
+    "FileLoader"
+]
 
-__all__ = ["kobotoolbox", "file"]
diff --git a/coordo-py/coordo/loaders/file.py b/coordo-py/coordo/loaders/file.py
deleted file mode 100644
index c29d8df..0000000
--- a/coordo-py/coordo/loaders/file.py
+++ /dev/null
@@ -1,26 +0,0 @@
-# Copyright COORDONNÉES 2025, 2026
-# SPDX-License-Identifier: MPL-2.0
-
-import shutil
-from pathlib import Path
-
-from ..datapackage import DataPackage, Field, Resource, Schema
-from ..datapackage.db_helpers import prepare_path, to_dp_type
-
-
-def load(dp: DataPackage, path: Path, overwrite=False):
-    query = f"SELECT * FROM {prepare_path(path)}"
-    conn, _ = dp.prepare_db()
-    rel = conn.sql(query)
-    schema = Schema()
-    for name, type in zip(rel.columns, rel.types):
-        schema.add_field(Field(name=name, **to_dp_type(type)))
-    conn.close()
-    dp.add_resource(
-        Resource(
-            name=path.stem,
-            path=path.name,
-            schema=schema,
-        )
-    )
-    shutil.copy(path, dp._basepath / path.name)
diff --git a/coordo-py/coordo/loaders/file_loader.py b/coordo-py/coordo/loaders/file_loader.py
new file mode 100644
index 0000000..9242c6e
--- /dev/null
+++ b/coordo-py/coordo/loaders/file_loader.py
@@ -0,0 +1,38 @@
+# Copyright COORDONNÉES 2025, 2026
+# SPDX-License-Identifier: MPL-2.0
+
+import shutil
+from pathlib import Path
+
+from coordo.loaders.loader import Loader, ResourceExistsStrategy
+from ..datapackage import DataPackage, Field, Resource, Schema
+from ..datapackage.db_helpers import prepare_path, to_dp_type
+
+
+class FileLoader(Loader):
+    
+    def __init__(self, package: Path, path: Path, strategy: ResourceExistsStrategy):
+        super().__init__(package, strategy)
+        self.path = path
+        
+    def extract(self):
+        query = f"SELECT * FROM {prepare_path(self.path)}"
+        conn, _ = self.dp.prepare_db()
+        rel = conn.sql(query)
+        schema = Schema()
+        for name, type in zip(rel.columns, rel.types):
+            schema.add_field(Field(name=name, **to_dp_type(type)))
+        conn.close()
+        # creating resurce for file
+        resource = Resource(
+            name=self.path.stem,
+            path=self.path.name,
+            schema=schema,
+        )
+        self.resources = [resource]
+    
+    def transform(self):
+        pass
+    
+    def load(self):
+        shutil.copy(self.path, self.dp._basepath / self.path.name)
diff --git a/coordo-py/coordo/loaders/kobotoolbox.py b/coordo-py/coordo/loaders/kobotoolbox_loader.py
similarity index 54%
rename from coordo-py/coordo/loaders/kobotoolbox.py
rename to coordo-py/coordo/loaders/kobotoolbox_loader.py
index e2cbe7a..f64d307 100644
--- a/coordo-py/coordo/loaders/kobotoolbox.py
+++ b/coordo-py/coordo/loaders/kobotoolbox_loader.py
@@ -14,7 +14,6 @@
 from pyxform.xls2json import parse_file_to_json
 from shapely.geometry import Point
 
-from coordo import LoadingStrategy
 from coordo.datapackage import (
     DataPackage,
     Field,
@@ -24,6 +23,7 @@
     Schema,
 )
 from coordo.helpers import safe
+from coordo.loaders.loader import Loader, ResourceExistsStrategy
 
 CONSTRAINT_GRAMMAR = r"""
 ?start: expression
@@ -135,101 +135,6 @@ def coords_to_point(coords):
         return Point(lon, lat, alt)
 
 
-def load(dp: DataPackage, xlsform: Path, xlsdata: Path, strategy: LoadingStrategy):
-    """
-    Loads a datapackage from an XLS form and XLS data file.
-    The xlsform is parsed with the pyxform.xls2json.parse_file_to_json function
-    while the xlsdata is parsed with pandas read_excel or read_csv functions.
-    """
-    # parse form from xlsform
-    print(f"Parsing form from {xlsform}")
-    form = parse_file_to_json(str(xlsform))
-    name = cast(str, form["id_string"].lower())
-    main_resource = _create_resource(name)
-
-    # parses questions from JSON form and add resources to the datapackage
-    _parse_form(dp, form, main_resource, strategy)
-
-    print(f"Parsing data from {xlsdata}")
-    if xlsdata.suffix == ".xlsx":
-        sheets_dict = pd.read_excel(xlsdata, sheet_name=None)
-    elif xlsdata.suffix == ".csv":
-        # TODO: I think this encoding is not the one from Kobo we should verify
-        sheets_dict = {
-            name: pd.read_csv(
-                xlsdata,
-                sep=";",
-                encoding="windows-1252",
-                decimal=",",
-            )
-        }
-    else:
-        raise ValueError(f"Unsupported file format: {xlsdata}")
-
-    # determine append mode based on strategy
-    append_mode = strategy in [LoadingStrategy.append, LoadingStrategy.append_strict]
-
-    print("Processing sheets...")
-    for i, (sheet_name, sheet) in enumerate(sheets_dict.items()):
-        table_name = main_resource.name if i == 0 else sheet_name.lower()
-        resource = next(r for r in dp.resources if r.name == table_name)
-        schema = safe(resource, "schema")
-        sheet = (
-            sheet.rename(
-                columns={"_parent_index": "parent_id"},
-            )
-            .convert_dtypes()
-            .replace(np.nan, None)
-        )
-        sheet[PRIMARY_KEY] = sheet.index + 1
-
-        fields = []
-        for field in schema.fields:
-            if field.name in sheet.columns:
-                if field.type == "geojson":
-                    sheet[field.name] = sheet[field.name].apply(coords_to_point)
-                if field.type == "list":
-                    sheet[field.name] = sheet[field.name].apply(
-                        lambda string: str(string).split()
-                    )
-                if field.type in DTYPES:
-                    sheet[field.name] = sheet[field.name].astype(DTYPES[field.type])
-            else:
-                print(
-                    f"Field {field.name} not found in data. Filling with empty values"
-                )
-                sheet[field.name] = ""
-            fields.append(field.name)
-
-        sheet = sheet[fields]
-        sheet = sheet.replace({np.nan: None})
-
-        path = Path(dp._basepath, table_name + ".parquet")
-        print(f"Saving {sheet_name!r} to {path}")
-
-        geo_cols = [f.name for f in schema.fields if f.type == "geojson"]
-        if geo_cols:
-            gdf = gpd.GeoDataFrame(sheet, geometry=geo_cols[0], crs="EPSG:4326")
-
-            # if append_mode, try to read existing data and concatenate
-            if append_mode:
-                pass
-
-            gdf.to_parquet(
-                path,
-                schema_version="1.1.0",
-                index=False,
-                write_covering_bbox=True,
-                geometry_encoding="WKB",  # We use this because duckdb can't open geoarrow as geometries
-            )
-        else:
-            # if append_mode, try to read existing data and concatenate
-            if append_mode:
-                pass
-
-            sheet.to_parquet(path, index=False)
-
-
 def _create_resource(name: str) -> Resource:
     return Resource(
         name=name,
@@ -241,23 +146,15 @@ def _create_resource(name: str) -> Resource:
     )
 
 
-def _parse_form(
-    pkg: DataPackage,
-    form: dict[str, Any],
-    resource: Resource,
-    strategy: LoadingStrategy,
-):
-    _parse_questions(pkg, form["children"], resource, strategy)
-    # print(resource)
-    pkg.add_resource_following_strategy(resource, strategy)
+def create_main_resource(xlsform: Path) -> Resource:
+    print(f"Parsing form from {xlsform}")
+    form = parse_file_to_json(str(xlsform))
+    name = cast(str, form["id_string"].lower())
+    return _create_resource(name)
+
 
 
-def _parse_questions(
-    pkg: DataPackage,
-    questions: List[Dict[str, Any]],
-    resource: Resource,
-    strategy: LoadingStrategy,
-):
+def _parse_questions(questions: List[Dict[str, Any]], resource: Resource) -> list[Resource]:
     """
     Parses questions (list of dictionaries) and adds them to the resource's schema.
     Example of structure of questions:
@@ -282,16 +179,20 @@ def _parse_questions(
         ]
     For each question having a 'group' type, parses recursively the children questions.
     """
+    parsed_resources: list[Resource] = []
+    
     schema = safe(resource, "schema")
     for question in questions:
         qtype = question["type"]
+        
         if qtype in METADATA_TYPES + IGNORE_TYPES:
             print("Skipping question type:", qtype)
-            continue
-        if qtype == "group":
-            _parse_questions(pkg, question["children"], resource, strategy)
-            continue
-        if qtype == "repeat":
+            
+        elif qtype == "group":
+            parsed_children_resources = _parse_questions(question["children"], resource)
+            parsed_resources += parsed_children_resources
+            
+        elif qtype == "repeat":
             child_resource = _create_resource(question["name"].lower())
             schema = safe(child_resource, "schema")
             schema.add_field(Field(name="parent_id", type="integer"))
@@ -304,9 +205,12 @@ def _parse_questions(
                     ),
                 )
             ]
-            _parse_form(pkg, question, child_resource, strategy)
-            continue
-        if qtype in DP_FIELDS:
+            parsed_resources.append(child_resource)
+            # recursively parse questions and get children resources
+            parsed_children_resources = _parse_questions(question["children"], child_resource)
+            parsed_resources += parsed_children_resources
+            
+        elif qtype in DP_FIELDS:
             kwargs = dict(name=question["name"], type=DP_FIELDS[qtype])
             if "label" in question:
                 kwargs["title"] = stringify(question["label"])
@@ -329,3 +233,105 @@ def _parse_questions(
                     for choice in question["choices"]
                 ]
             schema.fields.append(Field(**kwargs))
+
+    return parsed_resources
+
+
+class KoboToolboxLoader(Loader):
+    main_resource: Resource
+    sheets: dict[str, pd.DataFrame]
+    processed_sheets: dict[str, pd.DataFrame]
+    
+    def __init__(self, package: Path, xlsform: Path, xlsdata: Path, strategy: ResourceExistsStrategy):
+        super().__init__(package, strategy)
+        self.xlsform = xlsform
+        self.xlsdata = xlsdata
+        
+    def extract(self):
+        """
+        The xlsform is parsed with the pyxform.xls2json.parse_file_to_json function
+        while the xlsdata is parsed with pandas read_excel or read_csv functions.
+        """
+        print(f"Parsing form from {self.xlsform}")
+        form = parse_file_to_json(str(self.xlsform))
+        name = cast(str, form["id_string"].lower())
+        self.main_resource = _create_resource(name)
+        # parses questions from JSON form and add resources to the datapackage 
+        parsed_resources = _parse_questions(form["children"], self.main_resource)
+        # NOTE: we must add the main resource first so that foreign keys are resolved correctly
+        self.resources = [self.main_resource] + parsed_resources
+        
+        print(f"Parsing data from {self.xlsdata}")
+        if self.xlsdata.suffix == ".xlsx":
+            self.sheets = pd.read_excel(self.xlsdata, sheet_name=None)
+        elif self.xlsdata.suffix == ".csv":
+            # TODO: I think this encoding is not the one from Kobo we should verify
+            self.sheets = {
+                self.main_resource.name: pd.read_csv(
+                    self.xlsdata,
+                    sep=";",
+                    encoding="windows-1252",
+                    decimal=",",
+                )
+            }
+        else:
+            raise ValueError(f"Unsupported file format: {self.xlsdata}")
+            
+    def transform(self):
+        print("Processing sheets...")
+        self.processed_sheets = {}
+        for i, (sheet_name, sheet) in enumerate(self.sheets.items()):
+            table_name = self.main_resource.name if i == 0 else sheet_name.lower()
+            resource = self.dp.get_resource(table_name)
+            schema = safe(resource, "schema")
+            sheet = (
+                sheet.rename(
+                    columns={"_parent_index": "parent_id"},
+                )
+                .convert_dtypes()
+                .replace(np.nan, None)
+            )
+            sheet[PRIMARY_KEY] = sheet.index + 1
+            fields = []
+            for field in schema.fields:
+                if field.name in sheet.columns:
+                    if field.type == "geojson":
+                        sheet[field.name] = sheet[field.name].apply(coords_to_point)
+                    if field.type == "list":
+                        sheet[field.name] = sheet[field.name].apply(
+                            lambda string: str(string).split()
+                        )
+                    if field.type in DTYPES:
+                        sheet[field.name] = sheet[field.name].astype(DTYPES[field.type])
+                else:
+                    print(
+                        f"Field {field.name} not found in data. Filling with empty values"
+                    )
+                    sheet[field.name] = ""
+                fields.append(field.name)
+    
+            sheet = sheet[fields]
+            sheet = sheet.replace({np.nan: None})
+            self.processed_sheets[table_name] = sheet
+    
+    
+    def load(self):
+        for table_name, sheet in self.processed_sheets.items():
+            resource = self.dp.get_resource(table_name)
+            path = Path(self.dp._basepath, table_name + ".parquet")
+            print(f"Saving {table_name!r} to {path}")
+    
+            geo_cols = [f.name for f in resource.schema.fields if f.type == "geojson"]
+            if geo_cols:
+                gdf = gpd.GeoDataFrame(sheet, geometry=geo_cols[0], crs="EPSG:4326")
+    
+                gdf.to_parquet(
+                    path,
+                    schema_version="1.1.0",
+                    index=False,
+                    write_covering_bbox=True,
+                    geometry_encoding="WKB",  # We use this because duckdb can't open geoarrow as geometries
+                )
+            else:
+                sheet.to_parquet(path, index=False)
+    
\ No newline at end of file
diff --git a/coordo-py/coordo/loaders/loader.py b/coordo-py/coordo/loaders/loader.py
new file mode 100644
index 0000000..aca19ff
--- /dev/null
+++ b/coordo-py/coordo/loaders/loader.py
@@ -0,0 +1,39 @@
+from abc import ABC, abstractmethod
+from pathlib import Path
+
+from ..datapackage import DataPackage, ResourceExistsStrategy
+from ..datapackage.resource import Resource
+
+
+class Loader(ABC):
+    
+    def __init__(self, package: Path, strategy: ResourceExistsStrategy):
+        self.dp = DataPackage.from_path(package)
+        self.strategy = strategy
+        self.resources: list[Resource] = []
+    
+    def add_resources_to_datapackage(self):
+        for resource in self.resources:
+            self.dp.add_resource(resource, self.strategy)
+            print({res.name: res.schema.foreignKeys for res in self.dp.resources})
+        
+    def etl(self):
+        self.extract()
+        self.add_resources_to_datapackage()
+        self.transform()
+        self.load()
+        self.dp.save()
+    
+    @abstractmethod
+    def extract(self):
+        raise NotImplementedError()
+
+    
+    @abstractmethod
+    def transform(self):
+        raise NotImplementedError()
+    
+    @abstractmethod
+    def load(self):
+        raise NotImplementedError()
+

From 964bb15d6f64b02c3e289dbf0f7db40dcd49d53e Mon Sep 17 00:00:00 2001
From: Olivier <coen.olivier@gmail.com>
Date: Tue, 14 Apr 2026 23:56:06 +0200
Subject: [PATCH 08/22] pass linters

---
 .gitignore                                    |  2 +-
 coordo-py/coordo/__init__.py                  |  1 -
 coordo-py/coordo/cli.py                       |  2 +-
 coordo-py/coordo/datapackage/__init__.py      |  2 +-
 coordo-py/coordo/datapackage/package.py       |  8 +--
 coordo-py/coordo/datapackage/resource.py      |  2 +-
 coordo-py/coordo/loaders/__init__.py          |  6 +--
 coordo-py/coordo/loaders/file_loader.py       |  9 ++--
 .../coordo/loaders/kobotoolbox_loader.py      | 49 +++++++++++--------
 coordo-py/coordo/loaders/loader.py            | 15 +++---
 coordo-py/pyproject.toml                      |  8 +--
 11 files changed, 50 insertions(+), 54 deletions(-)

diff --git a/.gitignore b/.gitignore
index 20788a0..78e0287 100644
--- a/.gitignore
+++ b/.gitignore
@@ -2,4 +2,4 @@ uv.lock
 .DS_Store
 catalog/
 data/
-.vscode/
+.vscode/
\ No newline at end of file
diff --git a/coordo-py/coordo/__init__.py b/coordo-py/coordo/__init__.py
index 40c1185..ae7a756 100644
--- a/coordo-py/coordo/__init__.py
+++ b/coordo-py/coordo/__init__.py
@@ -21,4 +21,3 @@
     module="coordo",
     message=REGEX_TO_IGNORE,
 )
-
diff --git a/coordo-py/coordo/cli.py b/coordo-py/coordo/cli.py
index cb8adee..8756229 100644
--- a/coordo-py/coordo/cli.py
+++ b/coordo-py/coordo/cli.py
@@ -90,7 +90,7 @@ def kobotoolbox(
     ] = ResourceExistsStrategy.raise_error,
 ):
     KoboToolboxLoader(package, xlsform, xlsdata, strategy).etl()
-    
+
 
 @load.command()
 def file(
diff --git a/coordo-py/coordo/datapackage/__init__.py b/coordo-py/coordo/datapackage/__init__.py
index a535dd2..6bc8608 100644
--- a/coordo-py/coordo/datapackage/__init__.py
+++ b/coordo-py/coordo/datapackage/__init__.py
@@ -11,5 +11,5 @@
     "Schema",
     "ForeignKey",
     "ForeignKeyReference",
-    "ResourceExistsStrategy"
+    "ResourceExistsStrategy",
 ]
diff --git a/coordo-py/coordo/datapackage/package.py b/coordo-py/coordo/datapackage/package.py
index 66a144c..27330ac 100644
--- a/coordo-py/coordo/datapackage/package.py
+++ b/coordo-py/coordo/datapackage/package.py
@@ -158,7 +158,7 @@ def add_resource(
         )
         if self.resource_exists(resource.name):
             # resource already exists
-            
+
             if strategy == ResourceExistsStrategy.overwrite:
                 # remove and overwrite
                 self.remove_resource(resource.name)
@@ -189,7 +189,9 @@ def add_resource(
 
     def append_resource_if_not_exists(self, resource: Resource) -> None:
         if self.resource_exists(resource.name):
-            print(f"A resource named {resource.name} already exists in package {self.name}.")
+            print(
+                f"A resource named {resource.name} already exists in package {self.name}."
+            )
         else:
             resource._package = self
             self.resources.append(resource)
@@ -204,7 +206,7 @@ def write_resource(self, resource_name: str, it: Iterable[dict]):
         pass
         # resource = self.get_resource(name=resource_name)
         # schema = resource.get_schema()
-    
+
     def resource_exists(self, name: str) -> bool:
         return any(res.name == name for res in self.resources)
 
diff --git a/coordo-py/coordo/datapackage/resource.py b/coordo-py/coordo/datapackage/resource.py
index 33d4fc7..48eea1d 100644
--- a/coordo-py/coordo/datapackage/resource.py
+++ b/coordo-py/coordo/datapackage/resource.py
@@ -72,7 +72,7 @@ def add_foreignkey(self, fk: ForeignKey) -> None:
     def remove_foreignkey(self, fk: ForeignKey) -> None:
         if fk not in self.schema.foreignKeys:
             raise ValueError(f"Foreign key {fk} not found in resource {self.name}")
-        self.schema.foreignKeys.remove(fk)        
+        self.schema.foreignKeys.remove(fk)
 
     @model_validator(mode="after")
     def check_data_or_path(self) -> Self:
diff --git a/coordo-py/coordo/loaders/__init__.py b/coordo-py/coordo/loaders/__init__.py
index 6f359f2..d00e8be 100644
--- a/coordo-py/coordo/loaders/__init__.py
+++ b/coordo-py/coordo/loaders/__init__.py
@@ -5,8 +5,4 @@
 from .file_loader import FileLoader
 
 
-__all__ = [
-    "KoboToolboxLoader", 
-    "FileLoader"
-]
-
+__all__ = ["KoboToolboxLoader", "FileLoader"]
diff --git a/coordo-py/coordo/loaders/file_loader.py b/coordo-py/coordo/loaders/file_loader.py
index 9242c6e..4e23082 100644
--- a/coordo-py/coordo/loaders/file_loader.py
+++ b/coordo-py/coordo/loaders/file_loader.py
@@ -5,16 +5,15 @@
 from pathlib import Path
 
 from coordo.loaders.loader import Loader, ResourceExistsStrategy
-from ..datapackage import DataPackage, Field, Resource, Schema
+from ..datapackage import Field, Resource, Schema
 from ..datapackage.db_helpers import prepare_path, to_dp_type
 
 
 class FileLoader(Loader):
-    
     def __init__(self, package: Path, path: Path, strategy: ResourceExistsStrategy):
         super().__init__(package, strategy)
         self.path = path
-        
+
     def extract(self):
         query = f"SELECT * FROM {prepare_path(self.path)}"
         conn, _ = self.dp.prepare_db()
@@ -30,9 +29,9 @@ def extract(self):
             schema=schema,
         )
         self.resources = [resource]
-    
+
     def transform(self):
         pass
-    
+
     def load(self):
         shutil.copy(self.path, self.dp._basepath / self.path.name)
diff --git a/coordo-py/coordo/loaders/kobotoolbox_loader.py b/coordo-py/coordo/loaders/kobotoolbox_loader.py
index f64d307..82520a4 100644
--- a/coordo-py/coordo/loaders/kobotoolbox_loader.py
+++ b/coordo-py/coordo/loaders/kobotoolbox_loader.py
@@ -15,7 +15,6 @@
 from shapely.geometry import Point
 
 from coordo.datapackage import (
-    DataPackage,
     Field,
     ForeignKey,
     ForeignKeyReference,
@@ -153,8 +152,9 @@ def create_main_resource(xlsform: Path) -> Resource:
     return _create_resource(name)
 
 
-
-def _parse_questions(questions: List[Dict[str, Any]], resource: Resource) -> list[Resource]:
+def _parse_questions(
+    questions: List[Dict[str, Any]], resource: Resource
+) -> list[Resource]:
     """
     Parses questions (list of dictionaries) and adds them to the resource's schema.
     Example of structure of questions:
@@ -180,18 +180,18 @@ def _parse_questions(questions: List[Dict[str, Any]], resource: Resource) -> lis
     For each question having a 'group' type, parses recursively the children questions.
     """
     parsed_resources: list[Resource] = []
-    
+
     schema = safe(resource, "schema")
     for question in questions:
         qtype = question["type"]
-        
+
         if qtype in METADATA_TYPES + IGNORE_TYPES:
             print("Skipping question type:", qtype)
-            
+
         elif qtype == "group":
             parsed_children_resources = _parse_questions(question["children"], resource)
             parsed_resources += parsed_children_resources
-            
+
         elif qtype == "repeat":
             child_resource = _create_resource(question["name"].lower())
             schema = safe(child_resource, "schema")
@@ -207,9 +207,11 @@ def _parse_questions(questions: List[Dict[str, Any]], resource: Resource) -> lis
             ]
             parsed_resources.append(child_resource)
             # recursively parse questions and get children resources
-            parsed_children_resources = _parse_questions(question["children"], child_resource)
+            parsed_children_resources = _parse_questions(
+                question["children"], child_resource
+            )
             parsed_resources += parsed_children_resources
-            
+
         elif qtype in DP_FIELDS:
             kwargs = dict(name=question["name"], type=DP_FIELDS[qtype])
             if "label" in question:
@@ -241,12 +243,18 @@ class KoboToolboxLoader(Loader):
     main_resource: Resource
     sheets: dict[str, pd.DataFrame]
     processed_sheets: dict[str, pd.DataFrame]
-    
-    def __init__(self, package: Path, xlsform: Path, xlsdata: Path, strategy: ResourceExistsStrategy):
+
+    def __init__(
+        self,
+        package: Path,
+        xlsform: Path,
+        xlsdata: Path,
+        strategy: ResourceExistsStrategy,
+    ):
         super().__init__(package, strategy)
         self.xlsform = xlsform
         self.xlsdata = xlsdata
-        
+
     def extract(self):
         """
         The xlsform is parsed with the pyxform.xls2json.parse_file_to_json function
@@ -256,11 +264,11 @@ def extract(self):
         form = parse_file_to_json(str(self.xlsform))
         name = cast(str, form["id_string"].lower())
         self.main_resource = _create_resource(name)
-        # parses questions from JSON form and add resources to the datapackage 
+        # parses questions from JSON form and add resources to the datapackage
         parsed_resources = _parse_questions(form["children"], self.main_resource)
         # NOTE: we must add the main resource first so that foreign keys are resolved correctly
         self.resources = [self.main_resource] + parsed_resources
-        
+
         print(f"Parsing data from {self.xlsdata}")
         if self.xlsdata.suffix == ".xlsx":
             self.sheets = pd.read_excel(self.xlsdata, sheet_name=None)
@@ -276,7 +284,7 @@ def extract(self):
             }
         else:
             raise ValueError(f"Unsupported file format: {self.xlsdata}")
-            
+
     def transform(self):
         print("Processing sheets...")
         self.processed_sheets = {}
@@ -309,22 +317,22 @@ def transform(self):
                     )
                     sheet[field.name] = ""
                 fields.append(field.name)
-    
+
             sheet = sheet[fields]
             sheet = sheet.replace({np.nan: None})
             self.processed_sheets[table_name] = sheet
-    
-    
+
     def load(self):
+        print("Loading data...")
         for table_name, sheet in self.processed_sheets.items():
             resource = self.dp.get_resource(table_name)
             path = Path(self.dp._basepath, table_name + ".parquet")
             print(f"Saving {table_name!r} to {path}")
-    
+
             geo_cols = [f.name for f in resource.schema.fields if f.type == "geojson"]
             if geo_cols:
                 gdf = gpd.GeoDataFrame(sheet, geometry=geo_cols[0], crs="EPSG:4326")
-    
+
                 gdf.to_parquet(
                     path,
                     schema_version="1.1.0",
@@ -334,4 +342,3 @@ def load(self):
                 )
             else:
                 sheet.to_parquet(path, index=False)
-    
\ No newline at end of file
diff --git a/coordo-py/coordo/loaders/loader.py b/coordo-py/coordo/loaders/loader.py
index aca19ff..080431d 100644
--- a/coordo-py/coordo/loaders/loader.py
+++ b/coordo-py/coordo/loaders/loader.py
@@ -1,3 +1,6 @@
+# Copyright COORDONNÉES 2025, 2026
+# SPDX-License-Identifier: MPL-2.0
+
 from abc import ABC, abstractmethod
 from pathlib import Path
 
@@ -6,34 +9,30 @@
 
 
 class Loader(ABC):
-    
     def __init__(self, package: Path, strategy: ResourceExistsStrategy):
         self.dp = DataPackage.from_path(package)
         self.strategy = strategy
         self.resources: list[Resource] = []
-    
+
     def add_resources_to_datapackage(self):
         for resource in self.resources:
             self.dp.add_resource(resource, self.strategy)
-            print({res.name: res.schema.foreignKeys for res in self.dp.resources})
-        
+
     def etl(self):
         self.extract()
         self.add_resources_to_datapackage()
         self.transform()
         self.load()
         self.dp.save()
-    
+
     @abstractmethod
     def extract(self):
         raise NotImplementedError()
 
-    
     @abstractmethod
     def transform(self):
         raise NotImplementedError()
-    
+
     @abstractmethod
     def load(self):
         raise NotImplementedError()
-
diff --git a/coordo-py/pyproject.toml b/coordo-py/pyproject.toml
index d105112..61b1534 100644
--- a/coordo-py/pyproject.toml
+++ b/coordo-py/pyproject.toml
@@ -30,11 +30,5 @@ coordo = "coordo.cli:app"
 
 [dependency-groups]
 dev = [
-    "ruff>=0.15.8"
-]
-
-[project.optional-dependencies]
-dev = [
-    "pytest",
-    "ruff"
+    "ruff>=0.15.8",
 ]

From f7698f4cb4eabf385f94b5d5cfb44ca05ea86839 Mon Sep 17 00:00:00 2001
From: Olivier <coen.olivier@gmail.com>
Date: Thu, 16 Apr 2026 16:24:50 +0200
Subject: [PATCH 09/22] address first comments for review

---
 coordo-py/coordo/datapackage/package.py  | 11 +++--------
 coordo-py/coordo/datapackage/resource.py |  6 ++++++
 2 files changed, 9 insertions(+), 8 deletions(-)

diff --git a/coordo-py/coordo/datapackage/package.py b/coordo-py/coordo/datapackage/package.py
index 27330ac..37ecca7 100644
--- a/coordo-py/coordo/datapackage/package.py
+++ b/coordo-py/coordo/datapackage/package.py
@@ -42,11 +42,9 @@ def handle_path(path: str | list[str]) -> str:
 
 
 def check_resource_fields_match(res1: Resource, res2: Resource) -> None:
-    res1_field_names = [field.name for field in res1.schema.fields]
-    res2_field_names = [field.name for field in res2.schema.fields]
-    if set(res1_field_names) != set(res2_field_names):
+    if not res1.has_same_schema_as(res2):
         raise ValueError(
-            f"Field names do not match for resource {res1.name}: {sorted(res1_field_names)} != {sorted(res2_field_names)}"
+            f"Schemas do not match for resources {res1.name!r} and {res2.name!r}"
         )
 
 
@@ -136,10 +134,7 @@ def remove_resource(self, name: str) -> None:
 
         if resource.path:
             path = handle_path(resource.path)
-            try:
-                Path(self._basepath / path).unlink()
-            except FileNotFoundError:
-                print(f"Could not remove {path}. File not found.")
+            Path(self._basepath / path).unlink()
 
         self.resources = [res for res in self.resources if res.name != name]
 
diff --git a/coordo-py/coordo/datapackage/resource.py b/coordo-py/coordo/datapackage/resource.py
index 48eea1d..d102ce9 100644
--- a/coordo-py/coordo/datapackage/resource.py
+++ b/coordo-py/coordo/datapackage/resource.py
@@ -81,3 +81,9 @@ def check_data_or_path(self) -> Self:
         if count != 1:
             raise ValueError("Exactly one of 'data' or 'path' must be provided.")
         return self
+
+    def has_same_schema_as(self, other: Self) -> bool:
+        for attr in vars(self.schema):
+            if getattr(self.schema, attr) != getattr(other.schema, attr):
+                return False
+        return True
\ No newline at end of file

From c1d8911154ba7e3d5fb1dff4c6e131269f372db3 Mon Sep 17 00:00:00 2001
From: Olivier <coen.olivier@gmail.com>
Date: Thu, 16 Apr 2026 23:19:25 +0200
Subject: [PATCH 10/22] simplify resouce handling by datapackage

---
 coordo-py/coordo/cli.py                       | 19 ++--
 coordo-py/coordo/datapackage/__init__.py      |  3 +-
 coordo-py/coordo/datapackage/package.py       | 91 ++++---------------
 coordo-py/coordo/datapackage/resource.py      |  2 +-
 coordo-py/coordo/loaders/__init__.py          |  3 +-
 coordo-py/coordo/loaders/file_loader.py       |  6 +-
 .../coordo/loaders/kobotoolbox_loader.py      |  6 +-
 coordo-py/coordo/loaders/loader.py            | 33 +++++--
 8 files changed, 59 insertions(+), 104 deletions(-)

diff --git a/coordo-py/coordo/cli.py b/coordo-py/coordo/cli.py
index 8756229..9b88c89 100644
--- a/coordo-py/coordo/cli.py
+++ b/coordo-py/coordo/cli.py
@@ -3,13 +3,12 @@
 
 import signal
 from pathlib import Path
-from typing import Annotated
 
 import typer
 from dplib.models.schema.foreignKey import ForeignKey, ForeignKeyReference
 
-from coordo.loaders import KoboToolboxLoader, FileLoader
-from coordo.datapackage import DataPackage, ResourceExistsStrategy
+from coordo.loaders import ResourceAction, KoboToolboxLoader, FileLoader
+from coordo.datapackage import DataPackage
 from coordo.sql.builder import build_query
 
 from .map import Map
@@ -84,24 +83,18 @@ def kobotoolbox(
     xlsform: Path,
     xlsdata: Path,
     package: Path = typer.Option(help="Path to the package directory"),
-    strategy: Annotated[
-        ResourceExistsStrategy,
-        typer.Option(help="Strategy to use in case of already existing resource"),
-    ] = ResourceExistsStrategy.raise_error,
+    action: ResourceAction = typer.Option(help="Action to perform on resource"),
 ):
-    KoboToolboxLoader(package, xlsform, xlsdata, strategy).etl()
+    KoboToolboxLoader(package, xlsform, xlsdata, action).etl()
 
 
 @load.command()
 def file(
     path: Path,
     package: Path = typer.Option(".", help="Path to the package directory"),
-    strategy: Annotated[
-        ResourceExistsStrategy,
-        typer.Option(help="Strategy to use in case of already existing resource"),
-    ] = ResourceExistsStrategy.raise_error,
+    action: ResourceAction = typer.Option(help="Action to perform on resource"),
 ):
-    FileLoader(package, path, strategy).etl()
+    FileLoader(package, path, action).etl()
 
 
 app.add_typer(load, name="load")
diff --git a/coordo-py/coordo/datapackage/__init__.py b/coordo-py/coordo/datapackage/__init__.py
index 6bc8608..b8b37a0 100644
--- a/coordo-py/coordo/datapackage/__init__.py
+++ b/coordo-py/coordo/datapackage/__init__.py
@@ -1,7 +1,7 @@
 # Copyright COORDONNÉES 2025, 2026
 # SPDX-License-Identifier: MPL-2.0
 
-from .package import DataPackage, Field, ForeignKeyReference, ResourceExistsStrategy
+from .package import DataPackage, Field, ForeignKeyReference
 from .resource import ForeignKey, Resource, Schema
 
 __all__ = [
@@ -11,5 +11,4 @@
     "Schema",
     "ForeignKey",
     "ForeignKeyReference",
-    "ResourceExistsStrategy",
 ]
diff --git a/coordo-py/coordo/datapackage/package.py b/coordo-py/coordo/datapackage/package.py
index 37ecca7..fc718c7 100644
--- a/coordo-py/coordo/datapackage/package.py
+++ b/coordo-py/coordo/datapackage/package.py
@@ -3,7 +3,6 @@
 
 from pathlib import Path
 from typing import Iterable, Optional
-from enum import Enum
 
 import duckdb
 import geopandas as gpd
@@ -48,13 +47,6 @@ def check_resource_fields_match(res1: Resource, res2: Resource) -> None:
         )
 
 
-class ResourceExistsStrategy(str, Enum):
-    raise_error = "raise_error"
-    overwrite = "overwrite"
-    append = "append"
-    append_strict = "append_strict"
-
-
 class DataPackage(pydantic.BaseModel):
     id: Optional[str] = None
     name: str = pydantic.Field(pattern=r"^[a-z0-9._-]+$")
@@ -107,94 +99,51 @@ def save(self):
 
     def remove_resource(self, name: str) -> None:
         """
-        Remove a resource from the package:
-        - for all other resources in the current datapackage, remove any foreign keys pointing to this resource.
-        - remove the file associated with the resource.
+        Remove a resource from the package.
+        For all other resources in the current datapackage, check if they have a foreign key pointing to this resource
+        and raise error it if so.
         Args:
             name (str): the name of the resource to remove
         """
-        print(f"Removing resource {name} from DataPackage {self.name}")
+        print(f"Removing resource {name!r} from DataPackage {self.name!r}")
         resource = self.get_resource(name=name)
         # looping over all resources in the current datapackage, other than <resource>
         for res in self.resources:
             if res.name == name:
                 continue
-            # getting the schema of the resource
             res_schema = safe(res, "schema")
-            # removing all foreign keys pointing to <resource>, if any
-            # we do it in two steps: first collect all keys to remove, then remove them
-            # so that we don't modify the list while iterating over it
             if res_schema.foreignKeys:
-                foreign_keys_to_remove = []
                 for fk in res_schema.foreignKeys:
                     if fk.reference.resource == name:
-                        foreign_keys_to_remove.append(fk)
-                for fk in foreign_keys_to_remove:
-                    res.remove_foreignkey(fk)
-
+                        raise ValueError(
+                            f"Can't remove the resource {name!r} : {res.name!r} has a foreign key pointing to this resource. "
+                            "Please remove this foreign key before removing this resource."
+                        )
+        # remove the file associated with the resource
         if resource.path:
             path = handle_path(resource.path)
             Path(self._basepath / path).unlink()
-
+        # update resources list
         self.resources = [res for res in self.resources if res.name != name]
 
-    def add_resource(
-        self, resource: Resource, strategy: ResourceExistsStrategy
-    ) -> None:
-        """
-        Add a resource to the DataPackage according to the given strategy.
-
-        Args:
-            resource (Resource): The resource to add.
-            strategy (LoadingStrategy): The strategy to use when a resource with the same name already exists.
-        """
-        print(
-            f"Adding resource {resource.name} to DataPackage {self.name} with strategy={strategy.name}"
-        )
-        if self.resource_exists(resource.name):
-            # resource already exists
-
-            if strategy == ResourceExistsStrategy.overwrite:
-                # remove and overwrite
-                self.remove_resource(resource.name)
-                self.append_resource_if_not_exists(resource)
-
-            elif strategy == ResourceExistsStrategy.append:  # do nothing for now
-                self.append_resource_if_not_exists(resource)
-
-            elif strategy == ResourceExistsStrategy.append_strict:
-                # just check that fields match
-                current_resource = self.get_resource(resource.name)
-                check_resource_fields_match(current_resource, resource)
-                self.append_resource_if_not_exists(resource)
-
-            elif strategy == ResourceExistsStrategy.raise_error:
-                raise ValueError(
-                    f"A resource named {resource.name} already exists in package {self.name}."
-                )
-
-            else:
-                raise ValueError(
-                    f"Unknown strategy {strategy} for resource {resource.name}."
-                )
-
-        else:
-            # resource does not exist, just add it
-            self.append_resource_if_not_exists(resource)
-
-    def append_resource_if_not_exists(self, resource: Resource) -> None:
+    def add_resource(self, resource: Resource) -> None:
+        print(f"Adding resource {resource.name!r} to package {self.name!r}")
         if self.resource_exists(resource.name):
-            print(
-                f"A resource named {resource.name} already exists in package {self.name}."
+            raise ValueError(
+                f"A resource named {resource.name!r} already exists in package {self.name!r}. "
+                "Please remove the existing resource before adding a new one."
             )
         else:
             resource._package = self
             self.resources.append(resource)
 
+    def update_resource(self, resource: Resource) -> None:
+        pass
+
     def get_resource(self, name: str) -> Resource:
         found_resources = [res for res in self.resources if res.name == name]
-        assert len(found_resources) <= 1, f"Multiple resources named {name} found."
-        assert len(found_resources) > 0, f"Resource {name} not found."
+        assert len(found_resources) <= 1, f"Multiple resources named {name!r} found."
+        assert len(found_resources) > 0, f"Resource {name!r} not found."
         return found_resources[0]
 
     def write_resource(self, resource_name: str, it: Iterable[dict]):
diff --git a/coordo-py/coordo/datapackage/resource.py b/coordo-py/coordo/datapackage/resource.py
index d102ce9..1eada9c 100644
--- a/coordo-py/coordo/datapackage/resource.py
+++ b/coordo-py/coordo/datapackage/resource.py
@@ -86,4 +86,4 @@ def has_same_schema_as(self, other: Self) -> bool:
         for attr in vars(self.schema):
             if getattr(self.schema, attr) != getattr(other.schema, attr):
                 return False
-        return True
\ No newline at end of file
+        return True
diff --git a/coordo-py/coordo/loaders/__init__.py b/coordo-py/coordo/loaders/__init__.py
index d00e8be..b2cee98 100644
--- a/coordo-py/coordo/loaders/__init__.py
+++ b/coordo-py/coordo/loaders/__init__.py
@@ -1,8 +1,9 @@
 # Copyright COORDONNÉES 2025, 2026
 # SPDX-License-Identifier: MPL-2.0
 
+from .loader import ResourceAction
 from .kobotoolbox_loader import KoboToolboxLoader
 from .file_loader import FileLoader
 
 
-__all__ = ["KoboToolboxLoader", "FileLoader"]
+__all__ = ["ResourceAction", "KoboToolboxLoader", "FileLoader"]
diff --git a/coordo-py/coordo/loaders/file_loader.py b/coordo-py/coordo/loaders/file_loader.py
index 4e23082..4743a3f 100644
--- a/coordo-py/coordo/loaders/file_loader.py
+++ b/coordo-py/coordo/loaders/file_loader.py
@@ -4,14 +4,14 @@
 import shutil
 from pathlib import Path
 
-from coordo.loaders.loader import Loader, ResourceExistsStrategy
+from coordo.loaders.loader import Loader, ResourceAction
 from ..datapackage import Field, Resource, Schema
 from ..datapackage.db_helpers import prepare_path, to_dp_type
 
 
 class FileLoader(Loader):
-    def __init__(self, package: Path, path: Path, strategy: ResourceExistsStrategy):
-        super().__init__(package, strategy)
+    def __init__(self, package: Path, path: Path, action: ResourceAction):
+        super().__init__(package, action)
         self.path = path
 
     def extract(self):
diff --git a/coordo-py/coordo/loaders/kobotoolbox_loader.py b/coordo-py/coordo/loaders/kobotoolbox_loader.py
index 82520a4..7ae81e1 100644
--- a/coordo-py/coordo/loaders/kobotoolbox_loader.py
+++ b/coordo-py/coordo/loaders/kobotoolbox_loader.py
@@ -22,7 +22,7 @@
     Schema,
 )
 from coordo.helpers import safe
-from coordo.loaders.loader import Loader, ResourceExistsStrategy
+from coordo.loaders.loader import Loader, ResourceAction
 
 CONSTRAINT_GRAMMAR = r"""
 ?start: expression
@@ -249,9 +249,9 @@ def __init__(
         package: Path,
         xlsform: Path,
         xlsdata: Path,
-        strategy: ResourceExistsStrategy,
+        action: ResourceAction,
     ):
-        super().__init__(package, strategy)
+        super().__init__(package, action)
         self.xlsform = xlsform
         self.xlsdata = xlsdata
 
diff --git a/coordo-py/coordo/loaders/loader.py b/coordo-py/coordo/loaders/loader.py
index 080431d..9cebe50 100644
--- a/coordo-py/coordo/loaders/loader.py
+++ b/coordo-py/coordo/loaders/loader.py
@@ -3,28 +3,41 @@
 
 from abc import ABC, abstractmethod
 from pathlib import Path
+from enum import Enum
 
-from ..datapackage import DataPackage, ResourceExistsStrategy
+from ..datapackage import DataPackage
 from ..datapackage.resource import Resource
 
 
+class ResourceAction(str, Enum):
+    ADD = "add"
+    UPDATE = "update"
+    REMOVE = "remove"
+
+
 class Loader(ABC):
-    def __init__(self, package: Path, strategy: ResourceExistsStrategy):
+    def __init__(self, package: Path, action: ResourceAction):
         self.dp = DataPackage.from_path(package)
-        self.strategy = strategy
+        self.action = action
         self.resources: list[Resource] = []
 
-    def add_resources_to_datapackage(self):
-        for resource in self.resources:
-            self.dp.add_resource(resource, self.strategy)
-
     def etl(self):
         self.extract()
-        self.add_resources_to_datapackage()
-        self.transform()
-        self.load()
+        self.handle_resources()
+        if self.action in [ResourceAction.ADD, ResourceAction.UPDATE]:
+            self.transform()
+            self.load()
         self.dp.save()
 
+    def handle_resources(self):
+        for resource in self.resources:
+            if self.action == ResourceAction.ADD:
+                self.dp.add_resource(resource)
+            elif self.action == ResourceAction.UPDATE:
+                self.dp.update_resource(resource)
+            elif self.action == ResourceAction.REMOVE:
+                self.dp.remove_resource(resource.name)
+
     @abstractmethod
     def extract(self):
         raise NotImplementedError()

From 46ae7bcf9d4f03103dc42397c9d51a07de21051a Mon Sep 17 00:00:00 2001
From: Olivier <coen.olivier@gmail.com>
Date: Sat, 18 Apr 2026 07:30:10 +0200
Subject: [PATCH 11/22] add list of individual foreign keys to remove in error
 message

---
 coordo-py/coordo/datapackage/package.py | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/coordo-py/coordo/datapackage/package.py b/coordo-py/coordo/datapackage/package.py
index fc718c7..d2b7619 100644
--- a/coordo-py/coordo/datapackage/package.py
+++ b/coordo-py/coordo/datapackage/package.py
@@ -115,9 +115,15 @@ def remove_resource(self, name: str) -> None:
             if res_schema.foreignKeys:
                 for fk in res_schema.foreignKeys:
                     if fk.reference.resource == name:
+                        # build the list of foreign key field pairs
+                        fk_part_names = [
+                            f"'{res.name}.{field}' -> '{fk.reference.resource}.{reference_field}'"
+                            for field, reference_field in zip(fk.fields, fk.reference.fields)
+                        ]
+                        fk_part_names_str = "\n".join(fk_part_names)
                         raise ValueError(
                             f"Can't remove the resource {name!r} : {res.name!r} has a foreign key pointing to this resource. "
-                            "Please remove this foreign key before removing this resource."
+                            f"Please remove the following foreign keys beforehand:\n{fk_part_names_str}"
                         )
         # remove the file associated with the resource
         if resource.path:

From 5649e71b86000e80f4517e0ae7de7cfe345cf76f Mon Sep 17 00:00:00 2001
From: Olivier <coen.olivier@gmail.com>
Date: Sat, 18 Apr 2026 08:55:17 +0200
Subject: [PATCH 12/22] update addition of foreign key

---
 coordo-py/coordo/cli.py                  | 11 +++--------
 coordo-py/coordo/datapackage/package.py  |  8 ++------
 coordo-py/coordo/datapackage/resource.py | 23 +++++++++++++++++++++--
 3 files changed, 26 insertions(+), 16 deletions(-)

diff --git a/coordo-py/coordo/cli.py b/coordo-py/coordo/cli.py
index 9b88c89..8d3e497 100644
--- a/coordo-py/coordo/cli.py
+++ b/coordo-py/coordo/cli.py
@@ -5,7 +5,6 @@
 from pathlib import Path
 
 import typer
-from dplib.models.schema.foreignKey import ForeignKey, ForeignKeyReference
 
 from coordo.loaders import ResourceAction, KoboToolboxLoader, FileLoader
 from coordo.datapackage import DataPackage
@@ -112,13 +111,9 @@ def add_foreignkey(
     dp.get_resource(
         resource,
     ).add_foreignkey(
-        ForeignKey(
-            fields=[field],
-            reference=ForeignKeyReference(
-                fields=[foreign_field],
-                resource=None if resource == foreign_resource else foreign_resource,
-            ),
-        ),
+        fields=[field],
+        foreign_fields=[foreign_field],
+        foreign_resource=foreign_resource,
     )
     dp.save()
 
diff --git a/coordo-py/coordo/datapackage/package.py b/coordo-py/coordo/datapackage/package.py
index d2b7619..fb6e882 100644
--- a/coordo-py/coordo/datapackage/package.py
+++ b/coordo-py/coordo/datapackage/package.py
@@ -115,12 +115,8 @@ def remove_resource(self, name: str) -> None:
             if res_schema.foreignKeys:
                 for fk in res_schema.foreignKeys:
                     if fk.reference.resource == name:
-                        # build the list of foreign key field pairs
-                        fk_part_names = [
-                            f"'{res.name}.{field}' -> '{fk.reference.resource}.{reference_field}'"
-                            for field, reference_field in zip(fk.fields, fk.reference.fields)
-                        ]
-                        fk_part_names_str = "\n".join(fk_part_names)
+                        # build a string containing the list of foreign key field pairs 
+                        fk_part_names_str = "\n".join(res.get_fk_names(fk))
                         raise ValueError(
                             f"Can't remove the resource {name!r} : {res.name!r} has a foreign key pointing to this resource. "
                             f"Please remove the following foreign keys beforehand:\n{fk_part_names_str}"
diff --git a/coordo-py/coordo/datapackage/resource.py b/coordo-py/coordo/datapackage/resource.py
index 1eada9c..4b9b45f 100644
--- a/coordo-py/coordo/datapackage/resource.py
+++ b/coordo-py/coordo/datapackage/resource.py
@@ -5,7 +5,7 @@
 
 import duckdb
 import pydantic
-from dplib.models import Contributor, Dialect, ForeignKey, License, Schema, Source
+from dplib.models import Contributor, Dialect, ForeignKey, ForeignKeyReference, License, Schema, Source
 from pydantic import model_validator
 
 from .db_helpers import prepare_path
@@ -50,13 +50,25 @@ def load_table(self, conn: duckdb.DuckDBPyConnection):
         query = f'CREATE VIEW "{self.name}" AS SELECT * FROM {prepare_path(self.package._basepath / self.path)}'
         conn.execute(query)
 
-    def add_foreignkey(self, fk: ForeignKey) -> None:
+    def add_foreignkey(self, fields: list[str], foreign_fields: list[str], foreign_resource: str) -> None:
+        fk = ForeignKey(
+            fields=fields,
+            reference=ForeignKeyReference(
+                fields=foreign_fields,
+                resource=None if self.name == foreign_resource else foreign_resource,
+            )
+        )
+        fk_part_names_str = ", ".join(self.get_fk_names(fk))
+        print(f"Adding foreign key {fk_part_names_str}")
+        
         if not self._package:
             raise ValueError("You can't add a foreign key to an orphan resource.")
+            
         field_names = [f.name for f in self.schema.fields]
         for f in fk.fields:
             if f not in field_names:
                 raise ValueError(f"Resource {self.name} has no field named {f}")
+                
         parent_resource = (
             self._package.get_resource(name=fk.reference.resource)
             if fk.reference.resource
@@ -67,6 +79,7 @@ def add_foreignkey(self, fk: ForeignKey) -> None:
             assert f in field_names, (
                 f"Resource {parent_resource.name} has no field named {f}"
             )
+            
         self.schema.foreignKeys.append(fk)
 
     def remove_foreignkey(self, fk: ForeignKey) -> None:
@@ -87,3 +100,9 @@ def has_same_schema_as(self, other: Self) -> bool:
             if getattr(self.schema, attr) != getattr(other.schema, attr):
                 return False
         return True
+    
+    def get_fk_names(self, fk: ForeignKey) -> list[str]:
+        return [
+            f"'{self.name}.{field}' -> '{fk.reference.resource}.{reference_field}'"
+            for field, reference_field in zip(fk.fields, fk.reference.fields)
+        ]

From e7cee9b1aefcd98660e0756bc345a140ce963beb Mon Sep 17 00:00:00 2001
From: Olivier <coen.olivier@gmail.com>
Date: Sat, 18 Apr 2026 09:00:56 +0200
Subject: [PATCH 13/22] add error when foreign key exists

---
 coordo-py/coordo/datapackage/resource.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/coordo-py/coordo/datapackage/resource.py b/coordo-py/coordo/datapackage/resource.py
index 4b9b45f..9ef97cc 100644
--- a/coordo-py/coordo/datapackage/resource.py
+++ b/coordo-py/coordo/datapackage/resource.py
@@ -58,7 +58,7 @@ def add_foreignkey(self, fields: list[str], foreign_fields: list[str], foreign_r
                 resource=None if self.name == foreign_resource else foreign_resource,
             )
         )
-        fk_part_names_str = ", ".join(self.get_fk_names(fk))
+        fk_part_names_str = " & ".join(self.get_fk_names(fk))
         print(f"Adding foreign key {fk_part_names_str}")
         
         if not self._package:
@@ -79,6 +79,9 @@ def add_foreignkey(self, fields: list[str], foreign_fields: list[str], foreign_r
             assert f in field_names, (
                 f"Resource {parent_resource.name} has no field named {f}"
             )
+        
+        if fk in self.schema.foreignKeys:
+            raise ValueError(f"Foreign key {fk_part_names_str} already exists in resource {self.name}")
             
         self.schema.foreignKeys.append(fk)
 

From 5c37c8f6c9b22c1c58729310cfb57a94a3eceac5 Mon Sep 17 00:00:00 2001
From: Olivier <coen.olivier@gmail.com>
Date: Sat, 18 Apr 2026 15:14:41 +0200
Subject: [PATCH 14/22] add cli for removing foreign key

---
 coordo-py/coordo/cli.py                  | 18 ++++++++++++++++++
 coordo-py/coordo/datapackage/resource.py | 18 +++++++++++-------
 2 files changed, 29 insertions(+), 7 deletions(-)

diff --git a/coordo-py/coordo/cli.py b/coordo-py/coordo/cli.py
index 8d3e497..f716287 100644
--- a/coordo-py/coordo/cli.py
+++ b/coordo-py/coordo/cli.py
@@ -116,6 +116,24 @@ def add_foreignkey(
         foreign_resource=foreign_resource,
     )
     dp.save()
+    
+@app.command()
+def remove_foreignkey(
+    from_: str,
+    to: str,
+    package: Path = typer.Option(".", help="Path to the package directory"),
+):
+    dp = DataPackage.from_path(package)
+    resource, field = from_.split(".")
+    foreign_resource, foreign_field = to.split(".")
+    dp.get_resource(
+        resource,
+    ).remove_foreignkey(
+        fields=[field],
+        foreign_fields=[foreign_field],
+        foreign_resource=foreign_resource,
+    )
+    dp.save()
 
 
 dp = typer.Typer()
diff --git a/coordo-py/coordo/datapackage/resource.py b/coordo-py/coordo/datapackage/resource.py
index 9ef97cc..552aed9 100644
--- a/coordo-py/coordo/datapackage/resource.py
+++ b/coordo-py/coordo/datapackage/resource.py
@@ -60,15 +60,12 @@ def add_foreignkey(self, fields: list[str], foreign_fields: list[str], foreign_r
         )
         fk_part_names_str = " & ".join(self.get_fk_names(fk))
         print(f"Adding foreign key {fk_part_names_str}")
-        
         if not self._package:
             raise ValueError("You can't add a foreign key to an orphan resource.")
-            
         field_names = [f.name for f in self.schema.fields]
         for f in fk.fields:
             if f not in field_names:
                 raise ValueError(f"Resource {self.name} has no field named {f}")
-                
         parent_resource = (
             self._package.get_resource(name=fk.reference.resource)
             if fk.reference.resource
@@ -79,15 +76,22 @@ def add_foreignkey(self, fields: list[str], foreign_fields: list[str], foreign_r
             assert f in field_names, (
                 f"Resource {parent_resource.name} has no field named {f}"
             )
-        
         if fk in self.schema.foreignKeys:
             raise ValueError(f"Foreign key {fk_part_names_str} already exists in resource {self.name}")
-            
         self.schema.foreignKeys.append(fk)
 
-    def remove_foreignkey(self, fk: ForeignKey) -> None:
+    def remove_foreignkey(self, fields: list[str], foreign_fields: list[str], foreign_resource: str) -> None:
+        fk = ForeignKey(
+            fields=fields,
+            reference=ForeignKeyReference(
+                fields=foreign_fields,
+                resource=None if self.name == foreign_resource else foreign_resource,
+            )
+        )
+        fk_part_names_str = " & ".join(self.get_fk_names(fk))
+        print(f"Removing foreign key {fk_part_names_str}")
         if fk not in self.schema.foreignKeys:
-            raise ValueError(f"Foreign key {fk} not found in resource {self.name}")
+            raise ValueError(f"Foreign key {fk_part_names_str} not found in resource {self.name}")
         self.schema.foreignKeys.remove(fk)
 
     @model_validator(mode="after")

From c954c336c3a0a82133787f7ea7fc559004c077b9 Mon Sep 17 00:00:00 2001
From: Olivier <coen.olivier@gmail.com>
Date: Sun, 19 Apr 2026 09:53:04 +0200
Subject: [PATCH 15/22] Update resource.py

---
 coordo-py/coordo/datapackage/resource.py | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/coordo-py/coordo/datapackage/resource.py b/coordo-py/coordo/datapackage/resource.py
index 552aed9..58c2246 100644
--- a/coordo-py/coordo/datapackage/resource.py
+++ b/coordo-py/coordo/datapackage/resource.py
@@ -51,6 +51,10 @@ def load_table(self, conn: duckdb.DuckDBPyConnection):
         conn.execute(query)
 
     def add_foreignkey(self, fields: list[str], foreign_fields: list[str], foreign_resource: str) -> None:
+        # TODO: remove this check when addition of multiple fields at once is supported
+        if len(fields) > 1 or len(foreign_fields) > 1:
+            raise ValueError("Adding a foreign key with multiple fields is not supported yet.")
+        
         fk = ForeignKey(
             fields=fields,
             reference=ForeignKeyReference(
@@ -60,6 +64,7 @@ def add_foreignkey(self, fields: list[str], foreign_fields: list[str], foreign_r
         )
         fk_part_names_str = " & ".join(self.get_fk_names(fk))
         print(f"Adding foreign key {fk_part_names_str}")
+        
         if not self._package:
             raise ValueError("You can't add a foreign key to an orphan resource.")
         field_names = [f.name for f in self.schema.fields]

From cf6370d9e0fb77bf27052b36637c9dde23597cff Mon Sep 17 00:00:00 2001
From: Olivier <coen.olivier@gmail.com>
Date: Sat, 18 Apr 2026 07:36:34 +0200
Subject: [PATCH 16/22] add anonymised test data

---
 tests/data.xlsx    | Bin 0 -> 78416 bytes
 tests/inquiry.xlsx | Bin 0 -> 30309 bytes
 2 files changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 tests/data.xlsx
 create mode 100644 tests/inquiry.xlsx

diff --git a/tests/data.xlsx b/tests/data.xlsx
new file mode 100644
index 0000000000000000000000000000000000000000..cb13bd6e8eaf3017c6004617753a088e33de82f5
GIT binary patch
literal 78416
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
C){l$;

literal 0
HcmV?d00001

diff --git a/tests/inquiry.xlsx b/tests/inquiry.xlsx
new file mode 100644
index 0000000000000000000000000000000000000000..ca40368776ac14706ef0c9ab17595e592408d669
GIT binary patch
literal 30309
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
Db_t9%

literal 0
HcmV?d00001


From cca0854df5bad80c091b14b843e091f65cb38fd2 Mon Sep 17 00:00:00 2001
From: Olivier <coen.olivier@gmail.com>
Date: Sun, 19 Apr 2026 09:18:01 +0200
Subject: [PATCH 17/22] change location of files

---
 {tests => coordo-py/tests/test_data}/data.xlsx    | Bin
 {tests => coordo-py/tests/test_data}/inquiry.xlsx | Bin
 2 files changed, 0 insertions(+), 0 deletions(-)
 rename {tests => coordo-py/tests/test_data}/data.xlsx (100%)
 rename {tests => coordo-py/tests/test_data}/inquiry.xlsx (100%)

diff --git a/tests/data.xlsx b/coordo-py/tests/test_data/data.xlsx
similarity index 100%
rename from tests/data.xlsx
rename to coordo-py/tests/test_data/data.xlsx
diff --git a/tests/inquiry.xlsx b/coordo-py/tests/test_data/inquiry.xlsx
similarity index 100%
rename from tests/inquiry.xlsx
rename to coordo-py/tests/test_data/inquiry.xlsx

From ff1d50bf6635bc76c3f24a9afcf884f2a07db69c Mon Sep 17 00:00:00 2001
From: Olivier <coen.olivier@gmail.com>
Date: Tue, 21 Apr 2026 13:05:19 +0200
Subject: [PATCH 18/22] add test function

---
 coordo-py/pyproject.toml                      |   4 ++
 coordo-py/tests/__init__.py                   |   0
 coordo-py/tests/conftest.py                   |  21 ++++++++++
 coordo-py/tests/test_cli.py                   |  19 +++++++++
 coordo-py/tests/test_data/inquiry.xlsx        | Bin 30309 -> 0 bytes
 .../tests/test_data/{ => inventory}/data.xlsx | Bin
 coordo-py/tests/test_data/inventory/file.csv  |  37 ++++++++++++++++++
 .../tests/test_data/inventory/inquiry.xlsx    | Bin 0 -> 27773 bytes
 8 files changed, 81 insertions(+)
 create mode 100644 coordo-py/tests/__init__.py
 create mode 100644 coordo-py/tests/conftest.py
 create mode 100644 coordo-py/tests/test_cli.py
 delete mode 100644 coordo-py/tests/test_data/inquiry.xlsx
 rename coordo-py/tests/test_data/{ => inventory}/data.xlsx (100%)
 create mode 100644 coordo-py/tests/test_data/inventory/file.csv
 create mode 100644 coordo-py/tests/test_data/inventory/inquiry.xlsx

diff --git a/coordo-py/pyproject.toml b/coordo-py/pyproject.toml
index 61b1534..76b2ca9 100644
--- a/coordo-py/pyproject.toml
+++ b/coordo-py/pyproject.toml
@@ -28,7 +28,11 @@ coordo = "coordo.cli:app"
 [tool.setuptools.package-data]
 "coordo" = ["static/*", "**/*.sql"]
 
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
 [dependency-groups]
 dev = [
     "ruff>=0.15.8",
+    "pytest>=8.0",
 ]
diff --git a/coordo-py/tests/__init__.py b/coordo-py/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/coordo-py/tests/conftest.py b/coordo-py/tests/conftest.py
new file mode 100644
index 0000000..4cb5acb
--- /dev/null
+++ b/coordo-py/tests/conftest.py
@@ -0,0 +1,21 @@
+import pytest 
+from pathlib import Path
+
+DATA_DIR = Path("tests/test_data")
+INVENTORY_DIR = DATA_DIR / "inventory"
+
+@pytest.fixture
+def inventory_package():
+    return "catalog/inventory"
+
+@pytest.fixture
+def inventory_inquiry():
+    return INVENTORY_DIR / "inquiry.xlsx"
+
+@pytest.fixture
+def inventory_data():
+    return INVENTORY_DIR / "data.xlsx"
+
+@pytest.fixture
+def inventory_file():
+    return INVENTORY_DIR / "file.csv"
\ No newline at end of file
diff --git a/coordo-py/tests/test_cli.py b/coordo-py/tests/test_cli.py
new file mode 100644
index 0000000..638c7f3
--- /dev/null
+++ b/coordo-py/tests/test_cli.py
@@ -0,0 +1,19 @@
+import shutil
+from typer.testing import CliRunner
+from coordo.cli import app 
+
+runner = CliRunner()
+
+def get_output_and_check_exitcode(result):
+    print(result.stdout_bytes.decode())
+    assert result.exit_code == 0
+
+def test_add_package(inventory_package, inventory_inquiry, inventory_data, inventory_file):
+    result1 = runner.invoke(app, ["load", "kobotoolbox", str(inventory_inquiry), str(inventory_data), "--package", inventory_package, "--action", "add"])
+    get_output_and_check_exitcode(result1)
+    result2 = runner.invoke(app, ["load", "file", str(inventory_file), "--package", inventory_package, "--action", "add"])
+    get_output_and_check_exitcode(result2)
+    result3 = runner.invoke(app, ["add-foreignkey", "ind.ess_arb", "file.ess_arb", "--package", inventory_package])
+    get_output_and_check_exitcode(result3)
+    print(f"Removing package '{inventory_package}'")
+    shutil.rmtree(inventory_package)
\ No newline at end of file
diff --git a/coordo-py/tests/test_data/inquiry.xlsx b/coordo-py/tests/test_data/inquiry.xlsx
deleted file mode 100644
index ca40368776ac14706ef0c9ab17595e592408d669..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 30309
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
Db_t9%

diff --git a/coordo-py/tests/test_data/data.xlsx b/coordo-py/tests/test_data/inventory/data.xlsx
similarity index 100%
rename from coordo-py/tests/test_data/data.xlsx
rename to coordo-py/tests/test_data/inventory/data.xlsx
diff --git a/coordo-py/tests/test_data/inventory/file.csv b/coordo-py/tests/test_data/inventory/file.csv
new file mode 100644
index 0000000..e2ef7b7
--- /dev/null
+++ b/coordo-py/tests/test_data/inventory/file.csv
@@ -0,0 +1,37 @@
+ess_arb,value
+1,0.422
+2,0.694
+4,0.607
+5,0.607
+7,0.56
+8,0.738
+9,0.723
+10,0.56
+16,0.642
+25,0.8
+33,0.636
+35,0.627
+37,0.56
+39,0.886
+58,0.56
+67,0.56
+70,0.682
+72,0.736
+77,0.56
+93,0.854
+96,0.8
+105,0.681
+111,0.671
+127,0.55
+133,0.681
+145,0.465
+166,0.56
+173,0.56
+187,0.56
+194,0.641
+195,0.664
+198,0.56
+213,0.49
+243,0.56
+248,0.646
+251,0.56
diff --git a/coordo-py/tests/test_data/inventory/inquiry.xlsx b/coordo-py/tests/test_data/inventory/inquiry.xlsx
new file mode 100644
index 0000000000000000000000000000000000000000..73db790e6b8bb2f3879c6ff911beceb0eafdadb6
GIT binary patch
literal 27773
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

literal 0
HcmV?d00001


From bbd0a76f438791315a96f7c9a3839da3bb38422e Mon Sep 17 00:00:00 2001
From: Olivier <coen.olivier@gmail.com>
Date: Tue, 21 Apr 2026 15:34:24 +0200
Subject: [PATCH 19/22] factorise code in test_cli.py

---
 coordo-py/tests/test_cli.py | 25 ++++++++++++++++++-------
 1 file changed, 18 insertions(+), 7 deletions(-)

diff --git a/coordo-py/tests/test_cli.py b/coordo-py/tests/test_cli.py
index 638c7f3..854e14f 100644
--- a/coordo-py/tests/test_cli.py
+++ b/coordo-py/tests/test_cli.py
@@ -8,12 +8,23 @@ def get_output_and_check_exitcode(result):
     print(result.stdout_bytes.decode())
     assert result.exit_code == 0
 
-def test_add_package(inventory_package, inventory_inquiry, inventory_data, inventory_file):
-    result1 = runner.invoke(app, ["load", "kobotoolbox", str(inventory_inquiry), str(inventory_data), "--package", inventory_package, "--action", "add"])
-    get_output_and_check_exitcode(result1)
-    result2 = runner.invoke(app, ["load", "file", str(inventory_file), "--package", inventory_package, "--action", "add"])
-    get_output_and_check_exitcode(result2)
-    result3 = runner.invoke(app, ["add-foreignkey", "ind.ess_arb", "file.ess_arb", "--package", inventory_package])
-    get_output_and_check_exitcode(result3)
+def test_add_data_to_package(inventory_package, inventory_inquiry, inventory_data, inventory_file):
+    """
+    Test the following workflow:
+    - Load data from a kobotoolbox inquiry and a file into a package.
+    - Add a foreign key between two fields.
+    - Remove the foreign key.
+    - Add the foreign key again.
+    """
+    result = runner.invoke(app, ["load", "kobotoolbox", str(inventory_inquiry), str(inventory_data), "--package", inventory_package, "--action", "add"])
+    get_output_and_check_exitcode(result)
+    result = runner.invoke(app, ["load", "file", str(inventory_file), "--package", inventory_package, "--action", "add"])
+    get_output_and_check_exitcode(result)
+    result = runner.invoke(app, ["add-foreignkey", "ind.ess_arb", "file.ess_arb", "--package", inventory_package])
+    get_output_and_check_exitcode(result)
+    result = runner.invoke(app, ["remove-foreignkey", "ind.ess_arb", "file.ess_arb", "--package", inventory_package])
+    get_output_and_check_exitcode(result)
+    result = runner.invoke(app, ["add-foreignkey", "ind.ess_arb", "file.ess_arb", "--package", inventory_package])
+    get_output_and_check_exitcode(result)
     print(f"Removing package '{inventory_package}'")
     shutil.rmtree(inventory_package)
\ No newline at end of file

From ad0967bd0a2445a99a7502cc01137688dc727913 Mon Sep 17 00:00:00 2001
From: Olivier <coen.olivier@gmail.com>
Date: Tue, 21 Apr 2026 15:34:36 +0200
Subject: [PATCH 20/22] update uv environment

---
 coordo-py/pyproject.toml |  1 +
 coordo-py/uv.lock        | 40 +++++++++++++++++++++++++++++++++++++++-
 2 files changed, 40 insertions(+), 1 deletion(-)

diff --git a/coordo-py/pyproject.toml b/coordo-py/pyproject.toml
index 76b2ca9..6f05be6 100644
--- a/coordo-py/pyproject.toml
+++ b/coordo-py/pyproject.toml
@@ -30,6 +30,7 @@ coordo = "coordo.cli:app"
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]
+addopts = ["-s"]
 
 [dependency-groups]
 dev = [
diff --git a/coordo-py/uv.lock b/coordo-py/uv.lock
index 76198da..4b6488a 100644
--- a/coordo-py/uv.lock
+++ b/coordo-py/uv.lock
@@ -225,6 +225,7 @@ dependencies = [
 
 [package.dev-dependencies]
 dev = [
+    { name = "pytest" },
     { name = "ruff" },
 ]
 
@@ -249,7 +250,10 @@ requires-dist = [
 ]
 
 [package.metadata.requires-dev]
-dev = [{ name = "ruff", specifier = ">=0.15.8" }]
+dev = [
+    { name = "pytest", specifier = ">=8.0" },
+    { name = "ruff", specifier = ">=0.15.8" },
+]
 
 [[package]]
 name = "dateparser"
@@ -555,6 +559,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/0e/61/66938bbb5fc52dbdf84594873d5b51fb1f7c7794e9c0f5bd885f30bc507b/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea", size = 71008, upload-time = "2025-10-12T14:55:18.883Z" },
 ]
 
+[[package]]
+name = "iniconfig"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
+]
+
 [[package]]
 name = "itsdangerous"
 version = "2.2.0"
@@ -984,6 +997,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/e6/3f/a80ac00acbc6b35166b42850e98a4f466e2c0d9c64054161ba9620f95680/pandas-3.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:1c39eab3ad38f2d7a249095f0a3d8f8c22cc0f847e98ccf5bbe732b272e2d9fa", size = 9441003, upload-time = "2026-01-21T15:52:02.281Z" },
 ]
 
+[[package]]
+name = "pluggy"
+version = "1.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
+]
+
 [[package]]
 name = "propcache"
 version = "0.4.1"
@@ -1395,6 +1417,22 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/15/73/a7141a1a0559bf1a7aa42a11c879ceb19f02f5c6c371c6d57fd86cefd4d1/pyproj-3.7.2-cp314-cp314t-win_arm64.whl", hash = "sha256:d9d25bae416a24397e0d85739f84d323b55f6511e45a522dd7d7eae70d10c7e4", size = 6391844, upload-time = "2025-08-14T12:05:40.745Z" },
 ]
 
+[[package]]
+name = "pytest"
+version = "9.0.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "iniconfig" },
+    { name = "packaging" },
+    { name = "pluggy" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/7d/0d/549bd94f1a0a402dc8cf64563a117c0f3765662e2e668477624baeec44d5/pytest-9.0.3.tar.gz", hash = "sha256:b86ada508af81d19edeb213c681b1d48246c1a91d304c6c81a427674c17eb91c", size = 1572165, upload-time = "2026-04-07T17:16:18.027Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d4/24/a372aaf5c9b7208e7112038812994107bc65a84cd00e0354a88c2c77a617/pytest-9.0.3-py3-none-any.whl", hash = "sha256:2c5efc453d45394fdd706ade797c0a81091eccd1d6e4bccfcd476e2b8e0ab5d9", size = 375249, upload-time = "2026-04-07T17:16:16.13Z" },
+]
+
 [[package]]
 name = "python-dateutil"
 version = "2.9.0.post0"

From 7a912d9ab6581bb98964c4a1f9539d7304492ea0 Mon Sep 17 00:00:00 2001
From: Olivier <coen.olivier@gmail.com>
Date: Tue, 21 Apr 2026 15:34:50 +0200
Subject: [PATCH 21/22] add pytest step in CI

---
 .github/workflows/coordo-py.yml | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/.github/workflows/coordo-py.yml b/.github/workflows/coordo-py.yml
index 5bbb328..462b85a 100644
--- a/.github/workflows/coordo-py.yml
+++ b/.github/workflows/coordo-py.yml
@@ -34,3 +34,6 @@ jobs:
 
       - name: Run tests
         run: uv run test.py
+      
+      - name: Run pytest
+        run: uv run pytest

From 5faedcaa42afa56d28d9e964329fc664381b2b00 Mon Sep 17 00:00:00 2001
From: Olivier <coen.olivier@gmail.com>
Date: Tue, 21 Apr 2026 15:36:04 +0200
Subject: [PATCH 22/22] add copyright

---
 coordo-py/tests/__init__.py | 2 ++
 coordo-py/tests/conftest.py | 3 +++
 coordo-py/tests/test_cli.py | 3 +++
 3 files changed, 8 insertions(+)

diff --git a/coordo-py/tests/__init__.py b/coordo-py/tests/__init__.py
index e69de29..e5a1d76 100644
--- a/coordo-py/tests/__init__.py
+++ b/coordo-py/tests/__init__.py
@@ -0,0 +1,2 @@
+# Copyright COORDONNÉES 2025, 2026
+# SPDX-License-Identifier: MPL-2.0
\ No newline at end of file
diff --git a/coordo-py/tests/conftest.py b/coordo-py/tests/conftest.py
index 4cb5acb..37ed756 100644
--- a/coordo-py/tests/conftest.py
+++ b/coordo-py/tests/conftest.py
@@ -1,3 +1,6 @@
+# Copyright COORDONNÉES 2025, 2026
+# SPDX-License-Identifier: MPL-2.0
+
 import pytest 
 from pathlib import Path
 
diff --git a/coordo-py/tests/test_cli.py b/coordo-py/tests/test_cli.py
index 854e14f..67fd1fc 100644
--- a/coordo-py/tests/test_cli.py
+++ b/coordo-py/tests/test_cli.py
@@ -1,3 +1,6 @@
+# Copyright COORDONNÉES 2025, 2026
+# SPDX-License-Identifier: MPL-2.0
+
 import shutil
 from typer.testing import CliRunner
 from coordo.cli import app