hatch-calvar-sample 2026.1.19.1__py3-none-any.whl

hatch_calvar_sample/__about__.py

@@ -0,0 +1,34 @@
+# SPDX-FileCopyrightText: 2026-present QAToolist <qatoolist@gmail.com>
+#
+# SPDX-License-Identifier: MIT
+"""Version metadata for hatch_calvar_sample package."""
+
+# Import version function with fallback for Python < 3.8
+try:
+    from importlib.metadata import version as _version_func
+except ImportError:
+    # Python < 3.8
+    from importlib_metadata import (
+        version as _version_func,  # type: ignore[no-untyped-call]
+    )
+
+
+def get_package_version(package_name: str) -> str:
+    """Get version from package metadata."""
+    return _version_func(package_name)
+
+
+# Try to get version from package metadata (when installed)
+try:
+    __version__ = get_package_version("hatch-calvar-sample")
+except Exception:
+    # Fallback: try reading from VERSION file (for development builds)
+    import os
+    from pathlib import Path
+
+    version_file = Path(__file__).parent / "VERSION"
+    if version_file.exists():
+        __version__ = version_file.read_text().strip()
+    else:
+        # Last resort: read from environment variable
+        __version__ = os.environ.get("HATCH_CALVER_VERSION", "0.0.0.dev0")

hatch_calvar_sample/__init__.py

@@ -0,0 +1,8 @@
+# SPDX-FileCopyrightText: 2026-present QAToolist <qatoolist@gmail.com>
+#
+# SPDX-License-Identifier: MIT
+"""Sample hatch project demonstrating CalVer (YYYY.MM.DD.MICRO) with hatch."""
+
+from hatch_calvar_sample.__about__ import __version__
+
+__all__ = ["__version__"]

hatch_calvar_sample/cli.py

