Add stubs (dfurtado#39)

Author: dfurtado

.gitignore

@@ -17,3 +17,5 @@ dist
 .eggs
 .vscode
 gmon.out
+.vim
+pyproject.toml

dataclass_csv/__init__.pyi

@@ -0,0 +1,4 @@
+from .dataclass_reader import DataclassReader as DataclassReader
+from .dataclass_writer import DataclassWriter as DataclassWriter
+from .decorators import accept_whitespaces as accept_whitespaces, dateformat as dateformat
+from .exceptions import CsvValueError as CsvValueError

dataclass_csv/dataclass_reader.py

@@ -28,27 +28,27 @@ def __init__(
         if cls is None or not dataclasses.is_dataclass(cls):
             raise ValueError('cls argument needs to be a dataclass.')
 
-        self.cls = cls
-        self.optional_fields = self._get_optional_fields()
-        self.field_mapping: Dict[str, Dict[str, Any]] = {}
+        self._cls = cls
+        self._optional_fields = self._get_optional_fields()
+        self._field_mapping: Dict[str, Dict[str, Any]] = {}
 
-        self.reader = csv.DictReader(
+        self._reader = csv.DictReader(
             f, fieldnames, restkey, restval, dialect, *args, **kwds
         )
 
     def _get_optional_fields(self):
         return [
             field.name
-            for field in dataclasses.fields(self.cls)
+            for field in dataclasses.fields(self._cls)
             if not isinstance(field.default, dataclasses._MISSING_TYPE)
             or not isinstance(field.default_factory, dataclasses._MISSING_TYPE)
         ]
 
     def _add_to_mapping(self, property_name, csv_fieldname):
-        self.field_mapping[property_name] = csv_fieldname
+        self._field_mapping[property_name] = csv_fieldname
 
     def _get_metadata_option(self, field, key):
-        option = field.metadata.get(key, getattr(self.cls, f'__{key}__', None))
+        option = field.metadata.get(key, getattr(self._cls, f'__{key}__', None))
         return option
 
     def _get_default_value(self, field):
@@ -69,9 +69,9 @@ def _get_value(self, row, field):
         is_field_mapped = False
 
         try:
-            if field.name in self.field_mapping.keys():
+            if field.name in self._field_mapping.keys():
                 is_field_mapped = True
-                key = self.field_mapping.get(field.name)
+                key = self._field_mapping.get(field.name)
             else:
                 key = field.name
 
@@ -83,17 +83,17 @@ def _get_value(self, row, field):
                 value = row[key]
 
         except KeyError:
-            if field.name in self.optional_fields:
+            if field.name in self._optional_fields:
                 return self._get_default_value(field)
             else:
                 keyerror_message = f'The value for the column `{field.name}` is missing in the CSV file.'
                 if is_field_mapped:
                     keyerror_message = f'The value for the mapped column `{key}` is missing in the CSV file'
                 raise KeyError(keyerror_message)
         else:
-            if not value and field.name in self.optional_fields:
+            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:
+            elif not value and field.name not in self._optional_fields:
                 raise ValueError(f'The field `{field.name}` is required.')
             elif (
                 value
@@ -139,15 +139,15 @@ def _parse_date_value(self, field, date_value):
     def _process_row(self, row):
         values = []
 
-        for field in dataclasses.fields(self.cls):
+        for field in dataclasses.fields(self._cls):
             if not field.init:
                 continue
 
             try:
                 value = self._get_value(row, field)
             except ValueError as ex:
                 raise CsvValueError(
-                    ex, line_number=self.reader.line_num
+                    ex, line_number=self._reader.line_num
                 ) from None
 
             if not value and field.default is None:
@@ -174,7 +174,7 @@ def _process_row(self, row):
                     transformed_value = self._parse_date_value(field, value)
                 except ValueError as ex:
                     raise CsvValueError(
-                        ex, line_number=self.reader.line_num
+                        ex, line_number=self._reader.line_num
                     ) from None
                 else:
                     values.append(transformed_value)
@@ -189,7 +189,7 @@ def _process_row(self, row):
                     )
                 except ValueError as ex:
                     raise CsvValueError(
-                        ex, line_number=self.reader.line_num
+                        ex, line_number=self._reader.line_num
                     ) from None
                 else:
                     values.append(transformed_value)
@@ -203,14 +203,14 @@ def _process_row(self, row):
                         f'The field `{field.name}` is defined as {field.type} '
                         f'but received a value of type {type(value)}.'
                     ),
-                    line_number=self.reader.line_num,
+                    line_number=self._reader.line_num,
                 ) from e
             else:
                 values.append(transformed_value)
-        return self.cls(*values)
+        return self._cls(*values)
 
     def __next__(self):
-        row = next(self.reader)
+        row = next(self._reader)
         return self._process_row(row)
 
     def __iter__(self):

dataclass_csv/dataclass_reader.pyi

@@ -0,0 +1,9 @@
+from .exceptions import CsvValueError as CsvValueError
+from .field_mapper import FieldMapper as FieldMapper
+from typing import Any, Dict, List, Optional, Sequence, Type
+
+class DataclassReader:
+    def __init__(self, f: Any, cls: Type[object], fieldnames: Optional[Sequence[str]]=..., restkey: Optional[str]=..., restval: Optional[Any]=..., dialect: str=..., *args: List[Any], **kwds: Dict[str, Any]) -> None: ...
+    def __next__(self): ...
+    def __iter__(self) -> Any: ...
+    def map(self, csv_fieldname: str) -> FieldMapper: ...

dataclass_csv/dataclass_writer.pyi

@@ -0,0 +1,7 @@
+from .header_mapper import HeaderMapper as HeaderMapper
+from typing import Any, Dict, List, Type
+
+class DataclassWriter:
+    def __init__(self, f: Any, data: List[Any], cls: Type[object], dialect: str=..., **fmtparams: Dict[str, Any]) -> None: ...
+    def write(self, skip_header: bool=...) -> Any: ...
+    def map(self, propname: str) -> HeaderMapper: ...

dataclass_csv/decorators.pyi

@@ -0,0 +1,6 @@
+from typing import Any, Callable, Type, TypeVar
+
+F = TypeVar('F', bound=Callable[..., Any])
+
+def dateformat(date_format: str) -> Callable[[F], F]: ...
+def accept_whitespaces(_cls: Type[Any]=...) -> Callable[[F], F]: ...

dataclass_csv/exceptions.py

@@ -1,9 +1,12 @@
+from typing import Any
+
+
 class CsvValueError(Exception):
     """Error when a value in the CSV file cannot be parsed."""
 
-    def __init__(self, error, line_number):
-        self.error = error
-        self.line_number = line_number
+    def __init__(self, error: Any, line_number: int):
+        self.error: Any = error
+        self.line_number: int = line_number
 
     def __str__(self):
         return f'{self.error} [CSV Line number: {self.line_number}]'

dataclass_csv/exceptions.pyi

@@ -0,0 +1,6 @@
+from typing import Any
+
+class CsvValueError(Exception):
+    error: Any = ...
+    line_number: Any = ...
+    def __init__(self, error: Any, line_number: int) -> None: ...

dataclass_csv/field_mapper.py

@@ -6,13 +6,13 @@ class FieldMapper:
     in the CSV file to a specific `dataclass` field.
     """
 
-    def __init__(self, callback: Callable[[str], Any]):
-        def to(property_name):
+    def __init__(self, callback: Callable[[str], None]):
+        def to(property_name: str) -> None:
             """Specify the dataclass field to receive the value
             :param property_name: The dataclass property that
             will receive the csv value.
             """
 
             callback(property_name)
 
-        self.to = to
+        self.to: Callable[[str], None] = to

dataclass_csv/field_mapper.pyi

@@ -0,0 +1,5 @@
+from typing import Any, Callable
+
+class FieldMapper:
+    to: Any = ...
+    def __init__(self, callback: Callable[[str], None]) -> None: ...