crossportability 0.1.0__tar.gz

crossportability-0.1.0/LICENSE

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

crossportability-0.1.0/PKG-INFO

@@ -0,0 +1,48 @@
+Metadata-Version: 2.4
+Name: crossportability
+Version: 0.1.0
+Summary: Detect potential portability issues in Python projects.
+Author: Neel Patel
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/neelpatel-png/crossportability
+Project-URL: Repository, https://github.com/neelpatel-png/crossportability
+Project-URL: Issues, https://github.com/neelpatel-png/crossportability/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# CrossPortability
+A Python library for detecting potential operating-system and environment portability issues in Python projects.
+
+## Features
+- Detect Platform-Specific Imports
+- Detect OS-Specific Paths
+- Detect Platform Usage
+- Detect System Commands
+- Detect Platform-Specific Environment Variables
+- Analyze Individual Python Files
+- Recursively Analyze Python Projects
+- Generate Structured Detection Results
+- Generate Human-Readable Reports
+
+## Concepts Used
+- Abstract Syntax Tree (AST)
+- Static Code Analysis
+- pathlib
+- File Handling
+- Dictionaries
+- Lists
+- Functions
+- Exception Handling
+- Type Hints
+- Docstrings
+- Python Packages
+
+## Author
+- Patel Neel

crossportability-0.1.0/README.md

@@ -0,0 +1,29 @@
+# CrossPortability
+A Python library for detecting potential operating-system and environment portability issues in Python projects.
+
+## Features
+- Detect Platform-Specific Imports
+- Detect OS-Specific Paths
+- Detect Platform Usage
+- Detect System Commands
+- Detect Platform-Specific Environment Variables
+- Analyze Individual Python Files
+- Recursively Analyze Python Projects
+- Generate Structured Detection Results
+- Generate Human-Readable Reports
+
+## Concepts Used
+- Abstract Syntax Tree (AST)
+- Static Code Analysis
+- pathlib
+- File Handling
+- Dictionaries
+- Lists
+- Functions
+- Exception Handling
+- Type Hints
+- Docstrings
+- Python Packages
+
+## Author
+- Patel Neel

crossportability-0.1.0/crossportability/__init__.py

@@ -0,0 +1,4 @@
+from . import detect
+from . import report
+
+__version__ = "0.1.0"

crossportability-0.1.0/crossportability/detect.py

@@ -0,0 +1,233 @@
+from pathlib import Path
+import ast
+
+
+def _validate_path(path: str | Path) -> Path:
+    """
+    Validate that the supplied path exists.
+
+    Args:
+        path: A file or directory path.
+
+    Returns:
+        A Path object representing the supplied path.
+
+    Raises:
+        ValueError: If the path does not exist.
+    """
+    path = Path(path)
+    if not path.exists():
+        raise ValueError("Path does not exist")
+    return path
+
+
+def _get_python_files(path: str | Path) -> list[Path]:
+    """
+    Find Python files from a file or directory path.
+
+    Args:
+        path: A Python file or directory to scan.
+
+    Returns:
+        A list of Python file paths.
+
+    Raises:
+        ValueError: If the path is invalid or is not a Python file.
+    """
+    path = _validate_path(path)
+    if path.is_file():
+        if path.suffix == ".py":
+            return [path]
+        raise ValueError("File is not a Python file")
+    if path.is_dir():
+        return list(path.rglob("*.py"))
+    raise ValueError("Invalid path")
+
+
+def imports(path: str | Path) -> dict[str, list[tuple[str, str]]]:
+    """
+    Detect OS-specific Python imports.
+
+    Args:
+        path: A Python file or directory to scan.
+
+    Returns:
+        A dictionary mapping file paths to detected imports.
+
+    Raises:
+        ValueError: If the supplied path does not exist or is invalid.
+    """
+    files = _get_python_files(path)
+    results = {}
+    for file in files:
+        code = file.read_text()
+        tree = ast.parse(code)
+        findings = []
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Import):
+                for alias in node.names:
+                    module = alias.name
+                    if module in ["winsound", "winreg", "msvcrt"]:
+                        findings.append(("Windows", module))
+                    elif module in ["pwd", "grp", "termios", "fcntl"]:
+                        findings.append(("Unix", module))
+            elif isinstance(node, ast.ImportFrom):
+                module = node.module
+                if module in ["winsound", "winreg", "msvcrt"]:
+                    findings.append(("Windows", module))
+                elif module in ["pwd", "grp", "termios", "fcntl"]:
+                    findings.append(("Unix", module))
+        results[str(file)] = findings
+    return results
+
+
+def ospath(path: str | Path) -> dict[str, list[tuple[str, str]]]:
+    """
+    Detect hard-coded operating-system-specific paths.
+
+    Args:
+        path: A Python file or directory to scan.
+
+    Returns:
+        A dictionary mapping file paths to detected
+        Windows- or Unix-style paths.
+
+    Raises:
+        ValueError: If the supplied path does not exist or is invalid.
+    """
+    files = _get_python_files(path)
+    results = {}
+    for file in files:
+        code = file.read_text()
+        tree = ast.parse(code)
+        findings = []
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Constant):
+                if isinstance(node.value, str):
+                    if ":" in node.value and "\\" in node.value:
+                        findings.append(("Windows", node.value))
+                    elif node.value.startswith("/"):
+                        findings.append(("Unix", node.value))
+        results[str(file)] = findings
+    return results
+
+
+def platform_usage(path: str | Path) -> dict[str, list[str]]:
+    """
+    Detect platform-specific checks using os.name or sys.platform.
+
+    Args:
+        path: A Python file or directory to scan.
+
+    Returns:
+        A dictionary mapping file paths to detected platform checks.
+
+    Raises:
+        ValueError: If the supplied path does not exist or is invalid.
+    """
+    files = _get_python_files(path)
+    results = {}
+    for file in files:
+        code = file.read_text()
+        tree = ast.parse(code)
+        findings = []
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Attribute):
+                if isinstance(node.value, ast.Name):
+                    if node.value.id == "os" and node.attr == "name":
+                        findings.append("os.name")
+                    elif node.value.id == "sys" and node.attr == "platform":
+                        findings.append("sys.platform")
+        results[str(file)] = findings
+    return results
+
+
+def commands(path: str | Path) -> dict[str, list[str]]:
+    """
+    Detect potentially platform-dependent system commands.
+
+    Args:
+        path: A Python file or directory to scan.
+
+    Returns:
+        A dictionary mapping file paths to detected system commands.
+
+    Raises:
+        ValueError: If the supplied path does not exist or is invalid.
+    """
+    files = _get_python_files(path)
+    results = {}
+    for file in files:
+        code = file.read_text()
+        tree = ast.parse(code)
+        findings = []
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Call):
+                if isinstance(node.func, ast.Attribute):
+                    if isinstance(node.func.value, ast.Name):
+                        if node.func.value.id == "os" and node.func.attr == "system":
+                            findings.append("os.system")
+                        elif node.func.value.id == "subprocess" and node.func.attr == "run":
+                            findings.append("subprocess.run")
+        results[str(file)] = findings
+    return results
+
+
+def environment(path: str | Path) -> dict[str, list[tuple[str, str]]]:
+    """
+    Detect platform-specific environment variables.
+
+    Args:
+        path: A Python file or directory to scan.
+
+    Returns:
+        A dictionary mapping file paths to detected
+        Unix- or Windows-specific environment variables.
+
+    Raises:
+        ValueError: If the supplied path does not exist or is invalid.
+    """
+    files = _get_python_files(path)
+    results = {}
+    windows_variables = ["USERPROFILE", "APPDATA", "PROGRAMFILES"]
+    unix_variables = ["HOME", "PATH", "SHELL"]
+    for file in files:
+        code = file.read_text()
+        tree = ast.parse(code)
+        findings = []
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Subscript):
+                if isinstance(node.value, ast.Attribute):
+                    if isinstance(node.value.value, ast.Name):
+                        if node.value.value.id == "os" and node.value.attr == "environ":
+                            if isinstance(node.slice, ast.Constant):
+                                if isinstance(node.slice.value, str):
+                                    if node.slice.value in unix_variables:
+                                        findings.append(("Unix", node.slice.value))
+                                    elif node.slice.value in windows_variables:
+                                        findings.append(("Windows", node.slice.value))
+        results[str(file)] = findings
+    return results
+
+
+def scan(path: str | Path) -> dict:
+    """
+    Run all portability detection checks on a Python file or directory.
+
+    Args:
+        path: A Python file or directory to scan.
+
+    Returns:
+        A dictionary containing the results from all detection categories.
+
+    Raises:
+        ValueError: If the supplied path does not exist or is invalid.
+    """
+    return {
+        "os_paths": ospath(path),
+        "platform_usage": platform_usage(path),
+        "system_commands": commands(path),
+        "imports": imports(path),
+        "environment_variables": environment(path)
+    }
+        

crossportability-0.1.0/crossportability/report.py

@@ -0,0 +1,190 @@
+from . import detect
+
+
+def imports(path: str) -> str:
+    """
+    Generate a text report of platform-specific imports.
+
+    Args:
+        path: A Python file or directory to scan.
+
+    Returns:
+        A formatted string containing the detected imports.
+
+    Raises:
+        ValueError: If the path does not exist or is invalid.
+    """
+    results = detect.imports(path)
+    report = []
+    for file, findings in results.items():
+        report.append(f"FILE: {file}")
+        if findings:
+            for finding in findings:
+                report.append(f"  {finding[0]} → {finding[1]}")
+        else:
+            report.append("  No findings")
+        report.append("")
+    return "\n".join(report)
+
+
+def ospath(path: str) -> str:
+    """
+    Generate a report of operating-system-specific paths.
+
+    Args:
+        path: A Python file or directory to scan.
+
+    Returns:
+        A formatted string containing the detected OS-specific paths.
+
+    Raises:
+        ValueError: If the path does not exist or is invalid.
+    """
+    results = detect.ospath(path)
+    report = []
+    for file, findings in results.items():
+        report.append(f"FILE: {file}")
+        if findings:
+            for finding in findings:
+                report.append(f"  {finding[0]} → {finding[1]}")
+        else:
+            report.append("  No findings")
+        report.append("")
+    return "\n".join(report)
+
+
+def platform_usage(path: str) -> str:
+    """
+    Generate a report of platform-specific checks in Python code.
+
+    Args:
+        path: A Python file or directory to scan.
+
+    Returns:
+        A formatted string containing detected uses of os.name
+        and sys.platform.
+
+    Raises:
+        ValueError: If the path does not exist or is invalid.
+    """
+    results = detect.platform_usage(path)
+    report = []
+    for file, findings in results.items():
+        report.append(f"FILE: {file}")
+        if findings:
+            for finding in findings:
+                report.append(f"  {finding}")
+        else:
+            report.append("  No findings")
+        report.append("")
+    return "\n".join(report)
+
+
+def commands(path: str) -> str:
+    """
+    Generate a report of potentially platform-dependent system commands.
+
+    Args:
+        path: A Python file or directory to scan.
+
+    Returns:
+        A formatted string containing detected uses of os.system
+        and subprocess.run.
+
+    Raises:
+        ValueError: If the path does not exist or is invalid.
+    """
+    results = detect.commands(path)
+    report = []
+    for file, findings in results.items():
+        report.append(f"FILE: {file}")
+        if findings:
+            for finding in findings:
+                report.append(f"  {finding}")
+        else:
+            report.append("  No findings")
+        report.append("")
+    return "\n".join(report)
+
+
+def environment(path: str) -> str:
+    """
+    Generate a report of platform-specific environment variables.
+
+    Args:
+        path: A Python file or directory to scan.
+
+    Returns:
+        A formatted string containing the detected environment variables.
+
+    Raises:
+        ValueError: If the path does not exist or is invalid.
+    """
+    results = detect.environment(path)
+    report = []
+    for file, findings in results.items():
+        report.append(f"FILE: {file}")
+        if findings:
+            for finding in findings:
+                report.append(f"  {finding[0]} → {finding[1]}")
+        else:
+            report.append("  No findings")
+        report.append("")
+    return "\n".join(report)
+
+
+def scan(path: str) -> str:
+    """
+    Generate a complete portability report.
+
+    Args:
+        path: A Python file or directory to scan.
+
+    Returns:
+        A formatted string containing all portability detection results.
+
+    Raises:
+        ValueError: If the path does not exist or is invalid.
+    """
+    sections = []
+    sections.append("OS-SPECIFIC PATHS")
+    sections.append(ospath(path))
+    sections.append("PLATFORM DETECTION")
+    sections.append(platform_usage(path))
+    sections.append("SYSTEM COMMANDS")
+    sections.append(commands(path))
+    sections.append("PLATFORM-SPECIFIC IMPORTS")
+    sections.append(imports(path))
+    sections.append("ENVIRONMENT VARIABLES")
+    sections.append(environment(path))
+    return "\n\n".join(sections)
+
+
+def files(path: str) -> str:
+    """
+    Generate a formatted table of Python files found at the given path.
+
+    Args:
+        path: A Python file or directory to scan.
+
+    Returns:
+        A formatted string containing the discovered Python files.
+
+    Raises:
+        ValueError: If the path does not exist or is invalid.
+    """
+    results = detect._get_python_files(path)
+    if not results:
+        return "PYTHON FILES\n\nNo Python files found."
+    rows = []
+    rows.append("PYTHON FILES")
+    rows.append("-" * 60)
+    rows.append(f"{'#':<5} {'FILE'}")
+    rows.append("-" * 60)
+    for number, file in enumerate(results, start=1):
+        rows.append(f"{number:<5} {file}")
+    rows.append("-" * 60)
+    return "\n".join(rows)
+    
+
+    