@@ -0,0 +1,313 @@
+"""CLI tool for CalVer version management."""
+
+import argparse
+import json
+import sys
+from pathlib import Path
+from typing import Optional
+
+# Import version function with fallback for Python < 3.8
+try:
+    from importlib.metadata import version as _version_func
+except ImportError:
+    # Python < 3.8
+    from importlib_metadata import (
+        version as _version_func,  # type: ignore[no-untyped-call]
+    )
+
+
+# Import version calculation functions from script
+# We'll need to make these importable or duplicate the logic
+# For now, we'll import from the script directory
+sys.path.insert(0, str(Path(__file__).parent.parent.parent / "scripts"))
+try:
+    from calc_version import (
+        calculate_next_version,
+        check_pep440_compliance,
+        get_git_tags,
+        parse_calver_tag,
+        validate_version_format,
+    )
+except ImportError:
+    # Fallback if script not available
+    def calculate_next_version():
+        return "0.0.0.0"  # nosec B104
+
+    def validate_version_format(version: str) -> bool:
+        return bool(version)
+
+    def check_pep440_compliance(version: str) -> bool:
+        return True
+
+    def parse_calver_tag(tag: str):
+        return None
+
+    def get_git_tags():
+        return []
+
+
+def get_package_version_from_metadata() -> Optional[str]:
+    """Get version from installed package metadata.
+
+    Returns:
+        Version string or None if not available
+    """
+    try:
+        return _version_func("hatch-calvar-sample")
+    except Exception:
+        return None
+
+
+def version_calc(args: argparse.Namespace) -> int:
+    """Calculate next version.
+
+    Args:
+        args: Parsed command-line arguments
+
+    Returns:
+        Exit code (0 for success, 1 for error)
+    """
+    try:
+        version = calculate_next_version()
+    except Exception as e:
+        print(f"Error calculating version: {e}", file=sys.stderr)
+        return 1
+
+    if args.json:
+        output = {"version": version}
+        print(json.dumps(output))
+    else:
+        print(version)
+
+    return 0
+
+
+def version_check(args: argparse.Namespace) -> int:
+    """Check current version from different sources.
+
+    Args:
+        args: Parsed command-line arguments
+
+    Returns:
+        Exit code (0 for success, 1 for error)
+    """
+    versions = {}
+
+    # Check package metadata
+    pkg_version = get_package_version_from_metadata()
+    if pkg_version:
+        versions["package"] = pkg_version
+
+    # Check git tags
+    git_tags = get_git_tags()
+    calver_tags = [tag for tag in git_tags if parse_calver_tag(tag)]
+    if calver_tags:
+        # Get latest CalVer tag
+        parsed_tags = [(tag, parse_calver_tag(tag)) for tag in calver_tags]
+        parsed_tags.sort(key=lambda x: x[1], reverse=True)  # Sort by date/micro
+        latest_tag = parsed_tags[0][0]
+        # Remove 'v' prefix if present
+        if latest_tag.startswith("v"):
+            versions["git_tag"] = latest_tag[1:]
+        else:
+            versions["git_tag"] = latest_tag
+
+    # Check VERSION file
+    version_file = (
+        Path(__file__).parent.parent.parent / "src" / "hatch_calvar_sample" / "VERSION"
+    )
+    if version_file.exists():
+        versions["file"] = version_file.read_text().strip()
+
+    if args.json:
+        output = {"versions": versions}
+        print(json.dumps(output, indent=2))
+    else:
+        if versions:
+            print("Current versions:")
+            for source, ver in versions.items():
+                print(f"  {source}: {ver}")
+        else:
+            print("No version information found", file=sys.stderr)
+            return 1
+
+    return 0
+
+
+def version_validate(args: argparse.Namespace) -> int:
+    """Validate version format.
+
+    Args:
+        args: Parsed command-line arguments
+
+    Returns:
+        Exit code (0 for valid, 1 for invalid)
+    """
+    if not args.version:
+        print("Error: version argument required", file=sys.stderr)
+        return 1
+
+    version = args.version
+
+    # Validate format
+    is_valid_format = validate_version_format(version)
+
+    # Check PEP 440 compliance
+    is_pep440 = False
+    if is_valid_format:
+        is_pep440 = check_pep440_compliance(version)
+
+    if args.json:
+        output = {
+            "version": version,
+            "valid_format": is_valid_format,
+            "pep440_compliant": is_pep440,
+        }
+        print(json.dumps(output))
+        return 0 if (is_valid_format and is_pep440) else 1
+    else:
+        if not is_valid_format:
+            print(f"Invalid CalVer format: {version}", file=sys.stderr)
+            return 1
+
+        if not is_pep440:
+            print(f"Version not PEP 440 compliant: {version}", file=sys.stderr)
+            return 1
+
+        print(f"Version '{version}' is valid and PEP 440 compliant")
+        return 0
+
+
+def version_compare(args: argparse.Namespace) -> int:
+    """Compare two versions.
+
+    Args:
+        args: Parsed command-line arguments
+
+    Returns:
+        Exit code (0 for success, 1 for error)
+    """
+    if len(args.versions) != 2:
+        print("Error: exactly two versions required for comparison", file=sys.stderr)
+        return 1
+
+    v1_str, v2_str = args.versions
+
+    # Parse versions
+    v1 = parse_calver_tag(v1_str)
+    v2 = parse_calver_tag(v2_str)
+
+    if not v1:
+        print(f"Error: invalid version format: {v1_str}", file=sys.stderr)
+        return 1
+
+    if not v2:
+        print(f"Error: invalid version format: {v2_str}", file=sys.stderr)
+        return 1
+
+    # Compare (year, month, day, micro)
+    if v1 < v2:
+        result = "<"
+    elif v1 > v2:
+        result = ">"
+    else:
+        result = "=="
+
+    if args.json:
+        output = {
+            "version1": v1_str,
+            "version2": v2_str,
+            "comparison": result,
+        }
+        print(json.dumps(output))
+    else:
+        print(f"{v1_str} {result} {v2_str}")
+
+    return 0
+
+
+def version_info(args: argparse.Namespace) -> int:
+    """Show version information.
+
+    Args:
+        args: Parsed command-line arguments
+
+    Returns:
+        Exit code (0 for success, 1 for error)
+    """
+    info = {}
+
+    # Get next version
+    try:
+        next_version = calculate_next_version()
+        parsed = parse_calver_tag(next_version)
+        if parsed:
+            year, month, day, micro = parsed
+            info["next_version"] = next_version
+            info["date"] = f"{year:04d}-{month:02d}-{day:02d}"
+            info["micro"] = micro
+    except Exception as e:
+        info["next_version_error"] = str(e)
+
+    # Get current package version
+    pkg_version = get_package_version_from_metadata()
+    if pkg_version:
+        info["current_package_version"] = pkg_version
+
+    if args.json:
+        print(json.dumps(info, indent=2))
+    else:
+        print("Version Information:")
+        for key, value in info.items():
+            print(f"  {key}: {value}")
+
+    return 0
+
+
+def main():
+    """Main CLI entry point."""
+    parser = argparse.ArgumentParser(
+        description="CalVer version management CLI", prog="calver-check"
+    )
+    parser.add_argument("--json", action="store_true", help="Output in JSON format")
+
+    subparsers = parser.add_subparsers(dest="command", help="Command")
+
+    # calc command
+    calc_parser = subparsers.add_parser("calc", help="Calculate next CalVer version")
+    calc_parser.set_defaults(func=version_calc)
+
+    # check command
+    check_parser = subparsers.add_parser(
+        "check", help="Check current version from different sources"
+    )
+    check_parser.set_defaults(func=version_check)
+
+    # validate command
+    validate_parser = subparsers.add_parser(
+        "validate", help="Validate version format and PEP 440 compliance"
+    )
+    validate_parser.add_argument("version", help="Version string to validate")
+    validate_parser.set_defaults(func=version_validate)
+
+    # compare command
+    compare_parser = subparsers.add_parser("compare", help="Compare two versions")
+    compare_parser.add_argument("versions", nargs=2, help="Two versions to compare")
+    compare_parser.set_defaults(func=version_compare)
+
+    # info command
+    info_parser = subparsers.add_parser("info", help="Show version information")
+    info_parser.set_defaults(func=version_info)
+
+    args = parser.parse_args()
+
+    if not args.command:
+        parser.print_help()
+        return 1
+
+    # Call the appropriate function
+    return args.func(args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

hatch_calvar_sample-2026.1.19.1.dist-info/METADATA

@@ -0,0 +1,421 @@
+Metadata-Version: 2.4
+Name: hatch-calvar-sample
+Version: 2026.1.19.1
+Summary: Sample project demonstrating CalVer (YYYY.MM.DD.MICRO) with hatch
+Project-URL: Documentation, https://github.com/QAToolist/hatch-calvar-sample#readme
+Project-URL: Issues, https://github.com/QAToolist/hatch-calvar-sample/issues
+Project-URL: Source, https://github.com/QAToolist/hatch-calvar-sample
+Author-email: QAToolist <qatoolist@gmail.com>
+License-Expression: MIT
+License-File: LICENSE.txt
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python
+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
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.8
+Provides-Extra: dev
+Requires-Dist: bandit>=1.7.0; extra == 'dev'
+Requires-Dist: black>=24.1.0; extra == 'dev'
+Requires-Dist: isort>=5.13.0; extra == 'dev'
+Requires-Dist: mypy>=1.0.0; extra == 'dev'
+Requires-Dist: pre-commit>=3.0.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0.0; extra == 'dev'
+Requires-Dist: pytest>=7.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Provides-Extra: lint
+Requires-Dist: bandit>=1.7.0; extra == 'lint'
+Requires-Dist: black>=24.1.0; extra == 'lint'
+Requires-Dist: isort>=5.13.0; extra == 'lint'
+Requires-Dist: mypy>=1.0.0; extra == 'lint'
+Requires-Dist: pre-commit>=3.0.0; extra == 'lint'
+Requires-Dist: ruff>=0.1.0; extra == 'lint'
+Provides-Extra: test
+Requires-Dist: pytest-cov>=4.0.0; extra == 'test'
+Requires-Dist: pytest>=7.0.0; extra == 'test'
+Description-Content-Type: text/markdown
+
+# hatch-calvar-sample
+
+[![PyPI - Version](https://img.shields.io/pypi/v/hatch-calvar-sample.svg)](https://pypi.org/project/hatch-calvar-sample)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/hatch-calvar-sample.svg)](https://pypi.org/project/hatch-calvar-sample)
+
+Sample hatch-based Python project demonstrating **Calendar Versioning (CalVer)** with format `YYYY.MM.DD.MICRO` and automated PyPI release workflows.
+
+## Overview
+
+This project serves as a proof-of-concept for implementing CalVer versioning with the hatch build system. It demonstrates:
+
+- **Calendar Versioning (YYYY.MM.DD.MICRO)** calculated from git tags
+- **Dynamic versioning** with hatch build system
+- **Version checking CLI tool** with multiple commands
+- **Automated PyPI release** via GitHub Actions
+- **Complete release workflow** automation
+
+### Version Format
+
+The project uses CalVer format: `YYYY.MM.DD.MICRO`
+
+- `YYYY` - 4-digit year (e.g., 2024)
+- `MM` - 2-digit month (01-12)
+- `DD` - 2-digit day (01-31)
+- `MICRO` - Sequential number for releases on the same day (1, 2, 3, ...)
+
+Examples: `2024.01.18.1`, `2024.01.18.2`, `2024.03.15.1`
+
+## Installation
+
+```console
+pip install hatch-calvar-sample
+```
+
+## Features
+
+### Version Calculation
+
+The project includes a script that automatically calculates the next CalVer version based on:
+- Current UTC date
+- Existing git tags matching the CalVer pattern
+- Automatic MICRO increment for same-day releases
+
+### CLI Tool
+
+The `calver-check` CLI provides multiple commands for version management:
+
+```bash
+# Calculate next version
+calver-check calc
+
+# Check current version from different sources
+calver-check check
+
+# Validate version format
+calver-check validate 2024.01.18.1
+
+# Compare two versions
+calver-check compare 2024.01.18.1 2024.01.18.2
+
+# Show version information
+calver-check info
+```
+
+All commands support `--json` flag for machine-readable output:
+
+```bash
+calver-check calc --json
+```
+
+## Usage Examples
+
+### Calculating Next Version
+
+```bash
+# Using the script directly
+python scripts/calc_version.py
+
+# Using the CLI tool
+calver-check calc
+
+# With validation
+python scripts/calc_version.py --validate --pep440
+```
+
+### Checking Current Version
+
+```bash
+# Check version from package metadata
+calver-check check
+
+# Check with JSON output
+calver-check check --json
+```
+
+### Validating Version Format
+
+```bash
+# Validate a version string
+calver-check validate 2024.01.18.1
+
+# Invalid version will exit with error
+calver-check validate 2024.1.18.1
+```
+
+### Comparing Versions
+
+```bash
+# Compare two versions
+calver-check compare 2024.01.18.1 2024.01.18.2
+# Output: 2024.01.18.1 < 2024.01.18.2
+```
+
+## Release Process
+
+### Fully Automated Release Workflow
+
+The project uses GitHub Actions for **fully automated** PyPI releases. **No manual tagging required!** The workflow consists of two stages:
+
+#### Stage 1: Auto-tag on PR Merge
+
+When a pull request is merged to `main` or `master`:
+
+1. Automatically calculates next CalVer version using `scripts/calc_version.py`
+2. Creates a git tag with format `vYYYY.MM.DD.MICRO`
+3. Pushes the tag to the repository
+
+#### Stage 2: Build and Publish
+
+When a git tag matching `v*` is pushed:
+
+1. Extracts version from tag (strips `v` prefix)
+2. Validates CalVer format
+3. Builds package with hatch
+4. Validates distributions with twine
+5. Publishes to PyPI using Trusted Publishing
+
+### Automated Release Steps
+
+1. **Open a pull request** with your changes
+2. **Merge the pull request** to `main`/`master`
+3. **GitHub Actions automatically:**
+   - Calculates next CalVer version (e.g., `2024.01.18.1`)
+   - Creates tag `v2024.01.18.1`
+   - Builds the package
+   - Validates version format
+   - Publishes to PyPI
+
+No manual tagging required! The release happens automatically when PRs are merged.
+
+### Manual Release (Optional)
+
+If you need to manually create a release tag (for hotfixes, etc.):
+
+1. **Calculate next version:**
+   ```bash
+   calver-check calc
+   # Output: 2024.01.18.1
+   ```
+
+2. **Create and push git tag:**
+   ```bash
+   git tag v2024.01.18.1 -m "Release 2024.01.18.1"
+   git push origin v2024.01.18.1
+   ```
+
+The tag push will trigger the same build and publish workflow.
+
+### Using Makefile
+
+For convenience, use the Makefile targets:
+
+```bash
+# Calculate next version
+make version-calc
+
+# Check current version
+make version-check
+
+# Validate version format
+make version-validate VERSION=2024.01.18.1
+
+# Create and push release tag
+make release-tag
+
+# Build package for testing
+make build-test
+```
+
+## Project Structure
+
+```
+hatch-calvar-sample/
+├── pyproject.toml              # Hatch configuration with dynamic versioning
+├── README.md                   # This file
+├── CHANGELOG.md                # Changelog with CalVer format
+├── LICENSE.txt                 # MIT license
+├── Makefile                    # Convenient make targets
+├── .github/
+│   └── workflows/
+│       ├── auto-tag.yml        # Auto-create tag on PR merge
+│       └── release.yml         # Automated PyPI release workflow
+├── scripts/
+│   └── calc_version.py         # Version calculation script
+├── src/
+│   └── hatch_calvar_sample/
+│       ├── __init__.py         # Package with __version__
+│       ├── __about__.py        # Version metadata
+│       ├── VERSION             # Version file (generated during build)
+│       └── cli.py              # Version checking CLI implementation
+└── tests/
+    ├── test_version_calc.py    # Tests for version calculation
+    └── test_version_cli.py     # Tests for CLI tool
+```
+
+## Configuration
+
+### Dynamic Versioning
+
+The project uses hatch's dynamic versioning feature configured in `pyproject.toml`:
+
+```toml
+[tool.hatch.version]
+path = "src/hatch_calvar_sample/VERSION"
+```
+
+The VERSION file is created during the release workflow with the version extracted from the git tag.
+
+### Version Metadata in Code
+
+The package reads version from `importlib.metadata` when installed, with fallbacks:
+
+1. Package metadata (when installed)
+2. VERSION file (for development builds)
+3. Environment variable `HATCH_CALVER_VERSION`
+
+Access version programmatically:
+
+```python
+from hatch_calvar_sample import __version__
+
+print(__version__)  # Output: 2024.01.18.1
+```
+
+## Development
+
+### Setting Up Development Environment
+
+```bash
+# Clone the repository
+git clone https://github.com/QAToolist/hatch-calvar-sample.git
+cd hatch-calvar-sample
+
+# Install in development mode
+pip install -e .
+
+# Install development dependencies
+pip install pytest
+```
+
+### Running Tests
+
+```bash
+# Run all tests
+pytest
+
+# Run specific test file
+pytest tests/test_version_calc.py
+
+# Run with coverage
+pytest --cov=hatch_calvar_sample --cov=scripts
+```
+
+### Local Testing
+
+1. **Test version calculation:**
+   ```bash
+   python scripts/calc_version.py
+   ```
+
+2. **Test build process:**
+   ```bash
+   # Create VERSION file manually
+   echo "2024.01.18.1" > src/hatch_calvar_sample/VERSION
+
+   # Build package
+   hatch build
+
+   # Check built package
+   twine check dist/*
+   ```
+
+3. **Test installation:**
+   ```bash
+   pip install -e .
+   python -c "import hatch_calvar_sample; print(hatch_calvar_sample.__version__)"
+   ```
+
+## Version Calculation Logic
+
+The version calculation script:
+
+1. Gets current UTC date → `YYYY.MM.DD`
+2. Fetches all git tags (`git fetch --tags`)
+3. Parses tags matching CalVer pattern (`YYYY.MM.DD.MICRO` or `vYYYY.MM.DD.MICRO`)
+4. Filters tags with the same date
+5. Extracts MICRO numbers
+6. Calculates next MICRO = `max(existing) + 1` or `1` if none exist
+7. Returns: `YYYY.MM.DD.MICRO`
+
+### Edge Cases Handled
+
+- No tags → Returns `YYYY.MM.DD.1`
+- Multiple tags same date → Increments MICRO correctly
+- Date boundary crossing → Resets MICRO to 1 for new date
+- Invalid tag formats → Skipped gracefully
+- Timezone handling → Uses UTC for consistency
+
+## PEP 440 Compliance
+
+CalVer format `YYYY.MM.DD.MICRO` is PEP 440 compliant as a release segment. The format:
+
+- Uses numeric components
+- Follows semantic ordering (newer dates > older dates)
+- Valid for PyPI distribution
+
+Validate PEP 440 compliance:
+
+```bash
+calver-check validate 2024.01.18.1
+python scripts/calc_version.py --pep440
+```
+
+## Troubleshooting
+
+### Version Not Found
+
+If `__version__` is not available:
+
+1. Ensure package is installed: `pip install -e .`
+2. Check VERSION file exists: `ls src/hatch_calvar_sample/VERSION`
+3. Verify git tags: `git tag`
+
+### Build Errors
+
+If build fails:
+
+1. Verify VERSION file exists with valid format
+2. Check `pyproject.toml` dynamic version configuration
+3. Ensure hatch is installed: `pip install hatchling`
+
+### CLI Not Found
+
+If `calver-check` command is not available:
+
+1. Reinstall package: `pip install -e .`
+2. Check entry point in `pyproject.toml`
+3. Verify PATH includes Python scripts directory
+
+## Contributing
+
+This is a sample project for demonstration purposes. If you find it useful or want to adapt it for your project:
+
+1. Review the implementation details in scripts and source code
+2. Check the GitHub Actions workflow for CI/CD patterns
+3. Adapt the configuration for your project structure
+
+## License
+
+`hatch-calvar-sample` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.
+
+## References
+
+- [Hatch Documentation](https://hatch.pypa.io/)
+- [Calendar Versioning (CalVer)](https://calver.org/)
+- [PEP 440 - Version Identification](https://peps.python.org/pep-0440/)
+- [GitHub Actions](https://docs.github.com/en/actions)
+
+
+## Demo Change

hatch_calvar_sample-2026.1.19.1.dist-info/RECORD

@@ -0,0 +1,8 @@
+hatch_calvar_sample/__about__.py,sha256=xlD9nPpC2pVTXj7SnqL2D4Ii8Hx5PdoszDaQ-scX_m8,1107
+hatch_calvar_sample/__init__.py,sha256=Zo7rNhiPjw6aA00bIGyizV2ke8xv24cjV3C2K6MfPDI,265
+hatch_calvar_sample/cli.py,sha256=J3wnxje3vnx1Ep2YlPyBlkTBo4eUmBb8zesCHbZFj_k,8394
+hatch_calvar_sample-2026.1.19.1.dist-info/METADATA,sha256=STWKCFQb3Hn8T9vfDZym1L2vs7ZuGzGgXTgoNXmscE8,11396
+hatch_calvar_sample-2026.1.19.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+hatch_calvar_sample-2026.1.19.1.dist-info/entry_points.txt,sha256=vXoWTt7vuY493G-1mbwHnSSVt_ixdRvCZl2pHxszDjE,62
+hatch_calvar_sample-2026.1.19.1.dist-info/licenses/LICENSE.txt,sha256=mTqa2fQvFlr6XRReIRjiWIxWJ43FPXEV2mhd8o_HL4k,1096
+hatch_calvar_sample-2026.1.19.1.dist-info/RECORD,,

hatch_calvar_sample-2026.1.19.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

hatch_calvar_sample-2026.1.19.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+calver-check = hatch_calvar_sample.cli:main

hatch_calvar_sample-2026.1.19.1.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2026-present QAToolist <qatoolist@gmail.com>
+
+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.