p4 rough draft

.github/workflows/unittests.yaml

@@ -1,74 +0,0 @@
-name: Pytest
-
-on:
-  push:
-    branches:
-      - master
-  pull_request: {}
-
-jobs:
-  test:
-    name: Unit Tests
-    runs-on: ${{ matrix.os }}
-
-    strategy:
-      matrix:
-        os: [ubuntu-22.04, windows-latest, macos-latest]
-        python-version: ["3.8", "3.9", "3.10", "3.11"]
-
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v3
-
-    - name: Set up Python ${{ matrix.python-version }}
-      uses: actions/setup-python@v2
-      with:
-        python-version: ${{ matrix.python-version }}
-        cache: pip
-
-    - name: Install dependencies
-      run: |
-        python -m pip install --upgrade pip
-        pip install pytest pytest-cov
-        pip install -r requirements.txt
-    
-    - name: Test
-      run: |
-        pytest
-
-  coverage:
-    name: Coverage Summary
-    runs-on: ubuntu-22.04
-    permissions:
-      pull-requests: write
-      contents: read
-
-    if: github.event_name == 'pull_request'
-    strategy:
-      fail-fast: false
-
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v3
-
-    - name: Set up Python
-      uses: actions/setup-python@v2
-      with:
-        python-version: "3.11"
-        cache: pip
-
-    - name: Install dependencies
-      run: |
-        python -m pip install --upgrade pip
-        pip install pytest pytest-cov
-        pip install -r requirements.txt
-
-    - name: Run Coverage
-      run: |
-        pytest --junitxml=pytest.xml --cov-report=term-missing:skip-covered --cov=semver | tee pytest-coverage.txt
-
-    - name: Comment Result Summary
-      uses: MishaKav/pytest-coverage-comment@main
-      with:
-        pytest-coverage-path: ./pytest-coverage.txt
-        junitxml-path: ./pytest.xml

Dockerfile

@@ -1,33 +1,29 @@
-# ======= #
-# Builder #
-# ======= #
-FROM python:3.11-slim as builder
-COPY / /semver
-RUN pip wheel --no-cache-dir --wheel-dir /wheels /semver
+FROM centos/python-36-centos7
+ 
+USER root
 
-# ======== #
-# Finalize #
-# ======== #
-FROM python:3.11-slim
+#Perform updates
+RUN pip install --upgrade pip
+RUN yum update -y
+RUN yum -y remove git
+RUN yum -y install https://packages.endpoint.com/rhel/7/os/x86_64/endpoint-repo-1.7-1.x86_64.rpm
+RUN yum -y install git
 
-# Update and install git
-RUN apt-get update && apt-get install -y git
-
-# Create user
-RUN mkdir /semver && \
-    groupadd -g 10001 semver && \
-    useradd -u 10000 -g semver -d /semver semver \
-    && chown -R semver:semver /semver
+#Setup semver
+ADD / /semver
+WORKDIR /semver
+RUN python setup.py sdist
+RUN pip install dist/semver-*.tar.gz
 
 # Prep workspace
-RUN mkdir /workspace && \
-    chown -R semver:semver /workspace
+RUN mkdir /workspace
+WORKDIR /workspace
 VOLUME /workspace
 
-# Setup semver
-COPY --from=builder /wheels /semver/wheels
-RUN pip install --no-cache /semver/wheels/*
+#Permissions
+RUN useradd -d /semverUser semverUser
+RUN chown -R semverUser:semverUser /workspace
 
-USER semver:semver
-WORKDIR /workspace
-ENTRYPOINT [ "semver" ]
+CMD [ "semver" ]
+
+USER semverUser

semver/__init__.py

@@ -27,19 +27,19 @@ def main():
     """Main entry point for the application"""
     parser = argparse.ArgumentParser(description="Bump Semantic Version.")
     parser.add_argument(
-        "-n", "--no-push", help="do not try to push", action="store_false", dest="push"
+        "-n", "--no-push", help="Do not try to push", action="store_false", dest="push"
     )
     parser.add_argument(
         "-g",
         "--global-user",
-        help="set git user at a global level",
+        help="Set git user at a global level, helps in jenkins",
         action="store_true",
         dest="global_user",
     )
     parser.add_argument(
         "-D",
         "--debug",
-        help="sets logging level to DEBUG",
+        help="Sets logging level to DEBUG",
         action="store_true",
         dest="debug",
         default=False,

semver/get_version.py

@@ -11,14 +11,14 @@ def main():
     parser.add_argument(
         "-d",
         "--dot",
-        help="switch out / for . to be used in docker tag",
+        help="Switch out / for . to be used in docker tag",
         action="store_true",
         dest="dot",
     )
     parser.add_argument(
         "-D",
         "--debug",
-        help="sets logging level to DEBUG",
+        help="Sets logging level to DEBUG",
         action="store_true",
         dest="debug",
         default=False,
@@ -26,12 +26,12 @@ def main():
     parser.add_argument(
         "-f",
         "--format",
-        help="format for pre-release version syntax",
+        help="Format for pre-release version syntax",
         choices=["npm", "maven", "docker"],
         default=None,
     )
     parser.add_argument(
-        "-b", "--build-number", help="build number, used in pre-releases", default=0
+        "-b", "--build-number", help="Build number, used in pre-releases", default=0
     )
 
     args = parser.parse_args()

semver/scm/git.py

@@ -1,7 +1,7 @@
 import re
 import subprocess
 from typing import Union, List
-from functools import lru_cache
+from functools import cache
 
 import toml
 
@@ -9,7 +9,6 @@ from semver.scm import SCM
 from semver.logger import logger
 from semver.version_type import VersionType
 from semver.exceptions import SemverException
-from semver.utils import get_settings
 
 
 class Git(SCM):
@@ -29,7 +28,7 @@ class Git(SCM):
 
     def _run_command(
         self, *args: str, throwExceptions: bool = True
-    ) -> subprocess.CompletedProcess:
+    ) -> subprocess.CompletedProcess[str]:
         return subprocess.run(
             args,
             capture_output=True,
@@ -59,7 +58,7 @@ class Git(SCM):
         Get the latest tagged version from git tags
         :return: The latest tagged version
         """
-        config: dict = get_settings()
+        config: dict = toml.load("./.bumpversion.cfg")
 
         tag_expression: str = config["bumpversion"]["tag_name"].replace(
             "{new_version}", "[0-9]*.[0-9]*.[0-9]*"
@@ -82,26 +81,21 @@ class Git(SCM):
                 f"Error getting latest tagged git version: {str(e.stderr).rstrip()}"
             )
 
-        if (
-            tagged_versions is not None
-            and len(tagged_versions) > 0
-            and tagged_versions[-1] != ""
-        ):
+        if len(tagged_versions) > 0 and tagged_versions[-1] != "":
             version = tagged_versions[-1]
 
         logger.debug(f"Tag Version: {version}")
         return version
 
-    @lru_cache(maxsize=None)
+    @cache
     def get_branch(self) -> str:
         """
         Get the main branch
-        :return: The main branch
         """
         proc = self._run_command(self.git_bin, "rev-parse", "--abbrev-ref", "HEAD")
         return proc.stdout.rstrip()
 
-    @lru_cache(maxsize=None)
+    @cache
     def get_merge_branch(self) -> Union[str, None]:
         """
         Get the branches involved in the merge

semver/scm/perforce.py

@@ -0,0 +1,152 @@
+import subprocess
+from typing import Union, List
+
+import toml
+
+from semver.scm import SCM
+from semver.logger import logger
+from semver.utils import get_settings
+from semver.exceptions import SemverException
+
+
+class Perforce(SCM):
+    def __init__(self) -> None:
+        self.p4_bin = "p4"
+
+        super().__init__()
+
+    def _run_command(
+        self, *args: str, throwExceptions: bool = True
+    ) -> subprocess.CompletedProcess[str]:
+        return subprocess.run(
+            args,
+            capture_output=True,
+            text=True,
+            check=throwExceptions,
+        )
+
+    def get_tag_version(self) -> str:
+        """
+        Get the latest tagged version from Perforce labels
+        :return: The latest tagged version
+        """
+        config: dict = get_settings()
+
+        tag_expression: str = config["bumpversion"]["tag_name"].replace(
+            "{new_version}", "[0-9]*.[0-9]*.[0-9]*"
+        )
+
+        logger.debug("Tag expression: " + str(tag_expression))
+
+        # Default version is `0.0.0` or what is found in
+        version = self.get_file_version(config)
+
+        # If a version is found in Perforce labels, use that the latest labeled version
+        labeled_versions: Union[List[str], None] = None
+        try:
+            proc = self._run_command(self.p4_bin, "labels", "-e", tag_expression, "-m1")
+            labeled_versions = proc.stdout.rstrip().split("\n")
+        except subprocess.CalledProcessError as e:
+            raise SemverException(
+                f"Error getting latest labeled Perforce version: {str(e.stderr).rstrip()}"
+            )
+
+        if len(labeled_versions) > 0 and labeled_versions[-1] != "":
+            version = labeled_versions[-1]
+
+        logger.debug("Label Version: " + str(version))
+        return version
+
+    def get_branch(self) -> str:
+        """
+        Returns the name of the current Perforce stream
+        :return: The current Perforce stream
+        """
+        try:
+            proc = self._run_command(self.p4_bin, "client", "-o")
+            client = toml.loads(proc.stdout)
+            return client["Stream"]
+        except subprocess.CalledProcessError as e:
+            raise SemverException(
+                f"Error getting current Perforce stream: {str(e.stderr).rstrip()}"
+            )
+
+    def get_merge_branch(self) -> Union[str, None]:
+        """
+        Returns the name of the stream being intergrated into mainline
+        :return: The Perforce stream being intergrated into mainline
+        """
+        try:
+            proc = self._run_command(self.p4_bin, "client", "-o")
+            client = toml.loads(proc.stdout)
+            return client["StreamAtChange"]
+        except subprocess.CalledProcessError as e:
+            raise SemverException(
+                f"Error getting current Perforce stream: {str(e.stderr).rstrip()}"
+            )
+
+    def commit_and_push(self, branch: str) -> None:
+        """
+        Creates a changelist and submits it to Perforce
+        :param branch: The current Perforce stream
+        """
+        try:
+            proc = self._run_command(self.p4_bin, "change", "-o")
+            change = toml.loads(proc.stdout)
+            change["Description"] = f"Version Bump"
+            change["Files"] = [f"//{branch}/..."]
+            proc = subprocess.Popen([self.p4_bin, "change", "-i"], stdin=subprocess.PIPE)
+            proc.communicate(input=toml.dumps(change).encode())
+            proc.wait()
+            proc = self._run_command(self.p4_bin, "submit", "-c", str(change["Change"]))
+        except subprocess.CalledProcessError as e:
+            raise SemverException(
+                f"Error creating a CL and submitting to Perforce: {str(e.stderr).rstrip()}"
+            )
+
+    def tag_version(self, version: str) -> None:
+        """
+        Creates a Perforce label
+        :param version: The version to label
+        """
+        try:
+            proc = self._run_command(self.p4_bin, "label", "-o", version)
+            label = toml.loads(proc.stdout)
+            label["Description"] = f"Version {version}"
+            label["Options"] = "locked"
+            label["Revision"] = f"//{self.get_branch()}/..."
+            proc = subprocess.Popen([self.p4_bin, "label", "-i"], stdin=subprocess.PIPE)
+            proc.communicate(input=toml.dumps(label).encode())
+            proc.wait()
+        except subprocess.CalledProcessError as e:
+            raise SemverException(
+                f"Error creating a Perforce label: {str(e.stderr).rstrip()}"
+            )
+    def get_version_hash(self, version: str) -> str:
+        """
+        Returns the hash of the version label
+        :param version: The version label
+        :return: The hash of the version label
+        """
+        try:
+            proc = self._run_command(self.p4_bin, "labels", "-e", version, "-m1")
+            label = toml.loads(proc.stdout)
+            return label["Revision"]
+        except subprocess.CalledProcessError as e:
+            raise SemverException(
+                f"Error getting hash of version label: {str(e.stderr).rstrip()}"
+            )
+    
+    def get_hash(self) -> str:
+        """
+        Returns the hash of the current commit
+        :return: The hash of the current commit
+        """
+        try:
+            proc = self._run_command(self.p4_bin, "changes", "-m1")
+            change = toml.loads(proc.stdout)
+            return change["Change"]
+        except subprocess.CalledProcessError as e:
+            raise SemverException(
+                f"Error getting hash of current commit: {str(e.stderr).rstrip()}"
+            )

semver/tests/test_semver.py

@@ -67,8 +67,10 @@ class TestSemVer(unittest.TestCase):
     @mock.patch("toml.load")
     @mock.patch("pathlib.Path.is_file")
     @mock.patch("builtins.open", mock.mock_open())
+    @mock.patch("semver.logger.warning")
     def test_update_file_version(
         self,
+        mock_logger: mock.Mock,
         mock_path_is_file: mock.Mock,
         mock_toml_load: mock.Mock,
     ):
@@ -81,9 +83,11 @@ class TestSemVer(unittest.TestCase):
         }
         mock_path_is_file.return_value = True
         self.semver._update_file_version("1.0.1", "1.0.0")
+        mock_logger.assert_not_called()
 
         mock_path_is_file.return_value = False
         self.semver._update_file_version("1.0.1", "1.0.0")
+        mock_logger.assert_called_once()
 
     @mock.patch("semver.semver.SemVer._version_repo", mock.MagicMock())
     def test_run_ok(self):

semver/utils.py

@@ -1,6 +1,6 @@
 from typing import List
 from pathlib import Path
-from functools import lru_cache
+from functools import cache
 import configparser
 
 import toml
@@ -8,7 +8,7 @@ import toml
 from semver.exceptions import SemverException
 
 
-@lru_cache(maxsize=None)
+@cache
 def get_settings() -> dict:
     """
     Get the settings from the config file

setup.cfg

@@ -24,9 +24,7 @@ classifiers =
 [options]
 include_package_data = True
 packages = find:
-python_requires = >=3.8, <4
-install_requires =
-    toml
+python_requires = >=3.7, <4
 
 [options.packages.find]
 exclude =