crossportability-0.1.0/crossportability.egg-info/PKG-INFO

@@ -0,0 +1,48 @@
+Metadata-Version: 2.4
+Name: crossportability
+Version: 0.1.0
+Summary: Detect potential portability issues in Python projects.
+Author: Neel Patel
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/neelpatel-png/crossportability
+Project-URL: Repository, https://github.com/neelpatel-png/crossportability
+Project-URL: Issues, https://github.com/neelpatel-png/crossportability/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# CrossPortability
+A Python library for detecting potential operating-system and environment portability issues in Python projects.
+
+## Features
+- Detect Platform-Specific Imports
+- Detect OS-Specific Paths
+- Detect Platform Usage
+- Detect System Commands
+- Detect Platform-Specific Environment Variables
+- Analyze Individual Python Files
+- Recursively Analyze Python Projects
+- Generate Structured Detection Results
+- Generate Human-Readable Reports
+
+## Concepts Used
+- Abstract Syntax Tree (AST)
+- Static Code Analysis
+- pathlib
+- File Handling
+- Dictionaries
+- Lists
+- Functions
+- Exception Handling
+- Type Hints
+- Docstrings
+- Python Packages
+
+## Author
+- Patel Neel

crossportability-0.1.0/crossportability.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+LICENSE
+README.md
+pyproject.toml
+crossportability/__init__.py
+crossportability/detect.py
+crossportability/report.py
+crossportability.egg-info/PKG-INFO
+crossportability.egg-info/SOURCES.txt
+crossportability.egg-info/dependency_links.txt
+crossportability.egg-info/top_level.txt

crossportability-0.1.0/crossportability.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

crossportability-0.1.0/crossportability.egg-info/top_level.txt

@@ -0,0 +1 @@
+crossportability

crossportability-0.1.0/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools >= 77.0.3"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "crossportability"
+version = "0.1.0"
+description = "Detect potential portability issues in Python projects."
+readme = "README.md"
+license = "MIT"
+authors = [
+    { name = "Neel Patel" }
+]
+requires-python = ">=3.10"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Operating System :: OS Independent",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Software Development :: Testing",
+]
+
+[project.urls]
+Homepage = "https://github.com/neelpatel-png/crossportability"
+Repository = "https://github.com/neelpatel-png/crossportability"
+Issues = "https://github.com/neelpatel-png/crossportability/issues"

crossportability-0.1.0/setup.cfg

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