Added a workflow to build the latest differs.

Author: JSv4

.github/workflows/build-engines.yml

@@ -0,0 +1,37 @@
+name: Upload Python Package
+
+on:
+  pull_request:
+    branches: [ 'main' ]
+    paths-ignore: [ 'docs/**' ]
+
+permissions:
+  contents: read
+
+jobs:
+  deploy:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up .NET 8
+      uses: actions/setup-dotnet@v3
+      with:
+        dotnet-version: '8.0.x'
+    - name: Set up Python
+      uses: actions/setup-python@v3
+      with:
+        python-version: '3.x'
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install hatch
+    - name: Build differs
+      run: hatch run build
+    - name: Commit differ
+      run: |
+        git config --global user.name 'JSv4'
+        git config --global user.email 'JSv4@users.noreply.github.com'
+        git commit -am "Engine Builds"
+        git push

.github/workflows/python-publish.yml

@@ -14,10 +14,6 @@ jobs:
 
     steps:
     - uses: actions/checkout@v3
-    - name: Set up .NET 8
-      uses: actions/setup-dotnet@v3
-      with:
-        dotnet-version: '8.0.x'
     - name: Set up Python
       uses: actions/setup-python@v3
       with:

build_differ.py

@@ -2,7 +2,6 @@
 import os
 import tarfile
 import zipfile
-import sys
 
 
 def get_version():

docs/developer-guide.md

@@ -78,7 +78,13 @@ dotnet publish -c Release -r linux-x64 --self-contained
 dotnet publish -c Release -r win-x64 --self-contained
 ```
 
-3. Archive and package binaries into `./dist/`:
+3. Build a binary for MacOS:
+
+```bash
+dotnet publish -c Release -r osx-x64 --self-contained
+```
+
+4. Archive and package binaries into `./dist/`:
 
 
 ## Running Tests

hatch_run_build_hook.py

@@ -11,10 +11,6 @@ artifacts = [
   "*.tar.gz",
 ]
 
-# Build hook to build the binaries for distribution...
-[tool.hatch.build.hooks.custom]
-path = "hatch_run_build_hook.py"
-
 [project]
 name = "python-redlines"
 dynamic = ["version"]

pyproject.toml

@@ -1,8 +1,8 @@
 import subprocess
 import tempfile
-import logging
 import os
 import platform
+import logging
 import zipfile
 import tarfile
 from pathlib import Path
@@ -14,71 +14,74 @@
 
 
 class XmlPowerToolsEngine(object):
-    def __init__(self, reload_binary: bool = False):
-        self.extracted_binaries_path = self._unzip_binary()
-        self._reload_binary = reload_binary
+    def __init__(self):
+        self.extracted_binaries_path = self.__unzip_binary()
 
-    def _unzip_binary(self):
+    def __unzip_binary(self):
         """
         Unzips the appropriate C# binary for the current platform.
         """
         base_path = os.path.dirname(__file__)
-        logger.debug(f"Python redlining base path: {base_path}")
-
         binaries_path = os.path.join(base_path, 'dist')
-        logger.debug(f"Python redlining binaries path: {binaries_path}")
+        target_path = os.path.join(base_path, 'bin')
+
+        if not os.path.exists(target_path):
+            os.makedirs(target_path)
+
+        # Get the binary name and zip name based on the OS and architecture
+        binary_name, zip_name = self.__get_binaries_info()
 
+        # Check if the binary already exists. If not, extract it.
+        full_binary_path = os.path.join(target_path, binary_name)
+
+        if not os.path.exists(full_binary_path):
+            zip_path = os.path.join(binaries_path, zip_name)
+            self.__extract_binary(zip_path, target_path)
+
+        return os.path.join(target_path, binary_name)
+
+    def __extract_binary(self, zip_path: str, target_path: str):
+        """
+        Extracts the binary from the zip file based on the extension. Supports .zip and .tar.gz files
+        :parameter
+            zip_path: str - The path to the zip file
+            target_path: str - The path to extract the binary to
+        """
+        print(f"")
+        if zip_path.endswith('.zip'):
+            with zipfile.ZipFile(zip_path, 'r') as zip_ref:
+                zip_ref.extractall(target_path)
+
+        elif zip_path.endswith('.tar.gz'):
+            with tarfile.open(zip_path, 'r:gz') as tar_ref:
+                tar_ref.extractall(target_path)
+
+    def __get_binaries_info(self):
+        """
+        Returns the binary name and zip name based on the OS and architecture
+        :return
+            binary_name: str - The name of the binary file
+            zip_name: str - The name of the zip file
+        """
         os_name = platform.system().lower()
         arch = 'x64'  # Assuming x64 architecture
 
         if os_name == 'linux':
             zip_name = f"linux-{arch}-{__version__}.tar.gz"
             binary_name = 'linux-x64/redlines'
 
-        elif os_name == "windows":
+        elif os_name == 'windows':
             zip_name = f"win-{arch}-{__version__}.zip"
             binary_name = 'win-x64/redlines.exe'
 
-        elif os_name == "darwin":
+        elif os_name == 'darwin':
             zip_name = f"osx-{arch}-{__version__}.tar.gz"
             binary_name = 'osx-x64/redlines'
-        else:
-            raise EnvironmentError("Unsupported OS")
-
-        target_path = os.path.join(base_path, 'bin')
-        logger.debug(f"Target path: {target_path}")
 
-        # If target folder doesn't exist... created
-        if not os.path.exists(target_path):
-            os.makedirs(target_path)
-        else:
-            # If we don't want to reload the binary and it already exists... just return path
-            if not self._reload_binary:
-                return os.path.join(target_path, binary_name)
-
-        # Otherwise, go ahead and unzip... and this may vary depending on the architecture & env
-        if os_name == 'linux':
-            zip_path = os.path.join(binaries_path, zip_name)
-            if os.path.exists(zip_path):
-                with tarfile.open(zip_path, 'r:gz') as tar_ref:
-                    tar_ref.extractall(target_path)
-
-        elif os_name == 'windows':
-            zip_path = os.path.join(binaries_path, zip_name)
-            if os.path.exists(zip_path):
-                with zipfile.ZipFile(zip_path, 'r') as zip_ref:
-                    zip_ref.extractall(target_path)
-
-        elif os_name == 'darwin':
-            zip_path = os.path.join(binaries_path, zip_name)
-            if os.path.exists(zip_path):
-                with tarfile.open(zip_path, 'r:gz') as tar_ref:
-                    tar_ref.extractall(target_path)
-        # This is redundant given above test... but I'm leaving it here.
         else:
             raise EnvironmentError("Unsupported OS")
 
-        return os.path.join(target_path, binary_name)
+        return binary_name, zip_name
 
     def run_redline(self, author_tag: str, original: Union[bytes, Path], modified: Union[bytes, Path]) \
             -> Tuple[bytes, Optional[str], Optional[str]]: