swaggerizer 0.1.1__py3-none-any.whl

swaggerizer/helpers/create_project.py

@@ -0,0 +1,392 @@
+import os, re, shutil, yaml
+import sys, threading, time
+from collections import defaultdict
+from importlib import resources
+from ruamel.yaml import YAML
+from ruamel.yaml.error import YAMLError
+from .validator import validator
+
+class Swaggerizer:
+
+    def __init__(self, input_file):
+        self.target_file_path = os.path.abspath(input_file)
+        self.target_file_name = os.path.basename(self.target_file_path)
+        self.target_dir = os.path.dirname(self.target_file_path)
+        self.show_progress = False
+        self.version = None
+        self.src_sub_dirs = dict.fromkeys(["intro", "endpoints", "components"])
+        self.project_sections = {
+            # Correlate project sections to top-level OpenAPI sections...
+            "intro": {
+                "basics": {
+                    "v2": ["swagger", "info", "schemes", "host", "basePath", "externalDocs"],
+                    "v3": ["openapi", "info", "servers", "externalDocs"]
+                },
+                "other": ["tags"]
+            },
+            "endpoints": "paths",
+            "components": {
+                "v2": ["definitions", "parameters", "responses", "securityDefinitions"],
+                "v3": "components"
+            }
+            # ... anything else will get added to "misc".
+        }
+
+
+    def create(self):
+        if os.path.exists(self.target_file_path):
+            print(f"Found {self.target_file_path}.")
+            proceed = input("Create modularized OpenAPI project for this file? (Y/n) ").strip().lower()
+        else:
+            print(f"Could not find {self.target_file_path}.")
+            proceed = input("Create default modularized OpenAPI project in current directory? (Y/n) ").strip().lower()
+
+        if proceed in ["y", ""]:
+            print("\nCreating the project...")
+            self._create_project()
+        else:
+            print("\nCreate operation canceled.")
+
+
+    def _create_project(self):
+        # Check for existing "openapi_src" directory
+        openapi_src_dir = os.path.join(self.target_dir, "openapi_src")
+        if os.path.exists(openapi_src_dir):
+            print(f"\nError: Source directory {openapi_src_dir} already exists.")
+            print("       To avoid overwrite, rename this directory or create the new project somewhere else.\n")
+            print("Aborting project creation.")
+            return
+
+        # Validate the src file
+        if os.path.exists(self.target_file_path):
+            print("\n- Make sure input file is valid YAML", end=" ")
+            self.show_progress = True
+            progress_thread = threading.Thread(target=self._progress_tracker)
+            progress_thread.start()
+            try:
+                validator.validate_yaml(self.target_file_path)
+            finally:
+                self.show_progress = False
+                progress_thread.join()
+            print(" done")
+
+        # Create the project dir structure
+        print(f"- Create OpenAPI source directory: {openapi_src_dir}")
+        os.makedirs(openapi_src_dir)
+        self.src_sub_dirs.update({
+            "intro": os.path.join(openapi_src_dir, "0_intro"),
+            "endpoints": os.path.join(openapi_src_dir, "1_endpoints"),
+            "components": os.path.join(openapi_src_dir, "2_components")
+        })
+        for src_sub_dir in self.src_sub_dirs.values():
+            os.makedirs(src_sub_dir)
+
+        # Select the target file
+        if os.path.exists(self.target_file_path):
+            print(f"- Modularize OpenAPI content from file: {self.target_file_name}", end=" ")
+        else:
+            print("- Modularize OpenAPI content from the default 'pet store' file", end=" ")
+            self._copy_default_file(os.path.dirname(self.target_file_path), "openapi.yaml")
+
+        # Modularize the content...
+        self.show_progress = True
+        progress_thread = threading.Thread(target=self._progress_tracker)
+        progress_thread.start()
+
+        try:
+            self._extract_intro(self.src_sub_dirs["intro"])
+            self._extract_endpoints(self.src_sub_dirs["endpoints"])
+            if self.version == "v2":
+                self._extract_components_v2(self.src_sub_dirs["components"])
+            elif self.version == "v3":
+                self._extract_components_v3(self.src_sub_dirs["components"])
+            self._extract_misc(openapi_src_dir)
+        finally:
+            self.show_progress = False
+            progress_thread.join()
+        print(f" done (OpenAPI{self.version})")
+
+        # Add and update the makefile
+        print("- Add makefile to the source directory")
+        self._copy_default_file(openapi_src_dir, "makefile")
+        self._update_makefile(openapi_src_dir, self.src_sub_dirs["components"])
+
+        # Implement project structure creation and file organization here
+        print("\nProject creation complete!")
+        print("Read the docs @ https://swaggerizer.com")
+
+
+    def _extract_intro(self, output_dir):
+        """
+        Extracts OpenAPI intro sections as defined in self.project_sections["intro"]
+        and writes them to a series of files in src/intro.
+        """
+
+        # Use ruamel to preserve order and spacing
+        yaml = YAML()
+        yaml.preserve_quotes = True
+        yaml.indent(mapping=2, sequence=4, offset=2)
+        yaml.width = 4096
+
+        # Read the OpenAPI YAML input file
+        with open(self.target_file_path, 'r', encoding='utf-8') as input_file:
+            openapi_content = yaml.load(input_file)
+
+        # Determine the Swagger/OpenAPI version
+        if "swagger" in openapi_content:
+            self.version = "v2"
+        elif "openapi" in openapi_content:
+            self.version = "v3"
+        else:
+            raise ValueError("Error: Missing 'openapi' or 'swagger' tag in OpenAPI input file!")
+
+        # Get the project sections
+        basics_sections = self.project_sections["intro"]["basics"][self.version]
+        other_sections = self.project_sections["intro"]["other"]
+
+        # Write intro/basics.yaml
+        basics = {k: openapi_content[k] for k in basics_sections if k in openapi_content}
+        if basics:
+            output_file = os.path.join(output_dir, "basics.yaml")
+            with open(output_file, "w", encoding="utf-8") as file:
+                yaml.dump(basics, file)
+
+        # Write other sections to intro/<name>.yaml
+        for section in other_sections:
+            if section in openapi_content:
+                output_data = {section: openapi_content[section]}
+                output_file = os.path.join(output_dir, f"{section}.yaml")
+                with open(output_file, "w", encoding="utf-8") as file:
+                    yaml.dump(output_data, file)
+
+
+    def _extract_endpoints(self, output_dir):
+        """
+        Extracts the endpoints from the OpenAPI "paths" section and writes them to
+        a series of files in src/endpoints named by the tag group.
+        """
+
+        # Use ruamel to preserve order and indentation
+        yaml = YAML()
+        yaml.preserve_quotes = True
+        yaml.indent(mapping=2, sequence=4, offset=2)
+
+        # Read the OpenAPI YAML input file
+        with open(self.target_file_path, 'r', encoding='utf-8') as file:
+            openapi_content = yaml.load(file)
+
+        # Make sure the "paths" section exists
+        if 'paths' not in openapi_content:
+            raise ValueError("Error: Missing 'paths' section in OpenAPI input file!")
+
+        # Group endpoints by tag
+        tag_endpoints = defaultdict(dict)
+        for path, methods in openapi_content['paths'].items():
+            for method, details in methods.items():
+                if 'tags' in details:
+                    # store tagged endpoints by tag name
+                    for tag in details['tags']:
+                        tag = tag.replace(" ", "_").lower()
+                        if path not in tag_endpoints[tag]:
+                            tag_endpoints[tag][path] = {}
+                        tag_endpoints[tag][path][method] = details
+                else:
+                    # store untagged endpoints as "untagged"
+                    tag_endpoints['untagged'][path] = tag_endpoints['untagged'].get(path, {})
+                    tag_endpoints['untagged'][path][method] = details
+
+        # Write endpoints to the 'src/endpoints' dir
+        for tag, endpoints in tag_endpoints.items():
+            output_file_path = os.path.join(output_dir, f"{tag}.yaml")
+
+            # write to the output file
+            with open(output_file_path, 'w', encoding='utf-8') as output_file:
+                yaml.dump({'paths': endpoints}, output_file)
+
+            # remove 'paths:' label from output
+            self._chop_first_line(output_file_path)
+
+
+    def _extract_components_v2(self, output_dir):
+        """
+        Extracts the sections from the OpenAPI v2 top-level components sections and writes
+        them to a series of files in src/components named by the section.
+        """
+
+        # Use ruamel to preserve order and indentation
+        yaml = YAML()
+        yaml.preserve_quotes = True
+        yaml.indent(mapping=2, sequence=4, offset=2)
+
+        # Read the OpenAPI YAML input file
+        with open(self.target_file_path, 'r', encoding='utf-8') as file:
+            openapi_content = yaml.load(file)
+
+        # Get the list of v2 components
+        components_sections = self.project_sections["components"]["v2"]
+
+        # Write sections to the 'src/components' dir
+        for section_name in components_sections:
+            if section_name in openapi_content:
+                output_file = os.path.join(output_dir, f"{section_name}.yaml")
+
+                # include both section name and content
+                section_data = {section_name: openapi_content[section_name]}
+
+                # write to the output file
+                with open(output_file, 'w', encoding='utf-8') as out_file:
+                    yaml.dump(section_data, out_file)
+
+
+    def _extract_components_v3(self, output_dir):
+        """
+        Extracts the sections from the OpenAPI v3 "components" section and writes them
+        to a series of files in src/components named by the section.
+        """
+
+        # Use ruamel to preserve order and indentation
+        yaml = YAML()
+        yaml.preserve_quotes = True
+        yaml.indent(mapping=2, sequence=4, offset=2)
+
+        # Read the OpenAPI YAML input file
+        with open(self.target_file_path, 'r', encoding='utf-8') as file:
+            openapi_content = yaml.load(file)
+
+        # Make sure the "components" section exists
+        if 'components' not in openapi_content:
+            return
+
+        # Write components to the 'src/components' dir
+        components = openapi_content['components']
+        for section_name, section_content in components.items():
+            output_file = os.path.join(output_dir, f"{section_name}.yaml")
+            yaml.indent(mapping=4, sequence=4, offset=2)
+
+            # write to the output file
+            with open(output_file, 'w', encoding='utf-8') as out_file:
+                yaml.dump({'components': {section_name: section_content}}, out_file)
+
+            # remove 'components:' label from output
+            self._chop_first_line(output_file)
+
+
+    def _extract_misc(self, openapi_src_dir):
+        """
+        Extracts any other top-level OpenAPI sections besides the ones defined in 
+        self.project_sections. If present, writes them to src/misc.
+        """
+
+        # Use ruamel to preserve order and spacing
+        yaml = YAML()
+        yaml.preserve_quotes = True
+        yaml.indent(mapping=2, sequence=4, offset=2)
+        yaml.width = 4096
+
+        # Read the OpenAPI YAML input file
+        with open(self.target_file_path, 'r', encoding='utf-8') as input_file:
+            openapi_content = yaml.load(input_file)
+
+        # Assign all the main sections to a set
+        assigned_keys = self._collect_keys(self.project_sections)
+
+        # Find any unassigned keys in the OpenAPI file
+        misc_keys = sorted(set(openapi_content.keys()) - assigned_keys)
+
+        # If there misc keys, save and write them to src/misc dir
+        if misc_keys:
+            # save keys and create 'src/misc' dir
+            self.src_sub_dirs["misc"] = os.path.join(openapi_src_dir, "3_misc")
+            os.makedirs(self.src_sub_dirs["misc"])
+            self.project_sections["misc"] = misc_keys
+
+            # Write each section to 'misc/<name>.yaml'
+            for name in misc_keys:
+                output_data = {name: openapi_content[name]}
+                output_file = os.path.join(self.src_sub_dirs["misc"], f"{name}.yaml")
+                with open(output_file, "w", encoding="utf-8") as file:
+                    yaml.dump(output_data, file)
+
+
+    def _copy_default_file(self, target_dir, filename):
+        """
+        Copy default template files from swaggerizer/files into target_dir.
+        """
+        os.makedirs(target_dir, exist_ok=True)
+        src = resources.files("swaggerizer.files").joinpath(filename)
+        dest = os.path.join(target_dir, filename)
+        shutil.copy(src, dest)
+
+
+    def _update_makefile(self, src_dir, components_dir):
+        """
+        Add target to makefile to build final OpenAPI yaml file.
+        If no misc sections present, remove that part.
+        """
+
+        # Read default makefile content
+        make_file = os.path.join(src_dir, 'makefile')
+        with open(make_file, 'r', encoding='utf-8') as file:
+            content = file.read()
+
+        # Replace placeholder build target
+        content = re.sub(r'FINAL_BUILD_TARGET', self.target_file_name, content)
+
+        # If no components files, remove components build
+        if not os.listdir(components_dir):
+            content = re.sub(r'^.+components[:/].+\n', '', content, flags=re.MULTILINE)
+        elif self.version == "v2":
+            content = re.sub(r'^.+components[:].+\n', '', content, flags=re.MULTILINE)
+
+        # If no misc sections, remove misc build
+        if not self.project_sections.get("misc"):
+            content = re.sub(r'^.+_misc[/].+\n', '', content, flags=re.MULTILINE)
+
+        # Write final version of makefile
+        with open(make_file, 'w', encoding='utf-8') as file:
+            file.write(content)
+
+
+    def _collect_keys(self, data):
+        """
+        Iterate nested data structure to get all the keys.
+        """
+        keys = set()
+        if isinstance(data, str):
+            keys.add(data)
+        elif isinstance(data, list):
+            keys.update(data)
+        elif isinstance(data, dict):
+            for val in data.values():
+                if isinstance(val, dict) and self.version in val:
+                    keys.update(self._collect_keys(val[self.version]))
+                else:
+                    keys.update(self._collect_keys(val))
+        return keys
+    
+
+    def _chop_first_line(self, file_path):
+        """
+        Remove 1st line of output file during OpenAPI content modularization.
+        """
+        with open(file_path, 'r', encoding='utf-8') as file:
+            lines = file.readlines()
+
+        if len(lines) > 1:
+           # ouput everything after line 1
+           with open(file_path, 'w', encoding='utf-8') as file:
+              file.writelines(lines[1:])
+        else:
+            # output empty file
+            open(file_path, 'w').close()
+
+
+    def _progress_tracker(self):
+        """
+        Progress bar for long modularize operations.
+        """
+        while self.show_progress:
+            sys.stdout.write(".")
+            sys.stdout.flush()
+            time.sleep(2)
+

