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

{robotframework_tablelibrary-0.1.4 → robotframework_tablelibrary-0.2.1}/.pre-commit-config.yaml

@@ -9,6 +9,11 @@ repos:
         language: python
         types_or: [python, pyi]
         require_serial: true
+        args:
+          - --disable-error-code
+          - no-any-return
+          - --disable-error-code
+          - arg-type
 
   # try generating the libdoc documentation
   - repo: local
@@ -23,13 +28,6 @@ repos:
   # Ruff linter for Python files
   - repo: local
     hooks:
-      # - id: ruff-format
-      #   name: ruff-format
-      #   description: "Run 'ruff format' for extremely fast Python formatting"
-      #   entry: ruff format --force-exclude
-      #   language: python
-      #   types_or: [python, pyi, jupyter]
-      #   require_serial: true
 
       - id: ruff
         name: ruff
@@ -39,6 +37,14 @@ repos:
         types_or: [python, pyi, jupyter]
         require_serial: true
 
+      - id: ruff-format
+        name: ruff-format
+        description: "Run 'ruff format' for extremely fast Python formatting"
+        entry: ruff format --force-exclude
+        language: python
+        types_or: [python, pyi, jupyter]
+        require_serial: true
+
   # Robocop formatter and linter for Robot Framework (.robot and .resource files)
   - repo: local
     hooks:

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

@@ -1,5 +1,10 @@
 # Development
 
+## Unit Testing
+
+We are measuring the coverage of the unit tests & expect a minimum coverage of 95% - otherwise the pipeline job for the unit test execution will fail accordingly.    
+Please ensure you've added unit tests whenever adding new source code to the project.
+
 ## Release Creation
 
 ### Precondition

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: robotframework-tablelibrary
-Version: 0.1.4
+Version: 0.2.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
@@ -30,6 +30,7 @@ Requires-Dist: hatch; extra == 'dev'
 Requires-Dist: mypy; extra == 'dev'
 Requires-Dist: pre-commit; extra == 'dev'
 Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
 Requires-Dist: robotframework-robocop; extra == 'dev'
 Requires-Dist: ruff; extra == 'dev'
 Description-Content-Type: text/markdown

{robotframework_tablelibrary-0.1.4 → robotframework_tablelibrary-0.2.1}/create_release.sh

@@ -13,7 +13,12 @@ FILE="src/Tables/__about__.py"
 echo "🔧 Updating version to '${NEW_VERSION}' in '${FILE}'"
 
 # Example: __version__ = "0.0.6"  →  __version__ = "0.0.7"
-sed -i.bak -E "s/^(__version__\s*=\s*\")[^\"]+\"/\1${NEW_VERSION}\"/" "$FILE"
+if [[ "$OSTYPE" == "darwin"* ]]; then
+    sed -i '' -E "s/^(__version__ *= *\")[^\"]+/\1${NEW_VERSION}/" src/Tables/__about__.py
+else
+    sed -i.bak -E "s/^(__version__\s*=\s*\")[^\"]+\"/\1${NEW_VERSION}\"/" "$FILE"
+fi
+
 rm -f "${FILE}.bak"
 
 git checkout main

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

@@ -39,6 +39,7 @@ dev = [
     "hatch",
     "ruff",
     "pytest",
+    "pytest-cov",
     "pre-commit",
     "mypy",
     "robotframework-robocop"
@@ -91,12 +92,13 @@ exclude_lines = [
 [tool.hatch.envs.dev]
 dependencies = [
   "ruff",
-  "pytest"
+  "pytest",
+  "pytest-cov"
 ]
 [tool.hatch.envs.dev.scripts]
 lint = "ruff check ."
 atest = "robot tests/atest/"
-utest = "pytest"
+utest = "pytest --cov=Tables --cov-report=term-missing --cov-branch --cov-fail-under=95"
 docs = "libdoc src/Tables results/keyword_docs.html"
 
 [tool.mypy]
@@ -110,27 +112,26 @@ warn_unreachable = true
 pretty = true
 
 [tool.ruff]
-fix = false
 target-version = "py310"
-line-length = 100
+line-length = 125
 exclude = [
   "__pycache__",
   ".venv",
   "tools",
   "model",
+  ".git",
+  "build",
+  "dist"
 ]
 
 [tool.ruff.format]
 quote-style = "double"
+indent-style = "space"
 
 [tool.ruff.lint]
 ignore = [
-  "N815",  # mixedCase variable in class scope
-  "N803",  # argument name should be lowercase
-  "T201",  # Print statements
-  "INP001",  # part of an implicit namespace package
   "N999",  # Invalid module name
-  "E501", # Line Length
+  "E501" # docstrings
 ]
 select = [
   "E",
@@ -159,6 +160,7 @@ select = [
   "SIM",
   "RUF",
 ]
+unfixable = []
 
 [tool.robocop.lint]
 select = [

{robotframework_tablelibrary-0.1.4 → robotframework_tablelibrary-0.2.1}/src/Tables/__about__.py

@@ -1,4 +1,4 @@
 # SPDX-FileCopyrightText: 2025-present Marvin Klerx <marvinklerx20@gmail.com>
 #
 # SPDX-License-Identifier: MIT
-__version__ = "0.1.4"
+__version__ = "0.2.1"

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

@@ -1,9 +1,12 @@
 # SPDX-FileCopyrightText: 2025-present Marvin Klerx <marvinklerx20@gmail.com>
 #
 # SPDX-License-Identifier: MIT
+from robot import result, running
 from robot.api.deco import library
 from robotlibcore import HybridCore
 
+from Tables.utils.settings_stack import Scope, SettingsStack
+
 from .__about__ import __version__
 from .keywords import (
     Configuration,
@@ -45,6 +48,33 @@ class Tables(HybridCore):
     - latin-1
     - further more... (define your own file encoding with the given library argument)
 
+    == Live Data Streaming ==
+    Some keywords allow you to write the inserted or appended data directly into an output table file.
+    By default, the table library writes the modified table data first into the internal cache.
+    In this case, you decide when to write the data into a file.
+
+    If you require the modified data on the fly within the file on your file system, you can enable the streaming via ``Configure Streaming``.
+
+    Afterwards, every keyword that allows the on-the-fly streaming, writes the new data directly into the file system instead of modifying the table just in the cache.
+
+    Example:
+    |  # enable the streaming on-the-fly
+    |  Configure Streaming    True    Test
+    |
+    |  VAR    ${filepath} =    ${CURDIR}/results/test_writer_live_streaming_append_row.csv
+    |  VAR    @{headers} =    counter    random
+    |  ${uuid} =    Tables.Create Table    headers=${headers}    file_path=${filepath}
+    |
+    |  # append ten rows on-the-fly within the given csv file
+    |  FOR    ${i}    IN RANGE    ${10}
+    |      ${random} =    Generate Random String    10
+    |      VAR    @{row} =    ${i}    ${random}
+    |      Tables.Append Row    ${row}
+    |
+    |      ${table_content} =    Tables.Read Table    ${filepath}
+    |      Should Be Equal    ${table_content}[-1][1]    ${random}
+    |  END
+
     == Excel Files ==
     We have included a basic handling of ``Excel`` files,
     but for more complex excel features, please take a look at the following library:
@@ -155,18 +185,32 @@ class Tables(HybridCore):
         | ``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 ``\"``  |
         """
-        self._file_type = file_type
-        self._separator = separator
-        self._file_encoding: str = (
-            file_encoding.value if isinstance(file_encoding, FileEncoding) else file_encoding
+
+        # required variables for SettingsScope mechanism
+        self.scope_stack: dict = {}
+        self.suite_ids: dict[str, None] = {}
+        self.current_test_id: str | None = None
+        self.is_test_case_running = False
+
+        # following config variables are using SettingsStack engine with scopes
+        self.scope_stack["ignore_header"] = SettingsStack(ignore_header, self)
+        self.scope_stack["file_type"] = SettingsStack(file_type, self)
+        self.scope_stack["separator"] = SettingsStack(separator, self)
+        self.scope_stack["line_terminator"] = SettingsStack(line_terminator, self)
+        self.scope_stack["file_encoding"] = SettingsStack(
+            file_encoding.value if isinstance(file_encoding, FileEncoding) else file_encoding, self
         )
-        self._ignore_header = ignore_header
-        self._line_terminator = line_terminator
-        self._quoting = quoting
-        self._quoting_character = quoting_character
+        self.scope_stack["quoting"] = SettingsStack(quoting, self)
+        self.scope_stack["quoting_character"] = SettingsStack(quoting_character, self)
+        self.scope_stack["enable_streaming"] = SettingsStack(False, self)
 
         self.file_access = FileAccess(self)
 
+        self.ROBOT_LIBRARY_LISTENER = [
+            self,
+            Modifier(self, self.file_access),
+        ]
+
         libraries = [
             Configuration(self),
             Getter(self, self.file_access),
@@ -176,3 +220,29 @@ 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)
+
+    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)
+        self.is_test_case_running = True
+
+    def _end_test(self, _name: running.TestCase, attrs: result.TestCase):
+        self._remove_from_scope_stack(attrs.id)
+        self.current_test_id = None
+        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)
+
+    def _add_to_scope_stack(self, scope_id: str, scope: Scope):
+        for stack in self.scope_stack.values():
+            stack.start(scope_id, scope)
+
+    def _remove_from_scope_stack(self, scope_id):
+        for stack in self.scope_stack.values():
+            stack.end(scope_id)

robotframework_tablelibrary-0.2.1/src/Tables/general/library_attributes.py

@@ -0,0 +1,123 @@
+from typing import TYPE_CHECKING
+
+from Tables.utils.settings import Delimiter, FileEncoding, FileType, LineTerminator, Quoting, QuotingCharacter
+from Tables.utils.settings_stack import SettingsStack
+
+if TYPE_CHECKING:
+    from .. import Tables
+
+
+class LibraryAttributes:
+    def __init__(self, library: "Tables") -> None:
+        """
+        Expose library attributes to all classes
+        """
+        self.library = library
+
+    ###
+    ### New strategy: use SettingsStack like in Browser library for different scopes
+    ###
+
+    # ignore_header
+    @property
+    def ignore_header(self) -> bool:
+        return self.library.scope_stack["ignore_header"].get()
+
+    @property
+    def ignore_header_stack(self) -> SettingsStack:
+        return self.library.scope_stack["ignore_header"]
+
+    @ignore_header_stack.setter
+    def ignore_header_stack(self, stack: SettingsStack):
+        self.library.scope_stack["ignore_header"] = stack
+
+    # file_type
+    @property
+    def file_type(self) -> FileType:
+        return self.library.scope_stack["file_type"].get()
+
+    @property
+    def file_type_stack(self) -> SettingsStack:
+        return self.library.scope_stack["file_type"]
+
+    @file_type_stack.setter
+    def file_type_stack(self, stack: SettingsStack):
+        self.library.scope_stack["file_type"] = stack
+
+    # separator / delimiter
+    @property
+    def separator(self) -> Delimiter:
+        return self.library.scope_stack["separator"].get()
+
+    @property
+    def separator_stack(self) -> SettingsStack:
+        return self.library.scope_stack["separator"]
+
+    @separator_stack.setter
+    def separator_stack(self, stack: SettingsStack):
+        self.library.scope_stack["separator"] = stack
+
+    # line terminator
+    @property
+    def line_terminator(self) -> LineTerminator:
+        return self.library.scope_stack["line_terminator"].get()
+
+    @property
+    def line_terminator_stack(self) -> SettingsStack:
+        return self.library.scope_stack["line_terminator"]
+
+    @line_terminator_stack.setter
+    def line_terminator_stack(self, stack: SettingsStack):
+        self.library.scope_stack["line_terminator"] = stack
+
+    # file encoding
+    @property
+    def file_encoding(self) -> FileEncoding:
+        return self.library.scope_stack["file_encoding"].get()
+
+    @property
+    def file_encoding_stack(self) -> SettingsStack:
+        return self.library.scope_stack["file_encoding"]
+
+    @file_encoding_stack.setter
+    def file_encoding_stack(self, stack: SettingsStack):
+        self.library.scope_stack["file_encoding"] = stack
+
+    # quoting
+    @property
+    def quoting(self) -> Quoting:
+        return self.library.scope_stack["quoting"].get()
+
+    @property
+    def quoting_stack(self) -> SettingsStack:
+        return self.library.scope_stack["quoting"]
+
+    @quoting_stack.setter
+    def quoting_stack(self, stack: SettingsStack):
+        self.library.scope_stack["quoting"] = stack
+
+    # quoting character
+    @property
+    def quoting_character(self) -> QuotingCharacter:
+        return self.library.scope_stack["quoting_character"].get()
+
+    @property
+    def quoting_character_stack(self) -> SettingsStack:
+        return self.library.scope_stack["quoting_character"]
+
+    @quoting_character_stack.setter
+    def quoting_character_stack(self, stack: SettingsStack):
+        self.library.scope_stack["quoting_character"] = stack
+
+    # data streaming into files
+    @property
+    def enable_streaming(self) -> QuotingCharacter:
+        return self.library.scope_stack["enable_streaming"].get()
+
+    @property
+    def enable_streaming_stack(self) -> SettingsStack:
+        return self.library.scope_stack["enable_streaming"]
+
+    @enable_streaming_stack.setter
+    def enable_streaming_stack(self, stack: SettingsStack):
+        self.library.scope_stack["enable_streaming"] = stack

robotframework_tablelibrary-0.2.1/src/Tables/keywords/configuration.py

@@ -0,0 +1,201 @@
+from dataclasses import asdict, dataclass
+
+from robot.api import logger
+from robot.api.deco import keyword
+
+from ..general.library_attributes import LibraryAttributes
+from ..utils.settings import (
+    Delimiter,
+    FileEncoding,
+    FileType,
+    LineTerminator,
+    Quoting,
+    QuotingCharacter,
+)
+from ..utils.settings_stack import Scope
+
+
+@dataclass
+class ConfigCtx:
+    file_type: FileType
+    separator: Delimiter
+    quoting: Quoting
+    quoting_character: QuotingCharacter
+    line_terminator: LineTerminator
+    file_encoding: FileEncoding
+    ignore_header: bool
+    enable_streaming: bool
+
+
+class Configuration(LibraryAttributes):
+    @keyword(tags=["Configuration"])
+    def get_library_configuration(self) -> dict:
+        """
+        Keyword returns the current internal library configuration.
+
+        Return value is type ``ConfigCtx`` and contains all relevant configuration parameters.
+        """
+        return asdict(
+            ConfigCtx(
+                file_type=self.file_type,
+                separator=self.separator,
+                quoting=self.quoting,
+                quoting_character=self.quoting_character,
+                line_terminator=self.line_terminator,
+                file_encoding=self.file_encoding,
+                ignore_header=self.ignore_header,
+                enable_streaming=self.enable_streaming,
+            )
+        )
+
+    @keyword(tags=["Configuration"])
+    def configure_file_type(self, file_type: FileType, scope: Scope = Scope.Suite):
+        """
+        Change the internal file type during your test execution dynamically.
+
+        | =`Arguments`= | =`Description`= |
+        | ``file_type`` | Choose the new file type |
+
+        == Example ==
+        | Configure File Type    CSV
+        | Configure File Type    Excel
+        | Configure File Type    Parquet
+        """
+        old_config = self.file_type
+        self.file_type_stack.set(file_type, scope)
+        logger.debug(f"'file_type': old value: {old_config} - new value: {file_type}")
+        return old_config
+
+    @keyword(tags=["Configuration"])
+    def configure_separator(self, separator: Delimiter, scope: Scope = Scope.Suite):
+        """
+        Change the internal separator during your test execution dynamically.
+
+        | =`Arguments`= | =`Description`= |
+        | ``separator`` | Define a new separator |
+
+        == Example ==
+        | Configure Delimiter    ;
+        | Configure Delimiter    ,
+        | Configure Delimiter    \\t
+        """
+        old_config = self.separator
+        self.separator_stack.set(separator, scope)
+        logger.debug(f"'file_type': old value: {old_config} - new value: {separator}")
+        return old_config
+
+    @keyword(tags=["Configuration"])
+    def configure_quoting(self, quoting: Quoting, scope: Scope = Scope.Suite):
+        """
+        Change the internal quoting mode during your test execution dynamically.
+
+        | =`Arguments`= | =`Description`= |
+        | ``quoting`` | Define a new quoting mode |
+
+        == Example ==
+        | Configure Quoting    MINIMAL
+        | Configure Quoting    NONNUMERIC
+        | Configure Quoting    NONE
+        """
+        old_config = self.quoting
+        self.quoting_stack.set(quoting, scope)
+        logger.debug(f"'file_type': old value: {old_config} - new value: {quoting}")
+        return old_config
+
+    @keyword(tags=["Configuration"])
+    def configure_quoting_character(self, quoting_character: QuotingCharacter, scope: Scope = Scope.Suite):
+        """
+        Change the internal quoting character during your test execution dynamically.
+
+        | =`Arguments`= | =`Description`= |
+        | ``quoting`` | Define a new quoting mode |
+
+        == Example ==
+        | Configure Quoting Character    "
+        | Configure Quoting Character    '
+        """
+        old_config = self.quoting_character
+        self.quoting_character_stack.set(quoting_character, scope)
+        logger.debug(f"'file_type': old value: {old_config} - new value: {quoting_character}")
+        return old_config
+
+    @keyword(tags=["Configuration"])
+    def configure_line_terminator(self, line_terminator: LineTerminator, scope: Scope = Scope.Suite):
+        """
+        Change the internal line terminator during your test execution dynamically.
+
+        | =`Arguments`= | =`Description`= |
+        | ``line_terminator`` | Define a new line_terminator |
+
+        == Example ==
+        | Configure Line Terminator    LF
+        | Configure Line Terminator    CRLF
+        """
+        old_config = self.line_terminator
+        self.line_terminator_stack.set(line_terminator, scope)
+        logger.debug(f"'file_type': old value: {old_config} - new value: {line_terminator}")
+        return old_config
+
+    @keyword(tags=["Configuration"])
+    def configure_file_encoding(self, file_encoding: FileEncoding | str, scope: Scope = Scope.Suite):
+        """
+        Change the internal file encoding during your test execution dynamically.
+
+        | =`Arguments`= | =`Description`= |
+        | ``file_encoding`` | Define a new file encoding |
+
+        == Example ==
+        | Configure File Encoding    UTF_8
+        | Configure File Encoding    UTF_16
+        | Configure File Encoding    LATIN_1
+
+        see [Python Encoding Names|https://docs.python.org/3/library/codecs.html#standard-encodings]
+        """
+        old_config = self.file_encoding
+        self.file_encoding_stack.set(
+            file_encoding.value if isinstance(file_encoding, FileEncoding) else file_encoding, scope
+        )
+        logger.debug(f"'file_type': old value: {old_config} - new value: {file_encoding}")
+        return old_config
+
+    @keyword(tags=["Configuration"])
+    def configure_ignore_header(self, ignore_header: bool, scope: Scope = Scope.Suite):
+        """
+        Change the internal setting to (not) ignore the data header lines during your test execution dynamically.
+
+        | =`Arguments`= | =`Description`= |
+        | ``ignore_header`` | Ignore / recognize header columns |
+
+        == Example ==
+        | Configure Ignore Header    True
+        | Configure Ignore Header    False
+        """
+
+        old_config = self.ignore_header
+        self.ignore_header_stack.set(ignore_header, scope)
+        logger.debug(f"'ignore_header': old value: {old_config} - new value: {ignore_header}")
+        return old_config
+
+    @keyword(tags=["Configuration"])
+    def configure_streaming(self, enable_streaming: bool, scope: Scope = Scope.Suite):
+        """
+        Enable / disable the direct streaming of data into the given table file.
+
+        = Default Behaviour =
+        By default, you can open a table, modify the content in the internal cache of the Table library and afterwards to write it into a table file.
+
+        = Behaviour using Streaming =
+        Using the streaming behaviour enables you to write e.g. rows directly into the table file instead of the internal cache.
+        This can be required in case you need the data immediately in the file, and not in the cache.
+
+        | =`Arguments`= | =`Description`= |
+        | ``enable_streaming`` | Set to ``True`` to enable the streaming - default: ``False`` |
+
+        == Example ==
+        | Configure Streaming    True
+        | Configure Streaming    False
+        """
+        old_config = self.enable_streaming
+        self.enable_streaming_stack.set(enable_streaming, scope)
+        logger.debug(f"'file_type': old value: {old_config} - new value: {enable_streaming}")
+        return old_config

{robotframework_tablelibrary-0.1.4 → robotframework_tablelibrary-0.2.1}/src/Tables/keywords/excel.py

@@ -42,9 +42,7 @@ class Excel(LibraryAttributes):
     ###
 
     @keyword(tags=["Excel", "Getter"])
-    def excel_open(
-        self, alias: str, path: str, sheet_name: str | list[str | int] | None = None
-    ) -> str:
+    def excel_open(self, alias: str, path: str, sheet_name: str | list[str | int] | None = None) -> str:
         """
         Keyword to open the given excel file.
 
@@ -97,9 +95,7 @@ class Excel(LibraryAttributes):
                 self.current_file = None
             logger.info(f"Excel file '{alias}' is closed!")
             return True
-        raise KeyError(
-            f"Given file alias '{alias}' does not exist - check all opened files and their alias first!"
-        )
+        raise KeyError(f"Given file alias '{alias}' does not exist - check all opened files and their alias first!")
 
     @keyword(tags=["Excel", "Getter"])
     def excel_get_open_files(self) -> list: