cyberark-tpc-plugin-parser 0.1.0__tar.gz

cyberark_tpc_plugin_parser-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 (Peter McDonald)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

cyberark_tpc_plugin_parser-0.1.0/PKG-INFO

@@ -0,0 +1,72 @@
+Metadata-Version: 2.4
+Name: cyberark-tpc-plugin-parser
+Version: 0.1.0
+Summary: A package to help parse CyberArk TPC plugin prompts and process files.
+Author-email: Peter McDonald <git@petermcdonald.co.uk>
+License: MIT License
+        
+        Copyright (c) 2025 (Peter McDonald)
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# CyberArk TPC Plugin Parser
+
+CyberArk TPC Plugin Parser is a package intended to make it easy to work with CyberArk process
+and platform ini files.
+
+The lexer and parser breaks down the files to their constituent parts so that they can be
+further processed by other applications.
+
+## Installation
+
+CyberArk TPC Plugin Parser can be installed using Pip:
+
+```bash
+pip install cyberark-tpc-plugin-parser
+```
+
+## Usage
+
+The main point of entry is the parser, this takes the content of the process and prompts
+files as arguments:
+
+```python
+from tpc_plugin_parser.parser import Parser
+
+with open('/path/to/files/process.ini') as process_fh:
+    process_content: str = process_fh.read()
+    
+with open('/path/to/files/prompts.ini') as prompts_fh:
+    prompts_content: str = prompts_fh.read()
+
+parser: Parser = Parser(process_file=process_content, prompts_file=prompts_content)
+process_file_tokens = parser.process_file
+prompt_file_tokens = parser.prompts_file
+```

cyberark_tpc_plugin_parser-0.1.0/README.md

@@ -0,0 +1,34 @@
+# CyberArk TPC Plugin Parser
+
+CyberArk TPC Plugin Parser is a package intended to make it easy to work with CyberArk process
+and platform ini files.
+
+The lexer and parser breaks down the files to their constituent parts so that they can be
+further processed by other applications.
+
+## Installation
+
+CyberArk TPC Plugin Parser can be installed using Pip:
+
+```bash
+pip install cyberark-tpc-plugin-parser
+```
+
+## Usage
+
+The main point of entry is the parser, this takes the content of the process and prompts
+files as arguments:
+
+```python
+from tpc_plugin_parser.parser import Parser
+
+with open('/path/to/files/process.ini') as process_fh:
+    process_content: str = process_fh.read()
+    
+with open('/path/to/files/prompts.ini') as prompts_fh:
+    prompts_content: str = prompts_fh.read()
+
+parser: Parser = Parser(process_file=process_content, prompts_file=prompts_content)
+process_file_tokens = parser.process_file
+prompt_file_tokens = parser.prompts_file
+```

cyberark_tpc_plugin_parser-0.1.0/cyberark_tpc_plugin_parser.egg-info/PKG-INFO

@@ -0,0 +1,72 @@
+Metadata-Version: 2.4
+Name: cyberark-tpc-plugin-parser
+Version: 0.1.0
+Summary: A package to help parse CyberArk TPC plugin prompts and process files.
+Author-email: Peter McDonald <git@petermcdonald.co.uk>
+License: MIT License
+        
+        Copyright (c) 2025 (Peter McDonald)
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# CyberArk TPC Plugin Parser
+
+CyberArk TPC Plugin Parser is a package intended to make it easy to work with CyberArk process
+and platform ini files.
+
+The lexer and parser breaks down the files to their constituent parts so that they can be
+further processed by other applications.
+
+## Installation
+
+CyberArk TPC Plugin Parser can be installed using Pip:
+
+```bash
+pip install cyberark-tpc-plugin-parser
+```
+
+## Usage
+
+The main point of entry is the parser, this takes the content of the process and prompts
+files as arguments:
+
+```python
+from tpc_plugin_parser.parser import Parser
+
+with open('/path/to/files/process.ini') as process_fh:
+    process_content: str = process_fh.read()
+    
+with open('/path/to/files/prompts.ini') as prompts_fh:
+    prompts_content: str = prompts_fh.read()
+
+parser: Parser = Parser(process_file=process_content, prompts_file=prompts_content)
+process_file_tokens = parser.process_file
+prompt_file_tokens = parser.prompts_file
+```

cyberark_tpc_plugin_parser-0.1.0/cyberark_tpc_plugin_parser.egg-info/SOURCES.txt

@@ -0,0 +1,25 @@
+LICENSE
+README.md
+pyproject.toml
+cyberark_tpc_plugin_parser.egg-info/PKG-INFO
+cyberark_tpc_plugin_parser.egg-info/SOURCES.txt
+cyberark_tpc_plugin_parser.egg-info/dependency_links.txt
+cyberark_tpc_plugin_parser.egg-info/top_level.txt
+tests/test_lexer.py
+tests/test_parser.py
+tpc_plugin_parser/__init__..py
+tpc_plugin_parser/parser.py
+tpc_plugin_parser/lexer/__init__.py
+tpc_plugin_parser/lexer/lexer.py
+tpc_plugin_parser/lexer/tokens/__init__.py
+tpc_plugin_parser/lexer/tokens/assignment.py
+tpc_plugin_parser/lexer/tokens/comment.py
+tpc_plugin_parser/lexer/tokens/cpm_parameter_validation.py
+tpc_plugin_parser/lexer/tokens/fail_state.py
+tpc_plugin_parser/lexer/tokens/parse_error.py
+tpc_plugin_parser/lexer/tokens/section_header.py
+tpc_plugin_parser/lexer/tokens/transition.py
+tpc_plugin_parser/lexer/utilities/__init__.py
+tpc_plugin_parser/lexer/utilities/regex.py
+tpc_plugin_parser/lexer/utilities/token_name.py
+tpc_plugin_parser/lexer/utilities/types.py

cyberark_tpc_plugin_parser-0.1.0/cyberark_tpc_plugin_parser.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

cyberark_tpc_plugin_parser-0.1.0/cyberark_tpc_plugin_parser.egg-info/top_level.txt

@@ -0,0 +1 @@
+tpc_plugin_parser

cyberark_tpc_plugin_parser-0.1.0/pyproject.toml

@@ -0,0 +1,34 @@
+[project]
+name = "cyberark-tpc-plugin-parser"
+version = "0.1.0"
+description = "A package to help parse CyberArk TPC plugin prompts and process files."
+authors = [{ name = "Peter McDonald", email = "git@petermcdonald.co.uk"}]
+readme = "README.md"
+license = { file = "LICENSE" }
+requires-python = ">=3.11"
+
+classifiers = [
+  "Programming Language :: Python",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+  "Programming Language :: Python :: 3.15",
+]
+
+dependencies = []
+
+[dependency-groups]
+dev = [
+    "pytest>=8.4.2",
+    "pytest-cov>=7.0.0",
+    "ruff>=0.13.0",
+    "troml>=0.4.1",
+    "ty>=0.0.1a20",
+]
+
+[tool.pytest.ini_options]
+addopts = "--cov=tpc_plugin_parser --cov-report term-missing --cov-report xml:coverage.xml"
+
+[tool.ruff]
+line-length = 120

cyberark_tpc_plugin_parser-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

cyberark_tpc_plugin_parser-0.1.0/tests/test_lexer.py