swaggerizer/helpers/html_exporter.py

@@ -0,0 +1,112 @@
+import os, yaml, json
+from .json_utils import json_serializer
+
+"""
+Helper class for converting Swagger YAML files into HTML format.
+
+Example usage:
+    exporter = HTMLExporter("input.yaml", "output.html")
+    exporter.export()
+
+#  Copyright 2024 JR Halterlein
+#  Licensed under the Apache License, Version 2.0.
+#  See http://www.apache.org/licenses/LICENSE-2.0 for the full text.
+#
+#  This file is based on
+#  https://github.com/swagger-api/swagger-ui/blob/4f1772f6544699bc748299bd65f7ae2112777abc/dist/index.html
+#  (Copyright 2017 SmartBear Software, Licensed under Apache 2.0)
+#  https://github.com/yousan/swagger-yaml-to-html/blob/master/swagger-yaml-to-html.py
+#  (Copyright 2017 Otto Seiskari, Licensed under Apache 2.0)
+"""
+
+
+class HTMLExporter:
+    TEMPLATE = """
+    <!DOCTYPE html>
+    <html lang="en">
+    <head>
+      <meta charset="UTF-8">
+      <title>Swagger UI</title>
+      <link href="https://fonts.googleapis.com/css?family=Open+Sans:400,700|Source+Code+Pro:300,600|Titillium+Web:400,600,700" rel="stylesheet">
+      <link rel="stylesheet" type="text/css" href="https://cdnjs.cloudflare.com/ajax/libs/swagger-ui/5.28.0/swagger-ui.css" >
+      <link rel="stylesheet" type="text/css" href="customizer.css" >
+      <style>
+        html
+        {
+          box-sizing: border-box;
+          overflow: -moz-scrollbars-vertical;
+          overflow-y: scroll;
+        }
+        *,
+        *:before,
+        *:after
+        {
+          box-sizing: inherit;
+        }
+        body {
+          margin:0;
+          background: #fafafa;
+        }
+      </style>
+    </head>
+    <body>
+    <div id="swagger-ui"></div>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/swagger-ui/5.28.0/swagger-ui-bundle.js"> </script>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/swagger-ui/5.28.0/swagger-ui-standalone-preset.js"> </script>
+    <script src="customizer.js"> </script>
+    <script>
+    window.onload = function() {
+      var spec = %s;
+      // Build a system
+      const ui = SwaggerUIBundle({
+        spec: spec,
+        dom_id: '#swagger-ui',
+        deepLinking: true,
+        presets: [
+          SwaggerUIBundle.presets.apis,
+          SwaggerUIStandalonePreset
+        ],
+        plugins: [
+          SwaggerUIBundle.plugins.DownloadUrl
+        ],
+        layout: "StandaloneLayout"
+      })
+      window.ui = ui
+    }
+    </script>
+    </body>
+    </html>
+    """
+
+
+    def __init__(self, input_file, output_file):
+        self.input_file = input_file
+        if output_file:
+            self.output_file = output_file
+        else:
+            # Derive from input filename
+            input_dir = os.path.dirname(input_file)
+            base_name = os.path.splitext(os.path.basename(input_file))[0]
+            self.output_file = os.path.join(input_dir, f"{base_name}.html")
+
+
+    def export(self):
+        try:
+            # Read the YAML file
+            with open(self.input_file, 'r', encoding='utf-8') as infile:
+                spec = yaml.load(infile, Loader=yaml.FullLoader)
+
+            # Generate the HTML content
+            html_content = self.TEMPLATE % json.dumps(spec, default=json_serializer)
+
+            # Write the HTML content to the output file
+            with open(self.output_file, 'w', encoding='utf-8') as outfile:
+                outfile.write(html_content)
+
+            print(f"Exported HTML to {self.output_file}")
+
+        except FileNotFoundError:
+            print(f"Error: Input file '{self.input_file}' not found.")
+        except Exception as e:
+            print(f"Error during export: {e}")
+

swaggerizer/helpers/json2yaml_converter.py

@@ -0,0 +1,44 @@
+import os, json, yaml
+
+"""
+Helper class for converting JSON files into YAML format.
+
+Example usage:
+    converter = json2YamlConverter(args.input, args.output)
+    converter.convert()
+
+#  Copyright 2024 JR Halterlein
+#  Licensed under the Apache License, Version 2.0.
+#  See http://www.apache.org/licenses/LICENSE-2.0 for the full text.
+"""
+
+
+class json2YamlConverter:
+    def __init__(self, input_file, output_file):
+        self.input_file = input_file
+        if output_file:
+            self.output_file = output_file
+        else:
+            # Derive from input filename
+            input_dir = os.path.dirname(input_file)
+            base_name = os.path.splitext(os.path.basename(input_file))[0]
+            self.output_file = os.path.join(input_dir, f"{base_name}.yaml")
+
+    def convert(self):
+        try:
+            with open(self.input_file, 'r') as json_file:
+                data = json.load(json_file)
+            with open(self.output_file, 'w') as yaml_file:
+                yaml.dump(data, yaml_file, default_flow_style=False)
+        
+            print(f"Converted JSON file {self.input_file} to YAML file {self.output_file}.")
+
+        except FileNotFoundError:
+            print(f"Error: Input file '{self.input_file}' not found.")
+        except json.JSONDecodeError as e:
+            print(f"Error: Failed to parse JSON file. Details: {e}")
+        except PermissionError:
+            print(f"Error: Permission denied when accessing '{self.output_file}'.")
+        except Exception as e:
+            print(f"An unexpected error occurred: {e}")
+

swaggerizer/helpers/json_utils.py

@@ -0,0 +1,11 @@
+from datetime import date, datetime
+
+def json_serializer(obj):
+    """
+    Custom JSON serializer for non-serializable objects.
+    Converts datetime.date and datetime.datetime to ISO 8601 strings.
+    """
+    if isinstance(obj, (date, datetime)):
+        return obj.isoformat()
+    raise TypeError(f"Type {type(obj)} not serializable")
+

swaggerizer/helpers/validator.py

@@ -0,0 +1,67 @@
+import os, sys, json
+from json import JSONDecodeError
+from ruamel.yaml import YAML
+from ruamel.yaml.error import YAMLError
+
+class validator:
+
+    @staticmethod
+    def validate(file_path, file_type):
+        """
+        Validate a file as YAML or JSON, depending on file_type ('yaml'/'yml' or 'json').
+        Confirms the file exists before validation.
+        """
+        if not os.path.isfile(file_path):
+            print(f"\nInput file does not exist: {file_path}\n")
+            sys.exit(1)
+
+        type = (file_type or "").strip().lower()
+        if not type:
+            file, file_type = os.path.splitext(file_path)
+            type = file_type.lstrip(".").lower()
+
+        if type in ("yaml", "yml"):
+            validator.validate_yaml(file_path)
+            print(f"\n{file_path} is valid YAML.\n")
+        elif type == "json":
+            validator.validate_json(file_path)
+            print(f"\n{file_path} is valid JSON.\n")
+        else:
+            print(f"\nUnsupported file type: {type!r}. Expected 'yaml'/'yml' or 'json'.\n")
+            sys.exit(1)
+
+    
+    @staticmethod
+    def validate_yaml(file_path):
+        """
+        Validate structural YAML in src file.
+        Note: Does not validate OpenAPI spec.
+        """
+        yaml = YAML()
+
+        # Validate YAML structure
+        try:
+            with open(file_path, 'r', encoding='utf-8') as file:
+                file_content = yaml.load(file)
+        except YAMLError as e:
+            print(f"\nCould not parse YAML for input file: {file_path}")
+            print(f"Error details:\n\n{e}")
+            print("Fix YAML structural issues and try again.")
+            sys.exit(1)
+
+
+    @staticmethod
+    def validate_json(file_path):
+        """
+        Validate structural JSON in src file.
+        Note: Does not validate OpenAPI spec.
+        """
+        try:
+            with open(file_path, 'r', encoding='utf-8') as file:
+                file_content = json.load(file)
+        except JSONDecodeError as e:
+            print(f"\nCould not parse JSON for input file: {file_path}")
+            print(f"Error details:\n\n{e}")
+            print("Fix JSON structural issues and try again.")
+            sys.exit(1)
+

