pysfi 0.1.7__py3-none-any.whl

sfi/makepython/makepython.py

@@ -0,0 +1,326 @@
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import os
+import shutil
+import subprocess
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Callable
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    import tomli as tomllib  # type: ignore
+
+
+is_windows = sys.platform == "win32"
+is_linux = sys.platform == "linux"
+is_macos = sys.platform == "darwin"
+
+logging.basicConfig(level=logging.INFO, format="%(message)s")
+logger = logging.getLogger(__name__)
+cwd = Path.cwd()
+
+_BUILD_COMMANDS = ["uv", "poetry", "hatch"]
+
+
+def parse_pyproject_toml(directory: Path) -> dict:
+    """Parse pyproject.toml file in directory and return project data."""
+    project_toml = directory / "pyproject.toml"
+    if not project_toml.is_file():
+        logger.error(f"No pyproject.toml found in {directory}")
+        return {}
+
+    with project_toml.open("rb") as f:
+        return tomllib.load(f)
+
+
+def _get_build_command_from_toml(directory: Path) -> str | None:
+    """Get build command from pyproject.toml."""
+    logger.debug(f"Parsing pyproject.toml in {directory}")
+
+    project_data = parse_pyproject_toml(directory)
+    if not project_data:
+        return None
+
+    if "build-system" in project_data:
+        build_system = project_data["build-system"]
+        if "build-backend" in build_system:
+            build_backend = build_system["build-backend"]
+            if build_backend.startswith("poetry."):
+                return "poetry"
+            elif build_backend.startswith("hatchling."):
+                return "hatch"
+            else:
+                logger.error(f"Unknown build-backend: {build_backend}")
+                return None
+
+    logger.error("No `build-system` or `build-backend` found in pyproject.toml: ")
+    logger.error(json.dumps(project_data, indent=2, ensure_ascii=False, sort_keys=True))
+    return None
+
+
+def _get_build_command(directory: Path):
+    """Get build command from directory."""
+    project_path = directory / "pyproject.toml"
+    if project_path.is_file():
+        logger.debug(f"Found pyproject.toml in {directory}")
+        return _get_build_command_from_toml(directory)
+
+    for command in _BUILD_COMMANDS:
+        if shutil.which(command):
+            logger.debug(f"Found build command: {command}")
+            return command
+    logger.error(f"No build command found in {directory}")
+    sys.exit(1)
+    return None
+
+
+@dataclass
+class Command:
+    name: str
+    alias: str
+    cmds: list[str] | Callable[..., Any] | None = None
+
+
+def _clean(root_dir: Path):
+    _run_command(["rm", "-rf", "dist", "build", "*.egg-info"], root_dir)
+
+
+BUILD_COMMAND = _get_build_command(cwd) or ""
+_COMMANDS = [
+    Command(name="build", alias="b", cmds=[BUILD_COMMAND, "build"]),
+    Command(name="bumpversion", alias="bump", cmds=["bumpversion", "patch"]),
+    Command(name="clean", alias="c", cmds=_clean),
+    Command(name="publish", alias="p"),  # No preset commands
+    Command(name="test", alias="t", cmds=lambda: os.system("pytest")),
+    Command(name="test-benchmark", alias="tb", cmds=lambda: os.system("pytest -m benchmark")),
+    Command(name="test-coverage", alias="tc", cmds=lambda: os.system("pytest --cov=sfi")),
+    Command(name="token", alias="tk", cmds=lambda: _set_token(BUILD_COMMAND)),
+]
+_COMMAND_DICT = {command.name: command for command in _COMMANDS}
+_COMMAND_DICT.update({command.alias: command for command in _COMMANDS})
+_CHOICES = [command.alias for command in _COMMANDS]
+_CHOICES.extend([command.name for command in _COMMANDS])
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Make Python")
+    parser.add_argument("command", type=str, choices=_CHOICES, help=f"Command to run, options: {_CHOICES}")
+    parser.add_argument("--debug", "-d", action="store_true", help="Enable debug mode")
+
+    args = parser.parse_args()
+    if args.debug:
+        logger.setLevel(logging.DEBUG)
+
+    build_command = _get_build_command(cwd) or ""
+    logger.info(f"Using build command: {build_command}")
+    command = _COMMAND_DICT.get(args.command)
+    if command:
+        if callable(command.cmds):
+            command.cmds()
+        elif isinstance(command.cmds, list):
+            _run_command(command.cmds, cwd)
+        else:
+            logger.debug("No preset commands found")
+    else:
+        logger.error(f"Unknown command: {args.command}")
+        sys.exit(1)
+
+    if args.command in {"publish", "p"}:
+        if not _check_pypi_token(build_command):
+            _set_token(build_command)
+        _run_command([build_command, "publish"], cwd)
+
+
+def _set_token(build_command: str, show_header: bool = True) -> None:
+    """Set PyPI token for the specified build command."""
+    if show_header:
+        logger.info(f"Setting PyPI token for {build_command}...")
+
+    if build_command.lower() not in _BUILD_COMMANDS:
+        logger.error(f"Unknown build command: {build_command}")
+        logger.error(f"Please use `{'/'.join(_BUILD_COMMANDS)}`")
+        sys.exit(1)
+
+    token = input("Enter your PyPI token (leave empty to cancel): ").strip()
+    if not token:
+        logger.info("Invalid token, cancelled.")
+        return
+
+    if build_command == "uv":
+        _set_uv_token(token)
+    elif build_command == "poetry":
+        _set_poetry_token(token)
+    elif build_command == "hatch":
+        _set_hatch_token(token)
+    else:
+        logger.error(f"Unknown build command: {build_command}")
+        sys.exit(1)
+
+
+def _set_uv_token(token: str) -> None:
+    """Set PyPI token for uv."""
+    _write_to_env_file("UV_PUBLISH_TOKEN", token)
+
+    # Write to `uv.toml`
+    config_path = Path.home() / ".config" / "uv" / "uv.toml"
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+    content = f"""[publish]
+token = "{token}"
+"""
+    config_path.write_text(content)
+    logger.info(f"Token saved to {config_path}")
+
+
+def _set_poetry_token(token: str) -> None:
+    """Set PyPI token for poetry."""
+    _write_to_env_file("POETRY_PYPI_TOKEN_PYPI", token)
+    _run_command(["poetry", "config", "pypi-token.pypi", token], cwd)
+    logger.info("Token saved to Poetry configuration.")
+
+
+def _set_hatch_token(token: str) -> None:
+    """Set PyPI token for hatch."""
+    pypirc_path = Path.home() / ".pypirc"
+    pypirc_content = f"""[pypi]
+repository = https://upload.pypi.org/legacy/
+username = __token__
+password = {token}
+"""
+    pypirc_path.write_text(pypirc_content)
+    logger.info(f"Token saved to {pypirc_path}")
+
+
+def _check_pypi_token(build_command: str) -> bool:
+    """Check if PyPI token is configured before publishing."""
+    logger.info("Checking PyPI token configuration...")
+
+    token_found = False
+    if build_command == "uv":
+        # Check for uv publish token
+        token_env_vars = ["UV_PUBLISH_TOKEN", "PYPI_API_TOKEN"]
+        for var in token_env_vars:
+            if os.getenv(var):
+                logger.info(f"Found PyPI token in environment variable: {var}")
+                token_found = True
+                break
+
+        # Check for config file
+        config_path = Path.home() / ".config" / "uv" / "uv.toml"
+        if config_path.exists():
+            logger.info(f"Found uv config file: {config_path}")
+            token_found = True
+
+    elif build_command == "poetry":
+        # Check for poetry token
+        if os.getenv("POETRY_PYPI_TOKEN_PYPI"):
+            logger.info("Found PyPI token in POETRY_PYPI_TOKEN_PYPI environment variable")
+            token_found = True
+
+        # Check for poetry config
+        result = subprocess.run(
+            ["poetry", "config", "pypi-token.pypi"],
+            capture_output=True,
+            text=True,
+        )
+        if result.stdout.strip() and result.stdout.strip() != "None":
+            logger.info("Found PyPI token in Poetry configuration")
+            token_found = True
+
+    elif build_command == "hatch":
+        # Check for .pypirc
+        pypirc_path = Path.home() / ".pypirc"
+        if pypirc_path.exists():
+            logger.info(f"Found .pypirc file: {pypirc_path}")
+            token_found = True
+
+    return token_found
+
+
+def _run_command(cmd: list[str], directory: Path) -> None:
+    """Run a command in the specified directory."""
+    logger.debug(f"Running command: {' '.join(cmd)}")
+    try:
+        result = subprocess.run(cmd, cwd=directory, capture_output=True, text=True)
+    except subprocess.CalledProcessError as e:
+        logger.error(f"Command failed with exit code {e.returncode}")
+        sys.exit(e.returncode)
+
+    if result.stdout:
+        print(result.stdout)
+    if result.stderr:
+        print(result.stderr, file=sys.stderr)
+
+
+def _write_to_env_file(key: str, value: str) -> None:
+    """Write key-value pair to environment file."""
+    if is_windows:
+        subprocess.run(["setx", key, value], shell=True)
+    else:
+        _write_to_shell_config(f"export {key}='{value}'")
+
+
+def _get_shell_config_path() -> Path:
+    """Get the appropriate shell config file based on the current shell."""
+    # Try to detect the shell
+    shell = os.getenv("SHELL", "")
+    if "zsh" in shell:
+        return Path.home() / ".zshrc"
+    else:
+        # Default to .bashrc
+        return Path.home() / ".bashrc"
+
+
+def _write_to_shell_config(content: str) -> None:
+    """Write content to ~/.bashrc, replacing existing entries if they exist.
+
+    Deprecated: Use _write_to_shell_config instead.
+    """
+    config_path = _get_shell_config_path()
+    if not config_path.exists():
+        logger.warning(f"{config_path} does not exist, creating it...")
+        config_path.touch()
+
+    # Extract the variable name from the export statement
+    # Expected format: export VARIABLE_NAME=value
+    var_name = None
+    for line in content.strip().split("\n"):
+        if line.startswith("export ") and "=" in line:
+            var_name = line.split("=")[0].replace("export ", "").strip()
+            break
+
+    if not var_name:
+        logger.error("Invalid export statement format. Expected: export VARIABLE_NAME=value")
+        return
+
+    # Read existing content
+    existing_lines = config_path.read_text(encoding="utf-8").split("\n")
+
+    # Find and remove existing export statements for this variable
+    new_lines = []
+    found_existing = False
+    for line in existing_lines:
+        # Check if this line exports the same variable
+        if line.strip().startswith(f"export {var_name}=") or line.strip().startswith(f"export {var_name} ="):
+            found_existing = True
+            continue
+        new_lines.append(line)
+
+    if found_existing:
+        logger.info(f"Found existing export statement for {var_name}, replacing it...")
+
+    # Add new content
+    new_lines.append(content.strip())
+
+    # Write back to file
+    config_path.write_text("\n".join(new_lines), encoding="utf-8")
+
+    logger.info(f"Content written to {config_path}")
+    logger.info(f"Run `source {config_path}` to apply the changes")
+    logger.info(f"Run `cat {config_path}` to view the content")
+    logger.info(f"Run `cat {config_path} | grep 'export'` to view the exported variables")

sfi/pdfsplit/pdfsplit.py

@@ -0,0 +1,173 @@
+from __future__ import annotations
+
+import argparse
+import logging
+from pathlib import Path
+
+import fitz
+
+logging.basicConfig(level=logging.INFO, format="%(message)s")
+cwd = Path.cwd()
+logger = logging.getLogger(__name__)
+
+
+def parse_page_ranges(range_str: str, total_pages: int) -> list[int]:
+    """Parse page range string and return list of page numbers (1-indexed)."""
+    pages = []
+    for part in range_str.split(","):
+        part = part.strip()
+        if not part:
+            continue
+        if "-" in part:
+            start, end = part.split("-")
+            start = int(start) if start else 1
+            end = int(end) if end else total_pages
+            pages.extend(range(start, end + 1))
+        else:
+            pages.append(int(part))
+    return pages
+
+
+def split_by_number(input_file: Path, output_file: Path, number: int):
+    """Split PDF into specified number of parts evenly."""
+    doc = fitz.open(input_file)
+    total_pages = doc.page_count
+    base_pages = total_pages // number
+    remainder = total_pages % number
+
+    logger.debug(
+        f"Total pages: {total_pages}, Splitting into {number} parts, {base_pages} base pages per part, {remainder} extra pages"
+    )
+
+    current_page = 0
+    for i in range(number):
+        # First 'remainder' parts get one extra page
+        pages_in_this_part = base_pages + (1 if i < remainder else 0)
+
+        if current_page >= total_pages:
+            logger.debug(f"Skipping part {i + 1}: no more pages remaining")
+            continue
+
+        end_page = min(current_page + pages_in_this_part, total_pages)
+
+        part_file = output_file.parent / f"{output_file.stem}_part{i + 1}{output_file.suffix}"
+        part_doc = fitz.open()
+
+        for page_num in range(current_page, end_page):
+            part_doc.insert_pdf(doc, from_page=page_num, to_page=page_num)
+
+        part_doc.save(part_file)
+        part_doc.close()
+        logger.info(f"Created part {i + 1}: {part_file} (pages {current_page + 1}-{end_page})")
+
+        current_page = end_page
+
+    doc.close()
+
+
+def split_by_size(input_file: Path, output_file: Path, size: int):
+    """Split PDF into parts with specified page size."""
+    doc = fitz.open(input_file)
+    total_pages = doc.page_count
+
+    logger.debug(f"Total pages: {total_pages}, Splitting with {size} pages per part")
+
+    part = 0
+    start_page = 0
+
+    while start_page < total_pages:
+        end_page = min(start_page + size, total_pages)
+        part_file = output_file.parent / f"{output_file.stem}_part{part + 1}{output_file.suffix}"
+        part_doc = fitz.open()
+
+        for page_num in range(start_page, end_page):
+            part_doc.insert_pdf(doc, from_page=page_num, to_page=page_num)
+
+        part_doc.save(part_file)
+        part_doc.close()
+        logger.info(f"Created part {part + 1}: {part_file} (pages {start_page + 1}-{end_page})")
+
+        start_page = end_page
+        part += 1
+
+    doc.close()
+
+
+def split_by_range(input_file: Path, output_file: Path, range_str: str):
+    """Extract specific pages from PDF based on range string."""
+    doc = fitz.open(input_file)
+    total_pages = doc.page_count
+
+    pages = parse_page_ranges(range_str, total_pages)
+    pages = [p - 1 for p in pages if 1 <= p <= total_pages]  # Convert to 0-indexed
+
+    if not pages:
+        logger.error("No valid pages found in the specified range")
+        doc.close()
+        return
+
+    # Remove duplicates while preserving order
+    pages = sorted(set(pages))
+
+    logger.debug(f"Extracting pages: {[p + 1 for p in pages]}")
+
+    new_doc = fitz.open()
+    for page_num in pages:
+        new_doc.insert_pdf(doc, from_page=page_num, to_page=page_num)
+
+    new_doc.save(output_file)
+    new_doc.close()
+    doc.close()
+    logger.info(f"Created output file: {output_file} ({len(pages)} pages)")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Split PDF files")
+    parser.add_argument("input", help="Input PDF file")
+    parser.add_argument("output", nargs="?", help="Output PDF file (optional for -n and -s modes)")
+    parser.add_argument("-o", "--output-dir", default=str(cwd), help="Output directory (default: current directory)")
+    parser.add_argument("-f", "--output-format", help="Output file format pattern, e.g., 'split_{part:02d}.pdf'")
+    parser.add_argument("-v", "--verbose", action="store_true", help="Verbose output")
+
+    # Split by number, size, or range
+    group = parser.add_mutually_exclusive_group(required=True)
+    group.add_argument("-n", "--number", type=int, help="Number of splits")
+    group.add_argument("-s", "--size", type=int, default=1, help="Size of each split in pages")
+    group.add_argument("-r", "--range", type=str, help="Range of pages to extract, e.g., '1,2,4-10,15-20,25-'")
+
+    args = parser.parse_args()
+
+    if args.verbose:
+        logger.setLevel(logging.DEBUG)
+
+    output_dir = Path(args.output_dir)
+    if not output_dir.is_dir():
+        logger.error(f"Output directory {args.output_dir} does not exist, please check the path.")
+        return
+
+    input_file = Path(args.input)
+    if not input_file.is_file():
+        logger.error(f"Input file {args.input} does not exist, please check the path.")
+        return
+
+    # For -n and -s modes, output is optional and defaults to base name with suffix
+    # For -r mode, output is required
+    if args.range and not args.output:
+        logger.error("Output file is required for -r/--range mode")
+        return
+
+    if not args.range:
+        output_file = output_dir / (input_file.stem + "_split.pdf") if not args.output else Path(args.output)
+    else:
+        output_file = Path(args.output)
+
+    logger.info(f"Start splitting {input_file}")
+    if args.number:
+        split_by_number(input_file, output_file, args.number)
+    elif args.size:
+        split_by_size(input_file, output_file, args.size)
+    elif args.range:
+        split_by_range(input_file, output_file, args.range)
+    else:
+        logger.error("Please specify either -n, -s, or -r")
+        return

sfi/projectparse/projectparse.py

@@ -0,0 +1,152 @@
+"""Parse pyproject.toml files in directory, supports multiple projects."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import sys
+import time
+from pathlib import Path
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    import tomli as tomllib  # type: ignore
+
+__all__ = ["parse_project_data"]
+
+
+logging.basicConfig(level=logging.INFO, format="%(message)s")
+logger = logging.getLogger(__name__)
+cwd = Path.cwd()
+
+
+def parse_project_data(directory: Path, recursive: bool = False) -> dict:
+    """Parse pyproject.toml file in directory and return project data.
+
+    Returns:
+        dict: Project data.
+    """
+    data = _parse_pyproject(directory, recursive=recursive)
+    if not data:
+        return {}
+    return _extract_project_info(data)
+
+
+def _parse_pyproject(directory: Path, recursive: bool = False) -> dict[str, dict]:
+    """Parse pyproject.toml file in directory and return raw data."""
+    data = {}
+    if recursive:
+        for pyproject_path in directory.rglob("pyproject.toml"):
+            with pyproject_path.open("rb") as f:
+                data[pyproject_path.parent.stem] = tomllib.load(f)
+    else:
+        pyproject_path = directory / "pyproject.toml"
+        if not pyproject_path.is_file():
+            logger.error(f"No pyproject.toml found in {directory}")
+            return {}
+
+        with pyproject_path.open("rb") as f:
+            logger.debug(f"Parsing {pyproject_path}")
+            data[pyproject_path.parent.stem] = tomllib.load(f)
+
+    logger.debug(f"Parsed {len(data)} pyproject.toml files, data: {data}")
+    return data
+
+
+def _extract_project_info(data: dict) -> dict:
+    """Extract commonly used project information from parsed data."""
+    if not data:
+        logger.error("No data to extract")
+        return {}
+
+    project_info = {}
+    for key, value in data.items():
+        if "project" in value:
+            project = value.get("project", {})
+            build_system = value.get("build-system", {})
+            project_info.setdefault(
+                key,
+                {
+                    "name": project.get("name"),
+                    "version": project.get("version"),
+                    "description": project.get("description"),
+                    "readme": project.get("readme"),
+                    "requires_python": project.get("requires-python"),
+                    "dependencies": project.get("dependencies", []),
+                    "optional_dependencies": project.get("optional-dependencies", {}),
+                    "scripts": project.get("scripts", {}),
+                    "entry_points": project.get("entry-points", {}),
+                    "authors": project.get("authors", []),
+                    "license": project.get("license"),
+                    "keywords": project.get("keywords", []),
+                    "classifiers": project.get("classifiers", []),
+                    "urls": project.get("urls", {}),
+                    "build_backend": build_system.get("build-backend"),
+                    "requires": build_system.get("requires", []),
+                },
+            )
+        else:
+            logger.warning(f"No project information found in {key}")
+            project_info.setdefault(key, {})
+
+    logger.debug(f"Extracted {len(project_info)} projects, info: {project_info}")
+    return project_info
+
+
+def _check_directory(directory: str) -> bool:
+    """Check if directory is valid."""
+    if not directory:
+        logger.error("Error: No directory specified")
+        return False
+
+    dir_path = Path(directory)
+    if not dir_path.is_dir():
+        logger.error(f"Error: {dir_path} is not a directory")
+        return False
+
+    return True
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--directory", "-D", type=str, default=str(cwd), help="Directory to parse")
+    parser.add_argument("--debug", "-d", action="store_true", help="Debug mode")
+    parser.add_argument("--recursive", "-r", action="store_true", help="Recursively parse subdirectories")
+    parser.add_argument("--show", "-s", action="store_true", help="Show parsed data")
+    parser.add_argument("--output", "-o", type=str, default="projects.json", help="Output file path")
+
+    args = parser.parse_args()
+    if args.debug:
+        logger.setLevel(logging.DEBUG)
+
+    if not _check_directory(args.directory):
+        return
+
+    output_path = (cwd / args.output).with_suffix(".json")
+    if args.show:
+        if output_path.is_file():
+            logger.info(f"Loading output from `{output_path}`:")
+            with output_path.open("r", encoding="utf-8") as f:
+                output_data = json.load(f)
+            logger.info(json.dumps(output_data, indent=2, ensure_ascii=False, sort_keys=True))
+            return
+        else:
+            logger.debug(f"No json file found at {output_path}, continue parsing...")
+
+    t0 = time.perf_counter()
+    logger.info(f"Parsing pyproject.toml in {args.directory}")
+    output_data = parse_project_data(Path(args.directory), recursive=args.recursive)
+    if args.show:
+        logger.info(json.dumps(output_data, indent=2, ensure_ascii=False, sort_keys=True))
+        return
+
+    try:
+        with output_path.open("w", encoding="utf-8") as f:
+            json.dump(output_data, f, indent=2, ensure_ascii=False)
+    except Exception as e:
+        logger.error(f"Error writing output to {output_path}: {e}")
+        return
+    else:
+        logger.info(f"Output written to {output_path}, took {time.perf_counter() - t0:.4f}s")