@@ -0,0 +1,263 @@
+"""Test the lexer."""
+
+import pytest
+from tpc_plugin_parser.lexer.lexer import Lexer
+from tpc_plugin_parser.lexer.tokens.assignment import Assignment
+from tpc_plugin_parser.lexer.tokens.comment import Comment
+from tpc_plugin_parser.lexer.tokens.cpm_parameter_validation import CPMParameterValidation
+from tpc_plugin_parser.lexer.tokens.fail_state import FailState
+from tpc_plugin_parser.lexer.tokens.parse_error import ParseError
+from tpc_plugin_parser.lexer.tokens.section_header import SectionHeader
+from tpc_plugin_parser.lexer.tokens.transition import Transition
+from tpc_plugin_parser.lexer.utilities.token_name import TokenName
+
+
+class TestLexer(object):
+    """Test the lexer."""
+
+    @pytest.mark.parametrize(
+        "line,expected_token_list",
+        [
+            (
+                'password, source=FILE, Mandatory=![string equal -nocase "<username>" ""], allowcharacters=abc',
+                [
+                    (
+                        TokenName.CPM_PARAMETER_VALIDATION,
+                        CPMParameterValidation(
+                            line_number=1,
+                            name="password",
+                            source="FILE",
+                            mandatory='![string equal -nocase "<username>" ""]',
+                            allow_characters="abc",
+                            token_name=TokenName.CPM_PARAMETER_VALIDATION.value,
+                        ),
+                    ),
+                ],
+            ),
+            (
+                "TestVar",
+                [
+                    (
+                        TokenName.ASSIGNMENT,
+                        Assignment(
+                            line_number=1,
+                            name="TestVar",
+                            equals=None,
+                            assigned=None,
+                        ),
+                    ),
+                ],
+            ),
+            (
+                "testvar    =   ",
+                [
+                    (
+                        TokenName.ASSIGNMENT,
+                        Assignment(
+                            line_number=1,
+                            name="testvar",
+                            equals="=",
+                            assigned=None,
+                        ),
+                    ),
+                ],
+            ),
+            (
+                "test_var = 123",
+                [
+                    (
+                        TokenName.ASSIGNMENT,
+                        Assignment(
+                            line_number=1,
+                            name="test_var",
+                            equals="=",
+                            assigned="123",
+                        ),
+                    ),
+                ],
+            ),
+            (
+                "# this is a standard comment     ",
+                [
+                    (
+                        TokenName.COMMENT,
+                        Comment(
+                            line_number=1,
+                            content="# this is a standard comment",
+                        ),
+                    ),
+                ],
+            ),
+            (
+                ";this is a standard comment",
+                [
+                    (
+                        TokenName.COMMENT,
+                        Comment(
+                            line_number=1,
+                            content=";this is a standard comment",
+                        ),
+                    ),
+                ],
+            ),
+            (
+                "standard=FAIL('This is a standard fail state', 1234)",
+                [
+                    (
+                        TokenName.FAIL_STATE,
+                        FailState(
+                            name="standard",
+                            line_number=1,
+                            message="'This is a standard fail state'",
+                            code=1234,
+                        ),
+                    ),
+                ],
+            ),
+            (
+                "standard   =  FAIL  ('This is a standard fail state, isn't it?',     2468)",
+                [
+                    (
+                        TokenName.FAIL_STATE,
+                        FailState(
+                            name="standard",
+                            line_number=1,
+                            message="'This is a standard fail state, isn't it?'",
+                            code=2468,
+                        ),
+                    ),
+                ],
+            ),
+            (
+                "standard   =  FAIL  (This is a standard fail state, isn't it?,     2468)",
+                [
+                    (
+                        TokenName.FAIL_STATE,
+                        FailState(
+                            name="standard",
+                            line_number=1,
+                            message="This is a standard fail state, isn't it?",
+                            code=2468,
+                        ),
+                    ),
+                ],
+            ),
+            (
+                "[Some Section Header]",
+                [
+                    (
+                        TokenName.SECTION_HEADER,
+                        SectionHeader(
+                            line_number=1,
+                            name="Some Section Header",
+                        ),
+                    ),
+                ],
+            ),
+            (
+                "   [Some Section Header]    ",
+                [
+                    (
+                        TokenName.SECTION_HEADER,
+                        SectionHeader(
+                            line_number=1,
+                            name="Some Section Header",
+                        ),
+                    ),
+                ],
+            ),
+            (
+                "state1,condition,state2",
+                [
+                    (
+                        TokenName.TRANSITION,
+                        Transition(
+                            line_number=1,
+                            current_state="state1",
+                            condition="condition",
+                            next_state="state2",
+                        ),
+                    ),
+                ],
+            ),
+            (
+                " state_1    ,   condition2    , STATE2   ",
+                [
+                    (
+                        TokenName.TRANSITION,
+                        Transition(
+                            line_number=1,
+                            current_state="state_1",
+                            condition="condition2",
+                            next_state="STATE2",
+                        ),
+                    ),
+                ],
+            ),
+            (
+                "[Some Section Header]\r\rTestVar\r",
+                [
+                    (
+                        TokenName.SECTION_HEADER,
+                        SectionHeader(
+                            line_number=1,
+                            name="Some Section Header",
+                        ),
+                    ),
+                    (
+                        TokenName.ASSIGNMENT,
+                        Assignment(
+                            line_number=3,
+                            name="TestVar",
+                            equals=None,
+                            assigned=None,
+                        ),
+                    ),
+                ],
+            ),
+        ],
+    )
+    def test_token(self, line: str, expected_token_list) -> None:
+        """
+        Test to ensure that a token parses ok.
+
+        :param line: The line to be parsed.
+        :param expected_token_list: A copy of the object we expect to receive back.
+        """
+        lexer = Lexer(source=line)
+        tokens = lexer.tokens
+
+        # The following 2 lines have been added to ensure we receive the same tokens after process running twice.
+        lexer.process()
+        tokens_post_process = lexer.tokens
+
+        assert tokens == expected_token_list
+        assert tokens_post_process == tokens
+
+    @pytest.mark.parametrize(
+        "line,expected_tokens",
+        [
+            (
+                "This line will not match.",
+                [
+                    ParseError(
+                        line_number=1,
+                        content="This line will not match.",
+                    )
+                ],
+            ),
+        ],
+    )
+    def test_unmatched_lines(self, line: str, expected_tokens: list[ParseError]) -> None:
+        """
+        Test to ensure that the lexer returns a ParseError token.
+
+        :param line: The line to be parsed.
+        :param expected_tokens: Parse error tokens.
+        """
+        lex: Lexer = Lexer(source=line)
+        lex.process()
+        found_tokens = lex.tokens
+        assert len(found_tokens) == len(expected_tokens)
+        assert found_tokens[0][1].content == expected_tokens[0].content
+        assert found_tokens[0][1].line_number == expected_tokens[0].line_number

cyberark_tpc_plugin_parser-0.1.0/tests/test_parser.py

@@ -0,0 +1,44 @@
+"""Test the parser."""
+
+import pytest
+from tpc_plugin_parser.parser import Parser
+
+
+class TestParser(object):
+    """Test the lexer."""
+
+    @pytest.mark.parametrize(
+        "process_file,prompts_file",
+        [
+            (
+                "tests/data/process.ini",
+                "tests/data/prompts.ini",
+            ),
+        ],
+    )
+    def test_parser(self, process_file: str, prompts_file: str) -> None:
+        """
+        Test to ensure that a token parses ok.
+
+        :param process_file: Path to the process file.
+        :param prompts_file: Path to the prompts file.
+        """
+        with open(process_file, "r") as process_file:
+            process_content = process_file.read()
+
+        with open(prompts_file, "r") as prompts_file:
+            prompts_content = prompts_file.read()
+
+        parser = Parser(process_file=process_content, prompts_file=prompts_content)
+
+        assert len(parser.process_file) == 6
+        assert len(parser.process_file["default"]) == 6
+        assert len(parser.process_file["states"]) == 8
+        assert len(parser.process_file["transitions"]) == 7
+        assert len(parser.process_file["CPM Parameters Validation"]) == 5
+        assert len(parser.process_file["parameters"]) == 5
+        assert len(parser.process_file["Debug Information"]) == 7
+
+        assert len(parser.prompts_file) == 2
+        assert len(parser.prompts_file["default"]) == 6
+        assert len(parser.prompts_file["conditions"]) == 8

cyberark_tpc_plugin_parser-0.1.0/tpc_plugin_parser/__init__..py

@@ -0,0 +1 @@
+"""Standard blank init file for the package."""

cyberark_tpc_plugin_parser-0.1.0/tpc_plugin_parser/lexer/__init__.py

@@ -0,0 +1 @@
+"""Standard blank init file for the package."""

cyberark_tpc_plugin_parser-0.1.0/tpc_plugin_parser/lexer/lexer.py

