pysfi 0.1.5__tar.gz → 0.1.6__tar.gz

{pysfi-0.1.5 → pysfi-0.1.6}/PKG-INFO

@@ -1,9 +1,13 @@
 Metadata-Version: 2.4
 Name: pysfi
-Version: 0.1.5
+Version: 0.1.6
 Summary: Single File commands for Interactive python.
 Requires-Python: >=3.8
 Requires-Dist: tomli>=2.4.0; python_version < '3.11'
+Provides-Extra: all
+Requires-Dist: pymupdf>=1.24.11; extra == 'all'
+Provides-Extra: office
+Requires-Dist: pymupdf>=1.24.11; extra == 'office'
 Description-Content-Type: text/markdown
 
 # pysfi

{pysfi-0.1.5 → pysfi-0.1.6}/pyproject.toml

@@ -1,117 +1,132 @@
-[build-system]
-build-backend = "hatchling.build"
-requires = ["hatchling"]
-
-[project]
-dependencies = ["tomli>=2.4.0; python_version<'3.11'"]
-description = "Single File commands for Interactive python."
-name = "pysfi"
-readme = "README.md"
-requires-python = ">=3.8"
-version = "0.1.5"
-
-[project.scripts]
-alarmclk = "sfi.alarmclock.alarmclock:main"
-bumpversion = "sfi.bumpversion.bumpversion:main"
-embedinstall = "sfi.embedinstall.embedinstall:main"
-filedate = "sfi.filedate.filedate:main"
-mkp = "sfi.makepython.makepython:main"
-projectparse = "sfi.projectparse.projectparse:main"
-pyloadergen = "sfi.pyloadergen.pyloadergen:main"
-pypacker = "sfi.pypacker.pypacker:main"
-taskk = "sfi.taskkill.taskkill:main"
-wch = "sfi.which.which:main"
-
-[tool.hatch.build.targets.wheel]
-exclude = [
-    "sfi/*/README.md",
-    "sfi/*/dist",
-    "sfi/*/pyproject.toml",
-    "sfi/*/tests",
-]
-packages = ["sfi"]
-
-# Only include necessary source files to minimize package size
-[tool.hatch.build]
-include = ["README.md", "sfi/**/*.py", "sfi/pyproject.toml"]
-
-[tool.ruff]
-line-length = 120
-target-version = "py38"
-
-# Exclude files and directories
-exclude = [
-    ".bzr",
-    ".direnv",
-    ".eggs",
-    ".git",
-    ".git-rewrite",
-    ".hg",
-    ".mypy_cache",
-    ".nox",
-    ".pants.d",
-    ".pytype",
-    ".ruff_cache",
-    ".svn",
-    ".tox",
-    ".venv",
-    "__pypackages__",
-    "_build",
-    "buck-out",
-    "build",
-    "dist",
-    "node_modules",
-    "venv",
-]
-
-[tool.ruff.lint]
-dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
-fixable = ["ALL"]
-ignore = [
-    "B008", # Do not perform function calls in function arguments
-    "E501", # Line too long (handled by formatter)
-]
-select = [
-    "B",   # flake8-bugbear
-    "C4",  # flake8-comprehensions
-    "E",   # pycodestyle errors
-    "F",   # Pyflakes
-    "I",   # isort
-    "N",   # pep8-naming
-    "RUF", # Ruff-specific rules
-    "SIM", # flake8-simplify
-    "UP",  # pyupgrade
-    "W",   # pycodestyle warnings
-]
-unfixable = []
-
-[tool.ruff.lint.isort]
-known-first-party = ["sfi"]
-
-[tool.ruff.lint.per-file-ignores]
-"__init__.py" = ["F401"] # Allow unused imports
-
-[tool.uv.workspace]
-members = [
-    "sfi/alarmclock",
-    "sfi/bumpversion",
-    "sfi/embedinstall",
-    "sfi/filedate",
-    "sfi/makepython",
-    "sfi/projectparse",
-    "sfi/pyloadergen",
-    "sfi/pypacker",
-    "sfi/taskkill",
-    "sfi/which",
-]
-
-[dependency-groups]
-dev = [
-    "hatch>=1.14.2",
-    "pyside2>=5.15.2.1",
-    "pytest-cov>=5.0.0",
-    "pytest>=8.3.5",
-    "qdarkstyle>=3.2.3",
-    "ruff>=0.14.11",
-    "tomli>=2.4.0",
-]
+[build-system]
+build-backend = "hatchling.build"
+requires = ["hatchling"]
+
+[project]
+dependencies = ["tomli>=2.4.0; python_version<'3.11'"]
+description = "Single File commands for Interactive python."
+name = "pysfi"
+readme = "README.md"
+requires-python = ">=3.8"
+version = "0.1.6"
+
+[project.scripts]
+alarmclk = "sfi.alarmclock.alarmclock:main"
+bumpversion = "sfi.bumpversion.bumpversion:main"
+embedinstall = "sfi.embedinstall.embedinstall:main"
+filedate = "sfi.filedate.filedate:main"
+mkp = "sfi.makepython.makepython:main"
+pdfsplit = "sfi.pdfsplit.pdfsplit:main"
+projectparse = "sfi.projectparse.projectparse:main"
+pyloadergen = "sfi.pyloadergen.pyloadergen:main"
+pypacker = "sfi.pypacker.pypacker:main"
+taskk = "sfi.taskkill.taskkill:main"
+wch = "sfi.which.which:main"
+
+[project.optional-dependencies]
+all = ["pysfi[office]"]
+office = ["pymupdf>=1.24.11"]
+
+[tool.hatch.build.targets.wheel]
+exclude = [
+    "sfi/*/README.md",
+    "sfi/*/dist",
+    "sfi/*/pyproject.toml",
+    "sfi/*/tests",
+]
+packages = ["sfi"]
+
+# Only include necessary source files to minimize package size
+[tool.hatch.build]
+include = ["README.md", "sfi/**/*.py", "sfi/pyproject.toml"]
+
+[tool.ruff]
+line-length = 120
+target-version = "py38"
+
+# Exclude files and directories
+exclude = [
+    ".bzr",
+    ".direnv",
+    ".eggs",
+    ".git",
+    ".git-rewrite",
+    ".hg",
+    ".mypy_cache",
+    ".nox",
+    ".pants.d",
+    ".pytype",
+    ".ruff_cache",
+    ".svn",
+    ".tox",
+    ".venv",
+    "__pypackages__",
+    "_build",
+    "buck-out",
+    "build",
+    "dist",
+    "node_modules",
+    "venv",
+]
+
+[tool.ruff.lint]
+dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
+fixable = ["ALL"]
+ignore = [
+    "B008", # Do not perform function calls in function arguments
+    "E501", # Line too long (handled by formatter)
+]
+select = [
+    "B",   # flake8-bugbear
+    "C4",  # flake8-comprehensions
+    "E",   # pycodestyle errors
+    "F",   # Pyflakes
+    "I",   # isort
+    "N",   # pep8-naming
+    "RUF", # Ruff-specific rules
+    "SIM", # flake8-simplify
+    "UP",  # pyupgrade
+    "W",   # pycodestyle warnings
+]
+unfixable = []
+
+[tool.ruff.lint.isort]
+known-first-party = ["sfi"]
+
+[tool.ruff.lint.per-file-ignores]
+"__init__.py" = ["F401"] # Allow unused imports
+
+[tool.uv.workspace]
+members = [
+    "sfi/alarmclock",
+    "sfi/bumpversion",
+    "sfi/embedinstall",
+    "sfi/filedate",
+    "sfi/makepython",
+    "sfi/pdfsplit",
+    "sfi/projectparse",
+    "sfi/pyloadergen",
+    "sfi/pypacker",
+    "sfi/taskkill",
+    "sfi/which",
+]
+
+[dependency-groups]
+dev = [
+    "hatch>=1.14.2",
+    "pysfi[all]",
+    "pyside2>=5.15.2.1",
+    "pytest-cov>=5.0.0",
+    "pytest>=8.3.5",
+    "qdarkstyle>=3.2.3",
+    "ruff>=0.14.11",
+    "tomli>=2.4.0",
+]
+
+[tool.pytest.ini_options]
+addopts = "-v --tb=short"
+python_classes = ["Test*"]
+python_files = ["test_*.py"]
+python_functions = ["test_*"]
+pythonpath = ["."]
+testpaths = ["sfi"]

{pysfi-0.1.5 → pysfi-0.1.6}/sfi/__init__.py

@@ -1,3 +1,3 @@
 """Single File commands for Interactive python."""
 
-__version__ = "0.1.5"
+__version__ = "0.1.6"

{pysfi-0.1.5 → pysfi-0.1.6}/sfi/bumpversion/__init__.py

@@ -1,3 +1,3 @@
 """Bumpversion - Automated version number management tool."""
 
-__version__ = "0.1.5"
+__version__ = "0.1.6"

pysfi-0.1.6/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

pysfi-0.1.6/sfi/pdfsplit/tests/test_pdfsplit.py

@@ -0,0 +1,333 @@
+"""Tests for PDF split functionality."""
+
+import logging
+import shutil
+import sys
+import tempfile
+from pathlib import Path
+
+import fitz
+import pytest
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from sfi.pdfsplit.pdfsplit import parse_page_ranges, split_by_number, split_by_range, split_by_size
+
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+
+@pytest.fixture
+def temp_dir():
+    """Create a temporary directory for test files."""
+    dir_path = Path(tempfile.mkdtemp())
+    yield dir_path
+    # Cleanup
+    shutil.rmtree(dir_path, ignore_errors=True)
+
+
+@pytest.fixture
+def sample_pdf_10(temp_dir):
+    """Create a 10-page PDF for testing."""
+    pdf_path = temp_dir / "sample_10.pdf"
+    doc = fitz.open()
+    for i in range(10):
+        page = doc.new_page()  # pyright: ignore[reportAttributeAccessIssue]
+        text = fitz.Point(50, 72)
+        page.insert_text(text, f"This is page {i + 1}", fontsize=12)
+    doc.save(pdf_path)
+    doc.close()
+    logger.debug(f"Created test PDF: {pdf_path} with 10 pages")
+    return pdf_path
+
+
+@pytest.fixture
+def sample_pdf_5(temp_dir):
+    """Create a 5-page PDF for testing."""
+    pdf_path = temp_dir / "sample_5.pdf"
+    doc = fitz.open()
+    for i in range(5):
+        page = doc.new_page()  # pyright: ignore[reportAttributeAccessIssue]
+        text = fitz.Point(50, 72)
+        page.insert_text(text, f"This is page {i + 1}", fontsize=12)
+    doc.save(pdf_path)
+    doc.close()
+    logger.debug(f"Created test PDF: {pdf_path} with 5 pages")
+    return pdf_path
+
+
+def get_page_count(pdf_path: Path) -> int:
+    """Get the number of pages in a PDF."""
+    doc = fitz.open(pdf_path)
+    count = doc.page_count
+    doc.close()
+    return count
+
+
+def test_parse_page_ranges():
+    """Test page range parsing function."""
+    # Single pages
+    assert parse_page_ranges("1,2,3", 10) == [1, 2, 3]
+
+    # Range
+    assert parse_page_ranges("1-5", 10) == [1, 2, 3, 4, 5]
+
+    # Mixed
+    assert parse_page_ranges("1,3,5-7", 10) == [1, 3, 5, 6, 7]
+
+    # Open end range
+    assert parse_page_ranges("5-", 10) == [5, 6, 7, 8, 9, 10]
+
+    # Open start range
+    assert parse_page_ranges("-5", 10) == [1, 2, 3, 4, 5]
+
+    # Out of range pages are handled
+    assert parse_page_ranges("1,2,20", 10) == [1, 2, 20]
+
+
+def test_split_by_number_3_parts(sample_pdf_10, temp_dir):
+    """Test splitting 10-page PDF into 3 parts."""
+    output_file = temp_dir / "output.pdf"
+    split_by_number(sample_pdf_10, output_file, 3)
+
+    # Check that 3 parts were created
+    parts = sorted(temp_dir.glob("output_part*.pdf"))
+    assert len(parts) == 3
+
+    # Check page counts: 10 pages split into 3 parts should be 4, 3, 3 pages
+    page_counts = [get_page_count(p) for p in parts]
+    assert page_counts == [4, 3, 3]
+
+    logger.info(f"Split into 3 parts: {page_counts}")
+
+
+def test_split_by_number_equal(sample_pdf_10, temp_dir):
+    """Test splitting 10-page PDF into 5 parts."""
+    output_file = temp_dir / "output.pdf"
+    split_by_number(sample_pdf_10, output_file, 5)
+
+    parts = sorted(temp_dir.glob("output_part*.pdf"))
+    assert len(parts) == 5
+
+    # Each part should have 2 pages
+    page_counts = [get_page_count(p) for p in parts]
+    assert all(count == 2 for count in page_counts)
+
+    logger.info(f"Split into 5 equal parts: {page_counts}")
+
+
+def test_split_by_number_more_parts_than_pages(sample_pdf_5, temp_dir):
+    """Test splitting 5-page PDF into 10 parts."""
+    output_file = temp_dir / "output.pdf"
+    split_by_number(sample_pdf_5, output_file, 10)
+
+    parts = sorted(temp_dir.glob("output_part*.pdf"))
+    assert len(parts) == 5
+
+    # Each part should have 1 page
+    page_counts = [get_page_count(p) for p in parts]
+    assert all(count == 1 for count in page_counts)
+
+    logger.info(f"Split 5 pages into 10 parts: {page_counts}")
+
+
+def test_split_by_size_3_pages(sample_pdf_10, temp_dir):
+    """Test splitting PDF with 3 pages per part."""
+    output_file = temp_dir / "output.pdf"
+    split_by_size(sample_pdf_10, output_file, 3)
+
+    parts = sorted(temp_dir.glob("output_part*.pdf"))
+    assert len(parts) == 4
+
+    # Page counts should be 3, 3, 3, 1
+    page_counts = [get_page_count(p) for p in parts]
+    assert page_counts == [3, 3, 3, 1]
+
+    logger.info(f"Split by size 3: {page_counts}")
+
+
+def test_split_by_size_1_page(sample_pdf_10, temp_dir):
+    """Test splitting PDF with 1 page per part."""
+    output_file = temp_dir / "output.pdf"
+    split_by_size(sample_pdf_10, output_file, 1)
+
+    parts = sorted(temp_dir.glob("output_part*.pdf"))
+    assert len(parts) == 10
+
+    # Each part should have 1 page
+    page_counts = [get_page_count(p) for p in parts]
+    assert all(count == 1 for count in page_counts)
+
+    logger.info(f"Split by size 1: {page_counts}")
+
+
+def test_split_by_size_exact_division(sample_pdf_10, temp_dir):
+    """Test splitting PDF with exact division."""
+    output_file = temp_dir / "output.pdf"
+    split_by_size(sample_pdf_10, output_file, 5)
+
+    parts = sorted(temp_dir.glob("output_part*.pdf"))
+    assert len(parts) == 2
+
+    # Each part should have 5 pages
+    page_counts = [get_page_count(p) for p in parts]
+    assert page_counts == [5, 5]
+
+    logger.info(f"Split by size 5 (exact): {page_counts}")
+
+
+def test_split_by_range_single_pages(sample_pdf_10, temp_dir):
+    """Test extracting single pages."""
+    output_file = temp_dir / "extracted.pdf"
+    split_by_range(sample_pdf_10, output_file, "1,3,5,7,9")
+
+    assert output_file.exists()
+    assert get_page_count(output_file) == 5
+
+    # Verify the content (optional, just checking page count)
+    logger.info("Extracted 5 pages: 1,3,5,7,9")
+
+
+def test_split_by_range_with_dash(sample_pdf_10, temp_dir):
+    """Test extracting page ranges."""
+    output_file = temp_dir / "extracted.pdf"
+    split_by_range(sample_pdf_10, output_file, "1-3,5-7,9-10")
+
+    assert output_file.exists()
+    assert get_page_count(output_file) == 8  # Pages 1,2,3,5,6,7,9,10
+
+    logger.info("Extracted 8 pages with ranges: 1-3,5-7,9-10")
+
+
+def test_split_by_range_open_end(sample_pdf_10, temp_dir):
+    """Test extracting from a page to the end."""
+    output_file = temp_dir / "extracted.pdf"
+    split_by_range(sample_pdf_10, output_file, "5-")
+
+    assert output_file.exists()
+    assert get_page_count(output_file) == 6  # Pages 5,6,7,8,9,10
+
+    logger.info("Extracted pages 5- (6 pages)")
+
+
+def test_split_by_range_open_start(sample_pdf_10, temp_dir):
+    """Test extracting from start to a page."""
+    output_file = temp_dir / "extracted.pdf"
+    split_by_range(sample_pdf_10, output_file, "-3")
+
+    assert output_file.exists()
+    assert get_page_count(output_file) == 3  # Pages 1,2,3
+
+    logger.info("Extracted pages -3 (3 pages)")
+
+
+def test_split_by_range_complex(sample_pdf_10, temp_dir):
+    """Test complex page range."""
+    output_file = temp_dir / "extracted.pdf"
+    split_by_range(sample_pdf_10, output_file, "1,2,4-6,8-")
+
+    assert output_file.exists()
+    assert get_page_count(output_file) == 8  # Pages 1,2,4,5,6,8,9,10
+
+    logger.info("Extracted complex range: 1,2,4-6,8-")
+
+
+def test_split_by_range_out_of_range(sample_pdf_5, temp_dir):
+    """Test extracting pages beyond the PDF length."""
+    output_file = temp_dir / "extracted.pdf"
+    split_by_range(sample_pdf_5, output_file, "1,3,10,20")
+
+    assert output_file.exists()
+    assert get_page_count(output_file) == 2  # Only pages 1 and 3 exist
+
+    logger.info("Extracted pages with some out of range: 1,3,10,20")
+
+
+def test_split_by_range_all_pages(sample_pdf_10, temp_dir):
+    """Test extracting all pages."""
+    output_file = temp_dir / "extracted.pdf"
+    split_by_range(sample_pdf_10, output_file, "1-10")
+
+    assert output_file.exists()
+    assert get_page_count(output_file) == 10
+
+    logger.info("Extracted all 10 pages")
+
+
+def test_split_by_range_duplicate_pages(sample_pdf_10, temp_dir):
+    """Test extracting with duplicate page specifications."""
+    output_file = temp_dir / "extracted.pdf"
+    split_by_range(sample_pdf_10, output_file, "1,2,1,2,3-5,3-5")
+
+    assert output_file.exists()
+    # Should deduplicate: 1,2,3,4,5
+    assert get_page_count(output_file) == 5
+
+    logger.info("Extracted with duplicates (should deduplicate): 1,2,1,2,3-5,3-5")
+
+
+def test_output_file_naming(sample_pdf_10, temp_dir):
+    """Test that output files are named correctly."""
+    output_file = temp_dir / "test_output.pdf"
+    split_by_number(sample_pdf_10, output_file, 3)
+
+    # Check that parts are named correctly
+    parts = sorted(temp_dir.glob("test_output_part*.pdf"))
+    assert len(parts) == 3
+
+    # Check file names
+    filenames = [p.name for p in parts]
+    assert filenames == ["test_output_part1.pdf", "test_output_part2.pdf", "test_output_part3.pdf"]
+
+    logger.info(f"File naming test passed: {filenames}")
+
+
+def test_large_pdf(temp_dir):
+    """Test with a larger PDF (50 pages)."""
+    # Create 50-page PDF
+    pdf_path = temp_dir / "large_50.pdf"
+    doc = fitz.open()
+    for i in range(50):
+        page = doc.new_page()  # pyright: ignore[reportAttributeAccessIssue]
+        text = fitz.Point(50, 72)
+        page.insert_text(text, f"This is page {i + 1}", fontsize=12)
+    doc.save(pdf_path)
+    doc.close()
+
+    # Test split by size (10 pages each)
+    output_file = temp_dir / "large_output.pdf"
+    split_by_size(pdf_path, output_file, 10)
+
+    parts = sorted(temp_dir.glob("large_output_part*.pdf"))
+    assert len(parts) == 5
+
+    # Each part should have 10 pages
+    page_counts = [get_page_count(p) for p in parts]
+    assert all(count == 10 for count in page_counts)
+
+    logger.info("Large PDF (50 pages) split into 5 parts of 10 pages each")
+
+
+def test_edge_case_single_page_pdf(temp_dir):
+    """Test with a single-page PDF."""
+    pdf_path = temp_dir / "single.pdf"
+    doc = fitz.open()
+    page = doc.new_page()  # pyright: ignore[reportAttributeAccessIssue]
+    text = fitz.Point(50, 72)
+    page.insert_text(text, "Single page", fontsize=12)
+    doc.save(pdf_path)
+    doc.close()
+
+    # Split by number (should work)
+    output_file = temp_dir / "single_output.pdf"
+    split_by_number(pdf_path, output_file, 2)
+
+    parts = sorted(temp_dir.glob("single_output_part*.pdf"))
+    assert len(parts) == 1
+    assert get_page_count(parts[0]) == 1
+
+    logger.info("Single-page PDF handled correctly")
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v", "-s"])