phasma 0.1.0__py3-none-win_amd64.whl

phasma/__init__.py

@@ -0,0 +1,3 @@
+from .phasma import download_driver, render_page, render_url, execjs
+
+__all__ = ["download_driver", "render_page", "render_url", "execjs"]

phasma/__main__.py

@@ -0,0 +1,107 @@
+"""
+Phasma - PhantomJS driver for Python.
+Command-line interface.
+"""
+import sys
+import os
+import argparse
+from pathlib import Path
+
+# Add src directory to sys.path to allow absolute imports
+
+from phasma.phasma import download_driver, render_page, render_url, execjs
+from phasma.driver import Driver
+
+def main():
+    parser = argparse.ArgumentParser(description="Phasma: PhantomJS driver for Python")
+    subparsers = parser.add_subparsers(dest="command", help="Command to execute")
+
+    # driver command
+    driver_parser = subparsers.add_parser("driver", help="Manage PhantomJS driver")
+    driver_subparsers = driver_parser.add_subparsers(dest="driver_action", help="Driver action")
+
+    # driver download
+    dl_parser = driver_subparsers.add_parser("download", help="Download PhantomJS driver")
+    dl_parser.add_argument("--os", help="Operating system (windows, linux, darwin)")
+    dl_parser.add_argument("--arch", help="Architecture (32bit, 64bit)")
+
+    # driver --version and --path as optional arguments of driver command itself
+    driver_parser.add_argument("--version", action="store_true", help="Show driver version")
+    driver_parser.add_argument("--path", action="store_true", help="Show driver executable path")
+
+    # render-page
+    rp_parser = subparsers.add_parser("render-page", help="Render an HTML page")
+    rp_parser.add_argument("input", help="HTML file path or HTML string")
+    rp_parser.add_argument("--output", "-o", help="Output file path")
+    rp_parser.add_argument("--viewport", default="1024x768", help="Viewport size (widthxheight)")
+    rp_parser.add_argument("--wait", type=int, default=100, help="Wait time in milliseconds")
+
+    # render-url
+    ru_parser = subparsers.add_parser("render-url", help="Render a URL")
+    ru_parser.add_argument("url", help="URL to render")
+    ru_parser.add_argument("--output", "-o", help="Output file path")
+    ru_parser.add_argument("--viewport", default="1024x768", help="Viewport size (widthxheight)")
+    ru_parser.add_argument("--wait", type=int, default=0, help="Wait time in milliseconds")
+
+    # execjs
+    js_parser = subparsers.add_parser("execjs", help="Execute JavaScript code")
+    js_parser.add_argument("script", help="JavaScript code (use '-' to read from stdin)")
+    js_parser.add_argument("--arg", action="append", help="Additional arguments to pass")
+
+    args = parser.parse_args()
+
+    if args.command == "driver":
+        if args.driver_action == "download":
+            success = download_driver(os_name=args.os, arch=args.arch)
+            if success:
+                print("Driver downloaded successfully.")
+                sys.exit(0)
+            else:
+                print("Driver download failed.")
+                sys.exit(1)
+        elif args.version:
+            driver = Driver()
+            version = driver.version
+            print(f"PhantomJS driver version: {version}")
+        elif args.path:
+            driver = Driver()
+            path = driver.bin_path
+            print(path)
+        else:
+            driver_parser.print_help()
+            sys.exit(1)
+
+    elif args.command == "render-page":
+        # Determine if input is a file
+        input_path = Path(args.input)
+        if input_path.is_file():
+            page = input_path
+        else:
+            page = args.input
+        rendered = render_page(page, output=args.output, viewport_size=args.viewport, wait_time=args.wait)
+        if not args.output:
+            print(rendered)
+        else:
+            print(f"Rendered content saved to {args.output}")
+
+    elif args.command == "render-url":
+        rendered = render_url(args.url, output=args.output, viewport_size=args.viewport, wait_time=args.wait)
+        if not args.output:
+            print(rendered)
+        else:
+            print(f"Rendered content saved to {args.output}")
+
+    elif args.command == "execjs":
+        if args.script == "-":
+            script = sys.stdin.read()
+        else:
+            script = args.script
+        output = execjs(script, args=args.arg)
+        print(output)
+
+    else:
+        parser.print_help()
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