@@ -0,0 +1,238 @@
+"""Lexer module for reading and processing configuration files."""
+
+import re
+
+from tpc_plugin_parser.lexer.tokens.assignment import Assignment
+from tpc_plugin_parser.lexer.tokens.comment import Comment
+from tpc_plugin_parser.lexer.tokens.cpm_parameter_validation import (
+    CPMParameterValidation,
+)
+from tpc_plugin_parser.lexer.tokens.fail_state import FailState
+from tpc_plugin_parser.lexer.tokens.parse_error import ParseError
+from tpc_plugin_parser.lexer.tokens.section_header import SectionHeader
+from tpc_plugin_parser.lexer.tokens.transition import Transition
+from tpc_plugin_parser.lexer.utilities.regex import (
+    ASSIGNMENT,
+    COMMENT,
+    CPM_PARAMETER_VALIDATION,
+    FAIL_STATE,
+    SECTION_HEADER,
+    TRANSITION,
+)
+from tpc_plugin_parser.lexer.utilities.token_name import TokenName
+from tpc_plugin_parser.lexer.utilities.types import ALL_TOKEN_TYPES, TokenSpecs
+
+
+class Lexer(object):
+    """Object to handle processing the ini files."""
+
+    __slots__ = (
+        "_tokens",
+        "_source",
+        "_token_specs",
+    )
+
+    def __init__(self, source: str) -> None:
+        """Standard init for the Lexer object."""
+
+        self._tokens: list[
+            tuple[
+                TokenName,
+                ALL_TOKEN_TYPES,
+            ]
+        ] = []
+        self._source: str = source
+        self._token_specs: list[TokenSpecs] = [
+            {
+                "pattern": re.compile(ASSIGNMENT, re.IGNORECASE),
+                "token_name": TokenName.ASSIGNMENT,
+                "processor_method": "_process_assignment",
+            },
+            {
+                "pattern": re.compile(COMMENT, re.IGNORECASE),
+                "token_name": TokenName.COMMENT,
+                "processor_method": "_process_comment",
+            },
+            {
+                "pattern": re.compile(CPM_PARAMETER_VALIDATION, re.IGNORECASE),
+                "token_name": TokenName.CPM_PARAMETER_VALIDATION,
+                "processor_method": "_process_cpm_parameter_validation",
+            },
+            {
+                "pattern": re.compile(FAIL_STATE, re.IGNORECASE),
+                "token_name": TokenName.FAIL_STATE,
+                "processor_method": "_process_fail_state",
+            },
+            {
+                "pattern": re.compile(SECTION_HEADER, re.IGNORECASE),
+                "token_name": TokenName.SECTION_HEADER,
+                "processor_method": "_process_section_header",
+            },
+            {
+                "pattern": re.compile(TRANSITION, re.IGNORECASE),
+                "token_name": TokenName.TRANSITION,
+                "processor_method": "_process_transitions",
+            },
+        ]
+
+    def process(self) -> None:
+        """
+        Process the content of the file line by line.
+        """
+
+        if self._tokens:
+            # Returning as we have parsed the data already.
+            return
+
+        for line_number, line in enumerate(self._source.splitlines(), start=1):
+            for token_spec in self._token_specs:
+                if match := token_spec["pattern"].match(line):
+                    getattr(self, token_spec["processor_method"])(match=match, line_number=line_number)
+                    break
+            else:
+                if line.strip():
+                    self._process_parse_error(line=line, line_number=line_number)
+
+    def _process_assignment(self, match: re.Match, line_number: int) -> None:
+        """
+        Process a variable assignment line
+
+        :param match: Regex match of the assignment.
+        """
+        name: str = str(match.group("name")).strip()
+        equals = str(match.group("equals")).strip() if match.groupdict().get("equals", None) else None
+        assigned_stripped = str(match.group("value")).strip() if match.groupdict().get("value", None) else None
+        assigned = assigned_stripped or None
+        self._tokens.append(
+            (
+                TokenName.ASSIGNMENT,
+                Assignment(
+                    name=name,
+                    equals=equals,
+                    assigned=assigned,
+                    line_number=line_number,
+                ),
+            )
+        )
+
+    def _process_comment(self, match: re.Match, line_number: int) -> None:
+        """
+        Process the provided comment.
+
+        :param match: Regex match of the comment.
+        """
+        self._tokens.append(
+            (
+                TokenName.COMMENT,
+                Comment(
+                    content=str(match.group("comment")).strip(),
+                    line_number=line_number,
+                ),
+            )
+        )
+
+    def _process_cpm_parameter_validation(self, match: re.Match, line_number: int) -> None:
+        """
+        Process the provided parameter validation.
+
+        :param match: Regex match of the parameter validation.
+        """
+        allow_characters: str | None = None
+        if match.group("allowcharacters"):
+            allow_characters = str(match.group("allowcharacters")).strip()
+
+        self._tokens.append(
+            (
+                TokenName.CPM_PARAMETER_VALIDATION,
+                CPMParameterValidation(
+                    name=str(match.group("name")),
+                    source=str(match.group("source")),
+                    mandatory=str(match.group("mandatory")),
+                    allow_characters=allow_characters,
+                    line_number=line_number,
+                ),
+            )
+        )
+
+    def _process_fail_state(self, match: re.Match, line_number: int) -> None:
+        """
+        Process the provided fail state .
+
+        :param match: Regex match of the fail state.
+        """
+        self._tokens.append(
+            (
+                TokenName.FAIL_STATE,
+                FailState(
+                    name=str(match.group("name")).strip(),
+                    message=str(match.group("message")).strip(),
+                    code=int(match.group("code")),
+                    line_number=line_number,
+                ),
+            )
+        )
+
+    def _process_parse_error(self, line: str, line_number: int) -> None:
+        """
+        Process a line that has a parse error.
+
+        :param line: The line that has the parse error.
+        :param line_number: The line number of the line that has the parse error.
+        """
+        self._tokens.append(
+            (
+                TokenName.PARSE_ERROR,
+                ParseError(
+                    content=line.strip(),
+                    line_number=line_number,
+                ),
+            )
+        )
+
+    def _process_section_header(self, match: re.Match, line_number: int) -> None:
+        """
+        Process the provided section header.
+
+        :param match: Regex match of the section header.
+        """
+        self._tokens.append(
+            (
+                TokenName.SECTION_HEADER,
+                SectionHeader(
+                    name=str(match.group("name").strip()),
+                    line_number=line_number,
+                ),
+            )
+        )
+
+    def _process_transitions(self, match: re.Match, line_number: int) -> None:
+        """
+        Process the provided transitions.
+
+        :param match: Regex match of the transitions.
+        """
+        self._tokens.append(
+            (
+                TokenName.TRANSITION,
+                Transition(
+                    current_state=str(match.group("current")).strip(),
+                    condition=str(match.group("condition")).strip(),
+                    next_state=str(match.group("next")).strip(),
+                    line_number=line_number,
+                ),
+            )
+        )
+
+    @property
+    def tokens(
+        self,
+    ) -> list[
+        tuple[
+            TokenName,
+            ALL_TOKEN_TYPES,
+        ]
+    ]:
+        """A list of tokens found by the lexer."""
+        if not self._tokens:
+            self.process()
+        return self._tokens

cyberark_tpc_plugin_parser-0.1.0/tpc_plugin_parser/lexer/tokens/__init__.py

@@ -0,0 +1 @@
+"""Standard blank init file for the package."""

cyberark_tpc_plugin_parser-0.1.0/tpc_plugin_parser/lexer/tokens/assignment.py

@@ -0,0 +1,16 @@
+"""Class to hold the assignment token."""
+
+from dataclasses import dataclass
+
+from tpc_plugin_parser.lexer.utilities.token_name import TokenName
+
+
+@dataclass(frozen=True)
+class Assignment(object):
+    """Dataclass to hold variable assignment details."""
+
+    line_number: int
+    name: str
+    equals: str | None = None
+    assigned: str | None = None
+    token_name: str = TokenName.ASSIGNMENT.value

cyberark_tpc_plugin_parser-0.1.0/tpc_plugin_parser/lexer/tokens/comment.py

@@ -0,0 +1,14 @@
+"""Class to hold the comment token."""
+
+from dataclasses import dataclass
+
+from tpc_plugin_parser.lexer.utilities.token_name import TokenName
+
+
+@dataclass(frozen=True)
+class Comment(object):
+    """Dataclass to hold a comment."""
+
+    line_number: int
+    content: str
+    token_name: str = TokenName.COMMENT.value

cyberark_tpc_plugin_parser-0.1.0/tpc_plugin_parser/lexer/tokens/cpm_parameter_validation.py

@@ -0,0 +1,17 @@
+"""Class to hold the parameter validation token."""
+
+from dataclasses import dataclass
+
+from tpc_plugin_parser.lexer.utilities.token_name import TokenName
+
+
+@dataclass(frozen=True)
+class CPMParameterValidation(object):
+    """Dataclass to hold variable cpm parameter validation details."""
+
+    line_number: int
+    name: str
+    source: str
+    mandatory: str
+    allow_characters: str | None = None
+    token_name: str = TokenName.CPM_PARAMETER_VALIDATION.value

cyberark_tpc_plugin_parser-0.1.0/tpc_plugin_parser/lexer/tokens/fail_state.py

@@ -0,0 +1,16 @@
+"""Class to hold the fail state token."""
+
+from dataclasses import dataclass
+
+from tpc_plugin_parser.lexer.utilities.token_name import TokenName
+
+
+@dataclass(frozen=True)
+class FailState(object):
+    """Dataclass to hold a fail state."""
+
+    line_number: int
+    name: str
+    message: str
+    code: int
+    token_name: str = TokenName.FAIL_STATE.value

