work from

.github/dependabot.yml

@@ -0,0 +1,10 @@
+# Set update schedule for GitHub Actions
+
+version: 2
+updates:
+
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      # Check for updates to GitHub Actions every week
+      interval: "weekly"

.github/workflows/test.yml

@@ -0,0 +1,36 @@
+name: Test
+
+on:
+  push:
+    branches: ["master"]
+    paths:
+      - ".github/workflows/test.yml"
+      - "**.py"
+      - "uv.lock"
+      - "pyproject.toml"
+  pull_request:
+    paths:
+      - ".github/workflows/test.yml"
+      - "**.py"
+      - "uv.lock"
+      - "pyproject.toml"
+
+jobs:
+  test:
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.8", "3.9", "3.10", "3.11", "3.12", "3.13"]
+        os: [ubuntu-latest, macos-latest, windows-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+      - name: Install uv and set the python version ${{ matrix.python-version }}
+        uses: astral-sh/setup-uv@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install the project
+        run: uv sync --all-extras --dev
+      - name: Run tests
+        run: uv run pytest

.gitignore

@@ -1,21 +1,21 @@
-__pycache__
-*.pyc
-.idea
-env/
-*.swo
-*.swp
-*.*~
-*.egg
-*.egg-info
-.#*.*
-TAGS
-docs
-.mypy_cache
-.pytest_cache
-build
-dist
-.eggs
-.vscode
-gmon.out
-.vim
-pyproject.toml
+__pycache__
+*.pyc
+.idea
+env/
+*.swo
+*.swp
+*.*~
+*.egg
+*.egg-info
+.#*.*
+TAGS
+docs
+.mypy_cache
+.pytest_cache
+build
+dist
+.eggs
+.vscode
+gmon.out
+.vim
+.aider*

.python-version

@@ -0,0 +1 @@
+3.13

AUTHORS.md

@@ -2,10 +2,11 @@
 
 ## Development Lead
 
-* Daniel Furtado <daniel@dfurtado.com>
+* Daniel Furtado
 
 ## Contributors
 
+* Kraktus
 * Nick Schober
 * Zoltan Ivanfi
 * Alec Benzer

README.md

@@ -23,6 +23,11 @@ Dataclass CSV makes working with CSV files easier and much better than working w
 using a list of instances of a dataclass.
 
 
+## Thanks
+
+Thank you to all the amazing contributors who have supported this project over the years, with special thanks to [@kraktus](https://github.com/kraktus) for setting up GitHub Actions, improving automation for package creation, and making numerous code enhancements.
+
+
 ## Installation
 
 ```shell

dataclass_csv/dataclass_reader.py

@@ -24,6 +24,8 @@ def strtobool(value: str) -> bool:
     return value.lower() in trueValues
 
 
+T = TypeVar("T")
+
 def _verify_duplicate_header_items(header):
     if header is not None and len(header) == 0:
         return
@@ -42,6 +44,17 @@ def _verify_duplicate_header_items(header):
         )
 
 
+def strtobool(value: str) -> bool:
+    trueValues = ["true", "yes", "t", "y", "on", "1"]
+
+    validValues =  ["false", "no", "f", "n", "off", "0", *trueValues]
+
+    if value.lower() not in validValues:
+        raise ValueError(f"invalid boolean value {value}")
+
+    return value.lower() in trueValues
+
+
 def is_union_type(t):
     if hasattr(t, "__origin__") and t.__origin__ is Union:
         return True
@@ -60,7 +73,7 @@ class DataclassReader(Generic[T]):
     def __init__(
         self,
         f: Any,
-        cls: Type[T],
+        klass: Type[T],
         fieldnames: Optional[Sequence[str]] = None,
         restkey: Optional[str] = None,
         restval: Optional[Any] = None,
@@ -72,10 +85,10 @@ def __init__(
         if not f:
             raise ValueError("The f argument is required.")
 
-        if cls is None or not dataclasses.is_dataclass(cls):
-            raise ValueError("cls argument needs to be a dataclass.")
+        if klass is None or not dataclasses.is_dataclass(klass):
+            raise ValueError("klass argument needs to be a dataclass.")
 
-        self._cls = cls
+        self._cls = klass
         self._optional_fields = self._get_optional_fields()
         self._field_mapping: Dict[str, Dict[str, Any]] = {}
 
@@ -88,7 +101,7 @@ def __init__(
         if validate_header:
             _verify_duplicate_header_items(self._reader.fieldnames)
 
-        self.type_hints = typing.get_type_hints(cls)
+        self.type_hints = typing.get_type_hints(klass)
 
     def _get_optional_fields(self):
         return [
@@ -120,53 +133,52 @@ def _get_possible_keys(self, fieldname, row):
     def _get_value(self, row, field):
         is_field_mapped = False
 
-        try:
-            if field.name in self._field_mapping.keys():
-                is_field_mapped = True
-                key = self._field_mapping.get(field.name)
-            else:
-                key = field.name
+        if field.name in self._field_mapping.keys():
+            is_field_mapped = True
+            key = self._field_mapping.get(field.name)
+        else:
+            key = field.name
 
-            if key in row.keys():
-                value = row[key]
-            else:
+        if key in row.keys():
+            value = row[key]
+        else:
+            try:
                 possible_key = self._get_possible_keys(field.name, row)
                 key = possible_key if possible_key else key
                 value = row[key]
-
-        except KeyError:
-            if field.name in self._optional_fields:
-                return self._get_default_value(field)
-            else:
-                keyerror_message = f"The value for the column `{field.name}`"
-                if is_field_mapped:
-                    keyerror_message = f"The value for the mapped column `{key}`"
-                raise KeyError(f"{keyerror_message} is missing in the CSV file")
-        else:
-            if not value and field.name in self._optional_fields:
-                return self._get_default_value(field)
-            elif not value and field.name not in self._optional_fields:
-                raise ValueError(f"The field `{field.name}` is required.")
-            elif (
-                value
-                and field.type is str
-                and not len(value.strip())
-                and not self._get_metadata_option(field, "accept_whitespaces")
-            ):
-                raise ValueError(
-                    (
-                        f"It seems like the value of `{field.name}` contains "
-                        "only white spaces. To allow white spaces to all "
-                        "string fields, use the @accept_whitespaces "
-                        "decorator. "
-                        "To allow white spaces specifically for the field "
-                        f"`{field.name}` change its definition to: "
-                        f"`{field.name}: str = field(metadata="
-                        "{'accept_whitespaces': True})`."
-                    )
+            except KeyError:
+                if field.name in self._optional_fields:
+                    return self._get_default_value(field)
+                else:
+                    keyerror_message = f"The value for the column `{field.name}`"
+                    if is_field_mapped:
+                        keyerror_message = f"The value for the mapped column `{key}`"
+                    raise KeyError(f"{keyerror_message} is missing in the CSV file")
+
+        if not value and field.name in self._optional_fields:
+            return self._get_default_value(field)
+        elif not value and field.name not in self._optional_fields:
+            raise ValueError(f"The field `{field.name}` is required.")
+        elif (
+            value
+            and field.type is str
+            and not len(value.strip())
+            and not self._get_metadata_option(field, "accept_whitespaces")
+        ):
+            raise ValueError(
+                (
+                    f"It seems like the value of `{field.name}` contains "
+                    "only white spaces. To allow white spaces to all "
+                    "string fields, use the @accept_whitespaces "
+                    "decorator. "
+                    "To allow white spaces specifically for the field "
+                    f"`{field.name}` change its definition to: "
+                    f"`{field.name}: str = field(metadata="
+                    "{'accept_whitespaces': True})`."
                 )
-            else:
-                return value
+            )
+        else:
+            return value
 
     def _parse_date_value(self, field, date_value, field_type):
         dateformat = self._get_metadata_option(field, "dateformat")
@@ -231,7 +243,7 @@ def _process_row(self, row) -> T:
                     transformed_value = (
                         value
                         if isinstance(value, bool)
-                        else strtobool(str(value).strip()) == 1
+                        else strtobool(str(value).strip())
                     )
                 except ValueError as ex:
                     raise CsvValueError(ex, line_number=self._reader.line_num) from None

dataclass_csv/dataclass_writer.py

@@ -1,32 +1,33 @@
 import csv
 import dataclasses
-from typing import Type, Dict, Any, List
+from typing import Type, Dict, Any, List, Iterable, Generic, TypeVar
 from .header_mapper import HeaderMapper
 
 
-class DataclassWriter:
+
+T = TypeVar("T")
+
+
+class DataclassWriter(Generic[T]):
     def __init__(
         self,
         f: Any,
-        data: List[Any],
-        cls: Type[object],
+        data: Iterable[T],
+        klass: Type[T],
         dialect: str = "excel",
-        **fmtparams: Dict[str, Any],
+        **fmtparams: Any,
     ):
         if not f:
             raise ValueError("The f argument is required")
 
-        if not isinstance(data, list):
-            raise ValueError("Invalid 'data' argument. It must be a list")
-
-        if not dataclasses.is_dataclass(cls):
-            raise ValueError("Invalid 'cls' argument. It must be a dataclass")
+        if not dataclasses.is_dataclass(klass):
+            raise ValueError("Invalid 'klass' argument. It must be a dataclass")
 
         self._data = data
-        self._cls = cls
+        self._cls = klass
         self._field_mapping: Dict[str, str] = dict()
 
-        self._fieldnames = [x.name for x in dataclasses.fields(cls)]
+        self._fieldnames = [x.name for x in dataclasses.fields(klass)]
 
         self._writer = csv.writer(f, dialect=dialect, **fmtparams)
 
@@ -48,7 +49,6 @@ def write(self, skip_header: bool = False):
                 self._fieldnames = self._apply_mapping()
 
             self._writer.writerow(self._fieldnames)
-
         for item in self._data:
             if not isinstance(item, self._cls):
                 raise TypeError(