anpyra 0.1.0__py3-none-any.whl

anpyra/__init__.py

@@ -0,0 +1,22 @@
+"""Anpyra: Python source to native Android bytecode."""
+
+from .api import Activity, TextView
+from .build import BuildResult, build_apk, build_project
+from .common.compiler.frontend import CompileError, compile_file, compile_source
+from .config import AppConfig, ConfigError, Project, load_project
+
+__version__ = "0.1.0"
+__all__ = [
+    "Activity",
+    "TextView",
+    "AppConfig",
+    "Project",
+    "ConfigError",
+    "CompileError",
+    "BuildResult",
+    "load_project",
+    "build_project",
+    "build_apk",
+    "compile_source",
+    "compile_file",
+]

anpyra/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

anpyra/android/__init__.py

@@ -0,0 +1 @@
+"""Historical Android imports; implementation lives in platforms.mobile.android."""

anpyra/android/manifest.py

@@ -0,0 +1,14 @@
+"""Compatibility import path; implementation lives in anpyra.platforms.mobile.android.manifest."""
+
+from importlib import import_module as _import_module
+
+_implementation = _import_module("anpyra.platforms.mobile.android.manifest")
+__all__ = [name for name in dir(_implementation) if not name.startswith("_")]
+
+
+def __getattr__(name):
+    return getattr(_implementation, name)
+
+
+def __dir__():
+    return sorted(set(globals()) | set(dir(_implementation)))

anpyra/android/manifest_inspect.py

@@ -0,0 +1,14 @@
+"""Compatibility import path; implementation lives in anpyra.platforms.mobile.android.manifest_inspect."""
+
+from importlib import import_module as _import_module
+
+_implementation = _import_module("anpyra.platforms.mobile.android.manifest_inspect")
+__all__ = [name for name in dir(_implementation) if not name.startswith("_")]
+
+
+def __getattr__(name):
+    return getattr(_implementation, name)
+
+
+def __dir__():
+    return sorted(set(globals()) | set(dir(_implementation)))

anpyra/android/signing.py

@@ -0,0 +1,14 @@
+"""Compatibility import path; implementation lives in anpyra.platforms.mobile.android.signing."""
+
+from importlib import import_module as _import_module
+
+_implementation = _import_module("anpyra.platforms.mobile.android.signing")
+__all__ = [name for name in dir(_implementation) if not name.startswith("_")]
+
+
+def __getattr__(name):
+    return getattr(_implementation, name)
+
+
+def __dir__():
+    return sorted(set(globals()) | set(dir(_implementation)))

anpyra/android/verify.py

@@ -0,0 +1,14 @@
+"""Compatibility import path; implementation lives in anpyra.platforms.mobile.android.verify."""
+
+from importlib import import_module as _import_module
+
+_implementation = _import_module("anpyra.platforms.mobile.android.verify")
+__all__ = [name for name in dir(_implementation) if not name.startswith("_")]
+
+
+def __getattr__(name):
+    return getattr(_implementation, name)
+
+
+def __dir__():
+    return sorted(set(globals()) | set(dir(_implementation)))

anpyra/api.py

@@ -0,0 +1,5 @@
+"""Public authoring API, currently supplied by the Android backend."""
+
+from .platforms.mobile.android.api import Activity, TextView
+
+__all__ = ["Activity", "TextView"]

anpyra/build.py

