qgis-plugin-analyzer 1.3.0__py3-none-any.whl

analyzer/validators.py

@@ -0,0 +1,263 @@
+# /***************************************************************************
+#  QGIS Plugin Analyzer
+#
+#  Repository compliance validators for QGIS.org policies.
+#  ***************************************************************************/
+
+import ipaddress
+import pathlib
+import socket
+import urllib.error
+import urllib.parse
+import urllib.request
+from typing import Any, Dict, List
+
+# Prohibited binary extensions per QGIS repository policy
+BINARY_EXTENSIONS = {".exe", ".dll", ".so", ".dylib", ".pyd", ".bin", ".a", ".lib"}
+
+
+def scan_for_binaries(project_path: pathlib.Path, ignore_matcher: Any = None) -> List[str]:
+    """Scans the project for prohibited binary files per QGIS policies.
+
+    Args:
+        project_path: Root path of the project.
+        ignore_matcher: Optional object to determine if a path should be ignored.
+
+    Returns:
+        A list of relative paths to any binary files found.
+    """
+    binaries = []
+
+    for file_path in project_path.rglob("*"):
+        if file_path.is_file():
+            # Skip if matches ignore pattern
+            if ignore_matcher and ignore_matcher.is_ignored(file_path):
+                continue
+
+            if file_path.suffix.lower() in BINARY_EXTENSIONS:
+                rel_path = str(file_path.relative_to(project_path))
+                binaries.append(rel_path)
+
+    return binaries
+
+
+def calculate_package_size(project_path: pathlib.Path, ignore_matcher: Any = None) -> float:
+    """Calculates the total package size in Megabytes (MB).
+
+    Args:
+        project_path: Root path of the project.
+        ignore_matcher: Optional object to determine if a path should be ignored.
+
+    Returns:
+        The total size of the plugin package in MB.
+    """
+    total_size = 0
+
+    for file_path in project_path.rglob("*"):
+        if file_path.is_file():
+            # Skip if matches ignore pattern
+            if ignore_matcher:
+                str(file_path.relative_to(project_path))
+                if ignore_matcher.is_ignored(file_path):
+                    continue
+
+            total_size += file_path.stat().st_size
+
+    # Convert bytes to MB
+    return total_size / (1024 * 1024)
+
+
+def is_ssrf_safe(url: str) -> bool:
+    """Checks if a URL is safe from Server-Side Request Forgery (SSRF).
+
+    Validates that the hostname does not resolve to private, loopback, or
+    local IP ranges.
+
+    Args:
+        url: The URL string to validate.
+
+    Returns:
+        True if the URL is considered safe for outbound requests, False otherwise.
+    """
+    try:
+        parsed = urllib.parse.urlparse(url)
+        hostname = parsed.hostname
+        # We also block URLs without a hostname or non-standard ports if needed,
+        # but here we focus on IP resolving.
+        if not hostname:
+            return False
+
+        # Basic name check for common local addresses
+        if hostname.lower() in ("localhost", "127.0.0.1", "::1"):
+            return False
+
+        # Resolve host to IP
+        # We use socket.getaddrinfo to handle both IPv4 and IPv6
+        # This is more robust than gethostbyname
+        try:
+            addresses = socket.getaddrinfo(hostname, None)
+        except socket.gaierror:
+            # If we can't resolve it, it's either invalid or an internal name
+            # we shouldn't trust for public URL validation.
+            return False
+
+        for addr in addresses:
+            ip_str = addr[4][0]
+            ip = ipaddress.ip_address(ip_str)
+            # Check for private ranges:
+            # 10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16 (Private)
+            # 127.0.0.0/8 (Loopback)
+            # 169.254.0.0/16 (Link Local)
+            # and IPv6 equivalents
+            if ip.is_private or ip.is_loopback or ip.is_link_local or ip.is_unspecified:
+                return False
+
+        return True
+    except Exception:
+        return False
+
+
+def validate_metadata_urls(metadata: Dict[str, str]) -> Dict[str, str]:
+    """Validates the accessibility of URLs defined in the plugin metadata.
+
+    Args:
+        metadata: A dictionary containing metadata fields and their values.
+
+    Returns:
+        A dictionary mapping each URL to its validation status (e.g., 'ok', 'error').
+    """
+    url_fields = ["homepage", "tracker", "repository"]
+    results = {}
+
+    for field in url_fields:
+        url = metadata.get(field, "").strip()
+        if not url:
+            continue
+
+        # Skip if not a valid URL
+        if not url.startswith(("http://", "https://")):
+            results[url] = "invalid"
+            continue
+
+        # SSRF Protection: check if URL is safe before making the request
+        if not is_ssrf_safe(url):
+            results[url] = "error_ssrf_blocked"
+            continue
+
+        try:
+            # HEAD request to check availability
+            req = urllib.request.Request(url, method="HEAD")
+            req.add_header("User-Agent", "QGIS-Plugin-Analyzer/1.0")
+
+            with urllib.request.urlopen(req, timeout=5) as response:
+                if response.status == 200:
+                    results[url] = "ok"
+                else:
+                    results[url] = f"error_{response.status}"
+
+        except urllib.error.HTTPError as e:
+            results[url] = f"error_{e.code}"
+        except urllib.error.URLError:
+            results[url] = "error"
+        except TimeoutError:
+            results[url] = "timeout"
+        except Exception:
+            results[url] = "error"
+
+    return results
+
+
+def validate_plugin_structure(project_path: pathlib.Path) -> Dict[str, Any]:
+    """Validates that the plugin following the required QGIS file structure.
+
+    Args:
+        project_path: Root path of the plugin project.
+
+    Returns:
+        A dictionary containing the validation results and overall status.
+    """
+    mandatory = ["metadata.txt", "__init__.py", "LICENSE"]
+    found = {f: (project_path / f).exists() for f in mandatory}
+
+    # Check classFactory in __init__.py
+    init_file = project_path / "__init__.py"
+    has_factory = False
+    if init_file.exists():
+        try:
+            content = init_file.read_text(encoding="utf-8", errors="replace")
+            has_factory = "def classFactory" in content
+        except Exception:
+            has_factory = False
+
+    missing = [f for f, exists in found.items() if not exists]
+    py_files = list(project_path.glob("*.py"))
+    has_python = len(py_files) > 0
+
+    return {
+        "files": found,
+        "missing_files": missing,
+        "has_class_factory": has_factory,
+        "has_python_files": has_python,
+        "is_valid": all(found.values()) and has_factory and has_python,
+    }
+
+
+def validate_metadata(metadata_path: pathlib.Path) -> Dict[str, Any]:
+    """Validates the content of the metadata.txt file against QGIS requirements.
+
+    Args:
+        metadata_path: Path to the metadata.txt file.
+
+    Returns:
+        A dictionary containing validation details and mandatory/recommended missing fields.
+    """
+    required_fields = [
+        "name",
+        "description",
+        "version",
+        "qgisMinimumVersion",
+        "author",
+        "email",
+    ]
+
+    recommended_fields = [
+        "homepage",
+        "tracker",
+        "repository",
+        "tags",
+        "category",
+    ]
+
+    if not metadata_path.exists():
+        return {
+            "is_valid": False,
+            "missing": required_fields,
+            "recommended_missing": recommended_fields,
+        }
+
+    # Parse metadata.txt
+    metadata = {}
+    try:
+        with open(metadata_path, encoding="utf-8") as f:
+            for line in f:
+                line = line.strip()
+                if "=" in line and not line.startswith("#"):
+                    key, value = line.split("=", 1)
+                    metadata[key.strip()] = value.strip()
+    except Exception:
+        return {
+            "is_valid": False,
+            "missing": required_fields,
+            "recommended_missing": recommended_fields,
+            "error": "Failed to parse metadata.txt",
+        }
+
+    missing = [f for f in required_fields if f not in metadata or not metadata[f]]
+    recommended_missing = [f for f in recommended_fields if f not in metadata or not metadata[f]]
+
+    return {
+        "is_valid": len(missing) == 0,
+        "missing": missing,
+        "recommended_missing": recommended_missing,
+        "metadata": metadata,
+    }

qgis_plugin_analyzer-1.3.0.dist-info/METADATA

@@ -0,0 +1,239 @@
+Metadata-Version: 2.4
+Name: qgis-plugin-analyzer
+Version: 1.3.0
+Summary: A professional static analysis tool for QGIS (PyQGIS) plugins
+Author-email: geociencio <juanbernales@gmail.com>
+License: GPL-3.0-or-later
+Project-URL: Homepage, https://github.com/geociencio/qgis-plugin-analyzer
+Project-URL: Documentation, https://github.com/geociencio/qgis-plugin-analyzer/tree/main/docs
+Project-URL: Repository, https://github.com/geociencio/qgis-plugin-analyzer.git
+Project-URL: Issues, https://github.com/geociencio/qgis-plugin-analyzer/issues
+Project-URL: Chaneglog, https://github.com/geociencio/qgis-plugin-analyzer/blob/main/CHANGELOG.md
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Scientific/Engineering :: GIS
+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
+Dynamic: license-file
+
+# QGIS Plugin Analyzer 🛡️
+![GitHub release (latest by date)](https://img.shields.io/github/v/release/geociencio/qgis-plugin-analyzer?color=blue&logo=github)
+![Python Version](https://img.shields.io/badge/python-3.8%2B-blue?logo=python)
+![License](https://img.shields.io/badge/License-GPLv3-blue.svg)
+![Maintenance](https://img.shields.io/badge/Maintained%3F-yes-green.svg)
+![Conventional Commits](https://img.shields.io/badge/Conventional%20Commits-1.0.0-yellow.svg?logo=git)
+![Quality Score](https://img.shields.io/badge/Module%20Stability-55.6%2F100-yellow)
+![Maintainability](https://img.shields.io/badge/Maintainability-100.0%2F100-brightgreen)
+
+The **QGIS Plugin Analyzer** is a static analysis tool designed specifically for QGIS (PyQGIS) plugin developers. Its goal is to elevate plugin quality by ensuring they follow community best practices and are optimized for AI-assisted development.
+
+## ✨ Main Features
+
+- **High-Performance Engine**: Parallel analysis powered by `ProcessPoolExecutor` for ultra-fast execution on multi-core systems.
+- **Project Auto-Detection**: Intelligently distinguishes between official QGIS Plugins and Generic Python Projects, tailoring validation logic accordingly.
+- **Advanced Ignore Engine**: Robust `.analyzerignore` support with non-anchored patterns and smart default excludes (`.venv`, `build`, etc.).
+- **Deep Semantic Analysis**: Cross-file dependency graphing, circular import detection, and module coupling metrics.
+- **Interactive Auto-Fix Mode**: Automatically fix common QGIS issues (GDAL imports, PyQt bridge, logging, i18n) with safety checks.
+- **Official Repository Compliance**: Proactive validation of binaries, package size, and metadata URLs.
+- **Real-time Progress**: CLI feedback with a progress bar and ETA tracking.
+- **Enhanced Configuration Profiles**: Rule-level severity control (`error`, `warning`, `info`, `ignore`) via `pyproject.toml`.
+- **Integrated Ruff Analysis**: Combines custom QGIS rules with the fastest linter in the Python ecosystem.
+- **Qt Resource Validation**: Detect missing or broken resource paths (`:/plugins/...`) in your code.
+- **Signal/Slot Safety**: Detection of potentially missing slots or inherited slot warnings.
+- **AI-Ready**: Generates structured summaries and optimized contexts for LLMs.
+- **Zero Runtime Dependencies**: Works using only the Python standard library (Ruff as an external tool).
+
+## ⚖️ Why use this Analyzer? (Comparison)
+
+| Feature | **QGIS Plugin Analyzer** | flake8-qgis | Ruff (Standard) | Official Repo Bot |
+| :--- | :---: | :---: | :---: | :---: |
+| **Static Linting** | ✅ (Ruff + Custom) | ✅ (flake8) | ✅ (General) | ✅ (Limited) |
+| **QGIS-Specific Rules**| ✅ (Precise AST) | ✅ (Regex/AST) | ❌ | ✅ |
+| **Interactive Auto-Fix**| ✅ | ❌ | ❌ | ❌ |
+| **Semantic Analysis**  | ✅ | ❌ | ❌ | ❌ |
+| **Compliance Checks**  | ✅ | ❌ | ❌ | ✅ |
+| **i18n / API Audit**   | ✅ | ❌ | ❌ | ✅ |
+| **Architecture Audit** | ✅ (UI/Core) | ❌ | ❌ | ❌ |
+| **HTML/MD Reports**    | ✅ | ❌ | ❌ | ❌ |
+| **AI Context Gen**      | ✅ (Project Brain) | ❌ | ❌ | ❌ |
+
+### Key Differentiators
+
+1.  **High-Performance Hybrid Engine**: Combines multi-core AST processing with deep understanding of cross-file relationships and Qt-specific patterns.
+2.  **Safety-First Auto-Fixing**: AST-based transformations with Git status verification and interactive diff previews.
+3.  **Repository Compliance**: Local pre-checks to ensure your plugin passes the Official QGIS Repository policies.
+4.  **Zero Runtime Stack**: Minimal footprint, ultra-fast execution, and easy CI integration.
+5.  **AI-Centric Design**: Built to help developers and AI agents understand complex QGIS plugins instantly.
+
+## 🚀 Installation and Usage
+
+### Installation with `uv` (Recommended):
+
+If you have [uv](https://github.com/astral-sh/uv) installed, you can install the analyzer quickly and in isolation:
+
+**1. As a global tool (isolated):**
+```bash
+uv tool install git+https://github.com/geociencio/qgis-plugin-analyzer.git
+```
+
+**2. Local installation for development:**
+```bash
+git clone https://github.com/geociencio/qgis-plugin-analyzer
+cd qgis-plugin-analyzer
+uv sync
+```
+
+### Installation with `pip`:
+```bash
+pip install .
+```
+
+### Main Commands:
+
+**1. Analyze a Plugin:**
+```bash
+qgis-analyzer analyze /path/to/your/plugin -o ./quality_report
+```
+
+**2. Auto-Fix issues (Dry Run):**
+```bash
+qgis-analyzer fix /path/to/your/plugin
+```
+
+**3. Legacy Support:**
+The default command remains analysis if no subcommand is specified:
+```bash
+qgis-analyzer /path/to/your/plugin
+```
+
+## 🔄 Pre-commit Hook
+
+You can run `qgis-plugin-analyzer` automatically before every commit to ensure quality. Add this to your `.pre-commit-config.yaml`:
+
+```yaml
+  - repo: https://github.com/geociencio/qgis-plugin-analyzer
+    rev: v1.1.0  # Use the latest tag
+    hooks:
+      - id: qgis-plugin-analyzer
+      - id: qgis-plugin-analyzer
+```
+
+## 🤖 GitHub Action
+
+Use it directly in your CI/CD workflows:
+
+```yaml
+steps:
+  - uses: actions/checkout@v4
+  - name: Run QGIS Quality Check
+    uses: geociencio/qgis-plugin-analyzer@main
+    with:
+      path: .
+      output: quality_report
+      args: --profile release
+```
+
+## ⌨️ Full CLI Reference
+
+### `qgis-analyzer analyze`
+Audits an existing QGIS plugin repository.
+
+| Argument | Description | Default |
+| :--- | :--- | :--- |
+| `project_path` | **(Required)** Path to the plugin directory to analyze. | N/A |
+| `-o`, `--output` | Directory where HTML/Markdown reports will be saved. | `./analysis_results` |
+| `-p`, `--profile`| Configuration profile from `pyproject.toml` (`default`, `release`). | `default` |
+
+### `qgis-analyzer fix`
+Automatically fix common QGIS issues identified during analysis.
+
+| Argument | Description | Default |
+| :--- | :--- | :--- |
+| `path` | **(Required)** Path to the plugin directory. | N/A |
+| `--dry-run` | Show proposed changes without applying them. | `True` |
+| `--apply` | Apply fixes to the files (disables dry-run). | `False` |
+| `--auto-approve`| Apply fixes without interactive confirmation. | `False` |
+| `--rules` | Comma-separated list of rule IDs to fix. | Fix all |
+| `-o`, `--output` | Directory to read previous analysis from. | `./analysis_results` |
+
+### `qgis-analyzer summary`
+Shows a professional, color-coded summary of findings directly in your terminal.
+
+| Argument | Description | Default |
+| :--- | :--- | :--- |
+| `-b`, `--by` | Granularity of the summary: `total`, `modules`, `functions`, `classes`. | `total` |
+| `-i`, `--input` | Path to the `project_context.json` file to summarize. | `analysis_results/project_context.json` |
+
+**Example:**
+```bash
+# Executive summary
+qgis-analyzer summary
+
+# Identify high-complexity functions
+qgis-analyzer summary --by functions
+```
+
+### `qgis-analyzer list-rules`
+Displays the full catalog of implemented QGIS audit rules with their severity and descriptions.
+
+### `qgis-analyzer init`
+Initializes a recommended `.analyzerignore` file in the current directory with common Python and QGIS development exclusions.
+
+
+## 📊 Generated Reports
+
+- `project_context.json`: Full structured data for external integrations.
+
+## 📜 Audit Rules
+
+For a complete list of all implemented checks, their severity, and recommendations, please refer to the:
+
+👉 **[Detailed Rules Catalog (RULES.md)](RULES.md)**
+
+## 📚 References and Standards
+
+The development of this analyzer is based on official QGIS community guidelines, geospatial standards, and industry best practices:
+
+### Official QGIS Documentation
+- **[PyQGIS Developer Cookbook](https://docs.qgis.org/latest/en/docs/pyqgis_developer_cookbook/)**: The primary resource for PyQGIS API usage and standards.
+- **[QGIS Plugin Repository Requirements](https://plugins.qgis.org/publish/)**: Mandatory criteria for plugin approval in the official repository.
+- **[QGIS Coding Standards](https://docs.qgis.org/latest/en/docs/developer_guide/codingstandards.html)**: Core style and organization guidelines for the QGIS project.
+- **[QGIS HIG (Human Interface Guidelines)](https://docs.qgis.org/latest/en/docs/developer_guide/hig.html)**: Standards for consistent and accessible user interface design.
+
+### Industry & Community Standards
+- **[flake8-qgis Rules](https://github.com/qgis/flake8-qgis)**: Community-driven linting rules for PyQGIS (QGS101-106).
+- **[PEP 8 Style Guide](https://peps.python.org/pep-0008/)**: The fundamental style guide for Python code.
+- **[PEP 257 Docstring Conventions](https://peps.python.org/pep-0257/)**: Standards for docstring structure and content.
+- **[Maintainability Index (SEI)](https://learn.microsoft.com/en-us/visualstudio/code-quality/code-metrics-maintainability-index-range-and-meaning)**: Methodology for measuring software maintainability.
+- **[Conventional Commits](https://www.conventionalcommits.org/)**: Standard for clear, machine-readable commit history.
+- **[Keep a Changelog](https://keepachangelog.com/)**: Best practices for maintainable version history.
+
+### Internal Resources
+- **[Detailed Rules Catalog](RULES.md)**: Full documentation of all audit rules implemented in this analyzer.
+- **[Standardized Scoring Metrics](docs/SCORING_STANDARDS.md)**: Mathematical logic and thresholds for project evaluation.
+- **[Project Roadmap](docs/ROADMAP.md)**: Current status and future plans for the analyzer.
+- **[Documentation Folder](docs/)**: Historical release notes, competitive analysis, and modernization guides.
+
+## 🛠️ Contributing
+
+Contributions are welcome! Please refer to our **[Contributing Guide](CONTRIBUTING.md)** to learn how to report bugs, propose rules, and submit code changes.
+
+Audit rules are located in `src/analyzer/scanner.py`. Feel free to add new rules following the existing pattern!
+
+---
+## ⚖️ License
+
+This project is licensed under the **GNU General Public License v3 (GPL v3)**. See the [LICENSE](LICENSE) file for details.
+
+---
+*Developed for the SecInterp team and the QGIS community.*

qgis_plugin_analyzer-1.3.0.dist-info/RECORD

@@ -0,0 +1,30 @@
+__init__.py,sha256=m27nXDOFpStOzfg3Qqeaw7yj1wNmpnOH7xk5svlCprA,1185
+analyzer/__init__.py,sha256=m27nXDOFpStOzfg3Qqeaw7yj1wNmpnOH7xk5svlCprA,1185
+analyzer/cli.py,sha256=x6ZfhtTyJbLDSA8eNlKpXdeHc0nvvp0jdN40mYFHXPs,10488
+analyzer/engine.py,sha256=rbJtEQj1_Qr69Z3Uzx3c97iCw1BkS8A4gQv9WnV0Egk,22241
+analyzer/fixer.py,sha256=6CujODr4pJgdR2XuJoBOCrQxBHjJfvVsBmg4YZdKJAM,10653
+analyzer/scanner.py,sha256=o4pvtUnYn2ZYo5OhEwswm7BEeIA61XrosmrhS5Al8SI,34260
+analyzer/semantic.py,sha256=cVmSiTmI-b4DFZ5Q6kZUdqd6ZPH92pJmNAE60MIiZRI,8192
+analyzer/transformers.py,sha256=tFmelReM8ILpFjMBSDIDMCXPSZlD9t8FD7lTXVgfOgA,7103
+analyzer/validators.py,sha256=5JPwQYQ4KKThZchr34nV06-VToFhgBOtIp7lNhO5WTk,8344
+analyzer/models/__init__.py,sha256=NlDgdV1i9CoWJBgiENoJQuHnYCOzO6U_ui3wHOeT7xI,160
+analyzer/models/analysis_models.py,sha256=WXsYgbjD4ngBoyaY-YkwMMl2Jpbn96hue6zuSERZRb0,2362
+analyzer/reporters/__init__.py,sha256=fVsu2gCuBdDd_STD97Jku8otcO3j7NZrxxd_pGzf6Sw,280
+analyzer/reporters/html_reporter.py,sha256=j64KkjiRwwRBzIPZE7bBJGsbJEYIoSnZeho63tI4c5A,14919
+analyzer/reporters/markdown_reporter.py,sha256=sc0zBM4_hJmLE8tZF8lV_v7VLRlNSEhWqSivFZMQKac,8074
+analyzer/reporters/summary_reporter.py,sha256=v4XfmcE027fCIWmS5N0odCx-NdziWuCefBIacRhi8XA,7237
+analyzer/rules/__init__.py,sha256=UNZoY89SFQoUKYGj_rjwvv8md6vXSSM2pGPV6MqC2Fg,261
+analyzer/rules/modernization_rules.py,sha256=IJw8c6v7Q_5z3xF9Dh0eBrproRFZFtIOyWcArAsSv18,1071
+analyzer/rules/qgis_rules.py,sha256=N_1RxWrckOZWzcAMPI-07vLQPazO6MM7-LF69_NFMy8,2548
+analyzer/utils/__init__.py,sha256=7abAIymmrA8FlzqsM8JfKXnfx3HjX0r-8KdvmgKMRQA,1006
+analyzer/utils/ast_utils.py,sha256=LZ9NLrbJlhFGM7LsX6YNexOi_avJ0Sxzf8GdZHvoXK4,3831
+analyzer/utils/config_utils.py,sha256=reNyUonmik8Tpwx0RbaslsiienIqPDeiXBfh4Pv23_E,4690
+analyzer/utils/logging_utils.py,sha256=V0z7XeF46tj2oI247j2fRRafClbtMDVscVmg2JFYHV4,1257
+analyzer/utils/path_utils.py,sha256=BkffM1TRKAMPCzLx49rQzmYHYGbPwlI41LCK5QoN2oU,4097
+analyzer/utils/performance_utils.py,sha256=M3mfMVrOvyfgQiCQB0R5IkkBnAx-L9er4fGR9UL5E-0,4253
+qgis_plugin_analyzer-1.3.0.dist-info/licenses/LICENSE,sha256=bMxViCXCE9h3bzmw6oUvy4R_CvzOrV3aYhIvjBPx20A,35091
+qgis_plugin_analyzer-1.3.0.dist-info/METADATA,sha256=H5proK4GbF0j0Dsalp_8H1yczJ_TF4iQ4oBsxPRcEvM,11400
+qgis_plugin_analyzer-1.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+qgis_plugin_analyzer-1.3.0.dist-info/entry_points.txt,sha256=1dwiqkZC4hGYExrOgyhZkxv7CbClSZqJkVk42nlw1IY,52
+qgis_plugin_analyzer-1.3.0.dist-info/top_level.txt,sha256=i9U1DboCuTuaYpS-5GcgUeKIlSI00PoxYtnrfQWD8wo,18
+qgis_plugin_analyzer-1.3.0.dist-info/RECORD,,

qgis_plugin_analyzer-1.3.0.dist-info/WHEEL

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

qgis_plugin_analyzer-1.3.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+qgis-analyzer = analyzer.cli:main