quicktools-atom 0.3.0__tar.gz → 0.4.0__tar.gz

{quicktools_atom-0.3.0 → quicktools_atom-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quicktools-atom
-Version: 0.3.0
+Version: 0.4.0
 Summary: Math and string utilities with a bundled CLI, by AtomDev Studios
 Author-email: Samuel Peprah <windscribe.samuel@gmail.com>
 Project-URL: Homepage, https://github.com/Samuel-Peprah-cmd/quicktools
@@ -8,6 +8,14 @@ Project-URL: Repository, https://github.com/Samuel-Peprah-cmd/quicktools
 Project-URL: Documentation, https://samuel-peprah-cmd.github.io/quicktools/
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
+Requires-Dist: Pillow
+Requires-Dist: python-docx
+Requires-Dist: pypdf
+Requires-Dist: openpyxl
+Requires-Dist: reportlab
+Requires-Dist: PyYAML
+Requires-Dist: pdf2docx
+Requires-Dist: docx2pdf
 
 \# quicktools
 

{quicktools_atom-0.3.0 → quicktools_atom-0.4.0}/pyproject.toml

@@ -4,14 +4,23 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "quicktools-atom"
-version = "0.3.0"
+version = "0.4.0"
 description = "Math and string utilities with a bundled CLI, by AtomDev Studios"
 readme = "README.md"
 requires-python = ">=3.9"
 authors = [
     { name = "Samuel Peprah", email = "windscribe.samuel@gmail.com" }
 ]
-dependencies = []
+dependencies = [
+    "Pillow",
+    "python-docx",
+    "pypdf",
+    "openpyxl",
+    "reportlab",
+    "PyYAML",
+    "pdf2docx",
+    "docx2pdf",
+]
 
 [project.urls]
 Homepage = "https://github.com/Samuel-Peprah-cmd/quicktools"

quicktools_atom-0.4.0/src/quicktools/doctools.py

@@ -0,0 +1,89 @@
+"""Word document utilities: reading, creating, editing .docx files, and converting to/from PDF."""
+from docx import Document
+
+
+def read_docx_text(path: str) -> str:
+    """Extract and return all paragraph text from a .docx file."""
+    doc = Document(path)
+    return "\n".join(p.text for p in doc.paragraphs)
+
+
+def create_docx_from_text(text: str, output_path: str) -> None:
+    """Create a new .docx file, adding each line of text as a separate paragraph."""
+    doc = Document()
+    for line in text.split("\n"):
+        doc.add_paragraph(line)
+    doc.save(output_path)
+
+
+def get_docx_word_count(path: str) -> int:
+    """Count the total number of words across all paragraphs in a .docx file."""
+    doc = Document(path)
+    return sum(len(p.text.split()) for p in doc.paragraphs)
+
+
+def get_docx_paragraph_count(path: str) -> int:
+    """Count the number of paragraphs in a .docx file."""
+    return len(Document(path).paragraphs)
+
+
+def replace_text_in_docx(path: str, old: str, new: str, output_path: str) -> None:
+    """Replace all occurrences of `old` with `new` across every paragraph, saving to output_path."""
+    doc = Document(path)
+    for p in doc.paragraphs:
+        if old in p.text:
+            for run in p.runs:
+                if old in run.text:
+                    run.text = run.text.replace(old, new)
+    doc.save(output_path)
+
+
+def extract_docx_tables(path: str) -> list[list[list[str]]]:
+    """Extract every table in a .docx file as a list of tables, each a list of rows, each a list of cell strings."""
+    doc = Document(path)
+    all_tables = []
+    for table in doc.tables:
+        rows = []
+        for row in table.rows:
+            rows.append([cell.text for cell in row.cells])
+        all_tables.append(rows)
+    return all_tables
+
+
+def merge_docx_files(paths: list[str], output_path: str) -> None:
+    """Merge multiple .docx files into one, concatenating their paragraphs in order."""
+    combined = Document()
+    for i, path in enumerate(paths):
+        doc = Document(path)
+        for p in doc.paragraphs:
+            combined.add_paragraph(p.text)
+        if i < len(paths) - 1:
+            combined.add_page_break()
+    combined.save(output_path)
+
+
+def docx_to_pdf(path: str, output_path: str) -> None:
+    """Convert a .docx file to PDF. Requires Microsoft Word to be installed (Windows/macOS) and
+    the optional 'docx2pdf' package (pip install docx2pdf)."""
+    try:
+        from docx2pdf import convert
+    except ImportError:
+        raise ImportError(
+            "docx_to_pdf() requires docx2pdf. Install it with: pip install docx2pdf\n"
+            "Note: it also requires Microsoft Word to be installed on this machine."
+        )
+    convert(path, output_path)
+
+
+def pdf_to_docx(path: str, output_path: str) -> None:
+    """Convert a PDF file to .docx, preserving text layout where possible.
+    Requires the optional 'pdf2docx' package (pip install pdf2docx)."""
+    try:
+        from pdf2docx import Converter
+    except ImportError:
+        raise ImportError(
+            "pdf_to_docx() requires pdf2docx. Install it with: pip install pdf2docx"
+        )
+    cv = Converter(path)
+    cv.convert(output_path)
+    cv.close()

quicktools_atom-0.4.0/src/quicktools/filetools.py

@@ -0,0 +1,103 @@
+"""File utilities: reading, writing, hashing, zipping, and inspecting files of any type."""
+import os
+import json
+import hashlib
+import zipfile
+import mimetypes
+import shutil
+
+
+def get_file_info(path: str) -> dict:
+    """Return basic metadata about a file: size, extension, mime type, last modified time."""
+    stat = os.stat(path)
+    mime_type, _ = mimetypes.guess_type(path)
+    return {
+        "size_bytes": stat.st_size,
+        "extension": os.path.splitext(path)[1],
+        "mime_type": mime_type or "unknown",
+        "modified_time": stat.st_mtime,
+    }
+
+
+def read_text_file(path: str, encoding: str = "utf-8") -> str:
+    """Read and return the full contents of a text file."""
+    with open(path, "r", encoding=encoding) as f:
+        return f.read()
+
+
+def write_text_file(path: str, content: str, encoding: str = "utf-8") -> None:
+    """Write text content to a file, overwriting it if it exists."""
+    with open(path, "w", encoding=encoding) as f:
+        f.write(content)
+
+
+def read_json_file(path: str) -> object:
+    """Read and parse a JSON file, returning the resulting Python object."""
+    with open(path, "r", encoding="utf-8") as f:
+        return json.load(f)
+
+
+def write_json_file(path: str, data: object, indent: int = 2) -> None:
+    """Write a Python object to a file as formatted JSON."""
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(data, f, indent=indent)
+
+
+def read_yaml_file(path: str) -> object:
+    """Read and parse a YAML file, returning the resulting Python object."""
+    import yaml
+    with open(path, "r", encoding="utf-8") as f:
+        return yaml.safe_load(f)
+
+
+def write_yaml_file(path: str, data: object) -> None:
+    """Write a Python object to a file as YAML."""
+    import yaml
+    with open(path, "w", encoding="utf-8") as f:
+        yaml.safe_dump(data, f)
+
+
+def compute_file_hash(path: str, algorithm: str = "sha256") -> str:
+    """Compute the hex digest hash of a file's contents (works for any file type)."""
+    h = hashlib.new(algorithm)
+    with open(path, "rb") as f:
+        for chunk in iter(lambda: f.read(8192), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def zip_files(file_paths: list[str], output_zip_path: str) -> None:
+    """Compress a list of files into a single .zip archive."""
+    with zipfile.ZipFile(output_zip_path, "w", zipfile.ZIP_DEFLATED) as zf:
+        for path in file_paths:
+            zf.write(path, arcname=os.path.basename(path))
+
+
+def unzip_file(zip_path: str, output_dir: str) -> list[str]:
+    """Extract a .zip archive into output_dir, returning the list of extracted file names."""
+    with zipfile.ZipFile(zip_path, "r") as zf:
+        zf.extractall(output_dir)
+        return zf.namelist()
+
+
+def list_files_in_directory(directory: str, extension: str | None = None) -> list[str]:
+    """List all files in a directory, optionally filtered by extension (e.g. '.txt')."""
+    files = os.listdir(directory)
+    if extension:
+        files = [f for f in files if f.endswith(extension)]
+    return files
+
+
+def get_file_extension(path: str) -> str:
+    """Return the file extension of a path, including the leading dot (e.g. '.pdf')."""
+    return os.path.splitext(path)[1]
+
+
+def copy_file(src: str, dst: str) -> None:
+    """Copy a file from src to dst."""
+    shutil.copy2(src, dst)
+
+
+def delete_file(path: str) -> None:
+    """Delete a file. Raises FileNotFoundError if it doesn't exist."""
+    os.remove(path)

quicktools_atom-0.4.0/src/quicktools/imagetools.py

@@ -0,0 +1,128 @@
+"""Image utilities: format conversion, resizing, editing, and image-to-PDF, powered by Pillow.
+
+Supports conversion between PNG, JPEG/JPG, BMP, GIF, WEBP, TIFF, and more —
+the output format is inferred automatically from the output file's extension.
+"""
+from PIL import Image, ImageOps, ImageDraw, ImageFont
+
+
+def convert_image(input_path: str, output_path: str) -> None:
+    """Convert an image from one format to another (e.g. PNG -> JPEG, JPEG -> WEBP).
+    The target format is inferred from output_path's file extension."""
+    img = Image.open(input_path)
+    # JPEG doesn't support transparency (RGBA); flatten onto white if needed.
+    if output_path.lower().endswith((".jpg", ".jpeg")) and img.mode in ("RGBA", "P"):
+        img = img.convert("RGB")
+    img.save(output_path)
+
+
+def resize_image(input_path: str, output_path: str, width: int, height: int) -> None:
+    """Resize an image to the given width and height."""
+    img = Image.open(input_path)
+    resized = img.resize((width, height))
+    resized.save(output_path)
+
+
+def rotate_image(input_path: str, output_path: str, degrees: float) -> None:
+    """Rotate an image by the given number of degrees (counter-clockwise), expanding the canvas as needed."""
+    img = Image.open(input_path)
+    rotated = img.rotate(degrees, expand=True)
+    rotated.save(output_path)
+
+
+def flip_image(input_path: str, output_path: str, direction: str = "horizontal") -> None:
+    """Flip an image. direction is 'horizontal' or 'vertical'."""
+    img = Image.open(input_path)
+    if direction == "horizontal":
+        flipped = ImageOps.mirror(img)
+    elif direction == "vertical":
+        flipped = ImageOps.flip(img)
+    else:
+        raise ValueError("direction must be 'horizontal' or 'vertical'")
+    flipped.save(output_path)
+
+
+def grayscale_image(input_path: str, output_path: str) -> None:
+    """Convert an image to grayscale."""
+    img = Image.open(input_path).convert("L")
+    img.save(output_path)
+
+
+def crop_image(input_path: str, output_path: str, left: int, top: int, right: int, bottom: int) -> None:
+    """Crop an image to the box defined by (left, top, right, bottom) pixel coordinates."""
+    img = Image.open(input_path)
+    cropped = img.crop((left, top, right, bottom))
+    cropped.save(output_path)
+
+
+def get_image_info(path: str) -> dict:
+    """Return basic information about an image: format, dimensions, and color mode."""
+    img = Image.open(path)
+    return {"format": img.format, "size": img.size, "mode": img.mode}
+
+
+def create_thumbnail(input_path: str, output_path: str, max_size: int = 128) -> None:
+    """Create a thumbnail no larger than max_size x max_size, preserving aspect ratio."""
+    img = Image.open(input_path)
+    img.thumbnail((max_size, max_size))
+    img.save(output_path)
+
+
+def compress_image(input_path: str, output_path: str, quality: int = 70) -> None:
+    """Save a (typically JPEG) image at a reduced quality level to shrink file size."""
+    img = Image.open(input_path)
+    if img.mode in ("RGBA", "P"):
+        img = img.convert("RGB")
+    img.save(output_path, quality=quality, optimize=True)
+
+
+def merge_images_horizontally(paths: list[str], output_path: str) -> None:
+    """Combine multiple images side by side into a single image."""
+    images = [Image.open(p) for p in paths]
+    total_width = sum(img.width for img in images)
+    max_height = max(img.height for img in images)
+    combined = Image.new("RGB", (total_width, max_height), "white")
+    x_offset = 0
+    for img in images:
+        combined.paste(img, (x_offset, 0))
+        x_offset += img.width
+    combined.save(output_path)
+
+
+def merge_images_vertically(paths: list[str], output_path: str) -> None:
+    """Stack multiple images on top of each other into a single image."""
+    images = [Image.open(p) for p in paths]
+    max_width = max(img.width for img in images)
+    total_height = sum(img.height for img in images)
+    combined = Image.new("RGB", (max_width, total_height), "white")
+    y_offset = 0
+    for img in images:
+        combined.paste(img, (0, y_offset))
+        y_offset += img.height
+    combined.save(output_path)
+
+
+def add_text_watermark(input_path: str, output_path: str, text: str) -> None:
+    """Overlay a text watermark in the bottom-right corner of an image."""
+    img = Image.open(input_path).convert("RGBA")
+    overlay = Image.new("RGBA", img.size, (255, 255, 255, 0))
+    draw = ImageDraw.Draw(overlay)
+    try:
+        font = ImageFont.load_default()
+    except Exception:
+        font = None
+    bbox = draw.textbbox((0, 0), text, font=font)
+    text_w, text_h = bbox[2] - bbox[0], bbox[3] - bbox[1]
+    position = (img.width - text_w - 10, img.height - text_h - 10)
+    draw.text(position, text, fill=(255, 255, 255, 180), font=font)
+    watermarked = Image.alpha_composite(img, overlay).convert("RGB")
+    watermarked.save(output_path)
+
+
+def images_to_pdf(image_paths: list[str], output_pdf_path: str) -> None:
+    """Combine one or more images into a single multi-page PDF file."""
+    images = [Image.open(p).convert("RGB") for p in image_paths]
+    if not images:
+        raise ValueError("At least one image path is required")
+    first, rest = images[0], images[1:]
+    first.save(output_pdf_path, save_all=True, append_images=rest)

quicktools_atom-0.4.0/src/quicktools/pdftools.py

@@ -0,0 +1,161 @@
+"""PDF utilities: extracting, merging, splitting, rotating, and creating PDFs."""
+from pypdf import PdfReader, PdfWriter
+
+
+def extract_text_from_pdf(path: str) -> str:
+    """Extract and return all text content from a PDF file."""
+    reader = PdfReader(path)
+    return "\n".join(page.extract_text() or "" for page in reader.pages)
+
+
+def get_pdf_page_count(path: str) -> int:
+    """Return the number of pages in a PDF file."""
+    return len(PdfReader(path).pages)
+
+
+def merge_pdfs(paths: list[str], output_path: str) -> None:
+    """Merge multiple PDF files into a single PDF, in the given order."""
+    writer = PdfWriter()
+    for path in paths:
+        reader = PdfReader(path)
+        for page in reader.pages:
+            writer.add_page(page)
+    with open(output_path, "wb") as f:
+        writer.write(f)
+
+
+def split_pdf_to_pages(path: str, output_dir: str) -> list[str]:
+    """Split a PDF into individual single-page PDF files. Returns the list of output file paths."""
+    import os
+    reader = PdfReader(path)
+    output_paths = []
+    for i, page in enumerate(reader.pages):
+        writer = PdfWriter()
+        writer.add_page(page)
+        out_path = os.path.join(output_dir, f"page_{i + 1}.pdf")
+        with open(out_path, "wb") as f:
+            writer.write(f)
+        output_paths.append(out_path)
+    return output_paths
+
+
+def extract_pdf_pages(path: str, page_numbers: list[int], output_path: str) -> None:
+    """Extract specific pages (1-indexed) from a PDF into a new PDF file."""
+    reader = PdfReader(path)
+    writer = PdfWriter()
+    for num in page_numbers:
+        writer.add_page(reader.pages[num - 1])
+    with open(output_path, "wb") as f:
+        writer.write(f)
+
+
+def rotate_pdf(path: str, degrees: int, output_path: str) -> None:
+    """Rotate every page in a PDF by the given degrees (must be a multiple of 90)."""
+    reader = PdfReader(path)
+    writer = PdfWriter()
+    for page in reader.pages:
+        page.rotate(degrees)
+        writer.add_page(page)
+    with open(output_path, "wb") as f:
+        writer.write(f)
+
+
+def get_pdf_metadata(path: str) -> dict:
+    """Return the metadata (title, author, creation date, etc.) of a PDF file."""
+    reader = PdfReader(path)
+    meta = reader.metadata
+    return dict(meta) if meta else {}
+
+
+def create_pdf_from_text(text: str, output_path: str) -> None:
+    """Create a simple PDF file containing the given text, wrapping and paginating automatically."""
+    from reportlab.lib.pagesizes import letter
+    from reportlab.pdfgen import canvas
+    from reportlab.lib.units import inch
+
+    c = canvas.Canvas(output_path, pagesize=letter)
+    width, height = letter
+    margin = inch
+    max_width_chars = 90
+    y = height - margin
+    line_height = 14
+
+    import textwrap
+    for paragraph in text.split("\n"):
+        wrapped_lines = textwrap.wrap(paragraph, max_width_chars) or [""]
+        for line in wrapped_lines:
+            if y < margin:
+                c.showPage()
+                y = height - margin
+            c.drawString(margin, y, line)
+            y -= line_height
+    c.save()
+
+
+def encrypt_pdf(path: str, password: str, output_path: str) -> None:
+    """Create a password-protected copy of a PDF."""
+    reader = PdfReader(path)
+    writer = PdfWriter()
+    for page in reader.pages:
+        writer.add_page(page)
+    writer.encrypt(password)
+    with open(output_path, "wb") as f:
+        writer.write(f)
+
+
+def decrypt_pdf(path: str, password: str, output_path: str) -> None:
+    """Remove password protection from a PDF, given the correct password."""
+    reader = PdfReader(path)
+    if reader.is_encrypted:
+        reader.decrypt(password)
+    writer = PdfWriter()
+    for page in reader.pages:
+        writer.add_page(page)
+    with open(output_path, "wb") as f:
+        writer.write(f)
+
+
+def add_page_numbers(path: str, output_path: str) -> None:
+    """Add page numbers (bottom-center) to every page of a PDF."""
+    import io
+    from reportlab.pdfgen import canvas
+    from reportlab.lib.pagesizes import letter
+
+    reader = PdfReader(path)
+    writer = PdfWriter()
+
+    for i, page in enumerate(reader.pages):
+        packet = io.BytesIO()
+        page_width = float(page.mediabox.width)
+        c = canvas.Canvas(packet, pagesize=(page_width, float(page.mediabox.height)))
+        c.drawCentredString(page_width / 2, 20, str(i + 1))
+        c.save()
+        packet.seek(0)
+        overlay_reader = PdfReader(packet)
+        page.merge_page(overlay_reader.pages[0])
+        writer.add_page(page)
+
+    with open(output_path, "wb") as f:
+        writer.write(f)
+
+
+def pdf_to_images(path: str, output_dir: str, dpi: int = 150) -> list[str]:
+    """Render every page of a PDF as a PNG image. Requires the optional 'PyMuPDF' package
+    (pip install pymupdf) — raises ImportError with instructions if it's not installed."""
+    import os
+    try:
+        import fitz  # PyMuPDF
+    except ImportError:
+        raise ImportError(
+            "pdf_to_images() requires PyMuPDF. Install it with: pip install pymupdf"
+        )
+    doc = fitz.open(path)
+    output_paths = []
+    zoom = dpi / 72
+    matrix = fitz.Matrix(zoom, zoom)
+    for i, page in enumerate(doc):
+        pix = page.get_pixmap(matrix=matrix)
+        out_path = os.path.join(output_dir, f"page_{i + 1}.png")
+        pix.save(out_path)
+        output_paths.append(out_path)
+    return output_paths

quicktools_atom-0.4.0/src/quicktools/spreadsheettools.py

@@ -0,0 +1,72 @@
+"""Spreadsheet utilities: reading, writing, and converting between CSV, Excel, and JSON."""
+import csv
+import json
+
+
+def read_csv_file(path: str) -> list[dict]:
+    """Read a CSV file and return its rows as a list of dictionaries (keyed by header)."""
+    with open(path, "r", encoding="utf-8", newline="") as f:
+        return list(csv.DictReader(f))
+
+
+def write_csv_file(path: str, data: list[dict]) -> None:
+    """Write a list of dictionaries to a CSV file, using the first row's keys as headers."""
+    if not data:
+        raise ValueError("data must contain at least one row")
+    with open(path, "w", encoding="utf-8", newline="") as f:
+        writer = csv.DictWriter(f, fieldnames=list(data[0].keys()))
+        writer.writeheader()
+        writer.writerows(data)
+
+
+def csv_to_xlsx(csv_path: str, xlsx_path: str) -> None:
+    """Convert a CSV file into an Excel .xlsx file."""
+    from openpyxl import Workbook
+    rows = read_csv_file(csv_path)
+    wb = Workbook()
+    ws = wb.active
+    if rows:
+        ws.append(list(rows[0].keys()))
+        for row in rows:
+            ws.append(list(row.values()))
+    wb.save(xlsx_path)
+
+
+def xlsx_to_csv(xlsx_path: str, csv_path: str, sheet_name: str | None = None) -> None:
+    """Convert an Excel .xlsx file (a single sheet) into a CSV file."""
+    from openpyxl import load_workbook
+    wb = load_workbook(xlsx_path)
+    ws = wb[sheet_name] if sheet_name else wb.active
+    with open(csv_path, "w", encoding="utf-8", newline="") as f:
+        writer = csv.writer(f)
+        for row in ws.iter_rows(values_only=True):
+            writer.writerow(row)
+
+
+def json_to_csv(json_path: str, csv_path: str) -> None:
+    """Convert a JSON file (a list of flat objects) into a CSV file."""
+    with open(json_path, "r", encoding="utf-8") as f:
+        data = json.load(f)
+    write_csv_file(csv_path, data)
+
+
+def csv_to_json(csv_path: str, json_path: str) -> None:
+    """Convert a CSV file into a JSON file (a list of objects)."""
+    data = read_csv_file(csv_path)
+    with open(json_path, "w", encoding="utf-8") as f:
+        json.dump(data, f, indent=2)
+
+
+def get_xlsx_sheet_names(path: str) -> list[str]:
+    """Return the list of sheet names in an Excel workbook."""
+    from openpyxl import load_workbook
+    wb = load_workbook(path, read_only=True)
+    return wb.sheetnames
+
+
+def merge_csv_files(paths: list[str], output_path: str) -> None:
+    """Merge multiple CSV files (with the same columns) into a single CSV file."""
+    all_rows = []
+    for path in paths:
+        all_rows.extend(read_csv_file(path))
+    write_csv_file(output_path, all_rows)

{quicktools_atom-0.3.0 → quicktools_atom-0.4.0}/src/quicktools_atom.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quicktools-atom
-Version: 0.3.0
+Version: 0.4.0
 Summary: Math and string utilities with a bundled CLI, by AtomDev Studios
 Author-email: Samuel Peprah <windscribe.samuel@gmail.com>
 Project-URL: Homepage, https://github.com/Samuel-Peprah-cmd/quicktools
@@ -8,6 +8,14 @@ Project-URL: Repository, https://github.com/Samuel-Peprah-cmd/quicktools
 Project-URL: Documentation, https://samuel-peprah-cmd.github.io/quicktools/
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
+Requires-Dist: Pillow
+Requires-Dist: python-docx
+Requires-Dist: pypdf
+Requires-Dist: openpyxl
+Requires-Dist: reportlab
+Requires-Dist: PyYAML
+Requires-Dist: pdf2docx
+Requires-Dist: docx2pdf
 
 \# quicktools
 

{quicktools_atom-0.3.0 → quicktools_atom-0.4.0}/src/quicktools_atom.egg-info/SOURCES.txt

@@ -4,12 +4,18 @@ src/quicktools/__init__.py
 src/quicktools/calculus.py
 src/quicktools/cli.py
 src/quicktools/combinatorics.py
+src/quicktools/doctools.py
+src/quicktools/filetools.py
+src/quicktools/imagetools.py
 src/quicktools/linalg.py
 src/quicktools/mathtools.py
 src/quicktools/numbertheory.py
+src/quicktools/pdftools.py
+src/quicktools/spreadsheettools.py
 src/quicktools/strtools.py
 src/quicktools_atom.egg-info/PKG-INFO
 src/quicktools_atom.egg-info/SOURCES.txt
 src/quicktools_atom.egg-info/dependency_links.txt
 src/quicktools_atom.egg-info/entry_points.txt
+src/quicktools_atom.egg-info/requires.txt
 src/quicktools_atom.egg-info/top_level.txt

quicktools_atom-0.4.0/src/quicktools_atom.egg-info/requires.txt

@@ -0,0 +1,8 @@
+Pillow
+python-docx
+pypdf
+openpyxl
+reportlab
+PyYAML
+pdf2docx
+docx2pdf