@@ -0,0 +1,16 @@
+"""Public build entry points and native target dispatch."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from .common.project import Project
+from .platforms.mobile.android.build import BuildResult, _zip_payload, build_apk
+from .platforms.registry import get_backend
+
+__all__ = ["BuildResult", "build_apk", "build_project", "_zip_payload"]
+
+
+def build_project(project: str | Path | Project = ".", *, target: str = "android") -> BuildResult:
+    """Build using an implemented native backend; Android remains the default."""
+    return get_backend(target).build_project(project)

anpyra/cli.py

@@ -0,0 +1,124 @@
+"""The anpyra command and python -m anpyra share this entry point."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import shutil
+import subprocess
+import sys
+from dataclasses import asdict
+from importlib.metadata import version
+from pathlib import Path
+
+from . import __version__
+from .build import build_project
+from .platforms.mobile.android.verify import inspect_apk
+from .platforms.registry import get_backend, list_targets
+from .scaffold import init_project
+
+
+def _dump(dex, ir, args):
+    if args.dump_ir:
+        print(ir.pretty())
+    if args.dump_dalvik:
+        for method in dex.methods:
+            print(f"\n{method.name} ({method.code_units} code units)")
+            print("\n".join("  " + line for line in method.assembly))
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="anpyra", description="Native Python app toolchain; Android builds available today."
+    )
+    parser.add_argument("--version", action="version", version=f"Anpyra {__version__}")
+    commands = parser.add_subparsers(dest="command", required=True)
+    init = commands.add_parser("init", help="create an application project")
+    init.add_argument("directory", type=Path)
+    init.add_argument("--package", default="dev.anpyra.app")
+    init.add_argument("--label", default="Anpyra")
+    for name, help_text in (
+        ("build", "build and verify a signed APK"),
+        ("check", "validate source and DEX generation without writing artifacts"),
+    ):
+        command = commands.add_parser(name, help=help_text)
+        command.add_argument("project", type=Path, nargs="?", default=Path("."))
+        command.add_argument("--dump-ir", action="store_true")
+        command.add_argument("--dump-dalvik", action="store_true")
+        command.add_argument("--target", default="android", help="native target (default: android)")
+    commands.add_parser("targets", help="list implemented and planned native targets")
+    verify = commands.add_parser(
+        "verify",
+        help="verify an Anpyra APK's signature, content digest and DEX checksums",
+    )
+    verify.add_argument("apk", type=Path)
+    verify.add_argument("--json", action="store_true")
+    commands.add_parser("doctor", help="show host prerequisites and optional adb availability")
+    install = commands.add_parser("install", help="verify and install an APK using optional adb")
+    install.add_argument("apk", type=Path)
+    install.add_argument("--serial", help="select the adb device")
+    install.add_argument("--launch", action="store_true")
+    args = parser.parse_args(argv)
+    try:
+        if args.command == "init":
+            project = init_project(args.directory, package=args.package, label=args.label)
+            print(f"Created {project.root}")
+            print(f'anpyra build "{project.root}"')
+        elif args.command in {"build", "check"}:
+            backend = get_backend(args.target)
+            project = backend.load_project(args.project)
+            if args.command == "build":
+                result = build_project(project, target=args.target)
+                print(f"Built {result.apk_path} ({result.apk_size} bytes)")
+                print("Verified APK v2 signature, content digest, DEX SHA-1 and Adler-32.")
+                print(f"Build report: {result.report_path}")
+                _dump(result.dex_build, result.compile_result.ir, args)
+            else:
+                compiled, dex = backend.check_project(project)
+                print(f"Valid: {project.source_path}; {len(dex.methods)} method listings")
+                _dump(dex, compiled.ir, args)
+        elif args.command == "targets":
+            for target in list_targets():
+                status = "available" if target.implemented else "planned (not implemented)"
+                print(f"{target.name:8} {target.family:7} {status}")
+        elif args.command == "verify":
+            report = inspect_apk(args.apk)
+            if args.json:
+                print(json.dumps(asdict(report), indent=2))
+            else:
+                print(f"Verified {args.apk}: {report.package} / {report.activity}")
+        elif args.command == "doctor":
+            print(f"Anpyra: {__version__}")
+            print(f"Python: {sys.version.split()[0]} ({sys.executable})")
+            print(f"cryptography: {version('cryptography')}")
+            print("Build prerequisites: OK")
+            print(f"adb (optional for install): {shutil.which('adb') or 'not found'}")
+        elif args.command == "install":
+            report = inspect_apk(args.apk)
+            adb = shutil.which("adb")
+            if adb is None:
+                raise ValueError(
+                    "adb was not found on PATH; install Android platform-tools to use this command"
+                )
+            command = [adb] + (["-s", args.serial] if args.serial else [])
+            subprocess.run(command + ["install", "-r", str(args.apk.resolve())], check=True)
+            if args.launch:
+                subprocess.run(
+                    command
+                    + [
+                        "shell",
+                        "am",
+                        "start",
+                        "-W",
+                        "-n",
+                        f"{report.package}/{report.activity}",
+                    ],
+                    check=True,
+                )
+        return 0
+    except KeyboardInterrupt:
+        print("Interrupted.", file=sys.stderr)
+        return 130
+    except Exception as exc:
+        print(f"anpyra: {exc}", file=sys.stderr)
+        return 1

anpyra/common/README.md

@@ -0,0 +1,17 @@
+# 🧩 Common Framework Code
+
+Reusable source and project rules live here. Dependencies flow from platform backends toward common code.
+
+| File | Responsibility |
+| --- | --- |
+| `config.py` | Application ID, label and version validation; shared `ConfigError` |
+| `project.py` | Project settings protocol and source/output/state path validation |
+| `compiler/frontend.py` | Static Python AST validation, types and lowering |
+| `compiler/ir.py` | Immutable operation, function and application records |
+| Package `__init__.py` files | Package markers; no target registration |
+
+Common code must not import platform implementations or public Android facades. SDK values, DEX, binary XML, APK packaging and signing belong to Android's backend.
+
+The current front end and IR still describe Activity/TextView apps and carry Android lifecycle/descriptor/register assumptions. Future native backends require deliberate generalization; these folders do not imply cross-platform source compatibility today.
+
+Read the [native architecture guide](../../../docs/developer_guide/native_platforms.md) and [source reference](../../../docs/developer_guide/source_reference.md).

anpyra/common/__init__.py

@@ -0,0 +1 @@
+"""Shared application metadata, project paths and compiler analysis."""

anpyra/common/compiler/__init__.py

@@ -0,0 +1 @@
+"""Shared Python source analysis and intermediate representation."""