parse-changelog 1.0.10__py3-none-any.whl

parse_changelog/VERSION

@@ -0,0 +1 @@
+1.0.10

parse_changelog/__init__.py

@@ -0,0 +1,11 @@
+import os
+
+def get_version():
+    dir_path = os.path.dirname(os.path.realpath(__file__))
+    try:
+        with open(os.path.join(dir_path, "VERSION"), encoding="utf-8") as vf:
+            version = vf.read().strip()
+    except Exception: #pylint: disable=broad-exception-caught
+        version = "0.0.0"
+
+    return version

parse_changelog-1.0.10.data/scripts/parse-changelog

@@ -0,0 +1,292 @@
+#!python
+from argparse import ArgumentParser, ArgumentDefaultsHelpFormatter
+from collections import OrderedDict
+from datetime import datetime
+import json
+import os
+import re
+import sys
+import tempfile
+
+
+def add_release(changelog_file, new_release, release_date=None):
+    """
+    Add a new release to the changelog, using the current content of the Unreleased section.
+
+    Args:
+        changelog_file:     (str) changelog file to parse
+        new_release:        (str) version of the release to create
+        release_date:       (datetime) date of the release (default to today)
+    """
+    if not release_date:
+        release_date = datetime.now().strftime("%Y-%m-%d")
+
+    new_release_title = f"[{new_release}] - {release_date}"
+
+    changelog = parse(changelog_file)
+
+    if new_release in changelog:
+        print("Release already exists in changelog")
+        return
+
+    changelog[new_release] = {
+        "title": new_release_title,
+        "content": changelog["prerelease"]["content"],
+        "version": new_release,
+        "date": release_date
+    }
+    # Move the new release into the correct spot - move new release to the beginning, and then put prerelease and intro at the beginning
+    changelog.move_to_end(new_release, last=False)
+    changelog.move_to_end("prerelease", last=False)
+    changelog.move_to_end("introduction", last=False)
+
+    changelog["prerelease"]["content"] = ""
+
+    print(json.dumps(changelog, indent=2))
+    write_changelog(changelog_file, changelog)
+
+
+def parse(changelog_file):
+    """
+    Parse the changelog into JSON
+
+    Args:
+        changelog_file:     (str) changelog file to parse
+    """
+
+    #
+    # Mode 2 - parse the changelog into a list of releases
+    #
+    try:
+        with open(changelog_file, "r", encoding="utf-8") as cf:
+            changelog = cf.read()
+    except FileNotFoundError:
+        print(f"Could not find {changelog_file}")
+        sys.exit(1)
+
+    # This parser is extremely simple and makes many assumptions about the structure of the document.
+    # Instead of parsing headings into a generic tree structure, assume the changelog format where there is a single
+    # heading1 node, a list of heading2 nodes that refer to releases, and 0 or more heading3 nodes per release that
+    # refer to types of changes
+    release_list = OrderedDict()
+    current_release = None
+    current_content = []
+    found_heading1 = False
+    version = "unknown"
+    rel_date = "unknown"
+    for line in changelog.split("\n"):
+        if line.startswith("#"):
+            heading_level = line.count("#")
+            title = line.strip("#").strip()
+
+            # Main heading, there should only be one
+            if heading_level == 1:
+                assert title.lower() == "changelog", "The top level heading1 must be named Changelog"
+                assert not found_heading1, "There can only be one heading1"
+                found_heading1 = True
+                continue
+
+            # Heading2, this indicates a release section
+            if heading_level == 2:
+                # A new release means stop parsing for the previous release
+                # Add the previous release to the document
+                if current_release:
+                    if version != "unknown":
+                        section_key = version
+                    else:
+                        section_key = current_release
+                    release_list[section_key] = {
+                        "title": current_release,
+                        "content": "\n".join(current_content).rstrip(),
+                        "version": version,
+                        "date": rel_date}
+                else:
+                    release_list["introduction"] = {
+                        "title": "Changelog",
+                        "content": "\n".join(current_content).rstrip(),
+                        "version": "",
+                        "date": ""
+                    }
+
+                current_release = title
+                current_content = []
+                # Special case for Unreleased section
+                if title.lower() == "[unreleased]":
+                    version = "prerelease"
+                    rel_date = "unreleased"
+                else:
+                    # Parse version and release date from the section title
+                    m = re.match(
+                        r"\[(\d+\.\d+\.\d+)[-\.+0-9a-zA-Z]*\]\s+-\s+(\d{4}-\d{2}-\d{2})", title)
+                    if m:
+                        version = m.group(1)
+                        rel_date = m.group(2)
+                    else:
+                        version = "unknown"
+                        rel_date = "unknown"
+
+                continue
+
+            # Any other level is content inside a release
+            if heading_level >= 3:
+                current_content.append(line)
+                continue
+
+        # Anything other than a release line, add to the current content
+        current_content.append(line)
+
+    # Add the last section we found
+    if current_release:
+        if version != "unknown":
+            section_key = version
+        else:
+            section_key = current_release
+        release_list[section_key] = {
+            "title": current_release,
+            "content": "\n".join(current_content).rstrip(),
+            "version": version,
+            "date": rel_date}
+
+    return release_list
+
+
+def pretty_print(changelog_file, show_unreleased):
+    """
+    Print changelog as JSON
+
+    Args:
+        changelog_file:     (str) changelog file to parse
+        show_unreleased:    (bool) only show the unreleased section
+    """
+    changelog = parse(changelog_file)
+
+    # Only show the unreleased changes section
+    if show_unreleased:
+        print(changelog.get("prerelease", {}).get("content", ""))
+        return
+
+    # Show what we parsed, in JSON format
+    print(json.dumps(changelog, indent=2))
+
+
+def add_change(changelog_file, change_desc, change_type):
+    change_type = change_type.title()
+    if not change_desc.startswith("*"):
+        change_desc = "* " + change_desc
+    change_desc.rstrip()
+
+    changelog = parse(changelog_file)
+    prerelease = changelog.get("prerelease", {})
+    if not prerelease:
+        prerelease = {
+            "title": "[Unreleased]",
+            "content": "",
+            "version": "prerelease",
+            "date": "unreleased"
+        }
+
+    # Insert the new change at the appropriate section
+    content = prerelease.get("content", "")
+    new_content = ""
+    found = False
+    for line in content.split("\n"):
+        if re.search(r"^###\s+" + change_type, line, re.IGNORECASE):
+            found = True
+            # insert the new change description
+            if not new_content.endswith("\n"):
+                new_content += "\n"
+            new_content += line
+            if not new_content.endswith("\n"):
+                new_content += "\n"
+            new_content += change_desc + "\n"
+        else:
+            new_content += line
+            if not new_content.endswith("\n"):
+                new_content += "\n"
+    prerelease["content"] = new_content.rstrip()
+    if not found:
+        prerelease["content"] += f"\n### {change_type}\n{change_desc}"
+
+
+    changelog["prerelease"] = prerelease
+
+    print(json.dumps(changelog, indent=2))
+    write_changelog(changelog_file, changelog)
+
+
+def write_changelog(changelog_file, content):
+    """
+    Write out a changelog from the JSON structure
+
+    Args:
+        changelog_file:     (str) changelog file to parse
+        content:            (OrderedDict) content to write to the changelog
+    """
+    target_path = os.path.abspath(changelog_file)
+    target_dir = os.path.dirname(target_path) or "."
+    new_changelog = None
+    try:
+        with tempfile.NamedTemporaryFile("w", encoding="utf-8", dir=target_dir, delete=False) as tmp:
+            new_changelog = tmp.name
+            tmp.write("# Changelog\n")
+            intro = content.pop("introduction", {}).get("content", "")
+            tmp.write(f"{intro}\n")
+            tmp.write("\n")
+
+            for idx, heading in enumerate(content):
+                tmp.write(f"## {content[heading]['title']}\n")
+                if content[heading]["content"]:
+                    tmp.write(content[heading]["content"] + "\n")
+                if idx < len(content)-1:
+                    tmp.write("\n")
+        os.replace(new_changelog, target_path)
+    finally:
+        # Make sure intermediate file is removed
+        if new_changelog:
+            try:
+                os.remove(new_changelog)
+            except FileNotFoundError:
+                pass
+
+
+def get_version():
+    try:
+        import parse_changelog
+        return parse_changelog.get_version()
+    except ImportError:
+        return "0.0.0"
+
+
+if __name__ == "__main__":
+    change_types = ["added", "changed", "deprecated", "removed", "fixed", "security"]
+
+    parser = ArgumentParser(description="Parse and update changelog files",
+                            formatter_class=ArgumentDefaultsHelpFormatter)
+    # Common args
+    parser.add_argument("--changelog", "-c", dest="changelog_file", default="CHANGELOG.md",
+                        help="the changelog file to parse")
+    parser.add_argument("--version", "-v", action="version",
+                        version=get_version())
+    # Args for parsing
+    parsing_group = parser.add_argument_group(title="Parsing")
+    parsing_group.add_argument("--show-unreleased", "-u", dest="show_unreleased", action="store_true",
+                               help="When parsing, only show the changes from the Unreleased section")
+    # Args for creating a release
+    release_group = parser.add_argument_group("Adding a Release")
+    release_group.add_argument("--release", "-r", dest="new_release", metavar="X.Y.Z",
+                               help="Create a new release by moving the Unreleased section to the specified new release section")
+    release_group.add_argument("--date", "-d", dest="release_date", metavar="YYYY-MM-DD",
+                               help="Use this date for the new release, instead of today")
+    # Args for adding changes
+    change_group = parser.add_argument_group("Adding a change")
+    change_group.add_argument("--add-change", "-a", dest="change_desc", metavar="TEXT", help="One-line description of the change")
+    change_group.add_argument("--type", "-t", dest="change_type", metavar="TYPE", choices=change_types, help=f"The type of change {change_types}")
+
+    args = parser.parse_args()
+
+    if args.new_release:
+        add_release(args.changelog_file, args.new_release, args.release_date)
+    elif args.change_desc:
+        add_change(args.changelog_file, args.change_desc, args.change_type)
+    else:
+        pretty_print(args.changelog_file, args.show_unreleased)

parse_changelog-1.0.10.dist-info/LICENSE

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

parse_changelog-1.0.10.dist-info/METADATA

@@ -0,0 +1,125 @@
+Metadata-Version: 2.2
+Name: parse-changelog
+Version: 1.0.10
+Summary: A very simplistic changelog parser/updater
+Home-page: https://github.com/cseelye/parse-changelog
+Author: Carl Seelye
+Author-email: cseelye@gmail.com
+License: MIT
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: summary
+
+# parse-changelog
+This is a simplified changelog updater/parser, made for CI pipeline use. It has these abilities:
+1. Add a new change to the changelog, in the Unreleased section
+1. Add a new release into the changelog, using the list of changes from the Unreleased section
+1. Parse the releases in the changelog into a JSON structure.
+
+Changelogs must be in the format documented by [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), see the details
+below.
+
+Release history: [parse-changelog's CHANGELOG](https://github.com/cseelye/parse-changelog/blob/main/CHANGELOG.md)
+
+## Adding a Release
+This mode is invoked by using the `--release` arg and will parse the changelog and insert a new release at the beginning
+of the list of releases, using the changes from the Unreleased section. You can optionally specify a release date, or by
+default use todays date.
+
+The changelog must use the format `## [Unreleased]` (case insensitive) for this parser to find it.
+For example, here is the diff generated by adding a new release(`--release 1.0.2`):
+```
+## [Unreleased]
++
++## [1.0.2] - 2022-10-20
+ * Great new stuff
+
+ ## [1.0.1] - 2022-10-08
+```
+
+## Adding a Change
+This mode is invoked with the `--add-change` and `--type` args. It will parse the changelog to find the Unreleased
+section and any changes already there, find the correct change type heading, and add the new change.
+For example, here is the diff generated by adding a new fix (`--add-change "Fix that annoying bug" --type fixed`):
+```
+## [Unreleased]
+ * Great new stuff
++### Fixed
++* Fix that annoying bug
+
+ ## [1.0.1] - 2022-10-08
+```
+
+## Changelog Parsing
+This mode will parse the changelog into JSON and print it to the screen. It finds all of
+the heading2 entries (lines starting with `##`) and assumes each of those is a release. For each release, it parses
+the release title into version and date, and collects the content of the release as a single string. Each release
+heading must be of the format `## [release_version] - YYYY-MM-DD`, where `release_version` matches SemVer version string
+spec, and `YYYY-MM-DD` is a valid year-month-day. The one exception to this format is the special release heading for
+unreleased changes, which must match `## [Unreleased]`. The content of the release is parsed as a single string and not
+interpreted in any way.
+
+The top heading1 and project description are parsed into a special section named "introduction".
+
+For example, given the following changelog:
+```
+# Changelog
+
+My Project Name
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+* Great new stuff
+
+## [1.0.1] - 2022-10-08
+### Fixed
+* Minor bug that we missed
+### Changed
+* New name for an artifact
+
+## [1.0.0] - 2022-09-01
+Initial release
+* Some cool feature
+* Other interesting stuff
+```
+
+It will be parsed into this JSON:
+
+```
+{
+  "introduction": {
+    "title": "Changelog",
+    "content": "\nMy Project Name\n\nAll notable changes to this project will be documented in this file.\n\nThe format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),\nand this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).",
+    "version": "",
+    "date": ""
+  },
+  "prerelease": {
+    "title": "[Unreleased]",
+    "content": "* Great new stuff",
+    "version": "prerelease",
+    "date": "unreleased"
+  },
+  "[1.0.1] - 2022-10-08": {
+    "title": "[1.0.1] - 2022-10-08",
+    "content": "### Fixed\n* Minor bug that we missed\n### Changed\n* New name for an artifact",
+    "version": "1.0.1",
+    "date": "2022-10-08"
+  },
+  "[1.0.0] - 2022-09-01": {
+    "title": "[1.0.0] - 2022-09-01",
+    "content": "Initial release\n* Some cool feature\n* Other interesting stuff",
+    "version": "1.0.0",
+    "date": "2022-09-01"
+  }
+}
+```

parse_changelog-1.0.10.dist-info/RECORD

@@ -0,0 +1,8 @@
+parse_changelog/VERSION,sha256=ACUb7h0D9ljCMkkmeFqZbdBA3_Fr-ZOyxSCiDtu6csg,7
+parse_changelog/__init__.py,sha256=C1Qe0BVPxa61b441fKYGAf8Qd7XyHgBYDwR8F-RJxlA,324
+parse_changelog-1.0.10.data/scripts/parse-changelog,sha256=Dt5md5ZmhQ9Cge6v3l--X7rL1NK2wiy8HMDUSXdqdz8,10762
+parse_changelog-1.0.10.dist-info/LICENSE,sha256=Imudq40fjwY04eXGz5ObRd0xy51LT7X_jEphYX-9Y8Q,1068
+parse_changelog-1.0.10.dist-info/METADATA,sha256=BfG0kAk8APC9W4wInj2Bjgq9BhhH5n7Qsh5i7N67Fjg,4383
+parse_changelog-1.0.10.dist-info/WHEEL,sha256=beeZ86-EfXScwlR_HKu4SllMC9wUEj_8Z_4FJ3egI2w,91
+parse_changelog-1.0.10.dist-info/top_level.txt,sha256=scKFCMsZgB5m8oBmtrjV8iybGgm8pXaWF0XqfC6oLuY,16
+parse_changelog-1.0.10.dist-info/RECORD,,

parse_changelog-1.0.10.dist-info/WHEEL

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

parse_changelog-1.0.10.dist-info/top_level.txt

@@ -0,0 +1 @@
+parse_changelog