phasma/driver/__init__.py

@@ -0,0 +1,4 @@
+from .driver import Driver
+
+__all__ = ["Driver"]
+

phasma/driver/download.py

@@ -0,0 +1,222 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import hashlib
+import logging
+import os, platform, sys
+import shutil
+import tarfile, zipfile
+from pathlib import Path
+import urllib.request
+
+logger = logging.getLogger(__name__)
+
+DRIVER_PATH = Path(__file__).parent
+
+BASE_URL = "https://github.com/MohammadRaziei/phasma/releases/download/drivers"
+
+DRIVER_VERSION = "2.1.1"
+
+FILES = {
+    ("windows", "64bit", "2.1.1"): (
+        "phantomjs-2.1.1-windows.zip",
+        "d9fb05623d6b26d3654d008eab3adafd1f6350433dfd16138c46161f42c7dcc8",
+    ),
+    ("darwin", "64bit", "2.1.1"): (
+        "phantomjs-2.1.1-macosx.zip",
+        "538cf488219ab27e309eafc629e2bcee9976990fe90b1ec334f541779150f8c1",
+    ),
+    ("linux", "64bit", "2.1.1"): (
+        "phantomjs-2.1.1-linux-x86_64.tar.bz2",
+        "86dd9a4bf4aee45f1a84c9f61cf1947c1d6dce9b9e8d2a907105da7852460d2f",
+    ),
+    ("linux", "32bit", "2.1.1"): (
+        "phantomjs-2.1.1-linux-i686.tar.bz2",
+        "80e03cfeb22cc4dfe4e73b68ab81c9fdd7c78968cfd5358e6af33960464f15e3",
+    ),
+}
+
+ARCHIVE_SUFFIXES = (
+    ".tar.bz2",
+    ".zip",
+)
+
+def sha256(path: Path) -> str:
+    h = hashlib.sha256()
+    with path.open("rb") as f:
+        for chunk in iter(lambda: f.read(8192), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def detect_target(os_name: str, arch: str, version: str):
+    key = (os_name, arch, version)
+    if key not in FILES:
+        raise RuntimeError(f"Unsupported platform/version: {key}")
+    return FILES[key]
+
+
+def download(url: str, dst: Path):
+    urllib.request.urlretrieve(url, dst)
+
+
+def extract(archive: Path, dst: Path):
+    logger.info(f"Extracting: {archive.name}")
+    if archive.suffix == ".zip":
+        with zipfile.ZipFile(archive) as z:
+            z.extractall(dst)
+    elif archive.suffixes[-2:] == [".tar", ".bz2"]:
+        with tarfile.open(archive) as t:
+            t.extractall(dst)
+    else:
+        raise RuntimeError("Unknown archive format")
+
+
+def find_binary(root: Path) -> Path:
+    for p in root.rglob("phantomjs*"):
+        if p.is_file() and os.access(p, os.X_OK):
+            return p
+    raise RuntimeError("phantomjs binary not found")
+
+
+def download_and_extract(
+    *,
+    url: str,
+    archive: Path,
+    checksum: str,
+    extract_dir: Path,
+    force: bool,
+):
+    if force and archive.exists():
+        archive.unlink()
+
+    dest = extract_dir / "phantomjs"
+
+    is_ok = (dest / "bin").exists()
+
+    if is_ok:
+        logger.info("Path exists: %s", dest)
+        if force:
+            os.remove(dest)
+        else:
+            return is_ok
+
+    logger.info("Downloading %s to %s", url, archive)
+    download(url, archive)
+
+    logger.info("Verifying checksum")
+    if sha256(archive) != checksum:
+        raise RuntimeError("Checksum mismatch")
+    
+
+    if dest.exists():
+        shutil.rmtree(dest)
+
+    logger.info("Extracting")
+    extract(archive, extract_dir)
+
+    name = os.path.basename(archive)
+    for suf in ARCHIVE_SUFFIXES:
+        if name.endswith(suf):
+            name = name[:-len(suf)]
+    extract_path = extract_dir / name 
+
+    os.rename(extract_path, dest)
+    os.remove(archive)
+
+    return (dest / "bin").exists()
+
+
+def download_driver(
+    dest: Path | None = None,
+    version: str = "2.1.1",
+    os_name: str | None = None,
+    arch: str | None = None,
+    force: bool = False,
+) -> bool:
+    if dest is None:
+        dest = DRIVER_PATH
+    if os_name is None:
+        os_name = platform.system().lower()
+    if arch is None:
+        arch = platform.architecture()[0]
+        if arch not in ("32bit", "64bit"):
+            machine = platform.machine().lower()
+            arch = "64bit" if "64" in machine else "32bit"
+
+    dest.mkdir(parents=True, exist_ok=True)
+
+    filename, checksum = detect_target(os_name, arch, version)
+    url = f"{BASE_URL}/{filename}"
+    archive = dest / filename
+
+    binary = download_and_extract(
+        url=url,
+        archive=archive,
+        checksum=checksum,
+        extract_dir=dest,
+        force=force,
+    )
+
+    return binary
+
+
+def setup_logging(quiet: bool = False):
+    """
+    Configure global logging settings.
+
+    :param quiet: If True, only warnings and errors are shown.
+    """
+    level = logging.WARNING if quiet else logging.INFO
+
+    logging.basicConfig(
+        level=level,
+        format="%(asctime)s | %(levelname)-8s | %(name)s | %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+        handlers=[
+            logging.StreamHandler(sys.stdout)
+        ],
+        force=True  # overwrite any existing logging config
+    )
+
+def main():
+    parser = argparse.ArgumentParser(description="Download PhantomJS driver")
+    parser.add_argument("--dest", default=DRIVER_PATH.as_posix())
+    parser.add_argument("--version", default=DRIVER_VERSION)
+    parser.add_argument("--os", default=None, help="Operating system (e.g., Linux, Windows, Darwin)")
+    parser.add_argument("--arch", default=None, help="Architecture (e.g., 32bit, 64bit)")
+    parser.add_argument("--force", action="store_true")
+    parser.add_argument("--quiet", action="store_true")
+
+    args = parser.parse_args()
+
+    setup_logging(quiet=args.quiet)
+
+
+    # Detect OS and arch if not provided
+    os_name = args.os or platform.system()
+    arch = args.arch or platform.architecture()[0]
+
+    # Normalize architecture string (some systems return '32bit' or '64bit' already)
+    if arch not in ("32bit", "64bit"):
+        # Fallback: try to guess from machine
+        machine = platform.machine().lower()
+        if "64" in machine:
+            arch = "64bit"
+        else:
+            arch = "32bit"
+
+    logger.info("Target: OS=%s, Arch=%s, Version=%s", os_name, arch, args.version)
+
+    download_driver(
+        dest=Path(args.dest),
+        version=args.version,
+        os_name=os_name,
+        arch=arch,
+        force=args.force,
+    )
+
+
+if __name__ == "__main__":
+    main()

phasma/driver/driver.py

@@ -0,0 +1,157 @@
+import os
+import platform
+import stat
+import subprocess
+import sys
+from pathlib import Path
+from typing import List, Optional, Sequence, Union
+
+# Handle relative import when script is run directly
+if __package__ is None:
+    # Add src directory to sys.path to allow absolute imports
+    sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+    from download import DRIVER_PATH, DRIVER_VERSION, download_driver
+else:
+    from .download import DRIVER_PATH, DRIVER_VERSION, download_driver
+
+PHASMA_PATH = DRIVER_PATH / "phantomjs"
+
+
+class Driver:
+    """
+    Manages the PhantomJS executable path in an OS-aware manner.
+    - Always expects the binary inside a `bin/` subdirectory.
+    - Uses `phantomjs.exe` on Windows and `phantomjs` on Unix-like systems.
+    - Ensures the binary is executable (applies chmod +x on non-Windows).
+    - Downloads the driver automatically if not present.
+    """
+
+    @staticmethod
+    def download(os_name: str | None = None, arch: str | None = None):
+        return download_driver(dest=DRIVER_PATH, os_name=os_name, arch=arch)
+
+    def __init__(self):
+        # Determine the correct executable name based on the OS
+        self.system = platform.system()
+        self.exe_name = "phantomjs.exe" if self.system == "Windows" else "phantomjs"
+
+        # Final expected path: <DRIVER_PATH>/bin/<phantomjs or phantomjs.exe>
+        self._bin_path = PHASMA_PATH / "bin" / self.exe_name
+
+        # If the binary doesn't exist, download and set it up
+        if not self._bin_path.is_file():
+            # Download the driver to the root directory first
+            self.download()
+
+        self.get_exe_access()
+
+    def get_exe_access(self):
+        # On non-Windows systems, ensure the file is executable
+        if self.system != "Windows":
+            if not os.access(self._bin_path, os.X_OK):
+                try:
+                    current_mode = self._bin_path.stat().st_mode
+                    self._bin_path.chmod(current_mode | stat.S_IEXEC)
+                except OSError:
+                    # Ignore if permission cannot be changed (e.g., read-only FS)
+                    pass
+
+    @property
+    def bin_path(self) -> Path:
+        """Returns the absolute path to the PhantomJS executable."""
+        return self._bin_path
+
+    @property
+    def examples_path(self) -> Path:
+        return PHASMA_PATH / "examples"
+
+    @property
+    def examples_list(self) -> List:
+        return list(self.examples_path.iterdir())
+
+    @property
+    def version(self) -> str:
+        return DRIVER_VERSION
+
+    def exec(
+        self,
+        args: Union[str, Sequence[str]],
+        *,
+        capture_output: bool = False,
+        timeout: Optional[float] = None,
+        check: bool = False,
+        **kwargs,
+    ) -> subprocess.CompletedProcess:
+        """
+        Execute PhantomJS with the given arguments.
+
+        Args:
+            args: Command line arguments as a string or sequence of strings.
+            capture_output: If True, capture stdout and stderr.
+            timeout: Timeout in seconds.
+            check: If True, raise CalledProcessError on non-zero exit code.
+            **kwargs: Additional arguments passed to subprocess.run.
+
+        Returns:
+            subprocess.CompletedProcess instance.
+
+        Example:
+            >>> driver = Driver()
+            >>> result = driver.exec(["--version"])
+            >>> print(result.stdout)
+        """
+        if isinstance(args, str):
+            # Split by spaces (simple split, no quoted string handling)
+            args = args.split()
+
+        cmd = [str(self.bin_path), *list(args)]
+        return subprocess.run(
+            cmd,
+            capture_output=capture_output,
+            timeout=timeout,
+            check=check,
+            **kwargs,
+        )
+
+    def run(self, *args, **kwargs) -> subprocess.CompletedProcess:
+        """Alias for exec."""
+        return self.exec(*args, **kwargs)
+
+
+if __name__ == "__main__":
+    import argparse
+    import os
+    import sys
+
+    # Add src directory to sys.path to allow relative imports
+    sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+
+    parser = argparse.ArgumentParser(
+        description="Run PhantomJS via Driver", epilog="Example: python -m phasma.driver.driver --version"
+    )
+    parser.add_argument("args", nargs="*", help="Arguments to pass to PhantomJS (e.g., '--version', 'script.js')")
+    parser.add_argument("--capture-output", action="store_true", help="Capture stdout and stderr")
+    parser.add_argument("--timeout", type=float, help="Timeout in seconds")
+    parser.add_argument("--check", action="store_true", help="Raise CalledProcessError on non-zero exit code")
+    parsed, unknown = parser.parse_known_args()
+
+    driver = Driver()
+    try:
+        # Combine known positional args with unknown args (which are likely PhantomJS options)
+        all_args = parsed.args + unknown
+        result = driver.exec(
+            all_args,
+            capture_output=parsed.capture_output,
+            timeout=parsed.timeout,
+            check=parsed.check,
+        )
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    if parsed.capture_output:
+        if result.stdout:
+            sys.stdout.buffer.write(result.stdout)
+        if result.stderr:
+            sys.stderr.buffer.write(result.stderr)
+    sys.exit(result.returncode)