libro-book 0.1.0__tar.gz

libro_book-0.1.0/.cursor/rules/ja-rule.mdc

@@ -0,0 +1,18 @@
+---
+description: 
+globs: 
+alwaysApply: true
+---
+You are an expert Python developer, skilled in the ability to create beautiful command-line tools utilizing libraries and frameworks such as rich.
+
+Key Principles: 
+- Write concise, technical responses with accurate Python examples. 
+- Prioritize readability, efficiency, and maintainability. 
+- Use modular and reusable functions to handle common tasks. 
+- Follow PEP 8 style guidelines for Python code. 
+
+Data Handling:
+- Data is stored in a sqlite3 database, only use functions and SQL that are compatibile
+- Dates are stored in YYYY-MM-DD format
+
+

libro_book-0.1.0/.gitignore

@@ -0,0 +1,7 @@
+data/
+libro.db
+libro.bak
+
+.ruff_cache
+uv.lock
+.venv/

libro_book-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Marcus Kazmierczak
+
+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.

libro_book-0.1.0/PKG-INFO

@@ -0,0 +1,132 @@
+Metadata-Version: 2.4
+Name: libro-book
+Version: 0.1.0
+Summary: A command-line tool to track books read
+Author-email: Marcus Kazmierczak <marcus@mkaz.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: books,library,reading
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Requires-Dist: appdirs>=1.4
+Requires-Dist: rich>=13.3
+Description-Content-Type: text/markdown
+
+# Libro
+
+📚 Libro: A simple command-line tool to track your reading history, with your data stored locally in a SQLite database.
+
+## Usage
+
+Add new book: `libro add`
+
+Show books read by year: `libro show --year 2024`
+
+Show book details by id: `libro show 123`
+
+Show books read by year: `libro report`
+
+Show books read by author: `libro report --author`
+
+## Install
+
+Libro is packaged as `libro-book` on PyPI.
+
+```
+pip install libro-book
+```
+
+You can also clone this repository and install it locally:
+
+```
+git clone https://github.com/mkaz/libro.git
+cd libro
+pip install -e .
+```
+
+## Setup
+
+On first run, libro will create a `libro.db` database file based on database location. It will prompt for confirmation to proceed which also shows the location where the file will be created.
+
+**Database locations:**
+
+The following order is used to determine the database location:
+
+1. Using the `--db` flag on command-line.
+
+2. `libro.db` in current directory
+
+3. Environment variable `LIBRO_DB` to specify custom file/location
+
+4. Finally, the user's platform-specific data directory
+    * Linux: `~/.local/share/libro/libro.db`
+    * macOS: `~/Library/Application Support/libro/libro.db`
+    * Windows: `%APPDATA%\libro\libro.db`
+
+
+For example, if you want to create a new database file in the current directory, you can use the following command:
+
+```
+libro --db ./libro.db
+```
+
+### Import from Goodreads
+
+Libro can import your reading history from a Goodreads export CSV file.
+
+```
+libro import goodreads_library_export.csv
+```
+
+There is a `genre` field for fiction and nonfiction, but this data is not available in the Goodreads export. I still need to build the edit book functionality to change the genre.
+
+# Database Schema
+
+## Books table
+
+| Field | Type | Description |
+|-------|------|-------------|
+| id | primary key | Unique identifier |
+| title | string | Book title |
+| author | string | Book author |
+| pages | int | Number of pages in book |
+| pub_year | int | Year book was published |
+| genre | string | Fiction or nonfiction |
+
+## Reviews table
+
+| Field | Type | Description |
+|-------|------|-------------|
+| id | primary key | Unique identifier |
+| book_id | foreign key | Book identifier |
+| date_read | date | Date book was read |
+| rating | float | Number between 0 and 5 |
+| review | text | Review of book |
+
+# Packaging
+
+Notes to self, I forget how to do this stuff.
+
+Libro is packaged as `libro-book` on PyPI.
+
+Packaging is done with `hatchling`, [see Guide](https://packaging.python.org/en/latest/tutorials/packaging-projects/)
+
+```
+# install tools
+py -m pip install --upgrade build twine
+```
+
+```
+# build
+py -m build
+```
+
+```
+# upload
+py -m twine upload dist/*
+```

libro_book-0.1.0/justfile

@@ -0,0 +1,28 @@
+#!/usr/bin/env just --justfile
+
+# List all recipes
+default:
+    @just --list
+
+# Run pre-commit checks
+lint:
+    ruff check src/libro/
+
+# Clean Python artifacts
+clean:
+    rm -rf build/
+    rm -rf dist/
+    rm -rf *.egg-info
+    find . -type d -name __pycache__ -exec rm -rf {} +
+    find . -type f -name "*.pyc" -delete
+
+# Build the project
+install:
+    uv sync
+
+build: install
+    uv build
+
+# Run the CLI application
+run *args:
+    uv run src/libro/main.py {{args}}

libro_book-0.1.0/pyproject.toml

@@ -0,0 +1,36 @@
+[project]
+name = "libro-book"
+version = "0.1.0"
+description = "A command-line tool to track books read"
+authors = [ {name = "Marcus Kazmierczak", email = "marcus@mkaz.com"} ]
+license = "MIT"
+license-files = ["LICENSE"]
+readme = "readme.md"
+keywords = ["books", "reading", "library"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: End Users/Desktop",
+    "Natural Language :: English",
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+requires-python = ">=3.10"
+dependencies = [
+    "appdirs>=1.4",
+    "rich>=13.3",
+]
+
+[project.scripts]
+libro = "libro.main:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/libro"]
+
+
+[tool.ruff]
+target-version = "py310"

libro_book-0.1.0/readme.md

@@ -0,0 +1,113 @@
+# Libro
+
+📚 Libro: A simple command-line tool to track your reading history, with your data stored locally in a SQLite database.
+
+## Usage
+
+Add new book: `libro add`
+
+Show books read by year: `libro show --year 2024`
+
+Show book details by id: `libro show 123`
+
+Show books read by year: `libro report`
+
+Show books read by author: `libro report --author`
+
+## Install
+
+Libro is packaged as `libro-book` on PyPI.
+
+```
+pip install libro-book
+```
+
+You can also clone this repository and install it locally:
+
+```
+git clone https://github.com/mkaz/libro.git
+cd libro
+pip install -e .
+```
+
+## Setup
+
+On first run, libro will create a `libro.db` database file based on database location. It will prompt for confirmation to proceed which also shows the location where the file will be created.
+
+**Database locations:**
+
+The following order is used to determine the database location:
+
+1. Using the `--db` flag on command-line.
+
+2. `libro.db` in current directory
+
+3. Environment variable `LIBRO_DB` to specify custom file/location
+
+4. Finally, the user's platform-specific data directory
+    * Linux: `~/.local/share/libro/libro.db`
+    * macOS: `~/Library/Application Support/libro/libro.db`
+    * Windows: `%APPDATA%\libro\libro.db`
+
+
+For example, if you want to create a new database file in the current directory, you can use the following command:
+
+```
+libro --db ./libro.db
+```
+
+### Import from Goodreads
+
+Libro can import your reading history from a Goodreads export CSV file.
+
+```
+libro import goodreads_library_export.csv
+```
+
+There is a `genre` field for fiction and nonfiction, but this data is not available in the Goodreads export. I still need to build the edit book functionality to change the genre.
+
+# Database Schema
+
+## Books table
+
+| Field | Type | Description |
+|-------|------|-------------|
+| id | primary key | Unique identifier |
+| title | string | Book title |
+| author | string | Book author |
+| pages | int | Number of pages in book |
+| pub_year | int | Year book was published |
+| genre | string | Fiction or nonfiction |
+
+## Reviews table
+
+| Field | Type | Description |
+|-------|------|-------------|
+| id | primary key | Unique identifier |
+| book_id | foreign key | Book identifier |
+| date_read | date | Date book was read |
+| rating | float | Number between 0 and 5 |
+| review | text | Review of book |
+
+# Packaging
+
+Notes to self, I forget how to do this stuff.
+
+Libro is packaged as `libro-book` on PyPI.
+
+Packaging is done with `hatchling`, [see Guide](https://packaging.python.org/en/latest/tutorials/packaging-projects/)
+
+```
+# install tools
+py -m pip install --upgrade build twine
+```
+
+```
+# build
+py -m build
+```
+
+```
+# upload
+py -m twine upload dist/*
+```

libro_book-0.1.0/src/libro/actions/add.py

@@ -0,0 +1,54 @@
+import sqlite3
+
+from libro.utils import get_valid_input, validate_and_convert_date
+from libro.models import Book, Review
+
+
+def add_book(db, args):
+    try:
+        print("Enter book details:")
+        title = get_valid_input("Title: ")
+        author = get_valid_input("Author: ")
+
+        pub_year = get_valid_input(
+            "Publication year: ",
+            lambda x: validate_and_convert_date(x, "pub_year"),
+            allow_empty=True,
+        )
+        pages = get_valid_input("Number of pages: ", allow_empty=True)
+        genre = get_genre()
+
+        date_read = get_valid_input(
+            "Date read (YYYY-MM-DD): ",
+            lambda x: validate_and_convert_date(x, "date_read"),
+            allow_empty=True,
+        )
+        rating = get_valid_input("Rating (1-5): ", allow_empty=True)
+        my_review = get_valid_input("Your review:", allow_empty=True, multiline=True)
+
+        # Create and insert book
+        book = Book(
+            title=title, author=author, pub_year=pub_year, pages=pages, genre=genre
+        )
+        book_id = book.insert(db)
+
+        # Create and insert review
+        review = Review(
+            book_id=book_id, date_read=date_read, rating=rating, review=my_review
+        )
+        review.insert(db)
+
+        print(f"\nSuccessfully added '{title}' to the database!")
+
+    except sqlite3.Error as e:
+        print(f"Database error: {e}")
+    except Exception as e:
+        print(f"Error: {e}")
+
+
+def get_genre():
+    while True:
+        genre = input("Genre (fiction/nonfiction): ").strip().lower()
+        if genre in ["fiction", "nonfiction"]:
+            return genre
+        print("Please enter either 'fiction' or 'nonfiction'")

libro_book-0.1.0/src/libro/actions/db.py

@@ -0,0 +1,28 @@
+import sqlite3
+
+
+def init_db(dbfile):
+    conn = sqlite3.connect(dbfile)
+    cursor = conn.cursor()
+    cursor.execute("""CREATE TABLE books (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            title TEXT NOT NULL,
+            author TEXT NOT NULL,
+            pub_year INTEGER,
+            pages INTEGER,
+            genre TEXT
+        )
+    """)
+    conn.commit()
+
+    cursor.execute("""CREATE TABLE reviews (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            book_id INTEGER,
+            date_read DATE,
+            rating INTEGER,
+            review TEXT,
+            FOREIGN KEY (book_id) REFERENCES books(id)
+        )
+    """)
+
+    conn.close()

libro_book-0.1.0/src/libro/actions/importer.py

@@ -0,0 +1,94 @@
+from pathlib import Path
+import csv
+import re
+from datetime import datetime
+from libro.models import Book, Review
+
+
+def import_books(db, args):
+    f = args["file"]
+    print(f"Importing books from {f}")
+
+    # check file exists
+    if not Path(f).is_file():
+        print(f"File {f} not found")
+        return
+
+    # read file
+    count = 0
+    with open(f, "r") as file:
+        reader = csv.DictReader(file)
+        for row in reader:
+            # Author field includes where spacing and tabs, so we need to clean it up
+            author = row["Author"].replace("\t", " ").replace("  ", " ").strip()
+            while "  " in author:
+                author = author.replace("  ", " ")
+
+            # @TODO: Make this a import flag
+            # Title field includes series info that is not the title
+            # For example: Ender's Game (Ender's Saga, #1)
+            raw_title = row["Title"].strip()
+            # Regex to capture the title part before parenthesis *only if* the parenthesis contains '#'
+            series_pattern = re.compile(r"^(.*?)\s*\([^#]*#.*\)$")
+            match = series_pattern.match(raw_title)
+            if match:
+                # If it matches the series pattern (contains '#'), take the part before the parenthesis
+                title = match.group(1).strip()
+            else:
+                # Otherwise (no parenthesis or parenthesis without '#'), use the raw title as is
+                title = raw_title
+
+            # @TODO: Make this a import flag
+            # Moar cleanup - annoying non-fiction books have a colon and extra junk to promote.
+            # Remove colon and everything after it
+            # For example: Eats, Shoots & Leaves: The Zero Tolerance Approach to Punctuation
+            title = title.split(":")[0].strip()
+
+            pub_year = row["Original Publication Year"].strip()
+            pages = row["Number of Pages"].strip()
+            # Note: Ensure 'from datetime import datetime' is present at the top of the file.
+            raw_date_read = row["Date Read"].strip()
+            date_read = None  # Default to None if empty or invalid
+            if raw_date_read:
+                try:
+                    # Parse the date assuming Goodreads format YYYY/MM/DD
+                    date_obj = datetime.strptime(raw_date_read, "%Y/%m/%d")
+                    # Format to YYYY-MM-DD, which is suitable for SQLite and the Review model
+                    date_read = date_obj.strftime("%Y-%m-%d")
+                except ValueError:
+                    # Handle cases where the date format might be different or invalid
+                    print(
+                        f"Warning: Could not parse 'Date Read' field ('{raw_date_read}') for {title}. Setting date to None."
+                    )
+            rating = row["My Rating"].strip()
+            review = row["My Review"].strip()
+
+            # There are many lets combine and look for "read"
+            # Bookshelves, Bookshelves with positions, Exclusive Shelf into a set
+            shelf1 = row["Bookshelves"]
+            shelf2 = row["Bookshelves with positions"]
+            shelf3 = row["Exclusive Shelf"]
+            shelf = ",".join([s.strip() for s in [shelf1, shelf2, shelf3] if s])
+            shelf = shelf.split(",")
+            shelf = set(shelf)
+
+            if "read" in shelf:
+                count += 1
+
+                # Create and insert book
+                book = Book(
+                    title=title,
+                    author=author,
+                    pub_year=pub_year,
+                    pages=pages,
+                    genre="fiction",  # Default to fiction, could be improved
+                )
+                book_id = book.insert(db)
+
+                # Create and insert review
+                review = Review(
+                    book_id=book_id, date_read=date_read, rating=rating, review=review
+                )
+                review.insert(db)
+
+    print(f"Imported {count} books")

libro_book-0.1.0/src/libro/actions/report.py

@@ -0,0 +1,92 @@
+# Bar chart of books read by year
+
+import sqlite3
+from rich.console import Console
+from rich.table import Table
+from rich import box
+
+
+def get_books_by_year(db):
+    """Get count of books read per year."""
+    try:
+        cursor = db.cursor()
+        cursor.execute(
+            """
+            SELECT strftime('%Y', r.date_read) as year, COUNT(*) as count
+            FROM books b
+            JOIN reviews r ON b.id = r.book_id
+            WHERE r.date_read IS NOT NULL
+            GROUP BY year
+            ORDER BY year
+        """
+        )
+        return cursor.fetchall()
+    except sqlite3.Error as e:
+        print(f"Database error: {e}")
+        return None
+
+
+def show_author_report(db):
+    """Display a report of most read authors."""
+    try:
+        cursor = db.cursor()
+        cursor.execute("""
+            SELECT b.author, COUNT(*) as count
+            FROM books b
+            JOIN reviews r ON b.id = r.book_id
+            WHERE r.date_read IS NOT NULL
+            GROUP BY b.author
+            HAVING count >= 3
+            ORDER BY count DESC
+        """)
+        authors = cursor.fetchall()
+
+        if not authors:
+            print("No authors found with more than 3 books read.")
+            return
+
+        console = Console()
+        table = Table(show_header=True, title="Most Read Authors", box=box.SIMPLE)
+        table.add_column("Author", style="cyan")
+        table.add_column("Books Read", style="green")
+
+        for author, count in authors:
+            table.add_row(author, str(count))
+
+        console.print(table)
+
+    except sqlite3.Error as e:
+        print(f"Database error: {e}")
+
+
+def show_year_report(db):
+    """Display a bar chart of books read per year."""
+    books_by_year = get_books_by_year(db)
+    if not books_by_year:
+        print("No books found with read dates.")
+        return
+
+    console = Console()
+    table = Table(show_header=True, title="Books Read by Year", box=box.SIMPLE)
+    table.add_column("Year", style="cyan")
+    table.add_column("Count", style="green")
+    table.add_column("Bar", style="blue")
+
+    max_count = max(count for _, count in books_by_year)
+
+    for year, count in books_by_year:
+        # Create a bar using block characters
+        bar_length = int((count / max_count) * 50)  # Scale to 50 characters
+        bar = "▄" * bar_length
+
+        table.add_row(year, str(count), bar)
+
+    console.print(table)
+
+
+def report(db, args):
+    """Main report function that routes to specific report types based on args."""
+    if args.get("author") is True:
+        show_author_report(db)
+    else:
+        show_year_report(db)

libro_book-0.1.0/src/libro/actions/show.py

@@ -0,0 +1,133 @@
+import sqlite3
+from datetime import datetime
+from rich.console import Console
+from rich.table import Table
+
+
+def show_books(db, args={}):
+    # By year is default
+    # Current year is default year if not specified
+    year = args.get("year", datetime.now().year)
+
+    # if id is not none, show book detail
+    if args.get("id") is not None:
+        show_book_detail(db, args.get("id"))
+        return
+
+    books = get_books(db, year)
+    if not books:
+        print("No books found for the specified year.")
+        return
+
+    console = Console()
+    table = Table(show_header=True, title=f"Books Read in {year}")
+    table.add_column("id")
+    table.add_column("Title")
+    table.add_column("Author")
+    table.add_column("Rating")
+    table.add_column("Date Read")
+
+    # Sort books by genre (fiction first) and then by date
+    sorted_books = sorted(
+        books, key=lambda x: (x["genre"] != "fiction", x["date_read"] or "")
+    )
+
+    current_genre = None
+    for book in sorted_books:
+        # Add genre separator if genre changes
+        if book["genre"] != current_genre:
+            if current_genre is not None:  # Don't add separator before first genre
+                table.add_row("", "", "", "", "", style="dim")
+            current_genre = book["genre"]
+            table.add_row(
+                f"[bold]{current_genre.title()}[/bold]",
+                "",
+                "",
+                "",
+                "",
+                style="bold cyan",
+            )
+
+        # Format the date
+        date_str = book["date_read"]
+        if date_str:
+            try:
+                date_obj = datetime.strptime(date_str, "%Y-%m-%d")
+                formatted_date = date_obj.strftime("%b %d, %Y")
+            except ValueError:
+                formatted_date = date_str
+        else:
+            formatted_date = ""
+
+        table.add_row(
+            str(book["id"]),
+            book["title"],
+            book["author"],
+            str(book["rating"]),
+            formatted_date,
+        )
+
+    console.print(table)
+
+
+def show_book_detail(db, id):
+    cursor = db.cursor()
+    cursor.execute(
+        """SELECT b.id, b.title, b.author, b.pub_year, b.pages, b.genre,
+                  r.rating, r.date_read, r.review
+        FROM books b
+        LEFT JOIN reviews r ON b.id = r.book_id
+        WHERE b.id = ?""",
+        (id,),
+    )
+    book = cursor.fetchone()
+
+    if not book:
+        print(f"No book found with ID {id}")
+        return
+
+    console = Console()
+    table = Table(show_header=True, title="Book Details")
+    table.add_column("Field", style="cyan")
+    table.add_column("Value", style="green")
+
+    # Map of column names to display names
+    display_names = [
+        "ID",
+        "Title",
+        "Author",
+        "Publication Year",
+        "Pages",
+        "Genre",
+        "Rating",
+        "Date Read",
+        "My Review",
+    ]
+
+    for col, value in zip(range(len(display_names)), book):
+        table.add_row(display_names[col], str(value))
+
+    console.print(table)
+
+
+def get_books(db, year):
+    try:
+        cursor = db.cursor()
+        cursor.execute(
+            """
+            SELECT b.id, b.title, b.author, b.genre, r.rating, r.date_read
+            FROM books b
+            LEFT JOIN reviews r ON b.id = r.book_id
+            WHERE strftime('%Y', r.date_read) = ?
+            ORDER BY r.date_read ASC
+        """,
+            (str(year),),
+        )
+        books = cursor.fetchall()
+        return books
+    except sqlite3.Error as e:
+        print(f"Database error: {e}")
+        return None
+    except Exception as e:
+        print(f"Error: {e}")
+        return None

libro_book-0.1.0/src/libro/config.py

@@ -0,0 +1,87 @@
+import argparse
+import os
+import sys
+from pathlib import Path
+from typing import Dict
+from datetime import datetime
+from appdirs import AppDirs
+
+__version__ = "0.1.0"
+
+
+def init_args() -> Dict:
+    """Parse and return the arguments."""
+    parser = argparse.ArgumentParser(description="Book list")
+    parser.add_argument("--db", help="SQLite file")
+    parser.add_argument("-v", "--version", action="store_true")
+    parser.add_argument("-i", "--info", action="store_true")
+
+    # Create subparsers for commands
+    subparsers = parser.add_subparsers(dest="command", help="Commands")
+
+    # Report command with its specific arguments
+    report_parser = subparsers.add_parser("report", help="Show reports")
+    report_parser.add_argument(
+        "--author", action="store_true", help="Show author report"
+    )
+    report_parser.add_argument("--year", type=int, help="Year to filter books")
+
+    # Show command with its specific arguments
+    show_parser = subparsers.add_parser("show", help="Show books")
+    show_parser.add_argument("--year", type=int, help="Year to filter books")
+    show_parser.add_argument(
+        "id", type=int, nargs="?", help="Show details for a specific book ID"
+    )
+
+    # Add command with its specific arguments
+    add_parser = subparsers.add_parser("add", help="Add a book")
+    add_parser.add_argument("--title", type=str, help="Title of the book")
+    add_parser.add_argument("--author", type=str, help="Author of the book")
+    add_parser.add_argument("--year", type=int, help="Year of the book")
+
+    # Add command with its specific arguments
+    import_parser = subparsers.add_parser("import", help="Import books")
+    import_parser.add_argument("file", type=str, help="Goodreads CSV export file")
+
+    args = vars(parser.parse_args())
+
+    if args["version"]:
+        print(f"libro v{__version__}")
+        sys.exit()
+
+    # if not specified on command-line figure it out
+    if args["db"] is None:
+        args["db"] = get_db_loc()
+
+    if args["command"] is None:
+        args["command"] = "show"
+
+    if args.get("year") is None:
+        args["year"] = datetime.now().year
+
+    return args
+
+
+def get_db_loc() -> Path:
+    """Figure out where the libro.db file should be.
+    See README for spec"""
+
+    # check if tasks.db exists in current dir
+    cur_dir = Path(Path.cwd(), "libro.db")
+    if cur_dir.is_file():
+        return cur_dir
+
+    # check for env TASKS_DB
+    env_var = os.environ.get("LIBRO_DB")
+    if env_var is not None:
+        return Path(env_var)
+
+    # Finally use system specific data dir
+    dirs = AppDirs("Libro", "mkaz")
+
+    # No config file, default to data dir
+    data_dir = Path(dirs.user_data_dir)
+    if not data_dir.is_dir():
+        data_dir.mkdir()
+
+    return Path(dirs.user_data_dir, "libro.db")

libro_book-0.1.0/src/libro/main.py

@@ -0,0 +1,60 @@
+import sqlite3
+import sys
+from pathlib import Path
+
+from libro.config import init_args
+from libro.actions.show import show_books
+from libro.actions.report import report
+from libro.actions.add import add_book
+from libro.actions.db import init_db
+from libro.actions.importer import import_books
+
+
+def main():
+    print("")  # give me some space
+    args = init_args()
+
+    dbfile = Path(args["db"])
+    if args["info"]:
+        print(f"Using libro.db {dbfile}")
+
+    # check if taskdb exists
+    is_new_db = not dbfile.is_file()
+    if is_new_db:
+        response = input(f"Create new database at {dbfile}? [Y/n] ").lower()
+        if response not in ["", "y", "yes"]:
+            print("No database created")
+            sys.exit(1)
+        init_db(dbfile)
+
+    # Check if database is empty
+    if is_new_db:
+        print("Database created")
+        sys.exit(0)
+
+    try:
+        db = sqlite3.connect(dbfile)
+        db.row_factory = sqlite3.Row
+
+        command = args["command"]
+        if command == "add":
+            print("Add new book read")
+            add_book(db, args)
+        elif command == "show":
+            show_books(db, args)
+        elif command == "report":
+            report(db, args)
+        elif command == "import":
+            import_books(db, args)
+        else:
+            print("Not yet implemented")
+
+    except sqlite3.Error as e:
+        print(f"Database error: {e}")
+        sys.exit(1)
+    finally:
+        db.close()
+
+
+if __name__ == "__main__":
+    main()

libro_book-0.1.0/src/libro/models.py

@@ -0,0 +1,68 @@
+from dataclasses import dataclass
+from typing import Optional
+import sqlite3
+from datetime import date
+
+
+@dataclass
+class Book:
+    """Represents a book in the database."""
+
+    title: str
+    author: str
+    pub_year: Optional[int] = None
+    pages: Optional[int] = None
+    genre: Optional[str] = None
+    id: Optional[int] = None
+
+    def insert(self, db: sqlite3.Connection) -> int:
+        """Insert the book into the database and return its ID."""
+        cursor = db.cursor()
+        cursor.execute(
+            """
+            INSERT INTO books (
+                title, author, pub_year, pages, genre
+            ) VALUES (?, ?, ?, ?, ?)
+            """,
+            (
+                self.title,
+                self.author,
+                self.pub_year,
+                self.pages,
+                self.genre,
+            ),
+        )
+        self.id = cursor.lastrowid
+        db.commit()
+        return self.id
+
+
+@dataclass
+class Review:
+    """Represents a book review in the database."""
+
+    book_id: int
+    date_read: Optional[date] = None
+    rating: Optional[int] = None
+    review: Optional[str] = None
+    id: Optional[int] = None
+
+    def insert(self, db: sqlite3.Connection) -> int:
+        """Insert the review into the database and return its ID."""
+        cursor = db.cursor()
+        cursor.execute(
+            """
+            INSERT INTO reviews (
+                book_id, date_read, rating, review
+            ) VALUES (?, ?, ?, ?)
+            """,
+            (
+                self.book_id,
+                self.date_read,
+                self.rating,
+                self.review,
+            ),
+        )
+        self.id = cursor.lastrowid
+        db.commit()
+        return self.id

libro_book-0.1.0/src/libro/utils.py

@@ -0,0 +1,67 @@
+from datetime import datetime
+
+
+def validate_and_convert_date(date_str, field_name):
+    if not date_str:  # Handle empty dates
+        return True, None
+
+    formats = [
+        "%m/%d/%y",  # 1/24/15
+        "%m/%d/%Y",  # 1/24/2015
+        "%Y-%m-%d",  # 2015-01-24
+        "%Y",  # Just the year
+        "%B %d, %Y",  # March 14, 2024
+        "%d %B %Y",  # 14 March 2024
+    ]
+
+    for fmt in formats:
+        try:
+            date_obj = datetime.strptime(date_str, fmt)
+            if fmt == "%m/%d/%y":
+                if date_obj.year > datetime.now().year:
+                    date_obj = date_obj.replace(year=date_obj.year - 100)
+
+            if fmt == "%Y":
+                return True, f"{date_obj.year}-01-01"
+
+            return True, date_obj.strftime("%Y-%m-%d")
+        except ValueError:
+            continue
+
+    print(f"Error: Invalid date format in {field_name}: {date_str}")
+    return False, None
+
+
+def get_valid_input(prompt, validator=None, allow_empty=False, multiline=False):
+    if not multiline:
+        while True:
+            value = input(prompt).strip()
+            if not value and not allow_empty:
+                print("This field cannot be empty. Please try again.")
+                continue
+            if validator and value:
+                is_valid, converted_value = validator(value)
+                if is_valid:
+                    return converted_value if converted_value is not None else value
+            else:
+                return value
+    else:
+        print(prompt + " (Enter two consecutive blank lines to finish)")
+        lines = []
+        last_line_empty = False
+        while True:
+            line = input()  # Don't strip here to preserve indentation
+            if not line.strip():
+                if last_line_empty:
+                    if not lines and not allow_empty:
+                        print("This field cannot be empty. Please try again.")
+                        continue
+                    break
+                last_line_empty = True
+            else:
+                last_line_empty = False
+            lines.append(line)
+        # Remove the last empty line that was used as a terminator
+        if lines and not lines[-1].strip():
+            lines.pop()
+        return "\n".join(lines)