kmt 0.1.1__py3-none-any.whl

kmt/__init__.py

@@ -0,0 +1,3 @@
+from .kmt import main
+
+__all__ = ["main"]

kmt/__main__.py

@@ -0,0 +1,4 @@
+from .kmt import main
+
+if __name__ == "__main__":
+    main()

kmt/exception.py

@@ -0,0 +1,8 @@
+"""
+Contains common exceptions used by kmt
+"""
+
+class ValidationException(Exception):
+    """
+    Validation of some condition failed
+    """

kmt/handlers.py

@@ -0,0 +1,124 @@
+import ttast
+import logging
+import copy
+import yaml
+
+logger = logging.getLogger(__name__)
+
+class HandlerMetadata(ttast.Handler):
+    def parse(self):
+        pass
+
+    def is_per_block(self):
+        return True
+
+    def run(self, block):
+        pass
+
+class SupportHandlerExtractGVKN(ttast.SupportHandler):
+    def parse(self):
+        pass
+
+    def pre(self, block):
+        if block is None:
+            return
+        
+        # Best effort extract of Group, Version, Kind, Name from the object, if
+        # it is yaml
+
+        try:
+            manifest = yaml.safe_load(block.text)
+        except yaml.YAMLError as exc:
+            logger.debug(f"ExtractGVKN: Could not parse input object: {exc}")
+            return
+
+        # Make sure we're working with a dictionary
+        if not isinstance(manifest, dict):
+            logger.debug(f"ExtractGVKN: Parsed yaml is not a dictionary")
+            return
+
+        api_version = ""
+        group = ""
+        version = ""
+        name = ""
+        kind = ""
+
+        # api version
+        api_version = manifest.get("apiVersion", "")
+
+        # group and version
+        if api_version != "":
+            split = api_version.split("/")
+
+            if len(split) == 1:
+                version = split[0]
+            elif len(split) == 2:
+                group = split[0]
+                version = split[1]
+
+        # Kind
+        kind = manifest.get("kind")
+
+        # Name
+        metadata = manifest.get("metadata")
+        if isinstance(metadata, dict):
+            name = metadata.get("name", "")
+
+        block.meta["k8s_name"] = name
+        block.meta["k8s_kind"] = kind
+        block.meta["k8s_group"] = group
+        block.meta["k8s_version"] = version
+        block.meta["k8s_api_version"] = api_version
+
+
+    def post(self, block):
+        pass
+
+class SupportHandlerSplitYaml(ttast.SupportHandler):
+    def parse(self):
+        pass
+
+    def pre(self, block):
+        pass
+
+    def post(self, block):
+        if block is None:
+            return
+
+        lines = block.text.splitlines()
+        documents = []
+        current = []
+
+        for line in lines:
+
+            # Determine if we have the beginning of a yaml document
+            if line == "---" and len(current) > 0:
+                documents.append("\n".join(current))
+                current = []
+
+            current.append(line)
+
+        documents.append("\n".join(current))
+
+        # Strip each document
+        documents = [x.strip() for x in documents]
+
+        # If we have a single document and it's the same as the
+        # original block, just exit
+        if len(documents) == 1 and documents[0] == block.text:
+            return
+
+        # Add all documents to the pipeline text block list
+        new_blocks = [ttast.TextBlock(item) for item in documents]
+        for new_block in new_blocks:
+            new_block.meta = copy.deepcopy(block.meta)
+            new_block.tags = copy.deepcopy(block.tags)
+
+            self.state.pipeline.add_block(new_block)
+
+        # Remove the original source block from the list
+        self.state.pipeline.remove_block(block)
+
+        logger.debug(f"split_yaml: output 1 document -> {len(documents)} documents")
+
+        return new_blocks

kmt/kmt.py

@@ -0,0 +1,113 @@
+#!/usr/bin/env python3
+"""
+"""
+
+import argparse
+import logging
+import sys
+
+from .exception import *
+from .util import *
+import ttast
+from . import handlers
+
+logger = logging.getLogger(__name__)
+
+def process_args() -> int:
+    """
+    Processes kmt command line arguments, initialises and runs the pipeline to perform text processing
+    """
+
+    # Create parser for command line arguments
+    parser = argparse.ArgumentParser(
+        prog="kmt", description="Kubernetes Manifest Transform", exit_on_error=False
+    )
+
+    # Parser configuration
+    parser.add_argument(
+        "-c", action="append", dest="configs", help="Configuration files"
+    )
+
+    parser.add_argument(
+        "-d", action="store_true", dest="debug", help="Enable debug output"
+    )
+
+    args = parser.parse_args()
+
+    # Capture argument options
+    debug = args.debug
+    configs = args.configs
+
+    # Logging configuration
+    level = logging.WARNING
+    if debug:
+        level = logging.DEBUG
+
+    logging.basicConfig(level=level, format="%(levelname)s: %(message)s")
+
+    try:
+        # Add each config as a pipeline step, which will read and merge the config
+        steps = list()
+        if configs is not None:
+            for config_item in configs:
+                # If '-' is specified, read the configuration from stdin
+                if config_item == "-":
+                    step_def = {
+                        "type": "config",
+                        "stdin": True
+                    }
+                else:
+                    step_def = {
+                        "type": "config",
+                        "file": config_item
+                    }
+
+                steps.append(step_def)
+
+        pipeline = ttast.Pipeline()
+
+        # Include the default handlers and support handlers
+        pipeline.add_handlers(ttast.builtin_handlers())
+        pipeline.add_support_handlers(ttast.builtin_support_handlers())
+
+        # Add our custom handlers and support handlers
+        pipeline.add_support_handlers([
+            handlers.SupportHandlerSplitYaml,
+            handlers.SupportHandlerExtractGVKN
+        ])
+
+        # Add the steps we've defined to the pipeline
+        for step in steps:
+            pipeline.add_step(step)
+
+        # Start executing the pipeline
+        pipeline.run()
+
+    except Exception as e:  # pylint: disable=broad-exception-caught
+        if debug:
+            logger.error(e, exc_info=True, stack_info=True)
+        else:
+            logger.error(e)
+        return 1
+
+    return 0
+
+
+def main():
+    """
+    Entrypoint for the module.
+    Minor exception handling is performed, along with return code processing and
+    flushing of stdout on program exit.
+    """
+    try:
+        ret = process_args()
+        sys.stdout.flush()
+        sys.exit(ret)
+    except Exception as e:  # pylint: disable=broad-exception-caught
+        logging.getLogger(__name__).exception(e)
+        sys.stdout.flush()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

kmt/util.py

@@ -0,0 +1,67 @@
+
+import jinja2
+import logging
+
+from .exception import *
+
+logger = logging.getLogger(__name__)
+
+def validate(val, message):
+    if not val:
+        raise ValidationException(message)
+
+def template_if_string(val, mapping):
+    if val is not None and isinstance(val, str):
+        try:
+            environment = jinja2.Environment()
+
+            template = environment.from_string(val)
+            return template.render(mapping)
+        except KeyError as e:
+            raise PipelineRunException(f"Missing key in template substitution: {e}") from e
+
+    return val
+
+def parse_bool(obj) -> bool:
+    if obj is None:
+        raise PipelineRunException("None value passed to parse_bool")
+
+    if isinstance(obj, bool):
+        return obj
+
+    obj = str(obj)
+
+    if obj.lower() in ["true", "1"]:
+        return True
+
+    if obj.lower() in ["false", "0"]:
+        return False
+
+    raise PipelineRunException(f"Unparseable value ({obj}) passed to parse_bool")
+
+def pop_property(spec, key, *, template_map=None, default=None, required=False):
+    validate(isinstance(spec, dict), f"Invalid spec passed to pop_property. Must be dict")
+    validate(isinstance(template_map, dict) or template_map is None, "Invalid type passed as template_map")
+
+    if key not in spec:
+        # Raise exception is the key isn't present, but required
+        if required:
+            raise KeyError(f'Missing key "{key}" in spec or value is null')
+
+        # If the key is not present, return the default
+        return default
+
+    # Retrieve value
+    val = spec.pop(key)
+
+    # Template the value, depending on the type
+    if val is not None and template_map is not None:
+        if isinstance(val, str):
+            val = template_if_string(val, template_map)
+        elif isinstance(val, list):
+            val = [template_if_string(x, template_map) for x in val]
+        elif isinstance(val, dict):
+            for val_key in val:
+                val[val_key] = template_if_string(val[val_key], template_map)
+
+    return val

kmt-0.1.1.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 ArchMachina
+
+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.

kmt-0.1.1.dist-info/METADATA

@@ -0,0 +1,15 @@
+Metadata-Version: 2.1
+Name: kmt
+Version: 0.1.1
+Summary: Kubernetes Manifest Transform
+Home-page: https://github.com/archmachina/kmt
+Download-URL: https://pypi.org/project/kmt/
+Author: Jesse Reichman
+License: MIT
+Keywords: Kubernetes,Manifest,Transform
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: PyYAML >=6.0.0
+Requires-Dist: Jinja2 >=3.1.0
+Requires-Dist: ttast >=0.2.0
+

kmt-0.1.1.dist-info/RECORD

@@ -0,0 +1,12 @@
+kmt/__init__.py,sha256=qA0O5DS6W_R8GUO4lSsSopEJRH8QeDzYj7MLN-ZfY_I,42
+kmt/__main__.py,sha256=1oCvV66p7vdjcVUT7c3wdiPkM0Vq-B1DpISmo_hHZPw,61
+kmt/exception.py,sha256=PAQR7Di0Itn7SQnzVQKLoVSZE0n6bEW2lS8V2YksfHo,142
+kmt/handlers.py,sha256=IsVuWc2tL--Q_-wnYW86V3-m5nXZS1-8N1KsbNK_fGA,3221
+kmt/kmt.py,sha256=UOz7KISVEA25LlSl-EoBJZc3Xu9_kWGhY-LisEzFPWU,2989
+kmt/util.py,sha256=sM4-DXCAMD_KCc_XSzrycFOGqco2jCdJKJ52b8N-MNc,2008
+kmt-0.1.1.dist-info/LICENSE,sha256=tv8dENThTg6WliLKSLo5JT5xgoqRWJ7NTgoatu9HogE,1068
+kmt-0.1.1.dist-info/METADATA,sha256=9VcSLzTcFAbDNqBwDTh2JH0b_L95QcVF60avf1lLjOo,404
+kmt-0.1.1.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+kmt-0.1.1.dist-info/entry_points.txt,sha256=0W2nnP5Xle1_CDr9NMZSWz_CsXvD8RWl3FWAT3-cqT8,33
+kmt-0.1.1.dist-info/top_level.txt,sha256=w1tBmLKWmKZYlp-gga6CmkT69DIJpruXkPTwb2iKBEI,4
+kmt-0.1.1.dist-info/RECORD,,

kmt-0.1.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.43.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

kmt-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+kmt = kmt:main

kmt-0.1.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+kmt