cyberark_tpc_plugin_parser-0.1.0/tpc_plugin_parser/lexer/tokens/parse_error.py

@@ -0,0 +1,14 @@
+"""Class to hold a parse error token."""
+
+from dataclasses import dataclass
+
+from tpc_plugin_parser.lexer.utilities.token_name import TokenName
+
+
+@dataclass(frozen=True)
+class ParseError(object):
+    """Dataclass to hold sparse errors."""
+
+    line_number: int
+    content: str
+    token_name: str = TokenName.PARSE_ERROR.value

cyberark_tpc_plugin_parser-0.1.0/tpc_plugin_parser/lexer/tokens/section_header.py

@@ -0,0 +1,14 @@
+"""Class to hold the section header token."""
+
+from dataclasses import dataclass
+
+from tpc_plugin_parser.lexer.utilities.token_name import TokenName
+
+
+@dataclass(frozen=True)
+class SectionHeader(object):
+    """Dataclass to hold a section header name."""
+
+    line_number: int
+    name: str
+    token_name: str = TokenName.SECTION_HEADER.value

cyberark_tpc_plugin_parser-0.1.0/tpc_plugin_parser/lexer/tokens/transition.py

@@ -0,0 +1,16 @@
+"""Class to hold the state transition token."""
+
+from dataclasses import dataclass
+
+from tpc_plugin_parser.lexer.utilities.token_name import TokenName
+
+
+@dataclass(frozen=True)
+class Transition(object):
+    """Dataclass to hold state transitions."""
+
+    line_number: int
+    current_state: str
+    condition: str
+    next_state: str
+    token_name: str = TokenName.TRANSITION.value

cyberark_tpc_plugin_parser-0.1.0/tpc_plugin_parser/lexer/utilities/__init__.py

@@ -0,0 +1 @@
+"""Standard blank init file for the package."""

cyberark_tpc_plugin_parser-0.1.0/tpc_plugin_parser/lexer/utilities/regex.py

@@ -0,0 +1,10 @@
+"""List of regex the lexer uses."""
+
+ASSIGNMENT = (
+    r"^(?:[\s]*)(?P<name>[\w]+)(?:(?:[\s]*)(?P<equals>=)(?:(?:[\s]*)(?P<value>(?:(?!\s*fail\s*\().)+))?)?(?:[\s]*)$"
+)
+COMMENT = r"^(?:[\s]*)(?P<comment>(?:[#;]+)(?:.*))(?:[\s]*)$"
+CPM_PARAMETER_VALIDATION = r"^(?:[\s]*)(?P<name>[\w\\]+)(?:(?:[\s]*,[\s]*)(?:source)(?:[\s]*)=(?:[\s]*)(?P<source>[^, ]*))(?:(?:[\s]*,[\s]*)(?:mandatory)(?:[\s]*)=(?:[\s]*)(?P<mandatory>[^,]*))?(?:(?:[\s]*,[\s]*)(?:allowcharacters)(?:[\s]*)=(?:[\s]*)(?P<allowcharacters>.*))?$"
+FAIL_STATE = r"^(?:[\s]*)(?P<name>[\w]+)(?:[\s]*)=(?:[\s]*)(?:[\s]*)(?:fail)(?:[\s]*)\((?:[\s]*)(?P<message>.*)(?:[\s])?,(?:[\s]*)(?P<code>[0-9]+)\)(?:[\s]*)$"
+SECTION_HEADER = r"^(?:[\s]*)\[(?P<name>[\w]+(?:[\s]+[\w]+)*)](?:[\s]*)$"
+TRANSITION = r"^(?:[\s]*)(?P<current>[\w]+)(?:[\s]*,[\s]*)(?P<condition>[\w]+)(?:[\s]*,[\s]*)(?P<next>[\w]+)(?:[\s]*)$"

cyberark_tpc_plugin_parser-0.1.0/tpc_plugin_parser/lexer/utilities/token_name.py

@@ -0,0 +1,15 @@
+"""Enum to hold the allowed token names."""
+
+from enum import Enum
+
+
+class TokenName(Enum):
+    """CLass to hold the token name."""
+
+    ASSIGNMENT = "Assignment"
+    COMMENT = "Comment"
+    FAIL_STATE = "Fail State"
+    CPM_PARAMETER_VALIDATION = "CPM Parameter Validation"
+    PARSE_ERROR = "Parse Error"
+    SECTION_HEADER = "Section Header"
+    TRANSITION = "Transition"

