tmconfpy 1.0.0__py3-none-any.whl

tmconfpy/__init__.py

@@ -0,0 +1,17 @@
+# -*- coding: utf-8 -*-
+"""Top-level package for tmconfpy."""
+
+from .parser import Parser, tabularTmconf
+
+__all__ = [
+    "Parser",
+    "tabularTmconf",
+]
+__author__ = """Simon Kowallik"""
+__email__ = "sk-github@simonkowallik.com"
+__version__ = "1.0.0"  # pyproject.toml
+__projectname__ = "tmconfpy"
+# pylint: disable=line-too-long
+__description__ = "A Python library to serialize F5 BIG-IP configuration files to a python dict or JSON."
+__license__ = "Apache 2.0"
+__homepage__ = "https://github.com/simonkowallik/tmconfpy"

tmconfpy/__main__.py

@@ -0,0 +1,7 @@
+# -*- coding: utf-8 -*-
+"""Top-level package for tmconfpy."""
+
+from .cli import cli
+
+if __name__ == "__main__":
+    cli()

tmconfpy/apiserver.py

@@ -0,0 +1,208 @@
+# -*- coding: utf-8 -*-
+"""Simple API server for tmconfpy"""
+
+import enum
+from typing import Union
+
+from fastapi import Body, FastAPI, UploadFile
+from fastapi.responses import JSONResponse, Response
+from pydantic import BaseModel
+
+from . import (
+    __author__,
+    __description__,
+    __email__,
+    __homepage__,
+    __license__,
+    __projectname__,
+    __version__,
+)
+from .parser import Parser
+
+EXAMPLE_RESPONSES = {
+    "parser": {
+        200: {
+            "description": "Returns the parsed tmconf as JSON object.",
+            "content": {
+                "application/json": {
+                    "examples": {
+                        "object": {
+                            "summary": "object response",
+                            "value": {
+                                "ltm profile imap imap": {"activation-mode": "require"},
+                                "ltm profile pop3 pop3": {"activation-mode": "require"},
+                            },
+                        },
+                        "tabular": {
+                            "summary": "tabular response",
+                            "value": [
+                                [
+                                    "ltm profile imap",
+                                    "imap",
+                                    {"activation-mode": "require"},
+                                ],
+                                [
+                                    "ltm profile pop3",
+                                    "pop3",
+                                    {"activation-mode": "require"},
+                                ],
+                            ],
+                        },
+                    }
+                },
+                "application/x-ndjson": {
+                    "examples": {
+                        "jsonl": {
+                            "summary": "jsonl response",
+                            "value": [
+                                {
+                                    "ltm profile imap imap": {
+                                        "activation-mode": "require"
+                                    }
+                                },
+                                {
+                                    "ltm profile pop3 pop3": {
+                                        "activation-mode": "require"
+                                    }
+                                },
+                            ],
+                        },
+                    }
+                },
+            },
+        }
+    },
+    "fileparser": {
+        200: {
+            "description": "Returns the parsed tmconf for all submitted files as JSON objects in an array.",
+            "content": {
+                "application/json": {
+                    "example": [
+                        {
+                            "filename": "imap.tmconf",
+                            "output": {
+                                "ltm profile imap imap": {"activation-mode": "require"}
+                            },
+                        },
+                        {
+                            "filename": "pop3.tmconf",
+                            "output": {
+                                "ltm profile pop3 pop3": {"activation-mode": "require"}
+                            },
+                        },
+                    ]
+                }
+            },
+        },
+    },
+}
+
+
+app = FastAPI(
+    openapi_tags=[
+        {
+            "name": __projectname__,
+            "description": __description__,
+        },
+    ],
+    summary=__description__,
+    title=__projectname__,
+    version=__version__,
+    license_info={
+        "name": "Apache 2.0",
+        "url": "https://www.apache.org/licenses/LICENSE-2.0",
+    },
+    contact={"name": __author__, "url": __homepage__},
+    docs_url="/",
+)
+
+
+class ParserResponseFormat(str, enum.Enum):
+    """Response format of parsed tmconf data."""
+
+    object = "object"
+    tabular = "tabular"
+    jsonl = "jsonl"
+
+
+class FileParserResult(BaseModel):
+    """Result model for the fileparser endpoint."""
+
+    filename: str
+    output: dict
+
+
+@app.post(
+    "/fileparser/",
+    tags=[__projectname__],
+    response_model=list[FileParserResult],
+    responses=EXAMPLE_RESPONSES["fileparser"],
+    summary="Parse one or multiple files",
+)
+async def fileparser(
+    filename: list[UploadFile],
+):
+    """
+    Submit one or multiple files in multipart/form-data. Returns a JSON object with results for each file.
+
+    Example usage:
+
+    ```shell
+    $ curl -s http://localhost:8000/fileparser/ -F 'filename=@example/imap.tmconf' -F 'filename=@example/pop3.tmconf'
+    [
+        {"filename":"imap.tmconf","output":{"ltm profile imap imap":{"activation-mode":"require"}}},
+        {"filename":"pop3.tmconf","output":{"ltm profile pop3 pop3":{"activation-mode":"require"}}}
+    ]
+    ```
+    """
+    results: list = []
+    for _file in sorted(
+        filename, reverse=False, key=lambda upload_file: upload_file.filename
+    ):
+        data = await _file.read()
+        parsed = Parser(data.decode())
+        results.append(FileParserResult(filename=_file.filename, output=parsed.dict))
+
+    return results
+
+
+@app.post(
+    "/parser/",
+    tags=[__projectname__],
+    responses=EXAMPLE_RESPONSES["parser"],
+    response_model=None,
+    summary="Parse POST data",
+)
+async def parser(
+    tmconf: str = Body(
+        media_type="text/plain",
+        examples=[
+            "ltm profile imap imap {\n    activation-mode require\n}\nltm profile pop3 pop3 {\n    activation-mode require\n}"
+        ],
+    ),
+    response_format: ParserResponseFormat = ParserResponseFormat.object,
+) -> Union[Response, JSONResponse]:
+    """
+    Accepts a POST request with a tmconf file content as the body. Returns a JSON object with the parsed tmconf.
+
+    Example usage:
+
+    ```shell
+    $ curl -s http://localhost:8000/parser/ --data-binary @example/imap.tmconf
+    {"ltm profile imap imap":{"activation-mode":"require"}}
+    ```
+    """
+    parsed = Parser(tmconf)
+    # tabular
+    if response_format == ParserResponseFormat.tabular:
+        return JSONResponse(content=parsed.tabular)
+    # jsonl - jsonlines
+    elif response_format == ParserResponseFormat.jsonl:
+        return Response(
+            # media_type="application/x-ndjson", # fails rendering in Swagger UI
+            # media_type="application/jsonl", # https://github.com/wardi/jsonlines/issues/9
+            media_type="text/plain",  # most compatible choice
+            content=parsed.jsonl,
+        )
+    # object
+    return JSONResponse(content=parsed.dict)