swaggerizer/helpers/yaml2json_converter.py

@@ -0,0 +1,45 @@
+import os, json, yaml
+from .json_utils import json_serializer
+
+"""
+Helper class for converting YAML files into JSON format.
+
+Example usage:
+    converter = yaml2JsonConverter(args.input, args.output)
+    converter.convert()
+
+#  Copyright 2024 JR Halterlein
+#  Licensed under the Apache License, Version 2.0.
+#  See http://www.apache.org/licenses/LICENSE-2.0 for the full text.
+"""
+
+
+class yaml2JsonConverter:
+    def __init__(self, input_file, output_file):
+        self.input_file = input_file
+        if output_file:
+            self.output_file = output_file
+        else:
+            # Derive from input filename
+            input_dir = os.path.dirname(input_file)
+            base_name = os.path.splitext(os.path.basename(input_file))[0]
+            self.output_file = os.path.join(input_dir, f"{base_name}.json")
+
+    def convert(self):
+        try: 
+            with open(self.input_file, 'r') as yaml_file:
+                data = yaml.safe_load(yaml_file)
+            with open(self.output_file, 'w') as json_file:
+                json.dump(data, json_file, indent=4, default=json_serializer)
+        
+            print(f"Converted YAML file {self.input_file} to JSON file {self.output_file}")
+
+        except FileNotFoundError:
+            print(f"Error: Input file '{self.input_file}' not found.")
+        except yaml.YAMLError as e:
+            print(f"Error: Failed to parse YAML file. Details: {e}")
+        except PermissionError:
+            print(f"Error: Permission denied when accessing '{self.output_file}'.")
+        except Exception as e:
+            print(f"An unexpected error occurred: {e}")
+