cyberark_tpc_plugin_parser-0.1.0/tpc_plugin_parser/lexer/utilities/types.py

@@ -0,0 +1,23 @@
+"""Module for aggregating all token types used in the lexer."""
+
+from typing import TypedDict
+import re
+
+from tpc_plugin_parser.lexer.tokens.assignment import Assignment
+from tpc_plugin_parser.lexer.tokens.comment import Comment
+from tpc_plugin_parser.lexer.tokens.cpm_parameter_validation import (
+    CPMParameterValidation,
+)
+from tpc_plugin_parser.lexer.tokens.fail_state import FailState
+from tpc_plugin_parser.lexer.tokens.parse_error import ParseError
+from tpc_plugin_parser.lexer.tokens.section_header import SectionHeader
+from tpc_plugin_parser.lexer.tokens.transition import Transition
+from tpc_plugin_parser.lexer.utilities.token_name import TokenName
+
+ALL_TOKEN_TYPES = Assignment | Comment | FailState | CPMParameterValidation | ParseError | SectionHeader | Transition
+
+
+class TokenSpecs(TypedDict):
+    pattern: re.Pattern
+    token_name: TokenName
+    processor_method: str

cyberark_tpc_plugin_parser-0.1.0/tpc_plugin_parser/parser.py

@@ -0,0 +1,89 @@
+"""Parser module for reading and processing configuration files."""
+
+from tpc_plugin_parser.lexer.lexer import Lexer
+from tpc_plugin_parser.lexer.tokens.section_header import SectionHeader
+from tpc_plugin_parser.lexer.utilities.token_name import TokenName
+from tpc_plugin_parser.lexer.utilities.types import ALL_TOKEN_TYPES
+
+
+class Parser(object):
+    """Object to handle parsing ini files."""
+
+    __slots__ = (
+        "_process_file",
+        "_prompts_file",
+    )
+
+    def __init__(self, process_file: str, prompts_file: str) -> None:
+        """
+        Initializes the Parser with the given process and prompts files.
+
+        :param process_file (str): Content of the process file.
+        :param prompts_file (str): Content of the prompts file.
+        """
+
+        process_lexer = Lexer(source=process_file)
+        self._prepare_process(lexed_process=process_lexer)
+
+        prompts_lexer = Lexer(source=prompts_file)
+        self._prepare_prompts(lexed_prompts=prompts_lexer)
+
+    def _prepare_process(self, lexed_process: Lexer) -> None:
+        """
+        Prepare the process file from the lexed result.
+
+        :param lexed_process: Result of lexing the process file.
+        """
+        self._process_file = self._process_lex(lexed_file=lexed_process)
+
+    def _prepare_prompts(self, lexed_prompts: Lexer) -> None:
+        """
+        Prepare the prompts file from the lexed result.
+
+        :param lexed_prompts: Result of lexing the prompts file.
+        """
+        self._prompts_file = self._process_lex(lexed_file=lexed_prompts)
+
+    @staticmethod
+    def _process_lex(lexed_file: Lexer):
+        """
+        Process a lex and return the results.
+
+        :param lexed_file: Result of lexing a file.
+
+        :return: Result of processing the lexed file.
+        """
+        current_section_name: str = "default"
+        section_entries: list[ALL_TOKEN_TYPES,] = []
+        sorted_lex = {}
+        for lexed_line in lexed_file.tokens:
+            if lexed_line[0] == TokenName.SECTION_HEADER:
+                sorted_lex[current_section_name] = section_entries
+                if isinstance(lexed_line[1], SectionHeader):
+                    current_section_name = lexed_line[1].name
+                else:
+                    # This should never be reached, this is here to satisfy typing.
+                    current_section_name = "UNKNOWN"
+                section_entries = []
+                continue
+            section_entries.append(lexed_line[1])
+        sorted_lex[current_section_name] = section_entries
+        return sorted_lex
+
+    @property
+    def process_file(self):
+        """
+        Returns the parsed process configuration.
+
+        :return: List of tokens from the process file.
+        """
+        return self._process_file
+
+    @property
+    def prompts_file(self):
+        """
+        Returns the parsed prompts file.
+
+        :return: List of tokens from the prompts file.
+        """
+        return self._prompts_file