shelfinventory 0.1.0__py3-none-any.whl

shelfinventory/__init__.py

@@ -0,0 +1,8 @@
+"""Export an Audiobookshelf library as one CSV row per book.
+
+Read only. The package never sends anything but HTTP GET requests.
+"""
+
+__version__ = "0.1.0"
+
+__all__ = ["__version__"]

shelfinventory/api.py

@@ -0,0 +1,130 @@
+"""Minimal read-only client for the Audiobookshelf HTTP API.
+
+Only GET requests exist here. There is no method that writes, patches or deletes
+anything on the server, by design.
+
+Endpoints used, with the upstream source that documents their shape:
+
+* ``GET /api/libraries`` returns ``{"libraries": [...]}``
+  (``server/controllers/LibraryController.js``).
+* ``GET /api/libraries/{id}/items?limit=&page=`` returns
+  ``{"results": [...], "total": N, "limit": N, "page": N}`` and each entry is the
+  minified library item JSON (``server/models/LibraryItem.js``,
+  ``toOldJSONMinified``).
+* ``GET /api/items/{id}`` returns the expanded library item JSON, which is the
+  only place where series sequences and author lists are separate fields
+  (``server/models/Book.js``, ``oldMetadataToJSON``).
+
+Authentication is a bearer token in the ``Authorization`` header
+(``server/Auth.js``, ``fromAuthHeaderAsBearerToken``).
+"""
+
+from __future__ import annotations
+
+import json
+import urllib.error
+import urllib.parse
+import urllib.request
+
+DEFAULT_PAGE_SIZE = 500
+DEFAULT_TIMEOUT = 30.0
+
+
+class ApiError(Exception):
+    """Any failure while talking to the server, with a readable message."""
+
+
+def _default_opener(request, timeout):
+    return urllib.request.urlopen(request, timeout=timeout)
+
+
+class Client:
+    """A read-only Audiobookshelf client.
+
+    ``opener`` exists so the tests can answer requests from sample payloads
+    instead of reaching a server. It takes ``(request, timeout)`` and returns a
+    file-like object, exactly like :func:`urllib.request.urlopen`.
+    """
+
+    def __init__(self, base_url, token, timeout=DEFAULT_TIMEOUT, opener=None):
+        if not base_url:
+            raise ApiError("no server address was given")
+        if not token:
+            raise ApiError("no API token was given")
+        self.base_url = base_url.rstrip("/")
+        self.token = token
+        self.timeout = timeout
+        self._opener = opener or _default_opener
+
+    def get_json(self, path, params=None):
+        url = self.base_url + path
+        if params:
+            url += "?" + urllib.parse.urlencode(params)
+        request = urllib.request.Request(
+            url,
+            method="GET",
+            headers={
+                "Authorization": "Bearer " + self.token,
+                "Accept": "application/json",
+            },
+        )
+        try:
+            response = self._opener(request, self.timeout)
+        except urllib.error.HTTPError as error:
+            raise ApiError(_http_message(error, url)) from error
+        except urllib.error.URLError as error:
+            raise ApiError("could not reach %s: %s" % (url, error.reason)) from error
+        with response:
+            raw = response.read()
+        try:
+            return json.loads(raw.decode("utf-8"))
+        except (UnicodeDecodeError, ValueError) as error:
+            raise ApiError("%s did not answer with JSON" % url) from error
+
+    def libraries(self):
+        """Every library the token can see, as a list of dicts."""
+        payload = self.get_json("/api/libraries")
+        libraries = payload.get("libraries")
+        if not isinstance(libraries, list):
+            raise ApiError("the server did not return a list of libraries")
+        return libraries
+
+    def library_items(self, library_id, page_size=DEFAULT_PAGE_SIZE):
+        """Yield every library item of one library, walking the pages."""
+        if page_size < 1:
+            raise ApiError("the page size must be at least 1")
+        page = 0
+        seen = 0
+        while True:
+            payload = self.get_json(
+                "/api/libraries/%s/items" % urllib.parse.quote(str(library_id)),
+                {"limit": page_size, "page": page},
+            )
+            results = payload.get("results")
+            if not isinstance(results, list):
+                raise ApiError("the server did not return a list of items")
+            if not results:
+                return
+            for entry in results:
+                yield entry
+            seen += len(results)
+            total = payload.get("total")
+            if isinstance(total, int) and seen >= total:
+                return
+            if len(results) < page_size:
+                return
+            page += 1
+
+    def item(self, item_id):
+        """One library item in its expanded form."""
+        return self.get_json("/api/items/%s" % urllib.parse.quote(str(item_id)))
+
+
+def _http_message(error, url):
+    if error.code == 401:
+        return "the server rejected the token (401) for %s" % url
+    if error.code == 403:
+        return "the token is not allowed to read %s (403)" % url
+    if error.code == 404:
+        return "%s does not exist on this server (404)" % url
+    return "%s answered %s %s" % (url, error.code, error.reason)

shelfinventory/cli.py

@@ -0,0 +1,257 @@
+"""Command line entry point for shelfinventory."""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import os
+import sys
+
+from . import __version__
+from .api import DEFAULT_PAGE_SIZE, DEFAULT_TIMEOUT, ApiError, Client
+from .rows import COLUMNS, apply_exact_fields, count_filled, row_from_item
+
+TOKEN_ENV = "AUDIOBOOKSHELF_TOKEN"
+URL_ENV = "AUDIOBOOKSHELF_URL"
+
+DELIMITER_NAMES = {
+    "comma": ",",
+    "semicolon": ";",
+    "tab": "\t",
+    "pipe": "|",
+    "colon": ":",
+}
+
+
+def parse_delimiter(text):
+    """A delimiter given either by name or as the character itself."""
+    if text is None:
+        return ","
+    lowered = text.lower()
+    if lowered in DELIMITER_NAMES:
+        return DELIMITER_NAMES[lowered]
+    if text == "\\t":
+        return "\t"
+    if len(text) == 1:
+        return text
+    raise ValueError(
+        "a delimiter is one character, or one of: %s"
+        % ", ".join(sorted(DELIMITER_NAMES))
+    )
+
+
+def select_libraries(libraries, wanted):
+    """Pick the libraries to export, by name or id.
+
+    With no name given, every book library is exported. Podcast libraries are
+    never exported: the columns asked for are book columns.
+    """
+    books = [
+        library
+        for library in libraries
+        if library.get("mediaType", "book") == "book"
+    ]
+    if not wanted:
+        return books
+    by_key = {}
+    for library in books:
+        by_key[str(library.get("name", "")).lower()] = library
+        by_key[str(library.get("id", "")).lower()] = library
+    chosen = []
+    missing = []
+    for name in wanted:
+        library = by_key.get(name.lower())
+        if library is None:
+            missing.append(name)
+        elif library not in chosen:
+            chosen.append(library)
+    if missing:
+        known = ", ".join(str(library.get("name")) for library in books) or "none"
+        raise ApiError(
+            "no book library named %s; book libraries on this server: %s"
+            % (", ".join(missing), known)
+        )
+    return chosen
+
+
+def build_rows(client, libraries, page_size=DEFAULT_PAGE_SIZE,
+               duration_style="hms", exact=False):
+    """Every row of every given library, in the order the server returns them."""
+    rows = []
+    for library in libraries:
+        library_name = str(library.get("name", ""))
+        library_id = library.get("id")
+        for item in client.library_items(library_id, page_size=page_size):
+            row = row_from_item(item, library_name, duration_style)
+            if exact:
+                item_id = item.get("id")
+                if item_id:
+                    apply_exact_fields(row, client.item(item_id))
+            rows.append(row)
+    return rows
+
+
+def write_csv(rows, stream, delimiter=","):
+    writer = csv.DictWriter(
+        stream, fieldnames=list(COLUMNS), delimiter=delimiter, lineterminator="\n"
+    )
+    writer.writeheader()
+    for row in rows:
+        writer.writerow(row)
+
+
+def coverage_report(rows):
+    """Lines saying which columns the server actually filled."""
+    total = len(rows)
+    lines = ["%d book(s) exported, %d columns." % (total, len(COLUMNS))]
+    if not total:
+        return lines
+    counts = count_filled(rows)
+    empty = [name for name in COLUMNS if counts[name] == 0]
+    partial = [
+        "%s (%d/%d)" % (name, counts[name], total)
+        for name in COLUMNS
+        if 0 < counts[name] < total
+    ]
+    if empty:
+        lines.append("Empty for every book: %s." % ", ".join(empty))
+    else:
+        lines.append("Every column had a value on at least one book.")
+    if partial:
+        lines.append("Filled on some books only: %s." % ", ".join(partial))
+    return lines
+
+
+def build_parser():
+    parser = argparse.ArgumentParser(
+        prog="shelfinventory",
+        description=(
+            "Export an Audiobookshelf library to CSV, one row per book. "
+            "Reads over the HTTP API and writes nothing to the server."
+        ),
+    )
+    parser.add_argument(
+        "--url",
+        default=os.environ.get(URL_ENV),
+        help="server address, for example https://books.example.com (or %s)" % URL_ENV,
+    )
+    parser.add_argument(
+        "--library",
+        action="append",
+        metavar="NAME",
+        help="library name or id; repeat for several; default is every book library",
+    )
+    parser.add_argument(
+        "--out", metavar="FILE", help="write the CSV here instead of standard output"
+    )
+    parser.add_argument(
+        "--delimiter",
+        default=",",
+        help="field delimiter: one character, or comma, semicolon, tab, pipe, colon",
+    )
+    parser.add_argument(
+        "--duration",
+        choices=("hms", "seconds"),
+        default="hms",
+        help="duration as H:MM:SS (default) or as a number of seconds",
+    )
+    parser.add_argument(
+        "--exact",
+        action="store_true",
+        help=(
+            "read each book a second time to get exact author, narrator and "
+            "series fields instead of splitting the joined ones; one extra "
+            "request per book"
+        ),
+    )
+    parser.add_argument(
+        "--page-size",
+        type=int,
+        default=DEFAULT_PAGE_SIZE,
+        metavar="N",
+        help="books per request (default %d)" % DEFAULT_PAGE_SIZE,
+    )
+    parser.add_argument(
+        "--timeout",
+        type=float,
+        default=DEFAULT_TIMEOUT,
+        metavar="SECONDS",
+        help="request timeout in seconds (default %g)" % DEFAULT_TIMEOUT,
+    )
+    parser.add_argument(
+        "--list-libraries",
+        action="store_true",
+        help="print the libraries this token can read, then stop",
+    )
+    parser.add_argument(
+        "--quiet", action="store_true", help="do not print the column report"
+    )
+    parser.add_argument("--version", action="version", version=__version__)
+    return parser
+
+
+def main(argv=None):
+    parser = build_parser()
+    args = parser.parse_args(argv)
+
+    if not args.url:
+        parser.error("no server address; pass --url or set %s" % URL_ENV)
+    token = os.environ.get(TOKEN_ENV)
+    if not token:
+        parser.error(
+            "no API token; set %s to a token from your account settings" % TOKEN_ENV
+        )
+    try:
+        delimiter = parse_delimiter(args.delimiter)
+    except ValueError as error:
+        parser.error(str(error))
+    if args.page_size < 1:
+        parser.error("--page-size must be at least 1")
+
+    client = Client(args.url, token, timeout=args.timeout)
+    try:
+        libraries = client.libraries()
+        if args.list_libraries:
+            for library in libraries:
+                sys.stdout.write(
+                    "%s\t%s\t%s\n"
+                    % (
+                        library.get("name", ""),
+                        library.get("mediaType", ""),
+                        library.get("id", ""),
+                    )
+                )
+            return 0
+        chosen = select_libraries(libraries, args.library)
+        if not chosen:
+            sys.stderr.write("no book library on this server\n")
+            return 1
+        rows = build_rows(
+            client,
+            chosen,
+            page_size=args.page_size,
+            duration_style=args.duration,
+            exact=args.exact,
+        )
+    except ApiError as error:
+        sys.stderr.write("%s\n" % error)
+        return 1
+
+    if args.out:
+        try:
+            with open(args.out, "w", newline="", encoding="utf-8") as handle:
+                write_csv(rows, handle, delimiter)
+        except OSError as error:
+            sys.stderr.write("could not write %s: %s\n" % (args.out, error))
+            return 1
+    else:
+        write_csv(rows, sys.stdout, delimiter)
+
+    if not args.quiet:
+        for line in coverage_report(rows):
+            sys.stderr.write("%s\n" % line)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

shelfinventory/rows.py

@@ -0,0 +1,203 @@
+"""Turn Audiobookshelf library items into CSV rows.
+
+The column list is not ours. It is the list written by the person who asked for
+this export on the upstream feature request, in her own order. The only change
+is that her single "published date or year" entry becomes two columns, because
+the server stores those as two separate fields and joining them would lose one.
+"""
+
+from __future__ import annotations
+
+import datetime
+
+MULTI_JOIN = "; "
+
+COLUMNS = (
+    "title",
+    "subtitle",
+    "authors",
+    "narrators",
+    "series_name",
+    "series_sequence",
+    "genres",
+    "tags",
+    "published_date",
+    "published_year",
+    "publisher",
+    "asin",
+    "isbn",
+    "duration",
+    "date_added",
+    "library_name",
+    "relative_path",
+    "explicit",
+)
+
+
+def format_duration(seconds, style="hms"):
+    """Seconds as ``H:MM:SS``, or as a plain number of seconds."""
+    if seconds is None or isinstance(seconds, bool):
+        return ""
+    try:
+        value = float(seconds)
+    except (TypeError, ValueError):
+        return ""
+    if value != value or value in (float("inf"), float("-inf")):
+        return ""
+    if style == "seconds":
+        return "%g" % value
+    if value < 0:
+        return ""
+    whole = int(round(value))
+    hours, rest = divmod(whole, 3600)
+    minutes, secs = divmod(rest, 60)
+    return "%d:%02d:%02d" % (hours, minutes, secs)
+
+
+def format_added(added_at):
+    """Epoch milliseconds as an ISO 8601 instant in UTC."""
+    if added_at is None or isinstance(added_at, bool):
+        return ""
+    try:
+        millis = float(added_at)
+    except (TypeError, ValueError):
+        return ""
+    try:
+        moment = datetime.datetime.fromtimestamp(
+            millis / 1000.0, datetime.timezone.utc
+        )
+    except (OverflowError, OSError, ValueError):
+        return ""
+    return moment.strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def format_flag(value):
+    if value is None:
+        return ""
+    return "true" if value else "false"
+
+
+def _text(value):
+    if value is None or isinstance(value, bool):
+        return ""
+    return str(value)
+
+
+def _join(values):
+    if not isinstance(values, (list, tuple)):
+        return _text(values)
+    return MULTI_JOIN.join(_text(item) for item in values if _text(item))
+
+
+def split_series_name(series_name):
+    """Split the server's joined series string into names and sequences.
+
+    The paginated library endpoint does not expose series sequences as their own
+    field. It only exposes ``seriesName``, which the server builds by joining
+    ``"<name> #<sequence>"`` entries with ``", "``. Splitting that back apart is
+    a guess, not a reading: a series whose own name contains a comma, or a
+    sequence that contains " #", cannot be recovered this way. Use the exact
+    mode when that matters.
+    """
+    text = _text(series_name).strip()
+    if not text:
+        return "", ""
+    names = []
+    sequences = []
+    for entry in text.split(", "):
+        entry = entry.strip()
+        if not entry:
+            continue
+        name, marker, sequence = entry.rpartition(" #")
+        if marker:
+            names.append(name.strip())
+            sequences.append(sequence.strip())
+        else:
+            names.append(entry)
+            sequences.append("")
+    if not any(sequences):
+        return MULTI_JOIN.join(names), ""
+    return MULTI_JOIN.join(names), MULTI_JOIN.join(sequences)
+
+
+def row_from_item(item, library_name="", duration_style="hms"):
+    """One row, built from the minified library item the list endpoint returns."""
+    item = item if isinstance(item, dict) else {}
+    media = item.get("media") if isinstance(item.get("media"), dict) else {}
+    metadata = media.get("metadata") if isinstance(media.get("metadata"), dict) else {}
+    series_name, series_sequence = split_series_name(metadata.get("seriesName"))
+    return {
+        "title": _text(metadata.get("title")),
+        "subtitle": _text(metadata.get("subtitle")),
+        "authors": _text(metadata.get("authorName")),
+        "narrators": _text(metadata.get("narratorName")),
+        "series_name": series_name,
+        "series_sequence": series_sequence,
+        "genres": _join(metadata.get("genres")),
+        "tags": _join(media.get("tags")),
+        "published_date": _text(metadata.get("publishedDate")),
+        "published_year": _text(metadata.get("publishedYear")),
+        "publisher": _text(metadata.get("publisher")),
+        "asin": _text(metadata.get("asin")),
+        "isbn": _text(metadata.get("isbn")),
+        "duration": format_duration(media.get("duration"), duration_style),
+        "date_added": format_added(item.get("addedAt")),
+        "library_name": _text(library_name),
+        "relative_path": _text(item.get("relPath") or item.get("path")),
+        "explicit": format_flag(metadata.get("explicit")),
+    }
+
+
+def apply_exact_fields(row, expanded_item):
+    """Overwrite the parsed fields with the exact ones from an expanded item.
+
+    The expanded item endpoint returns ``authors``, ``narrators`` and ``series``
+    as real lists, so nothing has to be split back apart. Fields the expanded
+    payload does not carry are left as they were.
+    """
+    media = {}
+    if isinstance(expanded_item, dict):
+        candidate = expanded_item.get("media")
+        if isinstance(candidate, dict):
+            media = candidate
+    metadata = media.get("metadata") if isinstance(media.get("metadata"), dict) else {}
+
+    authors = metadata.get("authors")
+    if isinstance(authors, list):
+        row["authors"] = MULTI_JOIN.join(
+            _text(author.get("name") if isinstance(author, dict) else author)
+            for author in authors
+            if _text(author.get("name") if isinstance(author, dict) else author)
+        )
+
+    narrators = metadata.get("narrators")
+    if isinstance(narrators, list):
+        row["narrators"] = _join(narrators)
+
+    series = metadata.get("series")
+    if isinstance(series, list):
+        names = []
+        sequences = []
+        for entry in series:
+            if isinstance(entry, dict):
+                names.append(_text(entry.get("name")))
+                sequences.append(_text(entry.get("sequence")))
+            else:
+                names.append(_text(entry))
+                sequences.append("")
+        names = [name for name in names if name]
+        row["series_name"] = MULTI_JOIN.join(names)
+        row["series_sequence"] = (
+            MULTI_JOIN.join(sequences) if any(sequences) else ""
+        )
+    return row
+
+
+def count_filled(rows):
+    """How many rows have a non-empty value in each column."""
+    counts = dict((name, 0) for name in COLUMNS)
+    for row in rows:
+        for name in COLUMNS:
+            if row.get(name):
+                counts[name] += 1
+    return counts

shelfinventory-0.1.0.dist-info/METADATA

@@ -0,0 +1,130 @@
+Metadata-Version: 2.4
+Name: shelfinventory
+Version: 0.1.0
+Summary: Export an Audiobookshelf library to CSV, one row per book, with the columns people asked for. Read only, no dependencies.
+Author: Younes Z.
+License: MIT
+Project-URL: Homepage, https://github.com/Rezarys/shelfinventory
+Project-URL: Issues, https://github.com/Rezarys/shelfinventory/issues
+Keywords: audiobookshelf,audiobook,library,inventory,csv,export,catalog,selfhosted
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# shelfinventory
+
+```
+pip install shelfinventory
+```
+
+Export an Audiobookshelf library to CSV, one row per book, with the columns people actually asked for on the upstream request thread. It reads over the HTTP API and writes nothing back to your server.
+
+Why it exists: the request thread [advplyr/audiobookshelf#2085](https://github.com/advplyr/audiobookshelf/issues/2085) asks for a CSV inventory of what is really in the library. The workarounds described there are exporting from another tool, which reflects a different catalog, or opening the SQLite database with a generic client. This does the same job in one command, through the API, without touching the database file.
+
+## Use
+
+Set a token, then run it.
+
+```
+export AUDIOBOOKSHELF_TOKEN=your-api-token
+```
+
+```
+shelfinventory --url https://abs.example
+```
+
+That prints the CSV on standard output. To write a file instead:
+
+```
+shelfinventory --url https://abs.example --out books.csv
+```
+
+The token is the API token from your Audiobookshelf account settings. It is read from the environment only, never from an argument, so it does not land in your shell history. The server address can also come from `AUDIOBOOKSHELF_URL`.
+
+Titles contain commas, so the delimiter is yours to choose:
+
+```
+shelfinventory --url https://abs.example --delimiter tab
+```
+
+`--delimiter` takes one character, or one of `comma`, `semicolon`, `tab`, `pipe`, `colon`. Fields are quoted properly whatever you pick, so a comma inside a title never splits a row.
+
+## Columns
+
+Eighteen columns, in this order:
+
+- `title`
+- `subtitle`
+- `authors`
+- `narrators`
+- `series_name`
+- `series_sequence`
+- `genres`
+- `tags`
+- `published_date`
+- `published_year`
+- `publisher`
+- `asin`
+- `isbn`
+- `duration`
+- `date_added`
+- `library_name`
+- `relative_path`
+- `explicit`
+
+That list is not mine. It is the list written on the request thread, in the same order, with one change: the single "published date or year" entry became two columns, because the server stores those as two separate fields and merging them would throw one away.
+
+Multiple genres, tags or series are joined with `; ` inside one cell. Multiple authors and narrators get that same `; ` join only when you pass `--exact`; without it, they keep whatever separator the server itself used to join them. `duration` is `H:MM:SS` by default, or a number of seconds with `--duration seconds`. `date_added` is an ISO 8601 instant in UTC.
+
+Every run, unless you pass `--quiet`, prints a short report on standard error saying how many books were exported and which columns your server left empty for every one of them. That report is the honest answer to whether your library really carries this metadata, and it never mixes into the CSV.
+
+With no `--library`, every book library goes into the same CSV, and the `library_name` column says which one each row came from.
+
+## Series sequences, and one honest caveat
+
+The paginated library endpoint does not expose a series sequence as its own field. It exposes one joined string per book, built by the server as `"<name> #<sequence>"` entries separated by a comma. This tool splits that back apart, which is a guess and not a reading: a series whose own name contains a comma cannot be recovered that way.
+
+If exact series and author fields matter to you, use:
+
+```
+shelfinventory --url https://abs.example --exact
+```
+
+That reads each book a second time, through the endpoint that returns real lists, so nothing has to be split. It costs one extra request per book, which is why it is not the default.
+
+## Other options
+
+- `--library NAME` picks one library by name or id, and repeats.
+- `--list-libraries` prints what the token can read, then stops.
+- `--page-size N` sets how many books are fetched per request.
+- `--timeout SECONDS` sets the request timeout.
+- `--quiet` drops the column report.
+
+Podcast libraries are never exported. The columns above are book columns.
+
+## What is not verified
+
+Being plain about this matters more than looking finished:
+
+- No real Audiobookshelf instance has been read with this tool. The response shapes it expects come from the upstream public source code, read on 2026-09-30: `server/models/Book.js`, `server/models/LibraryItem.js` and `server/controllers/LibraryController.js`.
+- The tests run on sample payloads written for the tests, not on captured traffic from a live server.
+- Whether your server fills all eighteen columns is not something anyone has measured. The report printed on standard error is there so you can see it for yourself on the first run.
+
+If you run it on a real library, please say so on the issue tracker, whether it worked or not. The paragraph above gets corrected the day someone reports a first-hand result.
+
+## Requirements
+
+Python 3.9 or newer. The standard library only, no dependencies.
+
+## License
+
+MIT. Built with AI assistance, reviewed and tested by me.
+
+Younes Z.

shelfinventory-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+shelfinventory/__init__.py,sha256=_u_Z2HSgCe1bK5_WPhjaEAUS2c-9FbyE9kZQ3opHtGM,183
+shelfinventory/api.py,sha256=-i4v6eAPtips351AdPX5AhuewiFXOu-UWo6qxiRl0Jg,4780
+shelfinventory/cli.py,sha256=yRFmobcs56ThAcMvvzoqmALZwFS7U5tbfRQ9QYehGqU,7831
+shelfinventory/rows.py,sha256=-_rXtMrz2l-GD1gk7rl-pgre4LMsuMoZ-bSMVnjCWak,6750
+shelfinventory-0.1.0.dist-info/licenses/LICENSE,sha256=Y2A2qHmmnYqakqTX3wPyhl2UBUwP8eCtG7yH1ylrWRI,1066
+shelfinventory-0.1.0.dist-info/METADATA,sha256=mxe3qr99LYILhtTrFE_ByyfCU3bCj1GuPc6w-AS4IF4,5680
+shelfinventory-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+shelfinventory-0.1.0.dist-info/entry_points.txt,sha256=ItLveRLUHIQ5c31QEDX-_xgDUSxAFqCBkrEZEiLcpJk,59
+shelfinventory-0.1.0.dist-info/top_level.txt,sha256=IFNmcdpH79hPEAVev3u0b_GYSeOTUsJmVwedMQ0J-T0,15
+shelfinventory-0.1.0.dist-info/RECORD,,

shelfinventory-0.1.0.dist-info/WHEEL

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

shelfinventory-0.1.0.dist-info/entry_points.txt

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

shelfinventory-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Younes Z.
+
+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.

shelfinventory-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+shelfinventory