tmconfpy/cli.py

@@ -0,0 +1,70 @@
+# -*- coding: utf-8 -*-
+"""Command Line Interface for tmconfpy."""
+
+import argparse
+import sys
+
+from . import __description__, __homepage__, __license__, __projectname__, __version__
+from .parser import Parser
+
+
+def _cli_arg_parser():
+    """Build cli argument parser and return args object."""
+    parser = argparse.ArgumentParser(
+        prog=__projectname__,
+        description=__description__,
+        epilog=f"LICENSE: {__license__}, homepage: {__homepage__}",
+    )
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"%(prog)s {__version__}",
+    )
+    parser.add_argument(
+        "--output",
+        "-o",
+        type=argparse.FileType("w"),
+        help="File to write JSON output to.",
+        nargs="?",
+        default=sys.stdout,
+    )
+    parser.add_argument(
+        "--format",
+        type=str,
+        help="Output format. Defaults to object.",
+        choices=["object", "tabular", "jsonl"],
+        default="object",
+        required=False,
+    )
+    parser.add_argument(
+        "file_path",
+        type=argparse.FileType("r"),
+        help="Path to tmconf file to read. Use - for STDIN.",
+        nargs="?",
+        default=(None if sys.stdin.isatty() else sys.stdin),
+    )
+
+    return parser.parse_args()
+
+
+def cli():
+    """Handle CLI interaction."""
+    args = _cli_arg_parser()
+
+    tmconf_content = args.file_path.read() if args.file_path is not None else ""
+
+    if tmconf_content.strip() == "":
+        print(
+            "No file_path given or input is empty. Use -h|--help for help.",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+    parsed = Parser(tmconf_content)
+
+    if args.format == "tabular":
+        args.output.write(parsed.tabular_json)
+    elif args.format == "jsonl":
+        args.output.write(parsed.jsonl)
+    else:
+        args.output.write(parsed.json)

tmconfpy/parser.py

@@ -0,0 +1,407 @@
+# -*- coding: utf-8 -*-
+"""tmconfpy - Serialize F5 BIG-IP tmconf files to dict/JSON."""
+
+import json
+import logging
+import sys
+import re
+from collections import namedtuple
+from typing import Dict, Optional
+
+# pylint: disable=line-too-long,too-many-branches
+
+logging.basicConfig(
+    format="%(asctime)s - %(levelname)s - %(name)s - %(message)s",
+    datefmt="%Y-%m-%dT%H:%M:%SZ",
+    level=logging.INFO,
+    stream=sys.stderr,
+)
+log = logging.getLogger(__name__)
+#handler = logging.StreamHandler(sys.stderr)
+#handler.setLevel(logging.INFO)
+#log.addHandler(handler)
+
+# namedtuple for tabular data
+tabularTmconf = namedtuple("tabularTmconf", ["path", "name", "object"])
+
+
+class Parser:
+    """Parse tmconf data or file and serialize it to a python dict or JSON (str)."""
+
+    def __init__(self, tmconf: str, is_filepath: bool = False):
+        '''
+        Parse tmconf data or file and serialize it to a python dict and JSON.
+
+        Args:
+            tmconf (str): tmconf data (str) or file path.
+            is_filepath (bool): If True, `tmconf` is a file path, otherwise it is tmconf data.
+
+        Example:
+            >>> from tmconfpy import Parser
+            >>> parsed = Parser('example/imap.tmconf', is_filepath=True)
+            >>> parsed.dict
+            {'ltm profile imap imap': {'activation-mode': 'require'}}
+            >>> tmconf = r"""
+            ... ltm profile pop3 pop3 {
+            ...     activation-mode require
+            ... }
+            ... ltm profile imap imap {
+            ...     activation-mode require
+            ... }
+            ... """
+            >>> parsed = Parser(tmconf)
+            >>> parsed.json
+            '{"ltm profile pop3 pop3": {"activation-mode": "require"}, "ltm profile imap imap": {"activation-mode": "require"}}'
+            >>> parsed.tabular
+            [tabularTmconf(path='ltm profile pop3', name='pop3', object={'activation-mode': 'require'}), tabularTmconf(path='ltm profile imap', name='imap', object={'activation-mode': 'require'})]
+            >>> parsed.tabular_json
+            '[["ltm profile pop3", "pop3", {"activation-mode": "require"}], ["ltm profile imap", "imap", {"activation-mode": "require"}]]'
+            >>> parsed.jsonl
+            '{"path": "ltm profile pop3", "name": "pop3", "object": {"activation-mode": "require"}}\n{"path": "ltm profile imap", "name": "imap", "object": {"activation-mode": "require"}}'
+        '''
+        self._tmconf_text = self._read_tmconf_file(tmconf) if is_filepath else tmconf
+
+        self._tmconf_dict = self._parse_tmconf_content()
+        self._tmconf_json = ""
+        self._tmconf_jsonl = ""
+        self._tmconf_tabular: list[tabularTmconf] = []
+        self._tmconf_tabular_json = ""
+
+    @property
+    def dict(self) -> dict:
+        """Parsed tmconf as python dictionary."""
+        return self._tmconf_dict
+
+    @property
+    def json(self) -> str:
+        """Parsed tmconf as JSON string."""
+        if not self._tmconf_json:
+            self._tmconf_json = json.dumps(self._tmconf_dict)
+        return self._tmconf_json
+
+    @property
+    def jsonl(self) -> str:
+        """Parsed tmconf as JSONL string."""
+        if not self._tmconf_jsonl:
+            jsonl = [
+                json.dumps(path_name_object._asdict())
+                for path_name_object in self.tabular
+            ]
+            self._tmconf_jsonl = "\n".join(jsonl)
+        return self._tmconf_jsonl
+
+    @property
+    def tabular_json(self) -> str:
+        """Parsed tmconf as JSON array of arrays, each with three fields, path (str), name (str) object (object)."""
+        if not self._tmconf_tabular_json:
+            self._tmconf_tabular_json = json.dumps(
+                [path_name_object for path_name_object in self.tabular]
+            )
+        return self._tmconf_tabular_json
+
+    @property
+    def tabular(self) -> list[tabularTmconf]:
+        """Parsed tmconf as list of tuples, each with three fields, path (str), name (str) object (dict)."""
+        if not self._tmconf_tabular:
+            self._tmconf_tabular = [
+                (lambda path, obj: tabularTmconf(" ".join(path[:-1]), path[-1], obj))(
+                    item[0].split(" "), item[1]
+                )
+                for item in self.dict.items()
+            ]
+        return self._tmconf_tabular
+
+    def _group_objects(self, arr) -> list:
+        """Group tmconf objects into a list."""
+        group = []
+        i = 0
+        while i < len(arr):
+            current_line = arr[i]
+
+            if "{" in current_line and "}" in current_line and current_line[0] != " ":
+                group.append([current_line])
+            elif current_line.strip().endswith("{") and not current_line.startswith(
+                " "
+            ):
+                c = 0
+                rule_flag = self._is_irule(current_line)
+
+                bracket_count = 1
+                while bracket_count != 0:
+                    c += 1
+                    line = arr[i + c]
+                    subcount = 0
+
+                    previous_char = ""
+                    if not (
+                        (
+                            line.strip().startswith("#")
+                            or line.strip().startswith("set")
+                            or line.strip().startswith("STREAM")
+                        )
+                        and rule_flag
+                    ):
+                        updated_line = (
+                            line.strip().replace('\\"', "").replace(r'".+"', "")
+                        )
+                        for char in updated_line:
+                            if char == "{" and previous_char != "\\":
+                                subcount += 1
+                            if char == "}" and previous_char != "\\":
+                                subcount -= 1
+                            previous_char = char
+
+                        if self._is_irule(line):
+                            c -= 1
+                            bracket_count = 0
+                        bracket_count += subcount
+
+                group.append(arr[i : i + c + 1])
+                i += c
+            i += 1
+        return group
+
+    def _orchestrate(self, arr):
+        """Orchestrate the parsing of tmconf objects."""
+        key = self._get_object_name(arr[0])
+
+        # remove opening and closing brackets which are at the first and last position
+        arr.pop()
+
+        if len(arr) >= 1:
+            arr.pop(0)
+
+        obj = {}
+
+        # case: iRules (multiline string)
+        if self._is_irule(key):
+            obj = "\n".join(arr)
+
+        # case: monitor min X of {...}
+        elif "monitor min" in key:
+            arr = [s.strip() for s in arr]
+            obj = " ".join(arr).split(" ")
+
+        # skip cli script, also skip 'sys crypto cert-order-manager', it has quotation marks around curly brackets of 'order-info'
+        elif "cli script" not in key and "sys crypto cert-order-manager" not in key:
+            i = 0
+            while i < len(arr):
+                # case: nested object
+                # quoted bracket "{" won't trigger recursion
+                if arr[i].endswith("{") and len(arr) != 1:
+                    c = 0
+                    while arr[i + c] != "    }":
+                        c += 1
+                        if (i + c) >= len(arr):
+                            raise ValueError(
+                                f"Missing or mis-indented '}}' for line number {i+1}: '{arr[i]}'"
+                            )
+                    sub_obj_arr = self._remove_indent(arr[i : i + c + 1])
+
+                    # coerce unnamed objects into array
+                    coerce_arr = []
+                    arr_idx = 0
+                    for line in sub_obj_arr:
+                        if line == "    {":
+                            line = line.replace("{", f"{arr_idx} {{")
+                            arr_idx += 1
+                        coerce_arr.append(line)
+
+                    # recurse nested object
+                    obj.update(self._orchestrate(coerce_arr))
+
+                    # skip over nested block
+                    i += c
+
+                # case: empty object
+                elif "".join(arr[i].split(" ")).endswith("{ }") or "".join(
+                    arr[i].split(" ")
+                ).endswith("{}"):
+                    obj[arr[i].split("{")[0].strip()] = {}
+
+                # case: pseudo-array pattern (coerce to array)
+                elif "{" in arr[i] and "}" in arr[i] and '"' not in arr[i]:
+                    obj_name = arr[i].split("{")[0].strip()
+                    obj[obj_name] = self._obj_to_arr(arr[i])
+
+                # case: single-string property
+                elif (
+                    " " not in arr[i].strip()
+                    or re.match(r'^"[\s\S]*"$', arr[i].strip())
+                ) and "}" not in arr[i]:
+                    obj[arr[i].strip()] = ""
+
+                # regular string property
+                # ensure string props on same indentation level
+                elif self._count_indent(arr[i]) == 4:
+                    # case: multiline string
+                    count = arr[i].count('"')
+                    if count % 2 == 1:
+                        c = 1
+
+                        # keep count of '"'?
+                        while arr[i + c] and arr[i + c].count('"') % 2 != 1:
+                            c += 1
+
+                        chunk = arr[i : i + c + 1]
+                        sub_obj_arr = self._arr_to_multiline_str(chunk)
+                        obj.update(sub_obj_arr)
+                        i += c
+
+                    # case: typical string
+                    else:
+                        tmp = self._str_to_obj(arr[i].strip())
+                        # case: gtm monitor external and user-defined property
+                        if (
+                            key.startswith("gtm monitor external")
+                            and "user-defined" in tmp
+                        ):
+                            if "user-defined" not in obj:
+                                obj["user-defined"] = {}
+                            tmp_obj = self._str_to_obj(tmp["user-defined"])
+                            obj["user-defined"][list(tmp_obj.keys())[0]] = list(
+                                tmp_obj.values()
+                            )[0]
+                        else:
+                            obj.update(tmp)
+
+                # else log exception
+                else:
+                    log.warning("UNRECOGNIZED LINE for object '%s': '%s'", key, arr[i])
+                i += 1
+
+        return {key: obj}
+
+    @staticmethod
+    def _read_tmconf_file(filepath: str) -> str:
+        """read tmconf file, perform sanitization and checks, then return content as str."""
+        with open(filepath, "rb") as file:
+            data = file.read().decode()
+
+        # silent dos2unix
+        data = data.replace("\r\n", "\n")
+        # log warning of data contains utf-8 characters
+        if not data.isascii():
+            log.warning("File '%s' contains non-ASCII characters.", filepath)
+        return data
+
+    def _parse_tmconf_content(self) -> Dict:
+        """Parse the text of a tmconf file and return a dictionary of objects."""
+        file_arr = self._tmconf_text.split("\n")
+
+        # gtm topology
+        new_file_arr: list = []
+        topology_arr: list = []
+        topology_count = 0
+        longest_match_enabled = True
+        in_topology = False
+        irule = 0
+        data: Dict = {}
+
+        for line in file_arr:
+            # Process comments in iRules:
+            if irule == 0:
+                if line.strip().startswith("# "):
+                    # mark comments outside of irules with specific prefix
+                    line = line.strip().replace("# ", "#comment# ")
+                elif self._is_irule(line):
+                    irule += 1
+            # don't count brackets in commented or special lines
+            elif not line.strip().startswith("#"):
+                irule = irule + line.count("{") - line.count("}")
+
+            ldns = ""
+            server = ""
+            if "topology-longest-match" in line and "no" in line:
+                longest_match_enabled = False
+            if line.startswith("gtm topology ldns:"):
+                in_topology = True
+                if len(topology_arr) == 0:
+                    topology_arr.append("gtm topology /Common/Shared/topology {")
+                    topology_arr.append("    records {")
+                ldns_index = line.index("ldns:")
+                server_index = line.index("server:")
+                bracket_index = line.index("{")
+                ldns = line[ldns_index + 5 : server_index].strip()
+                topology_arr.append(f"        topology_{topology_count} {{")
+                topology_count += 1
+                topology_arr.append(f"            source {ldns}")
+                server = line[server_index + 7 : bracket_index].strip()
+                topology_arr.append(f"            destination {server}")
+            elif in_topology:
+                if line == "}":
+                    in_topology = False
+                    topology_arr.append("        }")
+                else:
+                    topology_arr.append(f"        {line}")
+            else:
+                new_file_arr.append(line)
+
+        if topology_arr:
+            topology_arr.append(
+                f"        longest-match-enabled {'yes' if longest_match_enabled else 'no'}"
+            )
+            topology_arr.append("    }")
+            topology_arr.append("}")
+
+        file_arr = new_file_arr + topology_arr
+
+        # remove whitespace and comments
+        file_arr = [
+            line
+            for line in file_arr
+            if not (line == "" or line.strip().startswith("#comment# "))
+        ]
+        group_arr = [self._orchestrate(obj) for obj in self._group_objects(file_arr)]
+        group_arr_dict = self._arr_to_dict(group_arr)
+
+        return {**data, **group_arr_dict}
+
+    @staticmethod
+    def _get_object_name(string: str) -> str:
+        """Returns the full object name."""
+        return string.rstrip().rstrip("{}").rstrip("{ }").strip()
+
+    @staticmethod
+    def _is_irule(string: str) -> bool:
+        """Returns True if `string` is an iRule, False otherwise."""
+        return "ltm rule" in string or "gtm rule" in string or "pem irule" in string
+
+    @staticmethod
+    def _count_indent(string: str) -> Optional[int]:
+        """Count the number of whitespaces at the beginning of a string."""
+        return re.search(r"\S", string).start() if re.search(r"\S", string) else None
+
+    def _remove_indent(self, arr) -> list:
+        """Remove indent (4 whitespaces) from each line in a list of strings if the line is indented."""
+        return [line[4:] if self._count_indent(line) > 1 else line for line in arr]
+
+    @staticmethod
+    def _obj_to_arr(line) -> list:
+        """Convert an tmconf object to an array."""
+        split = line.split("{")
+        body = "".join(split[1].split("}")).strip()
+        return body.split(" ")
+
+    @staticmethod
+    def _str_to_obj(line) -> Dict:
+        """Convert a tmconf string to a dictionary."""
+        split = line.strip().split(" ")
+        key = split.pop(0)
+        return {key: " ".join(split)}
+
+    @staticmethod
+    def _arr_to_multiline_str(arr) -> Dict:
+        """Convert an array to a multiline string."""
+        split = arr[0].strip().split(" ")
+        key = split.pop(0)
+        arr[0] = " ".join(split)
+        return {key: "\n".join(arr)}
+
+    @staticmethod
+    def _arr_to_dict(arr) -> Dict:
+        """Convert an array of objects to a dictionary."""
+        _data = {}
+        for obj in arr:
+            _data.update(obj)
+        return _data

tmconfpy-1.0.0.dist-info/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [2024] [Simon Kowallik]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

tmconfpy-1.0.0.dist-info/METADATA

@@ -0,0 +1,323 @@
+Metadata-Version: 2.1
+Name: tmconfpy
+Version: 1.0.0
+Summary: A Python library to serialize F5 BIG-IP configuration files to a python dict or JSON.
+Home-page: https://github.com/simonkowallik/tmconfpy
+Keywords: F5,DevOps,Security
+Author: Simon Kowallik
+Author-email: sk-github@simonkowallik.com
+Requires-Python: >=3.9,<4.0
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: System Administrators
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Internet
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System
+Classifier: Topic :: System :: Installation/Setup
+Classifier: Topic :: System :: Networking
+Classifier: Topic :: System :: Systems Administration
+Provides-Extra: apiserver
+Requires-Dist: fastapi (>=0.111.0,<0.112.0) ; extra == "apiserver"
+Requires-Dist: python-multipart (>=0.0.9,<0.0.10) ; extra == "apiserver"
+Requires-Dist: uvicorn (>=0.30.1,<0.31.0) ; extra == "apiserver"
+Project-URL: Documentation, https://github.com/simonkowallik/tmconfpy
+Project-URL: Repository, https://github.com/simonkowallik/tmconfpy
+Description-Content-Type: text/markdown
+
+# tmconfpy
+
+<p align="center">
+<a href="https://github.com/simonkowallik/tmconfpy/actions/workflows/ci-pipeline.yaml">
+    <img src="https://github.com/simonkowallik/tmconfpy/actions/workflows/ci-pipeline.yaml/badge.svg" alt="ci-pipeline">
+</a>
+<a href="https://codeclimate.com/github/simonkowallik/tmconfpy/test_coverage">
+    <img src="https://api.codeclimate.com/v1/badges/3f404be294dceae16361/test_coverage" alt="test coverage">
+</a>
+<a href="https://hub.docker.com/r/simonkowallik/tmconfpy">
+    <img src="https://img.shields.io/docker/image-size/simonkowallik/tmconfpy" alt="container image size">
+</a>
+<a href="https://github.com/simonkowallik/tmconfpy/releases">
+    <img src="https://img.shields.io/github/v/release/simonkowallik/tmconfpy" alt="releases">
+</a>
+</p>
+
+---
+
+**tmconfpy** provides a simple parser (`tmconfpy` command) to serialize a tmconf file (eg. `/config/bigip.conf`) to JSON (or python `dict`). The produced JSON is printed to `STDOUT` or a specified output (`--output`) file. It is also usable as a python module for easy consumption in your own projects.
+
+This project aims to be a minimalistic dependency free tool. It is based on [tmconfjs](https://github.com/simonkowallik/tmconfjs), it's parsing implementation leans heavily on the community project [F5 BIG-IP Automation Config Converter (BIG-IP ACC)](https://github.com/f5devcentral/f5-automation-config-converter/).
+
+The TMOS configuration parser [f5-corkscrew](https://github.com/f5devcentral/f5-corkscrew) is a more sophisticated alternative with advanced functionality and active development.
+
+Also checkout the jupyter notebook: [example/notebook.ipynb](./example/notebook.ipynb).
+
+## Documentation by example
+
+### Installation
+
+```shell
+pip3 install tmconfpy
+```
+
+### Command line usage
+
+When installed globally, `tmconfpy` can be invoked as a command:
+
+```shell
+tmconfpy example/test.tmconf 2>/dev/null \
+    | jq '."ltm profile client-ssl clientssl-secure"'
+```
+
+```json
+{
+  "app-service": "none",
+  "cert": "/Common/default.crt",
+  "cert-key-chain": {
+    "default": {
+      "cert": "/Common/default.crt",
+      "key": "/Common/default.key"
+    }
+  },
+  "chain": "none",
+  "ciphers": "ecdhe:rsa:!sslv3:!rc4:!exp:!des",
+  "defaults-from": "/Common/clientssl",
+  "inherit-certkeychain": "true",
+  "key": "/Common/default.key",
+  "options": [
+    "no-ssl",
+    "no-tlsv1.3"
+  ],
+  "passphrase": "none",
+  "renegotiation": "disabled"
+}
+```
+
+Errors, warnings or any debug information is written to `STDERR`:
+
+```shell
+tmconfpy example/test.tmconf \
+    >/dev/null 2> example/test.tmconf.log
+
+cat example/test.tmconf.log
+```
+
+```shell
+2024-06-30T18:39:16Z - WARNING - tmconfpy.parser - UNRECOGNIZED LINE for object 'sys software update': '     auto-check enabled'
+2024-06-30T18:39:16Z - WARNING - tmconfpy.parser - UNRECOGNIZED LINE for object 'sys software update': '     auto-phonehome enabled'
+2024-06-30T18:39:16Z - WARNING - tmconfpy.parser - UNRECOGNIZED LINE for object 'fatal-grace-time': '	time 500'
+2024-06-30T18:39:16Z - WARNING - tmconfpy.parser - UNRECOGNIZED LINE for object 'fatal-grace-time': '	enabled yes'
+```
+
+Input is also accepted from `STDIN`:
+
+```shell
+cat example/imap.tmconf | tmconfpy
+```
+
+```json
+{
+    "ltm profile imap imap": {
+        "activation-mode": "require"
+    }
+}
+```
+
+The `<file_path>` argument is preferred over `STDIN` however:
+
+```shell
+cat example/imap.tmconf | tmconfpy example/pop3.tmconf
+```
+
+```json
+{
+    "ltm profile pop3 pop3": {
+        "activation-mode": "require"
+    }
+}
+```
+
+The output can be written to a specified file using `--output` or `-o` when `STDOUT` is not desired:
+
+```shell
+tmconfpy --output example/pop3.tmconf.json example/pop3.tmconf
+cat example/pop3.tmconf.json
+```
+
+```json
+{
+    "ltm profile pop3 pop3": {
+        "activation-mode": "require"
+    }
+}
+```
+
+tmconfpy supports multiple output formats of the parsed tmconf data, which can be specified via `--format`.
+
+```shell
+(cat example/imap.tmconf; echo; cat example/pop3.tmconf) | \
+  tmconfpy --format jsonl
+```
+
+```json
+{"path": "ltm profile imap", "name": "imap", "object": {"activation-mode": "require"}}
+{"path": "ltm profile pop3", "name": "pop3", "object": {"activation-mode": "require"}}
+```
+
+```shell
+(cat example/imap.tmconf; echo; cat example/pop3.tmconf) | \
+  tmconfpy --format tabular
+```
+
+```json
+[
+  ["ltm profile imap", "imap", {"activation-mode": "require"}],
+  ["ltm profile pop3", "pop3", {"activation-mode": "require"}]
+]
+```
+
+### Use as python module
+
+```python
+>>> from tmconfpy import Parser
+>>> parsed = Parser('example/imap.tmconf', is_filepath=True)
+>>> parsed.dict
+{'ltm profile imap imap': {'activation-mode': 'require'}}
+>>> tmconf = r"""
+... ltm profile pop3 pop3 {
+...     activation-mode require
+... }
+... ltm profile imap imap {
+...     activation-mode require
+... }
+... """
+>>> parsed = Parser(tmconf)
+>>> parsed.json
+'{"ltm profile pop3 pop3": {"activation-mode": "require"}, "ltm profile imap imap": {"activation-mode": "require"}}'
+>>> parsed.tabular
+[tabularTmconf(path='ltm profile pop3', name='pop3', object={'activation-mode': 'require'}), tabularTmconf(path='ltm profile imap', name='imap', object={'activation-mode': 'require'})]
+>>> parsed.tabular_json
+'[["ltm profile pop3", "pop3", {"activation-mode": "require"}], ["ltm profile imap", "imap", {"activation-mode": "require"}]]'
+>>> parsed.jsonl
+'{"path": "ltm profile pop3", "name": "pop3", "object": {"activation-mode": "require"}}\n{"path": "ltm profile imap", "name": "imap", "object": {"activation-mode": "require"}}'
+```
+
+### Using the (optional) apiserver / container
+
+Run the container, the API listens on port 8000 (http).
+
+```shell
+docker run --rm -p 8000:8000 simonkowallik/tmconfpy
+```
+
+The container is also available on [ghcr.io](https://github.com/simonkowallik/tmconfpy/pkgs/container/tmconfpy) as an alternative to docker hub.
+
+```shell
+docker run --rm -p 8000:8000 ghcr.io/simonkowallik/tmconfpy
+```
+
+The apiserver can be reached at [http://localhost:8000/](http://localhost:8000/) and offers two endpoints which are described by the OpenAPI specification.
+
+API documentation can be reached at [/](http://localhost:8000/) and [/redoc](http://localhost:8000/redoc) for interactive use.
+
+Parsing a single file by using POST, note `--data-binary` is required to avoid interpretation of the file content:
+
+```shell
+curl -X POST -s http://localhost:8000/parser/ \
+  --data-binary @example/imap.tmconf
+```
+
+```json
+{"ltm profile imap imap":{"activation-mode":"require"}}
+```
+
+Parsing multiple files via multipart form:
+
+```shell
+curl -X POST -s http://localhost:8000/fileparser/ \
+  -F 'filename=@example/imap.tmconf' \
+  -F 'filename=@example/pop3.tmconf'
+```
+
+```json
+[
+  {"filename":"imap.tmconf",
+   "output":{"ltm profile imap imap":{"activation-mode":"require"}}
+  },
+  {"filename":"pop3.tmconf",
+   "output":{"ltm profile pop3 pop3":{"activation-mode":"require"}}
+  }
+]
+```
+
+#### JSONL and tabular data
+
+The `/parser/` api-endpoint also supports returning the parsed tmconf as JSONL or tabular data using the query parameter `?response_format=<format>`.
+
+```shell
+(cat example/imap.tmconf; echo; cat example/pop3.tmconf) | \
+  curl -X POST -s http://localhost:8000/parser/?response_format=jsonl \
+  --data-binary @-
+```
+
+```json
+{"path": "ltm profile imap", "name": "imap", "object": {"activation-mode": "require"}}
+{"path": "ltm profile pop3", "name": "pop3", "object": {"activation-mode": "require"}}
+```
+
+```shell
+(cat example/imap.tmconf; echo; cat example/pop3.tmconf) | \
+  curl -X POST -s http://localhost:8000/parser/?response_format=tabular \
+  --data-binary @-
+```
+
+```json
+[
+  ["ltm profile imap","imap",{"activation-mode":"require"}],
+  ["ltm profile pop3","pop3",{"activation-mode":"require"}]
+]
+```
+
+#### Using the container as a command line tool
+
+Use the `--entrypoint` argument with `tmconfpy` to invoke the tmconfpy tool instead of the apiserver (which is the default). Don't forget to pass `--interactive | -i` to the container.
+
+```shell
+cat example/imap.tmconf | docker run --rm --interactive --entrypoint tmconfpy simonkowallik/tmconfpy
+```
+
+```json
+{
+    "ltm profile imap imap": {
+        "activation-mode": "require"
+    }
+}
+```
+
+**Note** that you can't use `--output | -o` to write the output to a file using the above method unless you mount a volume into the container.
+
+## Disclaimer, Support, License
+
+Please read and understand the [LICENSE](./LICENSE) first.
+
+```
+There is no support on this project.
+
+It is maintained on best effort basis without any warranties.
+
+For any software or components used in this project, read their own LICENSE and SUPPORT policies.
+
+If you decide to use this project, you are solely responsible.
+```
+

tmconfpy-1.0.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+tmconfpy/__init__.py,sha256=iBk6padm13FTwYFPjZjVAKLQW3yUxiS53YGHPtu36IQ,524
+tmconfpy/__main__.py,sha256=YEE27lO9dTvLDtrfyI7qY3qXW6K9luDxVCN2lDqKZr0,122
+tmconfpy/apiserver.py,sha256=S9q1JMRWvk3mBcCeyxfCIk0CPWWcgrotPlmb1aNjq-A,6542
+tmconfpy/cli.py,sha256=HJWcoD3Jos1W7vUcsx5oduMUo8mN4dQhTYPaa8n6DhE,1858
+tmconfpy/parser.py,sha256=BS3-OcW1KcqYowWFNAXogKaRBVVstGwwgMgPguVrDZw,15680
+tmconfpy-1.0.0.dist-info/LICENSE,sha256=LcDn9UaM5Zj-BkLOYptNRl_RK8CaEHucz_80PK0iM6E,11347
+tmconfpy-1.0.0.dist-info/METADATA,sha256=b8nNmYNVA8xuUYtaMh_CK-Hfy1HfP9ElKYkrDOlsZGw,10419
+tmconfpy-1.0.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+tmconfpy-1.0.0.dist-info/entry_points.txt,sha256=M4VplGbpdy979RjFxFu_DRgnCvLYaPcWMGJKxbj4D6I,45
+tmconfpy-1.0.0.dist-info/RECORD,,

tmconfpy-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 1.9.0
+Root-Is-Purelib: true
+Tag: py3-none-any

tmconfpy-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+tmconfpy=tmconfpy.cli:cli
+