robotframework-tablelibrary 0.2.1__tar.gz → 0.3.1__tar.gz

{robotframework_tablelibrary-0.2.1 → robotframework_tablelibrary-0.3.1}/.github/workflows/build.yml

@@ -40,7 +40,8 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ["3.10", "3.11", "3.12"]
+        python-version: ["3.10", "3.11", "3.12", "3.13", "3.14"]
+        robotframework: ["7.0", "7.4.2"]
     steps:
     - uses: actions/checkout@v4
 
@@ -53,64 +54,22 @@ jobs:
       run: pip install hatch
 
     - name: Install dependencies
-      run: hatch env create dev
-
-    - name: Build wheel with Hatch
-      run: hatch build
-
-    - name: Install built wheel
-      run: pip install dist/*.whl
-
-    - name: Test import
-      run: python -c "import Tables"
+      run: hatch env create test.py${{ matrix.python-version }}-${{ matrix.robotframework }}
 
-  run-acceptance-tests:
-    runs-on: ubuntu-latest
-
-    steps:
-    - name: Checkout code
-      uses: actions/checkout@v4
+    - name: Show installed Python version
+      run: hatch run test.py${{ matrix.python-version }}-${{ matrix.robotframework }}:python --version
 
-    - name: Set up Python
-      uses: actions/setup-python@v5
-      with:
-        python-version: '3.12'
-
-    - name: Install Hatch
-      run: pip install hatch
-
-    - name: Install dependencies
-      run: hatch env create dev
+    - name: Show installed Robot Framework version
+      run: hatch run test.py${{ matrix.python-version }}-${{ matrix.robotframework }}:robot --version || test $? -eq 251
 
     - name: Build wheel with Hatch
       run: hatch build
 
-    - name: Run robot framework acceptance-tests
-      run: hatch run dev:atest
-
-  run-unit-tests:
-    runs-on: ubuntu-latest
-
-    steps:
-    - name: Checkout code
-      uses: actions/checkout@v4
-
-    - name: Set up Python
-      uses: actions/setup-python@v5
-      with:
-        python-version: '3.12'
-
-    - name: Install Hatch
-      run: pip install hatch
-
-    - name: Install dependencies
-      run: hatch env create dev
-
-    - name: Build wheel with Hatch
-      run: hatch build
+    - name: Run unit tests
+      run: hatch run test.py${{ matrix.python-version }}-${{ matrix.robotframework }}:utest
 
-    - name: Run unit tests with pytest
-      run: hatch run dev:utest
+    - name: Run acceptance tests
+      run: hatch run test.py${{ matrix.python-version }}-${{ matrix.robotframework }}:atest
 
   generate-libdoc-docs:
     runs-on: ubuntu-latest

{robotframework_tablelibrary-0.2.1 → robotframework_tablelibrary-0.3.1}/.github/workflows/release.yml

@@ -14,6 +14,8 @@ jobs:
     steps:
       - name: Checkout code
         uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
 
       - name: Create GitHub Release
         uses: softprops/action-gh-release@v2
@@ -31,6 +33,8 @@ jobs:
     steps:
       - name: Checkout code
         uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
 
       - name: Set up Python
         uses: actions/setup-python@v5

{robotframework_tablelibrary-0.2.1 → robotframework_tablelibrary-0.3.1}/.gitignore

@@ -9,6 +9,7 @@ __pycache__/
 # Distribution / packaging
 .Python
 build/
+src/Tables/_version.py
 develop-eggs/
 dist/
 downloads/

{robotframework_tablelibrary-0.2.1 → robotframework_tablelibrary-0.3.1}/DEVELOPMENT.md

@@ -20,19 +20,19 @@ In the ``root directory`` of this repository you will find a script called ``cre
 When executing this script, it expects exactly one argument: the new name of the release / tag.
 Here you need to provide always the syntax ``X.X.X``, e.g. ``0.1.9``, ``0.5.0`` or ``1.0.0``.
 
-The script will do two things automatically for you:
-1. Updating the version string in the **[\_\_about\_\_.py](src/Tables/__about__.py)**
-2. Creating & Pushing a new tag to GitHub.
+The package version is read from the Git tag. No version file needs to be changed or committed. Create and push a tag from the desired commit:
 
-Execute the following command to create a new release:
 ```
 cd <project-root-directory>
-./create_release.sh 1.0.0
+git checkout main
+git pull origin main
+git tag -a v1.0.0 -m "Release v1.0.0"
+git push origin v1.0.0
 ```
 
-After executing the script, three pipeline jobs are getting triggered automatically:
+After pushing the tag, three pipeline jobs are triggered automatically:
 1. First job creates a new ``Release`` in github with the name of the created ``Tag``.
-2. Second job uploads the new wheel package to ``PyPi`` with the ``__version__`` from the ``__about__.py`` file.
+2. Second job builds the wheel with the version from the Git tag and uploads it to ``PyPi``.
 3. Third job generates a new keyword documentation via ``libdoc`` on the main branch, but pushes it to the ``gh_pages`` where it is available as public ``GitHub Page``.
 
 ### *Backup* - Manual Version Bump & Tag Creation
@@ -40,29 +40,21 @@ After executing the script, three pipeline jobs are getting triggered automatica
 If the preferred way using the ``create_release.sh`` script does not work, you can also manually create a new release.
 Therefore, execute the following steps.
 
-#### 1. Increase Version
+#### Create a new tag
 
-Open the file **[\_\_about\_\_.py](src/Tables/__about__.py)** and increase the version (``0.0.5 = major.minor.path``) before building & uploading the new python wheel package!
-
-The new version **must be unique** & **not already existing** in ``PyPi`` & ``GitHub Releases``!!!
-
-Commit & push the changed version into the ``main`` branch of the repository.
-
-#### 2. Create new Tag
-
-Now, create a new tag from the main branch with the syntax ``vX.X.X`` -> example: ``v1.0.5``.
+Create a new tag from the desired commit with the syntax ``vX.X.X``. The version must be unique in PyPI and GitHub Releases.
 
 Use the following commands to create & push the tag:
 ```
-git tag v0.0.5
-git push origin v0.0.5
+git tag -a v1.0.0 -m "Release v1.0.0"
+git push origin v1.0.0
 ```
 
-#### 2.1. Creating GitHub Release & Deploy Wheel Package to PyPi
+#### Creating GitHub Release & Deploy Wheel Package to PyPi
 
 After pushing the new tag, three pipeline jobs are getting triggered automatically:
 1. First job creates a new ``Release`` in github with the name of the created ``Tag``.
-2. Second job uploads the new wheel package to ``PyPi`` with the ``__version__`` from the ``__about__.py`` file.
+2. Second job builds the wheel with the version from the Git tag and uploads it to ``PyPi``.
 3. Third job generates a new keyword documentation via ``libdoc`` on the main branch, but pushes it to the ``gh_pages`` where it is available as public ``GitHub Page``.
 
 ## Installing Dev Dependencies
@@ -97,6 +89,24 @@ hatch run dev:atest
 hatch run dev:utest
 ```
 
+### Execute Tests Against the Version Matrix
+
+Install Python 3.10 through 3.14 locally and make sure Hatch can find these interpreters. The test matrix covers Python 3.10-3.14 and Robot Framework 7.0 and 7.4.2.
+
+Run all unit and acceptance tests against every matrix combination:
+
+```shell
+hatch run test:all
+```
+
+To test one combination only, for example Python 3.14 with Robot Framework 7.4.2:
+
+```shell
+hatch run test.py3.14-7.4.2:all
+```
+
+Use `hatch env show` to list the generated matrix environments.
+
 ### Generate Docs via libdoc
 
 ```shell

{robotframework_tablelibrary-0.2.1 → robotframework_tablelibrary-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: robotframework-tablelibrary
-Version: 0.2.1
+Version: 0.3.1
 Summary: A Robot Framework library providing generic table keywords for several table file type like csv or excel.
 Project-URL: Homepage, https://github.com/imbus/robotframework-tablelibrary
 Project-URL: Documentation, https://github.com/imbus/robotframework-tablelibrary#readme
@@ -16,6 +16,8 @@ Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Requires-Python: >=3.10
 Requires-Dist: openpyxl
 Requires-Dist: overrides
@@ -110,6 +112,17 @@ ${result} =    BuiltIn.Evaluate    "index" not in "${content}"
 BuiltIn.Should Be True    ${result}
 ```
 
+### Missing values
+
+Missing values are returned using pandas' default values by default. To return parsed missing values as Python `None` in list, dictionary, cell, row, and column results, enable the setting. This includes pandas missing-value types such as `NaN`, `pd.NA`, and `NaT`, as well as values recognized as missing by the active parser, such as `N/A` and `NULL`:
+
+```
+Tables.Configure Missing As None    True
+${content} =    Tables.Read Table    ${CURDIR}${/}testdata${/}example_01.csv
+```
+
+DataFrame results and the library's internal DataFrames are not changed by this setting.
+
 ### File Format - Parquet
 ```
 ${content} =    Tables.Read Table    ${CURDIR}${/}testdata${/}example_05.parquet

{robotframework_tablelibrary-0.2.1 → robotframework_tablelibrary-0.3.1}/README.md

@@ -73,6 +73,17 @@ ${result} =    BuiltIn.Evaluate    "index" not in "${content}"
 BuiltIn.Should Be True    ${result}
 ```
 
+### Missing values
+
+Missing values are returned using pandas' default values by default. To return parsed missing values as Python `None` in list, dictionary, cell, row, and column results, enable the setting. This includes pandas missing-value types such as `NaN`, `pd.NA`, and `NaT`, as well as values recognized as missing by the active parser, such as `N/A` and `NULL`:
+
+```
+Tables.Configure Missing As None    True
+${content} =    Tables.Read Table    ${CURDIR}${/}testdata${/}example_01.csv
+```
+
+DataFrame results and the library's internal DataFrames are not changed by this setting.
+
 ### File Format - Parquet
 ```
 ${content} =    Tables.Read Table    ${CURDIR}${/}testdata${/}example_05.parquet

robotframework_tablelibrary-0.3.1/create_release.sh

@@ -0,0 +1,32 @@
+#!/usr/bin/env bash
+set -e
+
+# Script takes one argument: e.g. 0.1.0 or 1.0.0
+if [ -z "$1" ]; then
+  echo "❌ Usage: $0 <new_version>"
+  exit 1
+fi
+
+NEW_VERSION="$1"
+TAG="v${NEW_VERSION}"
+
+if git rev-parse "$TAG" >/dev/null 2>&1; then
+  echo "❌ Tag '${TAG}' already exists locally."
+  exit 1
+fi
+
+if git ls-remote --exit-code --tags origin "refs/tags/${TAG}" >/dev/null 2>&1; then
+  echo "❌ Tag '${TAG}' already exists on origin."
+  exit 1
+fi
+
+if ! git diff --quiet || ! git diff --cached --quiet; then
+  echo "❌ Working tree has uncommitted changes. Commit or stash them before creating a release."
+  exit 1
+fi
+
+echo "🏷️ Creating '${TAG}' on the current commit"
+git tag -a "$TAG" -m "Release ${TAG}"
+git push origin "$TAG"
+
+echo "✅ Tag '${TAG}' created and pushed. GitHub Actions will build and publish the release."

{robotframework_tablelibrary-0.2.1 → robotframework_tablelibrary-0.3.1}/pyproject.toml

@@ -1,5 +1,5 @@
 [build-system]
-requires = ["hatchling"]
+requires = ["hatchling", "hatch-vcs"]
 build-backend = "hatchling.build"
 
 [project]
@@ -21,6 +21,8 @@ classifiers = [
   "Programming Language :: Python :: 3.10",
   "Programming Language :: Python :: 3.11",
   "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
 ]
 dependencies = [
   "overrides",
@@ -58,7 +60,10 @@ only-include = ["src/Tables"]
 sources = ["src"]
 
 [tool.hatch.version]
-path = "src/Tables/__about__.py"
+source = "vcs"
+
+[tool.hatch.build.hooks.vcs]
+version-file = "src/Tables/_version.py"
 
 [tool.hatch.build]
 dev-mode-dirs = ["src"]
@@ -70,12 +75,28 @@ extra-dependencies = [
 [tool.hatch.envs.types.scripts]
 check = "mypy --install-types --non-interactive {args:src/Tables tests}"
 
+[tool.hatch.envs.test]
+dependencies = [
+  "pytest",
+  "pytest-cov",
+  "robotframework=={matrix:robotframework}",
+]
+
+[tool.hatch.envs.test.scripts]
+atest = "robot tests/atest/"
+utest = "pytest --cov=Tables --cov-report=term-missing --cov-branch --cov-fail-under=95"
+all = ["utest", "atest"]
+
+[[tool.hatch.envs.test.matrix]]
+python = ["3.10", "3.11", "3.12", "3.13", "3.14"]
+robotframework = ["7.0", "7.4.2"]
+
 [tool.coverage.run]
 source_pkgs = ["Tables", "tests"]
 branch = true
 parallel = true
 omit = [
-  "src/Tables/__about__.py",
+  "src/Tables/_version.py",
 ]
 
 [tool.coverage.paths]
@@ -103,6 +124,8 @@ docs = "libdoc src/Tables results/keyword_docs.html"
 
 [tool.mypy]
 python_version = "3.10"
+exclude = '(^|/)\.venv(/|$)'
+follow_imports = "skip"
 ignore_missing_imports = true
 no_implicit_optional = true
 strict_optional = true

{robotframework_tablelibrary-0.2.1 → robotframework_tablelibrary-0.3.1}/src/Tables/__init__.py

@@ -7,7 +7,7 @@ from robotlibcore import HybridCore
 
 from Tables.utils.settings_stack import Scope, SettingsStack
 
-from .__about__ import __version__
+from ._version import __version__
 from .keywords import (
     Configuration,
     Getter,
@@ -172,6 +172,7 @@ class Tables(HybridCore):
         line_terminator: LineTerminator = LineTerminator.LF,
         quoting: Quoting = Quoting.MINIMAL,
         quoting_character: QuotingCharacter = QuotingCharacter['"'],
+        missing_as_none: bool = False,
     ):
         """
         ``TableLibrary`` can be controlled by the following arguments:
@@ -184,6 +185,7 @@ class Tables(HybridCore):
         | ``line_terminator`` | Define the required line terminator for your table files. Default is ``False``  |
         | ``quoting`` | Define which values should be surrounded with quotes, please check the CSV quoting for more details. Default is ``MINIMAL``  |
         | ``quoting_character`` | Define quoting character to use for writing table files. Default is ``\"``  |
+        | ``missing_as_none`` | Return parsed missing values as Python ``None`` instead of pandas missing values. Default is ``False``  |
         """
 
         # required variables for SettingsScope mechanism
@@ -202,6 +204,7 @@ class Tables(HybridCore):
         )
         self.scope_stack["quoting"] = SettingsStack(quoting, self)
         self.scope_stack["quoting_character"] = SettingsStack(quoting_character, self)
+        self.scope_stack["missing_as_none"] = SettingsStack(missing_as_none, self)
         self.scope_stack["enable_streaming"] = SettingsStack(False, self)
 
         self.file_access = FileAccess(self)
@@ -222,12 +225,14 @@ class Tables(HybridCore):
         super().__init__(libraries)
 
     def _start_suite(self, _name: running.TestSuite, attrs: result.TestSuite):
-        self.suite_ids[attrs.id] = None
-        self._add_to_scope_stack(attrs.id, Scope.Suite)
+        suite_id = attrs.id
+        self.suite_ids[suite_id] = None
+        self._add_to_scope_stack(suite_id, Scope.Suite)
 
     def _start_test(self, _name: running.TestCase, attrs: result.TestCase):
-        self.current_test_id = attrs.id
-        self._add_to_scope_stack(attrs.id, Scope.Test)
+        test_id = attrs.id
+        self.current_test_id = test_id
+        self._add_to_scope_stack(test_id, Scope.Test)
         self.is_test_case_running = True
 
     def _end_test(self, _name: running.TestCase, attrs: result.TestCase):
@@ -236,8 +241,9 @@ class Tables(HybridCore):
         self.is_test_case_running = False
 
     def _end_suite(self, _name: running.TestSuite, attrs: result.TestSuite):
-        self._remove_from_scope_stack(attrs.id)
-        self.suite_ids.pop(attrs.id, None)
+        suite_id = attrs.id
+        self._remove_from_scope_stack(suite_id)
+        self.suite_ids.pop(suite_id, None)
 
     def _add_to_scope_stack(self, scope_id: str, scope: Scope):
         for stack in self.scope_stack.values():

robotframework_tablelibrary-0.3.1/src/Tables/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.3.1'
+__version_tuple__ = version_tuple = (0, 3, 1)
+
+__commit_id__ = commit_id = None

{robotframework_tablelibrary-0.2.1 → robotframework_tablelibrary-0.3.1}/src/Tables/general/library_attributes.py

@@ -121,3 +121,16 @@ class LibraryAttributes:
     @enable_streaming_stack.setter
     def enable_streaming_stack(self, stack: SettingsStack):
         self.library.scope_stack["enable_streaming"] = stack
+
+    # missing values
+    @property
+    def missing_as_none(self) -> bool:
+        return self.library.scope_stack["missing_as_none"].get()
+
+    @property
+    def missing_as_none_stack(self) -> SettingsStack:
+        return self.library.scope_stack["missing_as_none"]
+
+    @missing_as_none_stack.setter
+    def missing_as_none_stack(self, stack: SettingsStack):
+        self.library.scope_stack["missing_as_none"] = stack

{robotframework_tablelibrary-0.2.1 → robotframework_tablelibrary-0.3.1}/src/Tables/keywords/configuration.py

@@ -25,6 +25,7 @@ class ConfigCtx:
     file_encoding: FileEncoding
     ignore_header: bool
     enable_streaming: bool
+    missing_as_none: bool
 
 
 class Configuration(LibraryAttributes):
@@ -45,6 +46,7 @@ class Configuration(LibraryAttributes):
                 file_encoding=self.file_encoding,
                 ignore_header=self.ignore_header,
                 enable_streaming=self.enable_streaming,
+                missing_as_none=self.missing_as_none,
             )
         )
 
@@ -199,3 +201,26 @@ class Configuration(LibraryAttributes):
         self.enable_streaming_stack.set(enable_streaming, scope)
         logger.debug(f"'file_type': old value: {old_config} - new value: {enable_streaming}")
         return old_config
+
+    @keyword(tags=["Configuration"])
+    def configure_missing_as_none(self, missing_as_none: bool, scope: Scope = Scope.Suite):
+        """
+        Configure whether parsed missing values are returned as Python ``None``.
+
+        When enabled, pandas missing values such as ``NaN``, ``pd.NA`` and ``NaT``
+        are converted to ``None`` in list, dictionary, cell, row and column results.
+        Values recognized as missing by the active parser, such as ``N/A`` and ``NULL``,
+        are included. DataFrame results and the library's internal DataFrames are not changed.
+
+        | =`Arguments`= | =`Description`= |
+        | ``missing_as_none`` | Set to ``True`` to return missing values as Python ``None``. Default: ``False`` |
+        | ``scope`` | Scope in which the setting applies. |
+
+        == Example ==
+        | Configure Missing As None    True
+        | Configure Missing As None    False
+        """
+        old_config = self.missing_as_none
+        self.missing_as_none_stack.set(missing_as_none, scope)
+        logger.debug(f"'missing_as_none': old value: {old_config} - new value: {missing_as_none}")
+        return old_config

{robotframework_tablelibrary-0.2.1 → robotframework_tablelibrary-0.3.1}/src/Tables/keywords/getter.py

@@ -58,6 +58,8 @@ class Getter(LibraryAttributes):
             table_df = table_df.iloc[1:]
             data = data[1:]
 
+        data = self.file_reader.convert_missing_values(data)
+
         if return_type == TableFormat["List of dicts"]:
             df_for_dicts = table_df
 
@@ -65,7 +67,9 @@ class Getter(LibraryAttributes):
                 header = [str(x) for x in df_for_dicts.iloc[0].tolist()]
                 df_for_dicts = df_for_dicts.iloc[1:].copy()
                 df_for_dicts.columns = header
-            return cast(list[dict[str, Any]], df_for_dicts.to_dict(orient="records"))
+            return self.file_reader.convert_missing_values(
+                cast(list[dict[str, Any]], df_for_dicts.to_dict(orient="records"))
+            )
         return data
 
     @keyword(tags=["Getter"])
@@ -196,6 +200,9 @@ class Getter(LibraryAttributes):
         | =`Arguments`= | =`Description`= |
         | ``return_type`` | Choose what type of table format it should return. Default: list of lists|
 
+        If ``Configure Missing As None`` is enabled, missing values are returned as
+        Python ``None`` for list and dictionary results. DataFrame results are unchanged.
+
         == Return Value ==
         Return table in form as either list of lists, list of dicts or dataframe.
 
@@ -229,6 +236,9 @@ class Getter(LibraryAttributes):
         | ``assertion_expected`` | See ``robotframework-assertion-engine`` for more details |
         | ``message`` | Custom error message for failed assertion |
 
+        If ``Configure Missing As None`` is enabled, a missing cell is returned as
+        Python ``None`` and assertions are evaluated against the converted value.
+
         == Return Value ==
         Keyword returns the value of the given cell.
         In case of a failed assertion, the keyword will just fail without returning anything.
@@ -245,6 +255,7 @@ class Getter(LibraryAttributes):
         column = self.file_reader.cast_column_type(column)
 
         cell = table_df.loc[row, column] if isinstance(column, str) else table_df.iloc[row, column]
+        cell = self.file_reader.convert_missing_values(cell)
 
         if assertion_expected:
             if assertion_operator not in NumericalOperators:
@@ -272,6 +283,9 @@ class Getter(LibraryAttributes):
         | ``assertion_expected`` | See ``robotframework-assertion-engine`` for more details |
         | ``message`` | Custom error message for failed assertion |
 
+        If ``Configure Missing As None`` is enabled, missing column values are returned
+        as Python ``None`` and assertions are evaluated against the converted values.
+
         == Return Value ==
         Returns column values as a list.
 
@@ -291,7 +305,7 @@ class Getter(LibraryAttributes):
         column = self.file_reader.cast_column_type(column)
 
         column_df = table_df.loc[:, column] if isinstance(column, str) else table_df.iloc[:, column]
-        column_list = cast(list[Any], column_df.to_list())
+        column_list = self.file_reader.convert_missing_values(cast(list[Any], column_df.to_list()))
 
         if assertion_expected:
             if assertion_operator not in valid_assertions:
@@ -318,6 +332,9 @@ class Getter(LibraryAttributes):
         | ``assertion_expected`` | See ``robotframework-assertion-engine`` for more details |
         | ``message`` | Custom error message for failed assertion |
 
+        If ``Configure Missing As None`` is enabled, missing row values are returned as
+        Python ``None`` and assertions are evaluated against the converted values.
+
         == Return Value ==
         Returns row values as a list.
 
@@ -335,7 +352,7 @@ class Getter(LibraryAttributes):
         current_df = self.file_reader.file_sync.table_storage[self.file_reader.file_sync.current_file].data
         table_df = self.file_reader.validate_table_to_dataframe(data=current_df, row=row)
 
-        row_list = cast(list[Any], table_df.iloc[row].to_list())
+        row_list = self.file_reader.convert_missing_values(cast(list[Any], table_df.iloc[row].to_list()))
 
         if assertion_expected:
             if assertion_operator not in valid_assertions:
@@ -347,7 +364,7 @@ class Getter(LibraryAttributes):
         return row_list
 
     @keyword(tags=["Getter"])
-    def count_table(  # noqa: PLR0913
+    def count_table(  # noqa PLR0913
         self,
         path: Path | str,
         axis: Axis,

{robotframework_tablelibrary-0.2.1 → robotframework_tablelibrary-0.3.1}/src/Tables/utils/file_reader.py

@@ -50,7 +50,7 @@ class FileReader(LibraryAttributes):
             if self.file_type == FileType.Parquet and not self.ignore_header:
                 list_data.insert(0, list(data.columns))
 
-            return list_data
+            return self.convert_missing_values(list_data)
         if return_type == TableFormat["List of dicts"]:
             df_for_dicts = data
 
@@ -58,11 +58,25 @@ class FileReader(LibraryAttributes):
                 header = [str(x) for x in df_for_dicts.iloc[0].tolist()]
                 df_for_dicts = df_for_dicts.iloc[1:].copy()
                 df_for_dicts.columns = header
-            return cast(list[dict[str, Any]], df_for_dicts.to_dict(orient="records"))
+            return self.convert_missing_values(cast(list[dict[str, Any]], df_for_dicts.to_dict(orient="records")))
         if return_type == TableFormat["Dataframe"]:
             return data
         raise ValueError(f"Invalid TableFormat type. Please select valid values: {[key.name for key in TableFormat]}")
 
+    def convert_missing_values(self, value: Any) -> Any:
+        if not self.missing_as_none:
+            return value
+        if isinstance(value, list):
+            return [self.convert_missing_values(item) for item in value]
+        if isinstance(value, dict):
+            return {key: self.convert_missing_values(item) for key, item in value.items()}
+        try:
+            if bool(pd.isna(value)):
+                return None
+        except (TypeError, ValueError):
+            pass
+        return value
+
     def file_exists(self, path: Path) -> bool | FileNotFoundError:
         if not path.is_file():
             raise FileNotFoundError(f"File not found: {path}")
@@ -206,8 +220,8 @@ class FileReader(LibraryAttributes):
     def validate_table_to_dataframe(
         self,
         data: list[list] | DataFrame,
-        row: None | int = None,
-        column: None | str | int = None,
+        row: int | None = None,
+        column: str | int | None = None,
     ) -> DataFrame:
         """Formats a table (list of lists or dataframe) to dataframe. Also checks
         if provided row or column are valid (see validate_row/ validate_column)."""

{robotframework_tablelibrary-0.2.1 → robotframework_tablelibrary-0.3.1}/src/Tables/utils/file_writer.py

@@ -219,8 +219,8 @@ class FileWriter(LibraryAttributes):
     def set_dataframe_cells(
         self,
         data: Any,
-        row: None | int = None,
-        column: None | str | int = None,
+        row: int | None = None,
+        column: str | int | None = None,
         header: bool = True,
         return_type: TableFormat = TableFormat["Dataframe"],
     ) -> list[list] | list[dict] | DataFrame: