semtag 0.1.1__tar.gz

semtag-0.1.1/.github/workflows/publish.yml

@@ -0,0 +1,49 @@
+name: Publish to PyPI
+
+on:
+  push:
+    tags:
+      - 'v*'
+      - '[0-9]+.[0-9]+.[0-9]+'
+      - '[0-9]+.[0-9]+.[0-9]+-*'
+
+jobs:
+  build-and-publish:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      id-token: write  # Required for trusted publishing
+
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+      with:
+        fetch-depth: 0  # Required for setuptools_scm to get git history
+
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: '3.x'
+
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install build twine
+
+    - name: Build package
+      run: python -m build
+
+    - name: Check package
+      run: twine check dist/*
+
+    # Use the official PyPI publish action
+    - name: Publish to PyPI
+      uses: pypa/gh-action-pypi-publish@release/v1
+
+    # Use the GitHub Release action to creata release
+    - name: Create GitHub Release
+      uses: softprops/action-gh-release@v1
+      with:
+        generate_release_notes: true
+        files: |
+          dist/*

semtag-0.1.1/.gitignore

@@ -0,0 +1,64 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Virtual environments
+venv/
+env/
+ENV/
+env.bak/
+venv.bak/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# debug
+/tmp/

semtag-0.1.1/LICENSE

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

semtag-0.1.1/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: semtag
+Version: 0.1.1
+Summary: A tool for managing semantic version tags in git repositories
+Author-email: Mateusz Mikrut <mateusz.mikrut@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/mateuszmikrut/semtag
+Project-URL: Bug Reports, https://github.com/mateuszmikrut/semtag/issues
+Project-URL: Source, https://github.com/mateuszmikrut/semtag
+Keywords: git,tags,semantic-versioning,semver,version-control
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Version Control :: Git
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: gitpython>=3.1.0
+Dynamic: license-file
+
+# Semantic Version GIT Tagger
+
+A pretty trivial python script to easely manage git tags with semantic versioning (semver.org)  
+
+## Usage
+
+```bash
+semtag [options]
+```
+
+### Options
+
+- `-p, --patch` - Increment patch version (x.x.PATCH)
+- `-m, --minor` - Increment minor version (x.MINOR.0)
+- `-M, --major` - Increment major version (MAJOR.0.0)
+- `-b, --by` - Increment by a specific number (default: 1)
+- `-l, --label` - Add label to the version (e.g., -l rc1 creates 1.0.0-rc1)
+- `-u, --push` - Push the new tag to remote repository
+- `-n, --nofetch` - Do not fetch tags from remote prior creating new one
+<!-- - `-f, --force` - Force operation even if not on main/master branch -->
+- `-v, --verbose` - Increase verbosity (use -v, -vv, or -vvv for more detail)
+
+### Examples
+
+```bash
+# Increment minor version (1.0.0 -> 1.1.0)
+semtag -m
+
+# Increment major version (1.0.0 -> 2.0.0)
+semtag -M
+
+# Increment patch version (1.0.0 -> 1.0.5)
+semtag -p -b 5
+
+# Increment patch and add label (1.0.0 -> 1.0.1-rc1), don't fetch and push new tag
+semtag -n -u -p -l rc1
+```
+
+## Installation
+
+Using pip  (preferred)
+```bash
+pip install semtag
+```
+
+From git
+```bash
+git clone https://github.com/mateuszmikrut/semtag.git
+cd semtag
+python -m venv venv
+source ./venv/bin/activate
+pip install -r requirements.txt
+python ./semtag.py
+```
+
+## Supported Version Formats
+
+The script supports semantic versioning with the following formats:
+- `v1.0.0` (with 'v' prefix)
+- `1.0.0` (without prefix)
+- `1.0.0-rc1` (with prerelease label)
+
+When incrementing versions, prerelease labels are automatically removed.
+

semtag-0.1.1/README.md

@@ -0,0 +1,64 @@
+# Semantic Version GIT Tagger
+
+A pretty trivial python script to easely manage git tags with semantic versioning (semver.org)  
+
+## Usage
+
+```bash
+semtag [options]
+```
+
+### Options
+
+- `-p, --patch` - Increment patch version (x.x.PATCH)
+- `-m, --minor` - Increment minor version (x.MINOR.0)
+- `-M, --major` - Increment major version (MAJOR.0.0)
+- `-b, --by` - Increment by a specific number (default: 1)
+- `-l, --label` - Add label to the version (e.g., -l rc1 creates 1.0.0-rc1)
+- `-u, --push` - Push the new tag to remote repository
+- `-n, --nofetch` - Do not fetch tags from remote prior creating new one
+<!-- - `-f, --force` - Force operation even if not on main/master branch -->
+- `-v, --verbose` - Increase verbosity (use -v, -vv, or -vvv for more detail)
+
+### Examples
+
+```bash
+# Increment minor version (1.0.0 -> 1.1.0)
+semtag -m
+
+# Increment major version (1.0.0 -> 2.0.0)
+semtag -M
+
+# Increment patch version (1.0.0 -> 1.0.5)
+semtag -p -b 5
+
+# Increment patch and add label (1.0.0 -> 1.0.1-rc1), don't fetch and push new tag
+semtag -n -u -p -l rc1
+```
+
+## Installation
+
+Using pip  (preferred)
+```bash
+pip install semtag
+```
+
+From git
+```bash
+git clone https://github.com/mateuszmikrut/semtag.git
+cd semtag
+python -m venv venv
+source ./venv/bin/activate
+pip install -r requirements.txt
+python ./semtag.py
+```
+
+## Supported Version Formats
+
+The script supports semantic versioning with the following formats:
+- `v1.0.0` (with 'v' prefix)
+- `1.0.0` (without prefix)
+- `1.0.0-rc1` (with prerelease label)
+
+When incrementing versions, prerelease labels are automatically removed.
+

semtag-0.1.1/SemanticVersion.py

@@ -0,0 +1,91 @@
+"""
+Semantic versioning module for parsing and bumping ver_list numbers
+More about semantic versioning: https://semver.org/
+"""
+import re
+
+class SemanticVersion:
+  """Handle semantic versioning parsing and incrementing"""
+  def __init__(self, version_string: str):
+    self.original = version_string
+    self.prefix = ""
+    self.major = 0
+    self.minor = 0
+    self.patch = 0
+    self.label = ""
+    self._parse(version_string)
+
+  def _parse(self, version_string: str):
+    """Parse and validate semantic version string"""
+    # 'v' prefix handling
+    if version_string.startswith('v'):
+      self.prefix = 'v'
+      version_string = version_string[1:]
+
+    # regex from semver.org
+    pattern = r'^(?P<major>0|[1-9]\d*)\.(?P<minor>0|[1-9]\d*)\.(?P<patch>0|[1-9]\d*)(?:-(?P<prerelease>(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+(?P<buildmetadata>[0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$'
+    match = re.match(pattern, version_string)
+    
+    if not match:
+      raise ValueError(f"Invalid semantic version format: {self.original}")
+    
+    self.major = int(match.group('major'))
+    self.minor = int(match.group('minor'))
+    self.patch = int(match.group('patch'))
+    self.label = match.group('prerelease') or ""
+
+  def inc_major(self, by=1) -> 'SemanticVersion':
+    """ Increment major version and reset minor & patch"""
+    self.major += by
+    self.minor = 0
+    self.patch = 0
+    self.label = ""
+    return self
+  
+  def inc_minor(self, by=1) -> 'SemanticVersion':
+    """ Increment minor version and reset patch"""
+    self.minor += by
+    self.patch = 0
+    self.label = ""
+    return self
+  
+  def inc_patch(self, by=1) -> 'SemanticVersion':
+    """ Increment patch - preserve major & minor"""
+    self.patch += by
+    self.label = ""
+    return self
+  
+  def add_label(self, label: str) -> 'SemanticVersion':
+    """Add a label to the version"""
+    self.label = label
+    return self
+  
+  def __str__(self) -> str:
+    """Return concatinated string"""
+    version = f"{self.prefix}{self.major}.{self.minor}.{self.patch}"
+    if self.label:
+      version += f"-{self.label}"
+    return version
+  
+  def __repr__(self) -> str:
+    """Return representation of version"""
+    return f"SemanticVersion('{str(self)}')"
+
+
+### This is standalone function (could be @staticmethod as well) ###
+def semsort(versions: list[str]) -> list[str]:
+  """Sort semantic version tags by major, minor, patch """
+  ver_list = []
+  for v in versions:
+    try:
+      version = SemanticVersion(v)
+      ver_list.append((v, version))
+    except ValueError:
+      # Skip invalid semantic version tags
+      continue
+
+  ver_list.sort(
+    key=lambda x: (x[1].major, x[1].minor, x[1].patch),
+    reverse=True
+  )
+  return [x for x, _ in ver_list]

semtag-0.1.1/pyproject.toml

@@ -0,0 +1,43 @@
+[build-system]
+requires = ["setuptools>=45", "wheel", "setuptools_scm[toml]>=6.2"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "semtag"
+dynamic = ["version"]
+description = "A tool for managing semantic version tags in git repositories"
+readme = "README.md"
+requires-python = ">=3.8"
+license = "MIT"
+authors = [
+    {name = "Mateusz Mikrut", email = "mateusz.mikrut@gmail.com"}
+]
+keywords = ["git", "tags", "semantic-versioning", "semver", "version-control"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Topic :: Software Development :: Version Control :: Git",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+dependencies = [
+    "gitpython>=3.1.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/mateuszmikrut/semtag"
+"Bug Reports" = "https://github.com/mateuszmikrut/semtag/issues"
+Source = "https://github.com/mateuszmikrut/semtag"
+
+[project.scripts]
+semtag = "semtag:main"
+
+[tool.setuptools]
+py-modules = ["semtag", "SemanticVersion"]
+
+[tool.setuptools_scm]
+version_scheme = "post-release"

semtag-0.1.1/requirements.txt

@@ -0,0 +1 @@
+gitpython>=3.1.0

semtag-0.1.1/semtag.egg-info/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: semtag
+Version: 0.1.1
+Summary: A tool for managing semantic version tags in git repositories
+Author-email: Mateusz Mikrut <mateusz.mikrut@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/mateuszmikrut/semtag
+Project-URL: Bug Reports, https://github.com/mateuszmikrut/semtag/issues
+Project-URL: Source, https://github.com/mateuszmikrut/semtag
+Keywords: git,tags,semantic-versioning,semver,version-control
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Version Control :: Git
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: gitpython>=3.1.0
+Dynamic: license-file
+
+# Semantic Version GIT Tagger
+
+A pretty trivial python script to easely manage git tags with semantic versioning (semver.org)  
+
+## Usage
+
+```bash
+semtag [options]
+```
+
+### Options
+
+- `-p, --patch` - Increment patch version (x.x.PATCH)
+- `-m, --minor` - Increment minor version (x.MINOR.0)
+- `-M, --major` - Increment major version (MAJOR.0.0)
+- `-b, --by` - Increment by a specific number (default: 1)
+- `-l, --label` - Add label to the version (e.g., -l rc1 creates 1.0.0-rc1)
+- `-u, --push` - Push the new tag to remote repository
+- `-n, --nofetch` - Do not fetch tags from remote prior creating new one
+<!-- - `-f, --force` - Force operation even if not on main/master branch -->
+- `-v, --verbose` - Increase verbosity (use -v, -vv, or -vvv for more detail)
+
+### Examples
+
+```bash
+# Increment minor version (1.0.0 -> 1.1.0)
+semtag -m
+
+# Increment major version (1.0.0 -> 2.0.0)
+semtag -M
+
+# Increment patch version (1.0.0 -> 1.0.5)
+semtag -p -b 5
+
+# Increment patch and add label (1.0.0 -> 1.0.1-rc1), don't fetch and push new tag
+semtag -n -u -p -l rc1
+```
+
+## Installation
+
+Using pip  (preferred)
+```bash
+pip install semtag
+```
+
+From git
+```bash
+git clone https://github.com/mateuszmikrut/semtag.git
+cd semtag
+python -m venv venv
+source ./venv/bin/activate
+pip install -r requirements.txt
+python ./semtag.py
+```
+
+## Supported Version Formats
+
+The script supports semantic versioning with the following formats:
+- `v1.0.0` (with 'v' prefix)
+- `1.0.0` (without prefix)
+- `1.0.0-rc1` (with prerelease label)
+
+When incrementing versions, prerelease labels are automatically removed.
+

semtag-0.1.1/semtag.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+.gitignore
+LICENSE
+README.md
+SemanticVersion.py
+pyproject.toml
+requirements.txt
+semtag.py
+.ansible/.lock
+.github/workflows/publish.yml
+semtag.egg-info/PKG-INFO
+semtag.egg-info/SOURCES.txt
+semtag.egg-info/dependency_links.txt
+semtag.egg-info/entry_points.txt
+semtag.egg-info/requires.txt
+semtag.egg-info/top_level.txt

semtag-0.1.1/semtag.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

semtag-0.1.1/semtag.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+semtag = semtag:main

semtag-0.1.1/semtag.egg-info/requires.txt

@@ -0,0 +1 @@
+gitpython>=3.1.0

semtag-0.1.1/semtag.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+SemanticVersion
+semtag

semtag-0.1.1/semtag.py

@@ -0,0 +1,156 @@
+#!/usr/bin/env python3
+"""
+SemTag - A tool for managing semantic version tags in git repositories
+"""
+
+import argparse
+import logging
+# import sys
+from SemanticVersion import SemanticVersion, semsort
+import git
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+def main():
+  """ Main function """
+  ########################
+  ### Argument Parsing ###
+  ########################
+  parser = argparse.ArgumentParser(
+    description='SemTag - Manage semantic version tags in git repositories',
+    formatter_class=argparse.RawDescriptionHelpFormatter,
+    epilog="""
+Examples:
+  %(prog)s -m              # Increment minor version (1.0.0 -> 1.1.0)
+  %(prog)s -M              # Increment major version (1.0.0 -> 2.0.0)
+  %(prog)s -p -b 5         # Increment patch version by 5 (1.0.0 -> 1.0.5)
+  %(prog)s -p -l rc1       # Increment patch and add label (1.0.0 -> 1.0.1-rc1)
+        """
+  )
+  parser.add_argument('-v', '--verbose', action='count', default=0, help='Verbosity (-v for INFO, -vv for DEBUG)')
+  # parser.add_argument('-f', '--force', action='store_true', default=False, help='Force the operation even if not on main/master branch')
+  parser.add_argument('-b', '--by', action='store', type=int, default=1, help='Increment by a specific number')
+  
+  version_group = parser.add_mutually_exclusive_group(required=True)
+  version_group.add_argument('-p', '--patch', action='store_true', help='Increment patch version (x.x.PATCH)')
+  version_group.add_argument('-m', '--minor', action='store_true', help='Increment minor version (x.MINOR.0)')
+  version_group.add_argument('-M', '--major', action='store_true', help='Increment major version (MAJOR.0.0)')
+  
+  parser.add_argument('-l', '--label', type=str, default=None, help='Add label to the version (e.g., -l rc1 creates 1.0.0-rc1)')
+  parser.add_argument('-u', '--push', action='store_true', help='Push the new tag to remote repository', default=False)
+  parser.add_argument('-n', '--no-fetch', action='store_true', help='Do not fetch tags from remote before operation', default=False)
+  args = parser.parse_args()
+  
+  ### Logging based on verbosity ###
+  if args.verbose == 0:
+    log_level = logging.WARNING
+  elif args.verbose == 1:
+    log_level = logging.INFO
+  else:
+    log_level = logging.DEBUG
+  
+  logging.basicConfig(
+    level=log_level,
+    format='%(message)s' # Keep it simple (no timestamps, severity etc.)
+  )
+  
+  ##################
+  ### Main Logic ###
+  ##################
+  logger.debug(f"Arguments: {args}")
+  pwd = Path('.').resolve()
+
+  ### Check if this is a git workspace ###
+  try:
+    repo = git.Repo(pwd, search_parent_directories=True)
+    logger.debug(f"Found git repository at {repo.working_dir}")
+  except git.InvalidGitRepositoryError:
+    logger.error(f"{pwd} is not a git repository")
+    exit(1)
+  except git.GitCommandError as e:
+    logger.error(f"Git command failed: {e}")
+    exit(99)
+  
+  reponame = Path(repo.working_dir).name
+  logger.debug(f"Repository name : {reponame}")
+  
+  ## Check if on main/master branch (warning only)
+  # try:
+  #   if repo.active_branch.name not in ['main', 'master']:
+  #     logger.warning(f"You are on branch '{repo.active_branch.name}', not on main/master")
+  #   logger.debug(f"On {repo.active_branch.name} branch")
+  # except TypeError:
+  #   logger.warning("HEAD is detached, not on any branch")
+  #   exit(2)
+  
+
+  # Fetch tags from remote to avoid duplicates
+  if not args.no_fetch:
+    try:
+      logger.debug("Fetching tags from remote...")
+      repo.remotes.origin.fetch(tags=True)
+      logger.debug("Tags fetched successfully")
+    except Exception as e:
+      logger.warning(f"Error fetching tags: {e}")
+    
+  tags = semsort([tag.name for tag in repo.tags])
+  
+  if tags:
+    latest_tag = tags[0]
+    logger.debug(f"Latest semantic version tag: {latest_tag}")
+  else:
+    # No tags found, start with 0.0.0
+    logger.debug("No semantic version tags found. Starting with 0.0.0")
+    latest_tag = '0.0.0'
+    
+  # Initialize obj
+  current_version = SemanticVersion(latest_tag)
+  
+  ### Increment version ###
+  if args.major:
+    logger.debug("Incrementing major version")
+    current_version.inc_major(by=args.by)
+  elif args.minor:
+    logger.debug("Incrementing minor version")
+    current_version.inc_minor(by=args.by)
+  elif args.patch:
+    logger.debug("Incrementing patch version")
+    current_version.inc_patch(by=args.by)
+  
+  ### Label ###
+  if args.label:
+    logger.debug(f"Adding label: {args.label}")
+    current_version.add_label(args.label)
+  
+  new_tag = str(current_version)
+  logger.info(f"Generate tag: {new_tag}")
+    
+  ### Create and push
+  try:
+    #TODO: add tag message option later
+    #repo.create_tag(new_tag, message=f"Release {new_tag}")
+    repo.create_tag(new_tag)
+    logger.info(f"Successfully created tag: {new_tag}")
+    
+    # Push if requested
+    if args.push:
+      logger.info(f"Pushing tag '{new_tag}' to remote...")
+      repo.remote('origin').push(new_tag) # It only pushes the new tag not all from local repo
+      logger.info(f"Successfully pushed new tag: {new_tag}")
+    else:
+      logger.debug("Not pushing tag to remote")
+  except git.GitCommandError as e:
+    logger.error(f"Error creating/pushing tag: {e}")
+  except Exception as e:
+    logger.error(f"Error: {e}")  
+
+  # Print the new tag to stout as confirmation if not verbose
+  if args.verbose == 0:
+    GREEN = '\033[92m'
+    YELLOW = '\033[93m'
+    RESET = '\033[0m'
+    print(f"{GREEN}{reponame}{RESET} -> {YELLOW}{new_tag}{RESET}")
+
+if __name__ == "__main__":
+  main()

semtag-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+