uprightkit 0.1.0__py3-none-any.whl

uprightkit/__init__.py

@@ -0,0 +1,40 @@
+"""
+uprightKit — lightweight, pure-OpenCV document deskewing and orientation
+correction. No deep learning, no heavy model downloads.
+
+Quick start
+-----------
+    import uprightkit
+
+    # Single image, write result to disk
+    uprightkit.fix_image("scan.jpg", output_path="scan_fixed.jpg")
+
+    # PDF, page by page, write result to disk (requires: pip install uprightkit[pdf])
+    uprightkit.fix_pdf("doc.pdf", output_path="doc_fixed.pdf")
+
+    # Already have a numpy array (e.g. from cv2.imread)?
+    fixed = uprightkit.fix_array(image)
+"""
+
+from .api import (
+    InvalidImageError,
+    PdfSupportMissingError,
+    UprightKitError,
+    fix_array,
+    fix_image,
+    fix_pdf,
+)
+from .core import fix_skew_and_orientation
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "fix_array",
+    "fix_image",
+    "fix_pdf",
+    "fix_skew_and_orientation",
+    "UprightKitError",
+    "InvalidImageError",
+    "PdfSupportMissingError",
+    "__version__",
+]

uprightkit/api.py

@@ -0,0 +1,244 @@
+"""
+High-level, user-facing functions for uprightKit.
+
+These are the functions most users should import:
+
+    import uprightkit
+
+    uprightkit.fix_image("scan.jpg", output_path="scan_fixed.jpg")
+    uprightkit.fix_pdf("doc.pdf", output_path="doc_fixed.pdf")
+    fixed_array = uprightkit.fix_array(my_numpy_image)
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import List, Optional, Union
+
+import cv2
+import numpy as np
+
+from .core import InvalidImageError, UprightKitError, fix_skew_and_orientation
+
+PathLike = Union[str, "os.PathLike[str]"]
+
+__all__ = [
+    "fix_array",
+    "fix_image",
+    "fix_pdf",
+    "UprightKitError",
+    "InvalidImageError",
+    "PdfSupportMissingError",
+]
+
+
+class PdfSupportMissingError(UprightKitError):
+    """Raised when PDF features are used without the 'pdf' extra installed."""
+
+    def __init__(self) -> None:
+        super().__init__(
+            "PDF support requires the optional 'pymupdf' dependency. "
+            "Install it with: pip install uprightkit[pdf]"
+        )
+
+
+def fix_array(image: np.ndarray, **kwargs) -> np.ndarray:
+    """
+    Straighten an in-memory BGR image array (e.g. from cv2.imread/imdecode).
+
+    This is a thin, explicitly-named wrapper around
+    ``uprightkit.core.fix_skew_and_orientation`` for callers who prefer to
+    work entirely with arrays (e.g. inside an existing CV pipeline) without
+    touching the filesystem. All keyword arguments are forwarded; see
+    ``fix_skew_and_orientation`` for the full list (``correct_180_flip``,
+    ``skew_angle_tolerance``, etc).
+
+    Returns
+    -------
+    np.ndarray
+        The straightened image, as a new array (input is not modified).
+    """
+    return fix_skew_and_orientation(image, **kwargs)
+
+
+def fix_image(
+    input_path: PathLike,
+    output_path: Optional[PathLike] = None,
+    *,
+    jpeg_quality: int = 95,
+    **kwargs,
+) -> np.ndarray:
+    """
+    Straighten a single image file on disk.
+
+    Parameters
+    ----------
+    input_path:
+        Path to a JPEG/PNG/BMP/TIFF/etc image readable by OpenCV.
+    output_path:
+        If given, the corrected image is written here. The format is
+        inferred from the file extension (e.g. ``.png``, ``.jpg``).
+        If omitted, nothing is written to disk — only the array is returned.
+    jpeg_quality:
+        JPEG quality (0-100) used only when writing to a ``.jpg``/``.jpeg``
+        output path. Ignored for other formats.
+    **kwargs:
+        Forwarded to ``fix_skew_and_orientation`` (e.g. ``correct_180_flip``,
+        ``skew_angle_tolerance``, ``flip_density_ratio``).
+
+    Returns
+    -------
+    np.ndarray
+        The corrected image as a BGR numpy array.
+
+    Raises
+    ------
+    FileNotFoundError
+        If ``input_path`` does not exist.
+    InvalidImageError
+        If the file exists but cannot be decoded as an image.
+    """
+    input_path = Path(input_path)
+    if not input_path.is_file():
+        raise FileNotFoundError(f"no such file: {input_path}")
+
+    image = cv2.imread(str(input_path), cv2.IMREAD_COLOR)
+    if image is None:
+        raise InvalidImageError(
+            f"could not decode '{input_path}' as an image "
+            "(unsupported format or corrupt file)"
+        )
+
+    fixed = fix_skew_and_orientation(image, **kwargs)
+
+    if output_path is not None:
+        _write_image(fixed, Path(output_path), jpeg_quality=jpeg_quality)
+
+    return fixed
+
+
+def fix_pdf(
+    input_path: PathLike,
+    output_path: Optional[PathLike] = None,
+    *,
+    dpi: int = 200,
+    **kwargs,
+) -> List[np.ndarray]:
+    """
+    Straighten every page of a PDF, page by page.
+
+    Each page is rasterized to an image at the given DPI, run through the
+    same skew/orientation correction used for single images, and (if
+    ``output_path`` is given) reassembled into a new PDF.
+
+    Parameters
+    ----------
+    input_path:
+        Path to the source PDF.
+    output_path:
+        If given, a new PDF with all pages corrected is written here.
+        If omitted, only the in-memory list of corrected page images is
+        returned (nothing is written to disk).
+    dpi:
+        Resolution used when rasterizing each PDF page before processing.
+        Higher values preserve more detail but are slower and use more
+        memory. 150-300 is a reasonable range for most documents.
+    **kwargs:
+        Forwarded to ``fix_skew_and_orientation`` for every page (e.g.
+        ``correct_180_flip``, ``skew_angle_tolerance``).
+
+    Returns
+    -------
+    list[np.ndarray]
+        One corrected BGR image array per page, in page order.
+
+    Raises
+    ------
+    PdfSupportMissingError
+        If PyMuPDF (``pymupdf``) is not installed.
+    FileNotFoundError
+        If ``input_path`` does not exist.
+    InvalidImageError
+        If a given page fails to rasterize into a usable image.
+    """
+    try:
+        import fitz  # PyMuPDF
+    except ImportError as exc:
+        raise PdfSupportMissingError() from exc
+
+    input_path = Path(input_path)
+    if not input_path.is_file():
+        raise FileNotFoundError(f"no such file: {input_path}")
+
+    zoom = dpi / 72.0  # PyMuPDF's base render resolution is 72 DPI.
+    matrix = fitz.Matrix(zoom, zoom)
+
+    fixed_pages: List[np.ndarray] = []
+
+    with fitz.open(str(input_path)) as pdf:
+        if pdf.page_count == 0:
+            raise InvalidImageError(f"'{input_path}' has no pages")
+
+        for page_index in range(pdf.page_count):
+            page = pdf.load_page(page_index)
+            pix = page.get_pixmap(matrix=matrix)
+
+            # PyMuPDF gives RGB(A); OpenCV expects BGR.
+            img = np.frombuffer(pix.samples, dtype=np.uint8).reshape(
+                pix.height, pix.width, pix.n
+            )
+            if pix.n == 4:
+                img = cv2.cvtColor(img, cv2.COLOR_RGBA2BGR)
+            elif pix.n == 3:
+                img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
+            elif pix.n == 1:
+                img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
+            else:
+                raise InvalidImageError(
+                    f"page {page_index} has unexpected channel count: {pix.n}"
+                )
+
+            fixed_pages.append(fix_skew_and_orientation(img, **kwargs))
+
+    if output_path is not None:
+        _write_pdf(fixed_pages, Path(output_path))
+
+    return fixed_pages
+
+
+def _write_image(image: np.ndarray, output_path: Path, *, jpeg_quality: int) -> None:
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    ext = output_path.suffix.lower()
+
+    params = []
+    if ext in (".jpg", ".jpeg"):
+        params = [cv2.IMWRITE_JPEG_QUALITY, int(jpeg_quality)]
+
+    ok = cv2.imwrite(str(output_path), image, params)
+    if not ok:
+        raise UprightKitError(f"failed to write output image to '{output_path}'")
+
+
+def _write_pdf(pages: List[np.ndarray], output_path: Path) -> None:
+    try:
+        import fitz  # PyMuPDF
+    except ImportError as exc:
+        raise PdfSupportMissingError() from exc
+
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    doc = fitz.open()
+    try:
+        for page_img in pages:
+            ok, encoded = cv2.imencode(".png", page_img)
+            if not ok:
+                raise UprightKitError("failed to encode a page while building output PDF")
+
+            h, w = page_img.shape[:2]
+            page = doc.new_page(width=w, height=h)
+            page.insert_image(page.rect, stream=encoded.tobytes())
+
+        doc.save(str(output_path))
+    finally:
+        doc.close()

uprightkit/cli.py

@@ -0,0 +1,66 @@
+"""
+Command-line interface for uprightKit.
+
+Usage:
+    uprightkit scan.jpg fixed.jpg
+    uprightkit document.pdf fixed.pdf
+    uprightkit scan.jpg fixed.jpg --no-flip-fix
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+from .api import InvalidImageError, PdfSupportMissingError, UprightKitError, fix_image, fix_pdf
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="uprightkit",
+        description="Straighten a scanned image or PDF (fix skew + 180-degree flips).",
+    )
+    parser.add_argument("input", help="path to the input image or PDF")
+    parser.add_argument("output", help="path to write the corrected output")
+    parser.add_argument(
+        "--no-flip-fix",
+        action="store_true",
+        help="only fix skew angle; skip the 180-degree upside-down check",
+    )
+    parser.add_argument(
+        "--dpi",
+        type=int,
+        default=200,
+        help="rasterization DPI for PDF pages (default: 200, ignored for images)",
+    )
+
+    args = parser.parse_args(argv)
+
+    input_path = Path(args.input)
+    is_pdf = input_path.suffix.lower() == ".pdf"
+
+    try:
+        if is_pdf:
+            fix_pdf(
+                input_path,
+                output_path=args.output,
+                dpi=args.dpi,
+                correct_180_flip=not args.no_flip_fix,
+            )
+        else:
+            fix_image(
+                input_path,
+                output_path=args.output,
+                correct_180_flip=not args.no_flip_fix,
+            )
+    except (FileNotFoundError, InvalidImageError, PdfSupportMissingError, UprightKitError) as exc:
+        print(f"uprightkit: error: {exc}", file=sys.stderr)
+        return 1
+
+    print(f"uprightkit: wrote corrected output to {args.output}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

uprightkit/core.py

@@ -0,0 +1,166 @@
+"""
+Core image-straightening logic for uprightKit.
+
+This module contains zero web-framework code on purpose: it is meant to be
+imported and called directly from any Python project (scripts, notebooks,
+other web frameworks, preprocessing pipelines, etc).
+
+Algorithm (unchanged from the original prototype):
+    1. Detect fine skew angle using a probabilistic Hough transform over
+       Canny edges, then rotate to straighten it.
+    2. Detect gross 180-degree (upside-down) flips by comparing the
+       "ink density" of dilated text edges in the top half vs bottom half
+       of the image, then rotate 180 degrees if the bottom is much denser.
+"""
+
+from __future__ import annotations
+
+import math
+from typing import Optional
+
+import cv2
+import numpy as np
+
+
+class UprightKitError(Exception):
+    """Base exception for uprightKit errors."""
+
+
+class InvalidImageError(UprightKitError):
+    """Raised when an image cannot be read or is empty/invalid."""
+
+
+def fix_skew_and_orientation(
+    image: np.ndarray,
+    *,
+    hough_threshold: int = 100,
+    min_line_length: int = 100,
+    max_line_gap: int = 10,
+    skew_angle_tolerance: float = 0.5,
+    flip_density_ratio: float = 1.15,
+    correct_180_flip: bool = True,
+) -> np.ndarray:
+    """
+    Straighten a document image: fix small skew angle and 180-degree flips.
+
+    Parameters
+    ----------
+    image:
+        A BGR image as a numpy array (the format OpenCV uses natively,
+        e.g. from ``cv2.imread`` or ``cv2.imdecode``).
+    hough_threshold, min_line_length, max_line_gap:
+        Passed through to ``cv2.HoughLinesP`` for line detection. Increase
+        ``hough_threshold`` if you get false-positive rotations on noisy
+        images; decrease it if skew isn't being detected at all.
+    skew_angle_tolerance:
+        Minimum |angle| in degrees before a rotation is applied. Avoids
+        introducing blur from micro-rotations on already-straight images.
+    flip_density_ratio:
+        How much denser the bottom half's text edges must be than the top
+        half's before the image is flagged as upside-down. Tune this if
+        your documents don't have a "text-heavy top" layout (see Notes).
+    correct_180_flip:
+        Set to False to skip the upside-down detection step entirely and
+        only correct fine skew. Useful for document types where the
+        top/bottom density heuristic doesn't apply (e.g. photos, forms
+        with a centered logo, mostly-blank-top layouts).
+
+    Returns
+    -------
+    np.ndarray
+        A new BGR image, rotated/straightened. The input array is not
+        modified in place.
+
+    Raises
+    ------
+    InvalidImageError
+        If ``image`` is None, empty, or not a valid 2D/3D array.
+
+    Notes
+    -----
+    The 180-degree flip check assumes text/content is denser near the top
+    of a correctly-oriented page (true for many ID cards, forms, and
+    letters, but not universally true for all document types). If you're
+    getting incorrect flips on your document type, pass
+    ``correct_180_flip=False`` and handle orientation separately.
+    """
+    if image is None or not isinstance(image, np.ndarray) or image.size == 0:
+        raise InvalidImageError("image is None, empty, or not a valid numpy array")
+
+    if image.ndim not in (2, 3):
+        raise InvalidImageError(f"expected a 2D or 3D image array, got shape {image.shape}")
+
+    # Work on a copy so callers' original arrays are never mutated.
+    image = image.copy()
+    h, w = image.shape[:2]
+
+    if h == 0 or w == 0:
+        raise InvalidImageError(f"image has a zero dimension: shape={image.shape}")
+
+    gray = _to_gray(image)
+    blur = cv2.GaussianBlur(gray, (5, 5), 0)
+    edges = cv2.Canny(blur, 50, 150)
+
+    # --- 1. Fine skew correction via Hough transform ---
+    lines = cv2.HoughLinesP(
+        edges,
+        rho=1,
+        theta=np.pi / 180,
+        threshold=hough_threshold,
+        minLineLength=min_line_length,
+        maxLineGap=max_line_gap,
+    )
+
+    median_angle = _median_skew_angle(lines)
+
+    if median_angle is not None and abs(median_angle) > skew_angle_tolerance:
+        M = cv2.getRotationMatrix2D((w // 2, h // 2), median_angle, 1.0)
+        image = cv2.warpAffine(
+            image, M, (w, h),
+            flags=cv2.INTER_CUBIC,
+            borderMode=cv2.BORDER_REPLICATE,
+        )
+        # Recompute edges on the now-straightened image for the next step.
+        gray = _to_gray(image)
+        blur = cv2.GaussianBlur(gray, (5, 5), 0)
+        edges = cv2.Canny(blur, 50, 150)
+
+    # --- 2. Gross 180-degree flip correction via density profiling ---
+    if correct_180_flip:
+        kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (15, 3))
+        dilated = cv2.dilate(edges, kernel, iterations=2)
+
+        mid_y = h // 2
+        top_density = cv2.countNonZero(dilated[0:mid_y, :])
+        bottom_density = cv2.countNonZero(dilated[mid_y:h, :])
+
+        if bottom_density > top_density * flip_density_ratio:
+            image = cv2.rotate(image, cv2.ROTATE_180)
+
+    return image
+
+
+def _to_gray(image: np.ndarray) -> np.ndarray:
+    """Convert BGR or grayscale input to grayscale."""
+    if image.ndim == 2:
+        return image
+    return cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+
+
+def _median_skew_angle(lines: Optional[np.ndarray]) -> Optional[float]:
+    """Compute the median line angle, ignoring near-vertical lines."""
+    if lines is None:
+        return None
+
+    angles = []
+    for line in lines:
+        x1, y1, x2, y2 = line[0]
+        angle = math.degrees(math.atan2(y2 - y1, x2 - x1))
+        # Filter out extreme vertical lines (e.g. card/page borders).
+        if not (45 < abs(angle) < 135):
+            angles.append(angle)
+
+    if not angles:
+        return None
+
+    return float(np.median(angles))

uprightkit-0.1.0.dist-info/METADATA

@@ -0,0 +1,114 @@
+Metadata-Version: 2.4
+Name: uprightkit
+Version: 0.1.0
+Summary: Lightweight, pure-OpenCV document deskewing and orientation correction — no deep learning required.
+Author-email: Girija Geddavalasa <thatsgirijag@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/yourusername/uprightkit
+Project-URL: Issues, https://github.com/yourusername/uprightkit/issues
+Keywords: opencv,deskew,image-processing,document-scanner,ocr-preprocessing,pdf
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Multimedia :: Graphics :: Capture :: Scanners
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: opencv-python-headless>=4.5
+Requires-Dist: numpy>=1.20
+Provides-Extra: pdf
+Requires-Dist: pymupdf>=1.23; extra == "pdf"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Dynamic: license-file
+
+# uprightKit
+
+Lightweight, pure-OpenCV document deskewing and orientation correction.
+No deep learning, no model downloads, no GPU — just classical computer
+vision (Hough transform + edge-density profiling).
+
+It fixes two common problems with scanned/photographed documents:
+
+1. **Fine skew** — the page is tilted a few degrees.
+2. **180-degree flips** — the page was scanned/photographed upside down.
+
+## Install
+
+```bash
+pip install uprightkit
+
+# with PDF support:
+pip install uprightkit[pdf]
+```
+
+## Usage
+
+### Single image
+
+```python
+import uprightkit
+
+uprightkit.fix_image("scan.jpg", output_path="scan_fixed.jpg")
+```
+
+### PDF (page by page)
+
+```python
+import uprightkit
+
+uprightkit.fix_pdf("document.pdf", output_path="document_fixed.pdf")
+```
+
+### Already have a numpy array (e.g. in an existing OpenCV pipeline)?
+
+```python
+import cv2
+import uprightkit
+
+image = cv2.imread("scan.jpg")
+fixed = uprightkit.fix_array(image)  # returns a numpy array, BGR
+```
+
+### Command line
+
+```bash
+uprightkit scan.jpg scan_fixed.jpg
+uprightkit document.pdf document_fixed.pdf
+uprightkit scan.jpg scan_fixed.jpg --no-flip-fix   # skip the 180-degree check
+```
+
+## Tuning
+
+The 180-degree flip detector assumes a correctly-oriented page has more
+text/content density near the top half than the bottom half. This holds for
+many ID cards, forms, and letters — but not for every document layout. If you
+get incorrect flips on your documents, disable it:
+
+```python
+uprightkit.fix_image("scan.jpg", output_path="out.jpg", correct_180_flip=False)
+```
+
+Other tunable parameters (`skew_angle_tolerance`, `flip_density_ratio`,
+`hough_threshold`, `min_line_length`, `max_line_gap`) are documented in the
+docstring of `uprightkit.fix_skew_and_orientation`.
+
+## Why no deep learning?
+
+This is intentionally a fast, dependency-light tool meant for preprocessing
+pipelines (e.g. before OCR) where you don't want to pull in a multi-hundred-MB
+model or pay GPU inference cost just to straighten a page.
+
+## License
+
+MIT --- see [LICENSE](LICENSE).

uprightkit-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+uprightkit/__init__.py,sha256=8hBgriWY8H6aTFmLgLdPbmcLA56riL8fIFzCld2rvPM,939
+uprightkit/api.py,sha256=L9gU4YsWdajc6lb7mSBwsES_8oHnW6IG9Fq6tryBhUo,7467
+uprightkit/cli.py,sha256=5UBz8665mACzu0q4Eix6a9RbqvyxN5Bdg6ahT4TMQqI,1868
+uprightkit/core.py,sha256=3EqLh8zSBFT_2rC7sU7HX5IuEsRSHH2ZBKPHN6TzRC8,5752
+uprightkit-0.1.0.dist-info/licenses/LICENSE,sha256=cqbuOPC-kxXJwX4q6wE-ZeZ6wXgwGIaN_HQy_NO2-Sc,1068
+uprightkit-0.1.0.dist-info/METADATA,sha256=e2Iunjut1vTTy_xuwbFB9KjgfMsRqS2BV9b4rSjAo4Y,3596
+uprightkit-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+uprightkit-0.1.0.dist-info/entry_points.txt,sha256=LQ54r0cp-2mSgq8k4UzmrL3ykJE_7wcYqpKTDDNQkco,51
+uprightkit-0.1.0.dist-info/top_level.txt,sha256=UYe3-PS_k8QktjAId_Dl7ISye-uu6lRX54IpzncufaM,11
+uprightkit-0.1.0.dist-info/RECORD,,

uprightkit-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

uprightkit-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+uprightkit = uprightkit.cli:main

uprightkit-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 [Your Name]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

uprightkit-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+uprightkit