osc-fast-export 1.0.0__py3-none-any.whl

osc_fast_export-1.0.0.dist-info/METADATA

@@ -0,0 +1,47 @@
+Metadata-Version: 2.4
+Name: osc_fast_export
+Version: 1.0.0
+Summary: Generate git-fast-import compatible text stream from OSC history
+Author-email: Matěj Cepl <mcepl@cepl.eu>
+License-Expression: MIT
+Project-URL: homepage, https://codeberg.org/mcepl/osc-fast-export
+Project-URL: repository, https://codeberg.org/mcepl/osc-fast-export.git
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Information Technology
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Version Control
+Classifier: Topic :: Software Development :: Version Control :: Git
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Dynamic: license-file
+
+OSC (openSUSE build service VCS tool) fast-export compatible with
+`git fast-import(1)`.
+
+Just run this inside of the OBS package checkout and output
+should be piped to `git fast-import(1)`.
+
+It is useful to prepare authors file (per default
+`.osc/authorsfile.txt`) which is one-to-one mapping between logins
+(used in osc log) and full names+emails. E.g., one line of the
+file could be:
+
+```
+    mcepl = Matěj Cepl <mcepl@cepl.eu>
+```
+
+Cooperation with [git lfs](https://git-lfs.com/) is
+rather complicated: `git fast-import` can import only to
+completely empty branch, while `git lfs` doesn’t work without
+`.gitattributes`. The only solution I came up with is to put the
+content of `.gitattributes` into `.git/info/attributes`, which is
+read as well, but it doesn’t count as content of the repository
+itself.
+
+All issues, questions, complaints, or (even better!) patches
+should be send via email to
+[~mcepl/devel@lists.sr.ht](mailto:~mcepl/devel@lists.sr.ht) email
+list (for patches use [git send-email](https://git-send-email.io/)).

osc_fast_export-1.0.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+osc_fast_export.py,sha256=ad-zOQNpPHNfSvSUQBwUhZ0Wj-ei_R2GZcEMBE6h7iY,12086
+osc_fast_export-1.0.0.dist-info/licenses/LICENSE.txt,sha256=BxnyvG4KNEUw5-M5Jz-VbB87dcW1fdwEaMPO70AegtE,1073
+osc_fast_export-1.0.0.dist-info/METADATA,sha256=-d7zsQ6wFCDqtEAzqagsW5IhExoNT_-6ZMjrtcF8j2U,1876
+osc_fast_export-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+osc_fast_export-1.0.0.dist-info/entry_points.txt,sha256=-B-2JonSiPM4KfTWk9V4BGYFk0bRqBbMfr8h2ne8620,57
+osc_fast_export-1.0.0.dist-info/top_level.txt,sha256=7VKN28LmrR0k82aN2d9gKIdifX20DHB4xWfEu8u2iK8,16
+osc_fast_export-1.0.0.dist-info/RECORD,,

osc_fast_export-1.0.0.dist-info/WHEEL

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

osc_fast_export-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+osc-fast-export = osc_fast_export:main

osc_fast_export-1.0.0.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright 2022, Matěj Cepl mcepl at cepl dot eu
+
+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.

osc_fast_export-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+osc_fast_export

osc_fast_export.py

@@ -0,0 +1,400 @@
+#!/usr/bin/python3
+# https://git-scm.com/book/en/v2/Git-and-Other-Systems-Migrating-to-Git#_custom_importer
+
+import argparse
+import collections
+import configparser
+from datetime import datetime, timezone
+import logging
+import os.path
+import pathlib
+import pprint
+import signal
+from subprocess import CalledProcessError, PIPE, run
+import sys
+from typing import Dict, Iterator, List, Optional
+
+import xml.etree.ElementTree as ET
+
+logging.basicConfig(
+    format="%(levelname)s:%(funcName)s:%(message)s",
+    level=logging.INFO,
+)
+log = logging.getLogger("osc_fast_export")
+
+signal.signal(signal.SIGPIPE, signal.SIG_IGN)
+
+
+# For reading section-less config files
+# https://stackoverflow.com/a/2819788/164233
+def FakeSecHead(fp):
+    yield "[asection]\n"
+    yield from fp
+
+
+class LogEntry(
+    collections.namedtuple(
+        "LogEntry",
+        ["rev", "md5", "author", "date", "msg", "authors_map"],
+    )
+):
+    """
+    Represents a single log entry from the Open Build Service (OBS) history.
+
+    Attributes:
+        rev (int): The revision number of the entry.
+        md5 (str): The source MD5 checksum of the package at this revision.
+        author (str): The OBS username of the author.
+        date (datetime): The date and time of the commit.
+        msg (str): The commit message.
+    """
+
+    def __str__(self):
+        author_identity = self.authors_map.get(
+            self.author.lower(), self.author
+        )
+        return (
+            f"{self.rev}, {self.md5[:12]}, {author_identity},"
+            + f" {datetime.isoformat(self.date)}:\n{self.msg}"
+        )
+
+    def log_entry(self):
+        summary = self.msg.strip().split('\n')[0]
+        return f"{self.rev} {datetime.isoformat(self.date)}: {summary}"
+
+
+def get_authors() -> Dict[str, str]:
+    """
+    Reads the .osc/authorsfile.txt to get a mapping of OBS
+    usernames to Git author identities.
+
+    The authorsfile.txt is expected to be a simple key-value file
+    where keys are OBS usernames and values are Git author
+    strings (e.g., "Name <email@example.com>").
+
+    Returns:
+        Dict[str, str]: A dictionary mapping OBS usernames (str) to Git author
+                        strings (str).
+
+    Raises:
+        FileNotFoundError: If `.osc/authorsfile.txt` does not exist.
+    """
+    config = configparser.ConfigParser()
+    authors_map = {}
+    authorsfile = pathlib.Path(".osc", "authorsfile.txt")
+
+    if not authorsfile.exists():
+        raise FileNotFoundError(
+            "The .osc/authorsfile.txt file was not found."
+        )
+
+    with open(authorsfile, "r") as fp:
+        config.read_file(FakeSecHead(fp))
+    authors_map = dict(config.items("asection"))
+
+    log.debug("authors:\n%s", pprint.pformat(authors_map))
+    return authors_map
+
+
+def osc_log(authors_map: Dict[str, str]) -> Iterator[LogEntry]:
+    """
+    Retrieves the commit history of the current OBS package
+    checkout using 'osc log --xml'.
+
+    Raises:
+        SystemExit: If the script is not run from an OSC checkout.
+        RuntimeError: If the 'osc log' command fails to execute.
+
+    Returns:
+        LogEntry: A named tuple representing each log entry, in
+                  reverse chronological order (from oldest to newest revision).
+    """
+    log_pid = None
+    if not pathlib.Path(".osc").exists():
+        print(
+            "Must be run from the OSC checkout.", file=sys.stderr
+        )
+        sys.exit(9)
+    try:
+        log_pid = run(
+            ["osc", "log", "--xml"],
+            check=True,
+            text=True,
+            capture_output=True,
+        )
+    except CalledProcessError as exc:
+        raise RuntimeError(
+            f"Cannot collect log of the package!\nReported issue was:\n{str(exc)}"
+        ) from exc
+    log.debug("log_pid = %s", log_pid)
+
+    log_str = log_pid.stdout
+    log.debug("log_str:\n%s", log_str)
+    tree = ET.fromstring(log_str)
+    log_list = [
+        LogEntry(
+            int(entry.attrib["revision"]),
+            entry.attrib["srcmd5"],
+            entry.findtext("author"),
+            datetime.strptime(
+                entry.findtext("date"), "%Y-%m-%d %H:%M:%S"
+            ).replace(tzinfo=timezone.utc),
+            entry.findtext("msg"),
+            authors_map,
+        )
+        for entry in tree.iter("logentry")
+    ]
+    for entry in reversed(log_list):
+        log.info("%s", entry.log_entry())
+        yield entry
+
+
+def checkout_revision(rev: int):
+    """
+    Checks out a specific revision of the OBS package using 'osc
+    up -r' and cleans the working copy.
+
+    Args:
+        rev (int): The revision number to check out.
+
+    Raises:
+        RuntimeError: If 'osc up' or 'osc clean' commands fail.
+    """
+    try:
+        osc_pid = run(
+            ["osc", "up", "-e", "-r", f"{rev}"],
+            capture_output=True,
+            check=True,
+        )
+    except CalledProcessError as exc:
+        raise RuntimeError(
+            f"Cannot checkout revision {rev}!\nReported issue was:\n{exc.stderr}"
+        ) from exc
+
+    try:
+        osc_pid = run(
+            ["osc", "clean"],
+            capture_output=True,
+            check=True,
+        )
+    except CalledProcessError as exc:
+        raise RuntimeError(
+            f"Cannot clean checkout!\nReported issue was:\n{exc.stderr}"
+        ) from exc
+
+
+def _handle_missing_author(
+    obs_author: str,
+    authors_map: Dict[str, str],
+    non_interactive: bool,
+) -> str:
+    """
+    Handles cases where an OBS author is not found in the authors map.
+
+    If in non-interactive mode, it raises a ValueError.
+    Otherwise, it prompts the user for the author's name and email,
+    updates the authors_map, and appends the new mapping to
+    .osc/authorsfile.txt.
+
+    Args:
+        obs_author (str): The OBS username of the author.
+        authors_map (Dict[str, str]): The dictionary of author mappings.
+        non_interactive (bool): Flag to disable interactive prompts.
+
+    Returns:
+        str: The resolved Git author string.
+
+    Raises:
+        ValueError: If no author mapping is found in non-interactive mode.
+    """
+    if non_interactive:
+        raise ValueError(
+            f"No author mapping found for '{obs_author}' in non-interactive mode. "
+            f"Please add a mapping to .osc/authorsfile.txt for '{obs_author.lower()}'."
+        )
+
+    log.warning(
+        "No entry for %s in .osc/authorsfile.txt",
+        obs_author,
+    )
+    name = ""
+    while not (name or name == obs_author):
+        sys.stderr.write(f"Enter name for user '{obs_author}': ")
+        sys.stderr.flush()
+        name = input().strip()
+    email = ""
+    while not (email or "@" in email or "<" in email):
+        sys.stderr.write(
+            f"Enter email for user '{obs_author}': "
+        )
+        sys.stderr.flush()
+        email = input().strip()
+        if not email or "@" not in email:
+            log.warning(
+                "Invalid email, please enter a valid email address."
+            )
+
+    author = f"{name} <{email}>"
+    authors_map[obs_author.lower()] = author
+
+    authorsfile = pathlib.Path(".osc", "authorsfile.txt")
+    with open(authorsfile, "a") as fp:
+        fp.write(f"{obs_author.lower()} = {author}\n")
+    log.info(
+        "Mapping for %s saved to %s",
+        obs_author,
+        authorsfile,
+    )
+    return author
+
+
+def write_line(s: str):
+    sys.stdout.buffer.write((s + "\n").encode("utf-8"))
+    sys.stdout.buffer.flush()
+
+
+def write_binary(b: bytes):
+    sys.stdout.buffer.write(b)
+    sys.stdout.buffer.write(b"\n")
+    sys.stdout.buffer.flush()
+
+
+def print_export(
+    entry: LogEntry,
+    authors_map: Dict[str, str],
+    branch: str,
+    previous_mark: Optional[int],
+    non_interactive: bool,
+) -> int:
+    """
+    Prints Git fast-export commands for a given log entry.
+
+    This function generates the 'commit', 'mark', 'committer', 'data',
+    'deleteall', and 'M' (modify/add file) commands for git fast-import.
+    It checks out the specified revision, then iterates through all files
+    in the working directory (excluding .osc) to add them to the commit.
+
+    Args:
+        entry (LogEntry): The log entry object containing commit details.
+        authors_map (Dict[str, str]): A dictionary mapping OBS
+                                      usernames to Git author strings.
+        branch (str): The name of the Git branch to commit to.
+        previous_mark (Optional[int]): The mark of the previous commit in the
+                                       history, or None if this is the first commit.
+
+    Returns:
+        int: The 'mark' generated for the current commit (which
+             is the revision number).
+
+    Raises:
+        ValueError: If no Git author mapping is found for the OBS
+                    author in the log entry.
+    """
+    log.debug("entry:\n%s", str(entry))
+    mark = entry.rev
+
+    author = authors_map.get(entry.author.lower())
+    if author is None:
+        author = _handle_missing_author(
+            entry.author, authors_map, non_interactive
+        )
+    log.debug(f"author = {author}")
+
+    checkout_revision(entry.rev)
+    # Use the 'branch' parameter here
+    write_line(f"commit refs/heads/{branch}")
+    write_line(f"mark :{mark}")
+    if entry.md5:
+        write_line(f"original-oid {entry.md5}")
+    ts = int(entry.date.timestamp())
+    write_line(f"author {author} {ts} +0000")
+    write_line(f"committer {author} {ts} +0000")
+    msg_bytes = entry.msg.encode("utf-8")
+    write_line(f"data {len(msg_bytes)}")
+    write_binary(msg_bytes)
+    # Use the 'previous_mark' parameter here
+    if previous_mark:
+        write_line(f"from :{previous_mark}")
+
+    # Create actual content of the commit
+    # It is easier just to wipe out everything and include files again.
+    write_line("deleteall")
+    for dirpath, dirnames, filenames in os.walk("."):
+        # TODO are osc notes (aka osc comment) a thing?
+        dirpath = os.path.relpath(dirpath, ".")
+        if dirpath.startswith(".osc"):
+            continue
+        # It seems git-fast-export doesn't export directories at all
+        # and git-fast-import just creates them when needed.
+        # if dirpath != '.':
+        #     # create directory
+        #     print(f'M 040000 inline {dirpath}')
+        for fn in filenames:
+            fname = os.path.relpath(
+                os.path.join(dirpath, fn), "."
+            )
+            log.debug("dirpath = %s, fname = %s", dirpath, fname)
+            fstat = f"{os.stat(fname).st_mode:o}"
+            write_line(f"M {fstat} inline {fname}")
+            with open(fname, "rb") as inf:
+                dt = inf.read()
+                write_line(f"data {len(dt)}")
+                write_binary(dt)
+    write_line("")
+
+    return mark
+
+
+def main():
+    """
+    Main function to run the OSC to Git fast-export conversion.
+
+    Parses command-line arguments, sets up logging, retrieves author mappings,
+    and then iterates through the OBS log to generate Git fast-export commands
+    for each revision.
+    """
+    parser = argparse.ArgumentParser(prog="myprogram")
+    parser.add_argument(
+        "--debug",
+        action="store_true",
+        help="print out debugging information",
+    )
+    # Added optional branch argument
+    parser.add_argument(
+        "-b",
+        "--branch",
+        default="main",
+        help="branch name to store commits in (default: main)",
+    )
+    parser.add_argument(
+        "--non-interactive",
+        action="store_true",
+        help="disable interactive prompts for missing author information",
+    )
+    args = parser.parse_args()
+
+    if args.debug:
+        log.setLevel(logging.DEBUG)
+
+    authors = get_authors()
+
+    # Get the branch name from arguments
+    branch_name = args.branch
+
+    # Initialize the mark for the first commit
+    current_mark = None
+
+    for logentry in osc_log(authors):
+        # Pass the current_mark to print_export and update it with the new mark
+        current_mark = print_export(
+            logentry,
+            authors,
+            branch_name,
+            current_mark,
+            args.non_interactive,
+        )
+    write_line("done")
+
+
+if __name__ == "__main__":
+    main()