patrick/chitai
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

chore: format the tree and clear ruff's findings

Browse Source 
Applies ruff format, ruff check --fix and prettier, so CI can gate on all three.
The surviving unused imports were all re-exports in __init__.py, now covered by a
per-file ignore; the pdf.js viewer and the generated openapi types join the
vendored code that eslint and prettier already skip.
This commit is contained in:
patrick
2026-08-17 15:17:14 -04:00
parent b70ed5cb51
commit 45b03764d2
85 changed files with 847 additions and 709 deletions
Download Patch File Download Diff File Expand all files Collapse all files
backend/pyproject.toml
+5
View File
@@ -38,6 +38,11 @@ dev = [
"pytest-databases[postgres]>=0.15.0",
]
[tool.ruff.lint.per-file-ignores]
# The package __init__.py files exist to re-export their modules' public names, so every
# import in them is "unused" as far as F401 is concerned.
"__init__.py" = ["F401"]
[tool.pytest.ini_options]
asyncio_mode = "auto"
testpaths = ["tests"]
backend/src/chitai/app.py
+7 -3
View File
@@ -72,6 +72,7 @@ oauth2_auth = OAuth2PasswordBearerAuth[User](
watcher_task: asyncio.Task
@asynccontextmanager
async def setup_db_connection(app: Litestar) -> AsyncGenerator[None, None]:
# Setup databse
@@ -97,7 +98,7 @@ async def setup_db_connection(app: Litestar) -> AsyncGenerator[None, None]:
@asynccontextmanager
async def setup_directory_watcher(app: Litestar) -> AsyncGenerator[None, None]:
# Create book covers directory if it does not exist
await create_directory(settings.book_cover_path)
# Create consume directory
@@ -107,14 +108,17 @@ async def setup_directory_watcher(app: Litestar) -> AsyncGenerator[None, None]:
book_service = BookService(session=db_session)
library_service = LibraryService(session=db_session)
file_watcher = ConsumeDirectoryWatcher(settings.consume_path, library_service, book_service)
file_watcher = ConsumeDirectoryWatcher(
settings.consume_path, library_service, book_service
)
watcher_task = asyncio.create_task(file_watcher.init_watcher())
try:
yield
finally:
watcher_task.cancel()
def create_app() -> Litestar:
return Litestar(
route_handlers=[
backend/src/chitai/controllers/access.py
+1 -1
View File
@@ -1,7 +1,7 @@
# src/chitai/controllers/access.py
# Standard library
from typing import Annotated, Any
from typing import Annotated
import logging
# Third-party libraries
backend/src/chitai/controllers/author.py
+1 -2
View File
@@ -4,9 +4,8 @@
from typing import Annotated
# Third-party libraries
from litestar import Controller, post, get, patch, delete
from litestar import Controller, get
from litestar.params import Dependency
from litestar.exceptions import HTTPException
from advanced_alchemy.extensions.litestar.providers import create_service_dependencies
from advanced_alchemy.service.pagination import OffsetPagination
from advanced_alchemy.service import FilterTypeT
backend/src/chitai/controllers/kosync_device.py
+30 -26
View File
@@ -8,47 +8,51 @@ from litestar import Controller, post, get, delete
from litestar.di import Provide
from chitai.services import dependencies as deps
class DeviceController(Controller):
""" Controller for managing KOReader devices."""
dependencies = {
"device_service": Provide(deps.provide_kosync_device_service)
}
class DeviceController(Controller):
"""Controller for managing KOReader devices."""
dependencies = {"device_service": Provide(deps.provide_kosync_device_service)}
path = "/devices"
@get()
async def get_devices(self, device_service: KosyncDeviceService, current_user: User) -> OffsetPagination[KosyncDeviceRead]:
""" Return a list of all the user's devices."""
devices = await device_service.list(
KosyncDevice.user_id == current_user.id
)
async def get_devices(
self, device_service: KosyncDeviceService, current_user: User
) -> OffsetPagination[KosyncDeviceRead]:
"""Return a list of all the user's devices."""
devices = await device_service.list(KosyncDevice.user_id == current_user.id)
return device_service.to_schema(devices, schema_type=KosyncDeviceRead)
@post()
async def create_device(self, data: KosyncDeviceCreate, device_service: KosyncDeviceService, current_user: User) -> KosyncDeviceRead:
device = await device_service.create({
'name': data.name,
'user_id': current_user.id
})
async def create_device(
self,
data: KosyncDeviceCreate,
device_service: KosyncDeviceService,
current_user: User,
) -> KosyncDeviceRead:
device = await device_service.create(
{"name": data.name, "user_id": current_user.id}
)
return device_service.to_schema(device, schema_type=KosyncDeviceRead)
@delete("/{device_id:int}")
async def delete_device(self, device_id: int, device_service: KosyncDeviceService, current_user: User) -> None:
async def delete_device(
self, device_id: int, device_service: KosyncDeviceService, current_user: User
) -> None:
# Ensure the device exists and is owned by the user
device = await device_service.get_one(
KosyncDevice.id == device_id,
KosyncDevice.user_id == current_user.id
KosyncDevice.id == device_id, KosyncDevice.user_id == current_user.id
)
await device_service.delete(device.id)
@get("/{device_id:int}/regenerate")
async def regenerate_device_api_key(self, device_id: int, device_service: KosyncDeviceService, current_user: User) -> KosyncDeviceRead:
async def regenerate_device_api_key(
self, device_id: int, device_service: KosyncDeviceService, current_user: User
) -> KosyncDeviceRead:
# Ensure the device exists and is owned by the user
device = await device_service.get_one(
KosyncDevice.id == device_id,
KosyncDevice.user_id == current_user.id
KosyncDevice.id == device_id, KosyncDevice.user_id == current_user.id
)
updated_device = await device_service.regenerate_api_key(device.id)
return device_service.to_schema(updated_device, schema_type=KosyncDeviceRead)
return device_service.to_schema(updated_device, schema_type=KosyncDeviceRead)
backend/src/chitai/controllers/kosync_progress.py
+6 -5
View File
@@ -58,10 +58,14 @@ class KosyncController(Controller):
user: m.User,
) -> KosyncProgressRead:
"""Return the Kosync progress record associated with the given document."""
progress = await kosync_progress_service.get_by_document_hash(user.id, document_id)
progress = await kosync_progress_service.get_by_document_hash(
user.id, document_id
)
if not progress:
raise HTTPException(status_code=404, detail="No progress found for document")
raise HTTPException(
status_code=404, detail="No progress found for document"
)
return KosyncProgressRead(
document=progress.document,
@@ -85,6 +89,3 @@ class KosyncController(Controller):
detail="User accounts must be created via the main application",
status_code=HTTP_403_FORBIDDEN,
)
backend/src/chitai/controllers/library.py
+4 -2
View File
@@ -10,7 +10,7 @@ from typing import Annotated
# Third-party libraries
import aiofiles
from aiofiles import os as aios
from litestar import Controller, post, get, patch, delete
from litestar import Controller, post, get, delete
from litestar.enums import RequestEncodingType
from litestar.params import Body, Dependency
from litestar.exceptions import HTTPException
@@ -89,7 +89,9 @@ class LibraryController(Controller):
Injected Dependencies:
library_service: The service used to query and return library data.
"""
results, total = await library_service.list_and_count(*filters, load=[m.Library.books])
results, total = await library_service.list_and_count(
*filters, load=[m.Library.books]
)
return library_service.to_schema(
results, total, filters, schema_type=LibraryRead
)
backend/src/chitai/controllers/opds.py
+117 -103
View File
@@ -1,4 +1,3 @@
from chitai.services import dependencies as deps
from chitai.database import models as m
from chitai.services.author import AuthorService
@@ -6,7 +5,15 @@ from chitai.services.filters.author import AuthorLibraryFilter
from chitai.services.filters.publisher import PublisherLibraryFilter
from chitai.services.filters.tags import TagLibraryFilter
from chitai.services.opds.models import Entry, Link, LinkTypes, LinkRelations
from chitai.services.opds.opds import create_acquisition_feed, create_navigation_feed, create_library_navigation_feed, create_collection_navigation_feed, create_pagination_links, create_search_link, get_opensearch_document
from chitai.services.opds.opds import (
create_acquisition_feed,
create_navigation_feed,
create_library_navigation_feed,
create_collection_navigation_feed,
create_pagination_links,
create_search_link,
get_opensearch_document,
)
from chitai.services import BookService, ShelfService, LibraryService
from chitai.services.publisher import PublisherService
from chitai.services.tag import TagService
@@ -14,7 +21,7 @@ from litestar import Controller, Request, Response, get
from litestar.response import File
from litestar.di import Provide
from litestar.exceptions import HTTPException
from advanced_alchemy.filters import CollectionFilter, LimitOffset, OrderBy
from advanced_alchemy.filters import CollectionFilter, LimitOffset, OrderBy
from chitai.middleware.basic_auth import basic_auth_mw
from urllib.parse import urlencode
from typing import Annotated
@@ -22,11 +29,10 @@ from litestar.params import Dependency
from advanced_alchemy.service import FilterTypeT
class OpdsController(Controller):
""" Controller for managing OPDS endpoints """
"""Controller for managing OPDS endpoints"""
middleware=[basic_auth_mw]
middleware = [basic_auth_mw]
dependencies = {
"user": Provide(deps.provide_user_via_basic_auth),
@@ -76,32 +82,30 @@ class OpdsController(Controller):
title=lib.name,
href=f"/opds/library/{lib.id}",
rel=LinkRelations.SUBSECTION,
type=LinkTypes.NAVIGATION
type=LinkTypes.NAVIGATION,
)
]
) for lib in libraries
],
)
for lib in libraries
]
feed = create_navigation_feed(
id="/opds",
title="Root",
self_url="/opds",
links=[
Link(
rel="search",
href="/opds/opensearch",
type="application/opensearchdescription+xml",
title="Search books",
)
],
entries=entries
)
return Response(
feed,
media_type="application/xml"
id="/opds",
title="Root",
self_url="/opds",
links=[
Link(
rel="search",
href="/opds/opensearch",
type="application/opensearchdescription+xml",
title="Search books",
)
],
entries=entries,
)
return Response(feed, media_type="application/xml")
@get("/acquisition")
async def get_acquisition_feed(
self,
@@ -109,37 +113,41 @@ class OpdsController(Controller):
feed_id: str,
feed_title: str,
books_service: BookService,
book_filters: Annotated[list[FilterTypeT], Dependency(skip_validation=True)] = [],
filters: Annotated[list[FilterTypeT], Dependency(skip_validation=True)] = []
book_filters: Annotated[
list[FilterTypeT], Dependency(skip_validation=True)
] = [],
filters: Annotated[list[FilterTypeT], Dependency(skip_validation=True)] = [],
) -> Response:
all_filters = [*filters, *book_filters]
books, total = await books_service.list_and_count(*all_filters)
limit, offset = extract_limit_offset(all_filters)
links = []
# Create pagination links if it is a paginated feed
if request.query_params.get('paginated'):
if request.query_params.get("paginated"):
pagination = create_pagination_links(
request=request,
total=total,
limit=limit,
offset=offset,
feed_title=feed_title,
link_type=LinkTypes.ACQUISITION
link_type=LinkTypes.ACQUISITION,
)
links.extend([link for link in [pagination.next_link, pagination.prev_link] if link])
links.extend(
[link for link in [pagination.next_link, pagination.prev_link] if link]
)
# Add search link if this is a searchable feed
if request.query_params.get('search'):
if request.query_params.get("search"):
links.append(create_search_link(request))
# Create self URL
self_url = f"{request.url.path}?{urlencode(list(request.query_params.items()), doseq=True)}"
feed = create_acquisition_feed(
id=feed_id,
title=feed_title,
@@ -147,28 +155,26 @@ class OpdsController(Controller):
books=books,
links=links,
)
return Response(feed, media_type="application/xml")
return Response(feed, media_type="application/xml")
@get("/opensearch")
async def opensearch(self, user: m.User, request: Request) -> Response:
return Response(
get_opensearch_document(
base_url=f'/opds/search?{urlencode(list(request.query_params.items()), doseq=True)}&'
base_url=f"/opds/search?{urlencode(list(request.query_params.items()), doseq=True)}&"
),
media_type="application/xml"
media_type="application/xml",
)
@get("/library/{library_id:int}")
async def get_library_feed(self, library: m.Library) -> Response:
feed = create_library_navigation_feed(library)
return Response(feed, media_type="application/xml")
@get("/library/{library_id:int}/{collection_type:str}")
async def get_library_collection_feed(
self,
@@ -180,39 +186,51 @@ class OpdsController(Controller):
tag_service: TagService,
publisher_service: PublisherService,
request: Request,
filters: Annotated[list[FilterTypeT], Dependency(skip_validation=True)] = []
filters: Annotated[list[FilterTypeT], Dependency(skip_validation=True)] = [],
) -> Response:
service_map = {
'shelves': (shelf_service, lambda: shelf_service.list_and_count(
*filters,
CollectionFilter("library_id", values=[library.id]),
OrderBy("name", "asc"),
m.BookList.user_id == user.id
)),
'tags': (tag_service, lambda: tag_service.list_and_count(
*filters,
TagLibraryFilter(libraries=[library.id]),
OrderBy("name", "asc"),
uniquify=True,
)),
'authors': (author_service, lambda: author_service.list_and_count(
*filters,
AuthorLibraryFilter(libraries=[library.id]),
OrderBy("name", "asc"),
uniquify=True
)),
'publishers': (publisher_service, lambda: publisher_service.list_and_count(
*filters,
PublisherLibraryFilter(libraries=[library.id]),
OrderBy("name", "asc"),
uniquify=True
))
"shelves": (
shelf_service,
lambda: shelf_service.list_and_count(
*filters,
CollectionFilter("library_id", values=[library.id]),
OrderBy("name", "asc"),
m.BookList.user_id == user.id,
),
),
"tags": (
tag_service,
lambda: tag_service.list_and_count(
*filters,
TagLibraryFilter(libraries=[library.id]),
OrderBy("name", "asc"),
uniquify=True,
),
),
"authors": (
author_service,
lambda: author_service.list_and_count(
*filters,
AuthorLibraryFilter(libraries=[library.id]),
OrderBy("name", "asc"),
uniquify=True,
),
),
"publishers": (
publisher_service,
lambda: publisher_service.list_and_count(
*filters,
PublisherLibraryFilter(libraries=[library.id]),
OrderBy("name", "asc"),
uniquify=True,
),
),
}
if collection_type not in service_map:
raise HTTPException(status_code=404, detail="Collection type not found")
_, fetch_items = service_map[collection_type]
items, total = await fetch_items()
links = []
@@ -220,41 +238,40 @@ class OpdsController(Controller):
# Create pagination links if it is a paginated feed
limit, offset = extract_limit_offset(filters)
if request.query_params.get('paginated'):
if request.query_params.get("paginated"):
pagination = create_pagination_links(
request=request,
total=total,
limit=limit,
offset=offset,
feed_title=collection_type,
link_type=LinkTypes.ACQUISITION
link_type=LinkTypes.ACQUISITION,
)
links.extend([link for link in [pagination.next_link, pagination.prev_link] if link])
links.extend(
[link for link in [pagination.next_link, pagination.prev_link] if link]
)
feed = create_collection_navigation_feed(library, collection_type, items, links)
return Response(feed, media_type="application/xml")
@get("/search")
async def search_books(
self, books_service: BookService,
self,
books_service: BookService,
request: Request,
book_filters: Annotated[
list[FilterTypeT], Dependency(skip_validation=True)
] = [],
filters: Annotated[list[FilterTypeT], Dependency(skip_validation=True)] = []
filters: Annotated[list[FilterTypeT], Dependency(skip_validation=True)] = [],
) -> Response:
filters = [*filters, *book_filters]
books, total = await books_service.list_and_count(
*filters
)
books, total = await books_service.list_and_count(*filters)
limit, offset = extract_limit_offset(filters)
# Create pagination links
pagination = create_pagination_links(
request=request,
@@ -262,37 +279,34 @@ class OpdsController(Controller):
limit=limit,
offset=offset,
feed_title="Search Results",
link_type=LinkTypes.ACQUISITION
link_type=LinkTypes.ACQUISITION,
)
links = [link for link in [pagination.next_link, pagination.prev_link] if link]
catalog_xml = create_acquisition_feed(
id=f"/opds/search?q=q",
id="/opds/search?q=q",
title="Search results",
url=f"/opds/search?q=q",
url="/opds/search?q=q",
books=books,
links=links
links=links,
)
return Response(catalog_xml, media_type="application/xml")
@get(path="download/{book_id:int}/{file_id:int}")
async def get_file(
self, book_id: int, file_id: int, books_service: BookService
) -> File:
return await books_service.get_file(book_id, file_id)
def extract_limit_offset(filters: list[FilterTypeT]) -> tuple[int, int]:
"""Extract page size and offset from filters"""
limit_offset_filter = next(
(f for f in filters if isinstance(f, LimitOffset)),
None
)
limit_offset_filter = next((f for f in filters if isinstance(f, LimitOffset)), None)
if limit_offset_filter:
return limit_offset_filter.limit, limit_offset_filter.offset
raise ValueError("LimitOffset filter not found")
raise ValueError("LimitOffset filter not found")
backend/src/chitai/controllers/publisher.py
+1 -1
View File
@@ -4,7 +4,7 @@
from typing import Annotated
# Third-party libraries
from litestar import Controller, post, get, patch, delete
from litestar import Controller, get
from litestar.params import Dependency
from advanced_alchemy.extensions.litestar.providers import create_service_dependencies
from advanced_alchemy.service.pagination import OffsetPagination
backend/src/chitai/controllers/shelf.py
+3 -1
View File
@@ -70,7 +70,9 @@ class BookshelfController(Controller):
filters.append(CollectionFilter("library_id", values=libraries))
filters.append(m.BookList.user_id == current_user.id)
results, total = await shelf_service.list_and_count(*filters, load=[selectinload(m.BookList.book_links)])
results, total = await shelf_service.list_and_count(
*filters, load=[selectinload(m.BookList.book_links)]
)
return shelf_service.to_schema(results, total, filters, schema_type=ShelfRead)
@post()
backend/src/chitai/controllers/tag.py
+1 -1
View File
@@ -4,7 +4,7 @@
from typing import Annotated
# Third-party libraries
from litestar import Controller, post, get, patch, delete
from litestar import Controller, get
from litestar.params import Dependency
from advanced_alchemy.extensions.litestar.providers import create_service_dependencies
from advanced_alchemy.service.pagination import OffsetPagination
backend/src/chitai/database/models/book_list.py
+1 -1
View File
@@ -34,7 +34,7 @@ class BookList(BigIntAuditBase):
return len(self.book_links) if self.book_links else 0
except Exception:
return None
class BookListLink(BigIntBase):
__tablename__ = "book_list_links"
backend/src/chitai/database/models/book_progress.py
+1 -2
View File
@@ -1,7 +1,6 @@
from typing import Optional
from sqlalchemy import ForeignKey
from sqlalchemy.orm import Mapped, mapped_column
from sqlalchemy.orm import relationship
from advanced_alchemy.base import BigIntAuditBase
@@ -20,5 +19,5 @@ class BookProgress(BigIntAuditBase):
pdf_page: Mapped[Optional[int]]
percentage: Mapped[float]
completed: Mapped[Optional[bool]]
device: Mapped[Optional[str]] # Device that updated the progress
device: Mapped[Optional[str]] # Device that updated the progress
device_id: Mapped[Optional[str]]
backend/src/chitai/database/models/book_series.py
+1 -3
View File
@@ -1,12 +1,10 @@
from collections.abc import Hashable
from sqlalchemy.orm import Mapped, mapped_column
from sqlalchemy import ColumnElement, ForeignKey
from sqlalchemy import ColumnElement
from advanced_alchemy.base import BigIntAuditBase
from advanced_alchemy.mixins import UniqueMixin
from .book import Book
class BookSeries(BigIntAuditBase, UniqueMixin):
__tablename__ = "book_series"
backend/src/chitai/database/models/kosync_device.py
+2 -1
View File
@@ -1,9 +1,10 @@
from sqlalchemy import ColumnElement, ForeignKey
from sqlalchemy import ForeignKey
from sqlalchemy.orm import Mapped
from sqlalchemy.orm import mapped_column
from advanced_alchemy.base import BigIntAuditBase
class KosyncDevice(BigIntAuditBase):
__tablename__ = "devices"
backend/src/chitai/database/models/library.py
+1 -1
View File
@@ -15,7 +15,7 @@ class Library(BigIntAuditBase, SlugKey):
name: Mapped[str] = mapped_column(unique=True)
root_path: Mapped[str]
# Which structure to save the files in the filesystem (i.e {author_name}/{title}.{ext})
path_template: Mapped[str]
path_template: Mapped[str]
description: Mapped[Optional[str]]
icon: Mapped[str] = mapped_column(default="library")
read_only: Mapped[bool] = mapped_column(nullable=False, default=False)
backend/src/chitai/exceptions/handlers.py
-2
View File
@@ -1,6 +1,4 @@
from litestar import Request, Response, MediaType
from litestar.exceptions import HTTPException
from litestar.status_codes import HTTP_404_NOT_FOUND
from advanced_alchemy.exceptions import NotFoundError
backend/src/chitai/middleware/basic_auth.py
+17 -12
View File
@@ -1,9 +1,9 @@
from base64 import b64decode
from chitai.services.user import UserService
from litestar.middleware import (
AbstractAuthenticationMiddleware,
AuthenticationResult,
DefineMiddleware
AbstractAuthenticationMiddleware,
AuthenticationResult,
DefineMiddleware,
)
from litestar.connection import ASGIConnection
from litestar.exceptions import NotAuthorizedException, PermissionDeniedException
@@ -11,25 +11,30 @@ from chitai.config import settings
class BasicAuthenticationMiddleware(AbstractAuthenticationMiddleware):
async def authenticate_request(self, connection: ASGIConnection) -> AuthenticationResult:
"""Given a request, parse the header for Base64 encoded basic auth credentials. """
async def authenticate_request(
self, connection: ASGIConnection
) -> AuthenticationResult:
"""Given a request, parse the header for Base64 encoded basic auth credentials."""
# retrieve the auth header
auth_header = connection.headers.get("Authorization", None)
if not auth_header:
raise NotAuthorizedException()
username, password = b64decode(auth_header.split("Basic ")[1]).decode().split(":")
username, password = (
b64decode(auth_header.split("Basic ")[1]).decode().split(":")
)
try:
db_session = settings.alchemy_config.provide_session(connection.app.state, connection.scope)
db_session = settings.alchemy_config.provide_session(
connection.app.state, connection.scope
)
user_service = UserService(db_session)
user = await user_service.authenticate(username, password)
return AuthenticationResult(user=user, auth=None)
except PermissionDeniedException:
raise NotAuthorizedException()
basic_auth_mw = DefineMiddleware(BasicAuthenticationMiddleware)
basic_auth_mw = DefineMiddleware(BasicAuthenticationMiddleware)
backend/src/chitai/middleware/kosync_auth.py
+15 -11
View File
@@ -1,9 +1,9 @@
from chitai.services.user import UserService
from chitai.services.kosync_device import KosyncDeviceService
from litestar.middleware import (
AbstractAuthenticationMiddleware,
AuthenticationResult,
DefineMiddleware
AbstractAuthenticationMiddleware,
AuthenticationResult,
DefineMiddleware,
)
from litestar.connection import ASGIConnection
from litestar.exceptions import NotAuthorizedException, PermissionDeniedException
@@ -11,19 +11,23 @@ from chitai.config import settings
class KosyncAuthenticationMiddleware(AbstractAuthenticationMiddleware):
async def authenticate_request(self, connection: ASGIConnection) -> AuthenticationResult:
"""Given a request, parse the header for Base64 encoded basic auth credentials. """
async def authenticate_request(
self, connection: ASGIConnection
) -> AuthenticationResult:
"""Given a request, parse the header for Base64 encoded basic auth credentials."""
# retrieve the auth header
api_key = connection.headers.get("X-AUTH-USER", None)
if not api_key:
raise NotAuthorizedException()
try:
db_session = settings.alchemy_config.provide_session(connection.app.state, connection.scope)
db_session = settings.alchemy_config.provide_session(
connection.app.state, connection.scope
)
user_service = UserService(db_session)
device_service = KosyncDeviceService(db_session)
device = await device_service.get_by_api_key(api_key)
user = await user_service.get(device.user_id)
@@ -32,6 +36,6 @@ class KosyncAuthenticationMiddleware(AbstractAuthenticationMiddleware):
except PermissionDeniedException as exc:
print(exc)
raise NotAuthorizedException()
kosync_api_key_auth = DefineMiddleware(KosyncAuthenticationMiddleware)
kosync_api_key_auth = DefineMiddleware(KosyncAuthenticationMiddleware)
backend/src/chitai/schemas/book.py
-2
View File
@@ -273,5 +273,3 @@ class BookProgressCreate(BaseModel):
completed: bool | None = None
device_type: str | None = None
device_id: str | None = None
backend/src/chitai/schemas/library.py
+3 -2
View File
@@ -1,8 +1,8 @@
from pathlib import Path
from typing import Annotated
from pydantic import BaseModel, ConfigDict, Field, SkipValidation, computed_field
from litestar.datastructures import UploadFile
from advanced_alchemy.utils.text import slugify
from advanced_alchemy.utils.text import slugify
class LibraryCreate(BaseModel):
name: Annotated[str, Field(min_length=1)]
@@ -17,6 +17,7 @@ class LibraryCreate(BaseModel):
def slug(self) -> str:
return slugify(self.name)
class LibraryRead(BaseModel):
id: int
name: str
backend/src/chitai/schemas/shelf.py
+2 -2
View File
@@ -1,11 +1,11 @@
from pydantic import BaseModel, ConfigDict, Field, field_validator
from pydantic import BaseModel, Field, field_validator
class ShelfRead(BaseModel):
id: int
title: str
library_id: int | None = None
total: int | None = None # Number of books in the shelf
total: int | None = None # Number of books in the shelf
class ShelfCreate(BaseModel):
backend/src/chitai/services/book.py
+84 -50
View File
@@ -19,7 +19,7 @@ from advanced_alchemy.service import (
SQLAlchemyAsyncRepositoryService,
ModelDictT,
is_dict,
schema_dump
schema_dump,
)
from advanced_alchemy.repository import SQLAlchemyAsyncRepository
from advanced_alchemy.filters import CollectionFilter
@@ -349,7 +349,9 @@ def _series_position(data: Any) -> tuple[str, str | None]:
return normalize_title(series), (position or "").strip() or None
def _is_different_volume(left: tuple[str, str | None], right: tuple[str, str | None]) -> bool:
def _is_different_volume(
left: tuple[str, str | None], right: tuple[str, str | None]
) -> bool:
"""
Whether two books are numbered entries of one series, and not the same entry.
@@ -464,8 +466,6 @@ class BookService(SQLAlchemyAsyncRepositoryService[Book]):
repository_type = Repo
async def create_book(
self,
data: ModelDictT[Book],
@@ -647,7 +647,10 @@ class BookService(SQLAlchemyAsyncRepositoryService[Book]):
return []
statement = (
select(Book).where(or_(*conditions)).options(*self._MATCH_LOADS).order_by(Book.id)
select(Book)
.where(or_(*conditions))
.options(*self._MATCH_LOADS)
.order_by(Book.id)
)
if exclude_book_id is not None:
@@ -724,7 +727,9 @@ class BookService(SQLAlchemyAsyncRepositoryService[Book]):
ValueError: If fewer than two distinct books were named, one of them does
not exist, or they do not all belong to one library.
"""
merged_ids = [book_id for book_id in dict.fromkeys(merged_ids) if book_id != survivor_id]
merged_ids = [
book_id for book_id in dict.fromkeys(merged_ids) if book_id != survivor_id
]
if not merged_ids:
raise ValueError("A merge needs at least two different books")
@@ -848,12 +853,16 @@ class BookService(SQLAlchemyAsyncRepositoryService[Book]):
# Reading progress is per user, and the furthest one is the true answer for a
# reader who has been through the EPUB and not the PDF.
rows = (
await session.execute(
select(BookProgress)
.where(BookProgress.book_id.in_([survivor_id, *merged_ids]))
.order_by(BookProgress.percentage.desc())
(
await session.execute(
select(BookProgress)
.where(BookProgress.book_id.in_([survivor_id, *merged_ids]))
.order_by(BookProgress.percentage.desc())
)
)
).scalars().all()
.scalars()
.all()
)
furthest: dict[int, BookProgress] = {}
for progress in rows:
@@ -902,14 +911,19 @@ class BookService(SQLAlchemyAsyncRepositoryService[Book]):
# and only one of them however many books offered it.
held_names = select(Identifier.name).where(Identifier.book_id == survivor_id)
incoming = (
await session.execute(
select(Identifier)
.where(
Identifier.book_id.in_(merged_ids), Identifier.name.notin_(held_names)
(
await session.execute(
select(Identifier)
.where(
Identifier.book_id.in_(merged_ids),
Identifier.name.notin_(held_names),
)
.order_by(Identifier.book_id, Identifier.id)
)
.order_by(Identifier.book_id, Identifier.id)
)
).scalars().all()
.scalars()
.all()
)
taken: set[str] = set()
for identifier in incoming:
@@ -932,15 +946,19 @@ class BookService(SQLAlchemyAsyncRepositoryService[Book]):
merged = set(merged_ids)
rows = (
await session.execute(
select(DuplicateDismissal).where(
or_(
DuplicateDismissal.book_a_id.in_(merged_ids),
DuplicateDismissal.book_b_id.in_(merged_ids),
(
await session.execute(
select(DuplicateDismissal).where(
or_(
DuplicateDismissal.book_a_id.in_(merged_ids),
DuplicateDismissal.book_b_id.in_(merged_ids),
)
)
)
)
).scalars().all()
.scalars()
.all()
)
existing = await self._dismissed_pairs()
doomed: list[int] = []
@@ -1025,7 +1043,9 @@ class BookService(SQLAlchemyAsyncRepositoryService[Book]):
# copies meet as long as they agree on any one of them.
for title in titles:
for author in authors:
buckets[(MATCHED_ON_TITLE_AUTHOR, f"{title}\x00{author}")].append(book_id)
buckets[(MATCHED_ON_TITLE_AUTHOR, f"{title}\x00{author}")].append(
book_id
)
dismissed = await self._dismissed_pairs()
series = {book_id: _series_position(book) for book_id, book in books.items()}
@@ -1071,8 +1091,14 @@ class BookService(SQLAlchemyAsyncRepositoryService[Book]):
raise ValueError("A book cannot be dismissed against itself")
found = (
await self.repository.session.execute(select(Book.id).where(Book.id.in_(pair)))
).scalars().all()
(
await self.repository.session.execute(
select(Book.id).where(Book.id.in_(pair))
)
)
.scalars()
.all()
)
if len(set(found)) != 2:
raise ValueError("No such book")
@@ -1305,7 +1331,9 @@ class BookService(SQLAlchemyAsyncRepositoryService[Book]):
**kwargs,
)
result.books.append(book)
await self._record_possible_duplicates(result.possible_duplicates, book, library)
await self._record_possible_duplicates(
result.possible_duplicates, book, library
)
return result
@@ -1344,7 +1372,7 @@ class BookService(SQLAlchemyAsyncRepositoryService[Book]):
consume_path: Path,
library: Library,
allow_duplicates: bool = False,
**kwargs
**kwargs,
) -> ImportResult:
"""
Import files that are already on disk, from the consume directory.
@@ -1368,7 +1396,6 @@ class BookService(SQLAlchemyAsyncRepositoryService[Book]):
result = ImportResult()
file_groups: dict[Path, list[Path]] = defaultdict(list)
for file_path in file_paths:
rel_path = file_path.relative_to(consume_path)
parent_rel = rel_path.parent
@@ -1379,11 +1406,10 @@ class BookService(SQLAlchemyAsyncRepositoryService[Book]):
group_key = rel_path # Use the file itself as the key
else:
group_key = parent_rel # Use parent directory as key
# Add to appropriate group
file_groups[group_key].append(file_path)
# For each grouping
for group, files in file_groups.items():
# Fingerprinted before anything moves, since the paths are about to change.
@@ -1405,7 +1431,7 @@ class BookService(SQLAlchemyAsyncRepositoryService[Book]):
cleanup_empty_parent_directories(consume_path / group, consume_path)
continue
data: dict[str, Any] = {'files': accepted}
data: dict[str, Any] = {"files": accepted}
await self._parse_metadata_from_files(data, root_path=consume_path)
await self._save_cover_image(data)
@@ -1446,7 +1472,9 @@ class BookService(SQLAlchemyAsyncRepositoryService[Book]):
book = await super().create(data)
result.books.append(book)
await self._record_possible_duplicates(result.possible_duplicates, book, library)
await self._record_possible_duplicates(
result.possible_duplicates, book, library
)
await self.repository.session.commit()
@@ -1554,17 +1582,11 @@ class BookService(SQLAlchemyAsyncRepositoryService[Book]):
# What the catalogue claims and what is on disk can disagree: Calibre keeps the
# row when a file is moved away behind its back.
present = [
file.path
for file in entry.files
if await aios.path.isfile(file.path)
file.path for file in entry.files if await aios.path.isfile(file.path)
]
if not present:
reason = (
"no files on disk"
if entry.files
else "no files in the catalogue"
)
reason = "no files on disk" if entry.files else "no files in the catalogue"
result.skipped.append(
UnimportedBook(
calibre_id=entry.calibre_id, title=entry.title, reason=reason
@@ -1918,9 +1940,13 @@ class BookService(SQLAlchemyAsyncRepositoryService[Book]):
# TODO: Move only the files associated with the book instead of the whole directory
await move_dir_contents(book.path, updated_path)
data["path"] = str(updated_path)
cleanup_empty_parent_directories(Path(book.path), Path(library.root_path))
cleanup_empty_parent_directories(
Path(book.path), Path(library.root_path)
)
return await super().update(data, item_id=book_id, execution_options={"populate_existing": True})
return await super().update(
data, item_id=book_id, execution_options={"populate_existing": True}
)
async def add_files(
self,
@@ -1979,7 +2005,9 @@ class BookService(SQLAlchemyAsyncRepositoryService[Book]):
data["files"] = files
new_files = await self._save_book_files(library, data, fingerprints)
book.files.extend(new_files)
await self.update_book(book.id, {"files": [file for file in book.files]}, library)
await self.update_book(
book.id, {"files": [file for file in book.files]}, library
)
@staticmethod
async def _restore_file(
@@ -2067,22 +2095,24 @@ class BookService(SQLAlchemyAsyncRepositoryService[Book]):
model_data = await self._populate_with_unique_relationships(data)
return model_data
def _preprocess_book_data(self, data: dict) -> dict:
"""Transform API input format to model format."""
if not isinstance(data, dict):
return data
# Transform dict identifiers to list of Identifier objects
if "identifiers" in data and isinstance(data["identifiers"], dict):
data["identifiers"] = [
Identifier(name=key, value=val)
for key, val in data["identifiers"].items()
]
return data
async def _populate_with_unique_relationships(self, data: ModelDictT[Book]) -> ModelDictT[Book]:
async def _populate_with_unique_relationships(
self, data: ModelDictT[Book]
) -> ModelDictT[Book]:
"""
Ensure relationship entities (authors, series, tags, etc.) are unique in the database.
@@ -2307,7 +2337,9 @@ class BookService(SQLAlchemyAsyncRepositoryService[Book]):
data["files"] = file_metadata
return data["files"]
async def _parse_metadata_from_files(self, data: dict, root_path: Path | None = None) -> dict:
async def _parse_metadata_from_files(
self, data: dict, root_path: Path | None = None
) -> dict:
"""
Extract metadata (title, author, etc.) from book files.
@@ -2319,7 +2351,9 @@ class BookService(SQLAlchemyAsyncRepositoryService[Book]):
Returns:
The data with extracted metadata populated in empty fields.
"""
extracted_metadata = await MetadataExtractor.extract_metadata(data["files"], root_path)
extracted_metadata = await MetadataExtractor.extract_metadata(
data["files"], root_path
)
# Add missing fields and update empty (falsey) fields with extracted metadata
for attr in extracted_metadata.keys():
backend/src/chitai/services/bookshelf.py
-5
View File
@@ -1,13 +1,8 @@
# src/chitai/services/bookshelf.py
# Third-party libraries
from typing import Any, Sequence
from advanced_alchemy.exceptions import ErrorMessages
from advanced_alchemy.filters import StatementFilter
from advanced_alchemy.service import SQLAlchemyAsyncRepositoryService
from advanced_alchemy.repository import SQLAlchemyAsyncRepository
from advanced_alchemy.utils.dataclass import Empty, EmptyType
from sqlalchemy import ColumnElement, Select, delete
# Local imports
from chitai.database.models.book_list import BookList, BookListLink
backend/src/chitai/services/calibre.py
+19 -4
View File
@@ -297,7 +297,9 @@ class CalibreLibrary:
async def count(self) -> int:
"""How many books the catalogue holds, without reading any of them."""
rows = await self._in_thread(lambda: self._execute("SELECT count(*) FROM books"))
rows = await self._in_thread(
lambda: self._execute("SELECT count(*) FROM books")
)
return int(rows[0][0])
async def books(self) -> list[CalibreBook]:
@@ -393,7 +395,9 @@ class CalibreLibrary:
calibre_id=book_id,
uuid=str(uuid or ""),
title=str(title or ""),
authors=[unescape_author(name) for name in authors.get(book_id, [])],
authors=[
unescape_author(name) for name in authors.get(book_id, [])
],
description=strip_html(descriptions.get(book_id)),
published_date=parse_date(pubdate),
series=in_series,
@@ -510,8 +514,19 @@ class _TextExtractor(HTMLParser):
# a description of three paragraphs comes out as one run-on sentence.
_BREAKS = frozenset(
{
"p", "br", "div", "li", "tr", "blockquote", "hr",
"h1", "h2", "h3", "h4", "h5", "h6",
"p",
"br",
"div",
"li",
"tr",
"blockquote",
"hr",
"h1",
"h2",
"h3",
"h4",
"h5",
"h6",
}
)
backend/src/chitai/services/consume.py
+25 -21
View File
@@ -4,17 +4,23 @@ from collections import defaultdict
from chitai.config import settings
from chitai.database.models.library import Library
from chitai.services import BookService, LibraryService
from chitai.services.metadata_extractor import Extractor
from chitai.services.utils import create_directory
from watchfiles import awatch, Change
class ConsumeDirectoryWatcher:
"""Watches a directory and batch processes files by their relative path."""
def __init__(self, watch_path: str, library_service: LibraryService, book_service: BookService, batch_delay: float = 3.0):
def __init__(
self,
watch_path: str,
library_service: LibraryService,
book_service: BookService,
batch_delay: float = 3.0,
):
"""
Initialize the file watcher.
Args:
watch_path: Directory path to watch
batch_delay: Seconds to wait before processing a batch
@@ -41,9 +47,9 @@ class ConsumeDirectoryWatcher:
for change_type, file_path in changes:
if change_type != Change.added:
continue
file_path = Path(file_path)
# If a directory was added, scan it for existing files
if file_path.is_dir():
print(f"Directory added: {file_path}")
@@ -51,28 +57,28 @@ class ConsumeDirectoryWatcher:
else:
print(f"File added: {file_path}")
await self._handle_file_added(file_path)
except asyncio.CancelledError:
print("File watcher stopped")
# Wait for any pending processing tasks
if self._processing_tasks:
await asyncio.gather(*self._processing_tasks, return_exceptions=True)
raise
async def _handle_file_added(self, file_path: Path):
"""Handle a single file being added."""
# Get relative path from watch directory
rel_path = file_path.relative_to(self.watch_path)
parent_rel = rel_path.parent
library = parent_rel.parts[0]
# Add to appropriate group
self.file_groups[library].add(file_path)
# Schedule batch processing for this group
self._schedule_batch_processing(library)
async def _handle_directory_added(self, dir_path: Path):
"""Handle a directory being added - scan it for existing files."""
try:
@@ -83,35 +89,34 @@ class ConsumeDirectoryWatcher:
await self._handle_file_added(file_path)
except Exception as e:
print(f"Error scanning directory {dir_path}: {e}")
def _schedule_batch_processing(self, library_slug: str):
"""Schedule batch processing for a specific path group."""
# Create a task to process this group after a delay
task = asyncio.create_task(self._delayed_batch_process(library_slug))
self._processing_tasks.add(task)
task.add_done_callback(self._processing_tasks.discard)
async def _delayed_batch_process(self, library_slug: str):
"""Wait for batch delay, then process accumulated files."""
await asyncio.sleep(self.batch_delay)
# Get and clear the file list for this path
if library_slug not in self.file_groups:
return
files_to_process = self.file_groups[library_slug].copy()
self.file_groups[library_slug].clear()
if not files_to_process:
return
print(f"Batch processing {len(files_to_process)} files from {library_slug}")
await self._process_batch(files_to_process, library_slug)
async def _process_batch(self, file_paths: set[Path], library_slug: str):
"""Process a batch of files."""
try:
result = await self.book_service.create_many_from_existing_files(
list(file_paths),
self.watch_path / Path(library_slug),
@@ -138,10 +143,9 @@ class ConsumeDirectoryWatcher:
f"already be in the library as: {names}"
)
except Exception as e:
print(f"Error processing batch: {e}")
raise e
async def _get_library(self, slug: str) -> Library:
return await self.library_service.get_one(Library.slug == slug)
backend/src/chitai/services/dependencies.py
+2 -5
View File
@@ -2,7 +2,7 @@
# Standard library
from __future__ import annotations
from typing import Any, AsyncGenerator, Callable, NotRequired, Optional
from typing import Any, AsyncGenerator, Optional
# Third-party libraries
from advanced_alchemy.extensions.litestar.providers import (
@@ -13,7 +13,6 @@ from advanced_alchemy.extensions.litestar.providers import (
)
from advanced_alchemy.exceptions import NotFoundError
from advanced_alchemy.filters import CollectionFilter, StatementFilter
from advanced_alchemy.service import FilterTypeT
from sqlalchemy.orm import selectinload
from sqlalchemy.ext.asyncio import AsyncSession
from litestar import Request
@@ -25,7 +24,6 @@ from litestar.di import Provide
from advanced_alchemy.extensions.litestar.providers import create_filter_dependencies
# Local imports
from chitai import schemas as s
from chitai.database import models as m
from chitai.services import (
UserService,
@@ -154,7 +152,6 @@ def create_book_filter_dependencies(
# OVERRIDE: Custom search filter with trigram search
if config.get("search"):
search_fields = config.get("search")
def provide_trigram_search_filter(
search_string: str | None = Parameter(
@@ -370,6 +367,7 @@ def provide_optional_user(request: Request[m.User, Token, Any]) -> m.User | None
return None
async def provide_user_via_basic_auth(request: Request[m.User, None, Any]) -> m.User:
return request.user
@@ -381,4 +379,3 @@ async def provide_user_via_kosync_auth(request: Request[m.User, None, Any]) -> m
provide_kosync_device_service = create_service_provider(KosyncDeviceService)
provide_kosync_progress_service = create_service_provider(KosyncProgressService)
backend/src/chitai/services/filesystem_library.py
-2
View File
@@ -4,9 +4,7 @@ from pathlib import Path
import re
from jinja2 import Template
from advanced_alchemy.service import ModelDictT
import chitai.database.models as m
# TODO: Replace Jinja2 templates with a simpler custom templating system.
# Current Jinja2 implementation is overly complex for basic path generation.
backend/src/chitai/services/filters/author.py
+1 -1
View File
@@ -1,4 +1,4 @@
from typing import Any, Optional
from typing import Optional
from dataclasses import dataclass
from advanced_alchemy.filters import (
backend/src/chitai/services/filters/book.py
+9 -5
View File
@@ -3,11 +3,10 @@ from typing import Any, Optional
from dataclasses import dataclass, field
from sqlalchemy.orm import aliased
from sqlalchemy import Select, and_, desc, func, or_, text
from sqlalchemy import Select, and_, func, or_, text
from advanced_alchemy.filters import (
StatementTypeT,
StatementFilter,
CollectionFilter,
ModelT,
)
@@ -135,7 +134,7 @@ class ProgressFilter(StatementFilter):
status_conditions.append(
and_(
or_(
m.BookProgress.completed == False,
m.BookProgress.completed.is_(False),
m.BookProgress.completed.is_(None),
),
m.BookProgress.percentage > 0,
@@ -143,7 +142,7 @@ class ProgressFilter(StatementFilter):
)
if ProgressStatus.READ in self.statuses:
status_conditions.append(m.BookProgress.completed == True)
status_conditions.append(m.BookProgress.completed.is_(True))
if ProgressStatus.UNREAD in self.statuses:
status_conditions.append(m.BookProgress.id.is_(None))
@@ -154,6 +153,7 @@ class ProgressFilter(StatementFilter):
@dataclass
class FileFilter(StatementFilter):
"""Filter books that are related to the given files."""
file_ids: list[int]
def append_to_statement(
@@ -165,17 +165,21 @@ class FileFilter(StatementFilter):
return super().append_to_statement(statement, model, *args, **kwargs)
@dataclass
class FileHashFilter(StatementFilter):
file_hashes: list[str]
def append_to_statement(self, statement: StatementTypeT, model: type[ModelT], *args, **kwargs) -> StatementTypeT:
def append_to_statement(
self, statement: StatementTypeT, model: type[ModelT], *args, **kwargs
) -> StatementTypeT:
statement = statement.where(
m.Book.files.any(m.FileMetadata.hash.in_(self.file_hashes))
)
return super().append_to_statement(statement, model, *args, **kwargs)
@dataclass
class CustomOrderBy(StatementFilter):
"""Order by filter with support for 'random' and 'last accessed' orderings."""
backend/src/chitai/services/kosync_device.py
+11 -7
View File
@@ -1,16 +1,21 @@
from __future__ import annotations
import secrets
from chitai.database.models.kosync_device import KosyncDevice
from advanced_alchemy.service import SQLAlchemyAsyncRepositoryService, ModelDictT, schema_dump
from advanced_alchemy.service import (
SQLAlchemyAsyncRepositoryService,
ModelDictT,
schema_dump,
)
from advanced_alchemy.repository import SQLAlchemyAsyncRepository
class KosyncDeviceService(SQLAlchemyAsyncRepositoryService[KosyncDevice]):
"""Service for managing KOReader devices."""
API_KEY_LENGTH_IN_BYTES = 8
class Repo(SQLAlchemyAsyncRepository[KosyncDevice]):
""" Repository for KosyncDevice entities."""
"""Repository for KosyncDevice entities."""
model_type = KosyncDevice
@@ -18,18 +23,17 @@ class KosyncDeviceService(SQLAlchemyAsyncRepositoryService[KosyncDevice]):
async def create(self, data: ModelDictT[KosyncDevice], **kwargs) -> KosyncDevice:
data = schema_dump(data)
data['api_key'] = self._generate_api_key()
data["api_key"] = self._generate_api_key()
return await super().create(data, **kwargs)
async def get_by_api_key(self, api_key: str) -> KosyncDevice:
return await self.get_one(KosyncDevice.api_key == api_key)
async def regenerate_api_key(self, device_id: int) -> KosyncDevice:
async def regenerate_api_key(self, device_id: int) -> KosyncDevice:
device = await self.get(device_id)
api_key = self._generate_api_key()
device.api_key = api_key
return await self.update(device)
def _generate_api_key(self) -> str:
return secrets.token_hex(self.API_KEY_LENGTH_IN_BYTES)
backend/src/chitai/services/kosync_progress.py
+3 -1
View File
@@ -16,7 +16,9 @@ class KosyncProgressService(SQLAlchemyAsyncRepositoryService[KosyncProgress]):
repository_type = Repo
async def get_by_document_hash(self, user_id: int, document: str) -> KosyncProgress | None:
async def get_by_document_hash(
self, user_id: int, document: str
) -> KosyncProgress | None:
"""Get progress for a specific document and user."""
return await self.get_one_or_none(
KosyncProgress.user_id == user_id,
backend/src/chitai/services/library.py
+3 -7
View File
@@ -5,7 +5,6 @@ from pathlib import Path
from advanced_alchemy.service import SQLAlchemyAsyncRepositoryService
from advanced_alchemy.repository import SQLAlchemyAsyncRepository
from advanced_alchemy import service
from advanced_alchemy.utils.text import slugify
# Local imports
from chitai.database.models.library import Library
@@ -18,6 +17,7 @@ from chitai.services.utils import (
from chitai.config import settings
class LibraryService(SQLAlchemyAsyncRepositoryService[Library]):
"""Service for managing libraries and their configuration."""
@@ -48,7 +48,7 @@ class LibraryService(SQLAlchemyAsyncRepositoryService[Library]):
"""
# TODO: What if a library root_path is a child of an existing library?
if existing := await self.list(Library.root_path == library.root_path):
if await self.list(Library.root_path == library.root_path):
raise ValueError(f"Library already exists at '{library.root_path}'")
if library.read_only:
@@ -57,8 +57,7 @@ class LibraryService(SQLAlchemyAsyncRepositoryService[Library]):
raise DirectoryDoesNotExist(
f"Root directory '{library.root_path}' must exist for a read-only library"
)
# TODO: Verify the read-only library has read permissions
created_library = await super().create(
service.schema_dump(library, exclude_unset=False), **kwargs
@@ -71,9 +70,6 @@ class LibraryService(SQLAlchemyAsyncRepositoryService[Library]):
await create_directory(Path(settings.consume_path) / Path(library.slug))
return created_library
# TODO: Implement library deletion and optional file deletion
async def delete(
backend/src/chitai/services/metadata_extractor.py
+44 -25
View File
@@ -103,8 +103,18 @@ def parse_identifier(value: str, scheme: str | None = None) -> tuple[str, str] |
# Numbered editions, in the forms covers and catalogue records actually use:
# "3rd Edition", "2E", "4e", "8_e", "/6e", "(2nd edition)", "Third International Edition".
_ORDINAL_WORDS = {
"first": 1, "second": 2, "third": 3, "fourth": 4, "fifth": 5, "sixth": 6,
"seventh": 7, "eighth": 8, "ninth": 9, "tenth": 10, "eleventh": 11, "twelfth": 12,
"first": 1,
"second": 2,
"third": 3,
"fourth": 4,
"fifth": 5,
"sixth": 6,
"seventh": 7,
"eighth": 8,
"ninth": 9,
"tenth": 10,
"eleventh": 11,
"twelfth": 12,
}
# Words that sit between the number and "Edition" and belong to the same statement.
@@ -161,7 +171,9 @@ def split_edition(title: str | None) -> tuple[str | None, int | None]:
stripped = _EDITION.sub(" ", title)
stripped = re.sub(r"\s{2,}", " ", stripped)
stripped = re.sub(r"\s+([,;:.!?])", r"\1", stripped) # "Works : What" → "Works: What"
stripped = re.sub(
r"\s+([,;:.!?])", r"\1", stripped
) # "Works : What" → "Works: What"
stripped = stripped.strip(" ,;:-–—/")
# A title that is only an edition statement is not improved by having none.
@@ -178,7 +190,9 @@ class FileExtractor(Protocol):
) -> dict[str, Any]: ...
@classmethod
async def extract_text(cls, input: UploadFile | BinaryIO | bytes | Path | str) -> str: ...
async def extract_text(
cls, input: UploadFile | BinaryIO | bytes | Path | str
) -> str: ...
class Extractor:
@@ -187,7 +201,9 @@ class Extractor:
format_priorities = {"epub": 1, "pdf": 2}
@classmethod
async def extract_metadata(cls, files: list[UploadFile] | list[Path], root_path: Path | None = None) -> dict[str, Any]:
async def extract_metadata(
cls, files: list[UploadFile] | list[Path], root_path: Path | None = None
) -> dict[str, Any]:
metadata = {}
# Sort based on file priority
@@ -235,7 +251,7 @@ class Extractor:
metadata = FilepathExtractor.extract_metadata(files[0], root_path) | metadata
# format the title
if metadata.get('title', None):
if metadata.get("title", None):
# Before the subtitle split, so the edition cannot be mistaken for one:
# "How Linux Works, 3rd Edition: What Every Superuser Should Know" has to
# lose the edition first for the colon count to mean anything.
@@ -282,8 +298,8 @@ class Extractor:
file_ext = get_file_extension(filename)
if file_ext is None:
return float('inf')
return float("inf")
return Extractor.format_priorities.get(file_ext, float("inf"))
@classmethod
@@ -618,8 +634,10 @@ class FilepathExtractor(FileExtractor):
"""Extracts metadata from the filepath."""
@classmethod
def extract_metadata(cls, input: UploadFile | Path | str, root_path: Path | None = None) -> dict[str, Any]:
def extract_metadata(
cls, input: UploadFile | Path | str, root_path: Path | None = None
) -> dict[str, Any]:
if isinstance(input, UploadFile):
path = Path(input.filename).parent
else:
@@ -627,33 +645,34 @@ class FilepathExtractor(FileExtractor):
if root_path:
path = path.relative_to(root_path)
parts = path.parts
metadata: dict[str, str | None] = {}
if len(parts) == 3:
# Format: Author/Series/Part - Title/filename
metadata['author'] = parts[0]
metadata["author"] = parts[0]
# Extract part number and title from directory name (parts[2])
dirname = parts[2]
match = re.match(r'^([\d.]+)\s*-\s*(.+)$', dirname)
match = re.match(r"^([\d.]+)\s*-\s*(.+)$", dirname)
if match:
metadata['series_position'] = match.group(1) # Keep as string
metadata['series'] = parts[1]
metadata['title'] = match.group(2).strip()
metadata["series_position"] = match.group(1) # Keep as string
metadata["series"] = parts[1]
metadata["title"] = match.group(2).strip()
else:
metadata['series'] = parts[1]
metadata['title'] = path.stem
metadata["series"] = parts[1]
metadata["title"] = path.stem
elif len(parts) == 2:
# Format: Author/Title
metadata['author'] = parts[0]
metadata['title'] = path.stem # Remove extension
metadata["author"] = parts[0]
metadata["title"] = path.stem # Remove extension
return metadata
class FilenameExtractor(FileExtractor):
"""Extracts metadata from the filename."""
backend/src/chitai/services/opds/models.py
+37 -23
View File
@@ -4,43 +4,57 @@ from typing import Any, Literal, Optional, Sequence
from pydantic import BaseModel, Field
from datetime import datetime
class LinkTypes(StrEnum):
NAVIGATION = "application/atom+xml;profile=opds-catalog;kind=navigation"
ACQUISITION = "application/atom+xml;profile=opds-catalog;kind=acquisition"
OPEN_SEARCH = "application/opensearchdescription+xml"
class AcquisitionRelations(StrEnum):
_BASE = "http://opds-spec.org/acquisition"
ACQUISITION = _BASE # A generic relation that indicates that the entry may be retrieved
OPEN_ACCESS = f"{_BASE}/open-access" # Entry may be retrieved without any requirement
BORROW = f"{_BASE}/borrow" # Entry may be retrieved as part of a lending transaction
BUY = f"{_BASE}/buy" # Entry may be retrieved as part of a purchase
SAMPLE = f"{_BASE}/sample" # Subset of the entry may be retrieved
PREVIEW = f"{_BASE}/preview" # Subset of the entry may be retrieved
SUBSCRIBE = f"{_BASE}/subscribe" # Entry my be retrieved as a part of a subscription
ACQUISITION = (
_BASE # A generic relation that indicates that the entry may be retrieved
)
OPEN_ACCESS = (
f"{_BASE}/open-access" # Entry may be retrieved without any requirement
)
BORROW = (
f"{_BASE}/borrow" # Entry may be retrieved as part of a lending transaction
)
BUY = f"{_BASE}/buy" # Entry may be retrieved as part of a purchase
SAMPLE = f"{_BASE}/sample" # Subset of the entry may be retrieved
PREVIEW = f"{_BASE}/preview" # Subset of the entry may be retrieved
SUBSCRIBE = (
f"{_BASE}/subscribe" # Entry my be retrieved as a part of a subscription
)
class NavigationRelations(StrEnum):
_BASE = ""
class LinkRelations(StrEnum):
""" Link types for OPDSv1.2 related resources
"""Link types for OPDSv1.2 related resources
https://specs.opds.io/opds-1.2.html#6-additional-link-relations
"""
_BASE = "http://opds-spec.org"
START = "start" # The OPDS catalog root
SUBSECTION = "subsection" # an OPDS feed not better described by any of the below relations
SHELF = f"{_BASE}/shelf" # Entries acquired by the euser
SUBSCRIPTIONS = f"{_BASE}/subscriptions" # Entries available with users's subscription
NEW = f"{_BASE}/sort/new" # Newest entries
POPULAR = f"{_BASE}/sort/popular" # Most popular entries
FEATURED = f"{_BASE}/featured" # Entries selected for promotion
RECOMMENDED = f"{_BASE}/recommended" # Entries recommended to the specific user
START = "start" # The OPDS catalog root
SUBSECTION = (
"subsection" # an OPDS feed not better described by any of the below relations
)
SHELF = f"{_BASE}/shelf" # Entries acquired by the euser
SUBSCRIPTIONS = (
f"{_BASE}/subscriptions" # Entries available with users's subscription
)
NEW = f"{_BASE}/sort/new" # Newest entries
POPULAR = f"{_BASE}/sort/popular" # Most popular entries
FEATURED = f"{_BASE}/featured" # Entries selected for promotion
RECOMMENDED = f"{_BASE}/recommended" # Entries recommended to the specific user
class Feed(BaseModel): # OPDS Catalog root element
@@ -117,9 +131,8 @@ class AcquisitionFeedLink(Link):
class NavigationFeedLink(Link):
type: str = Field(
default=LinkTypes.NAVIGATION, serialization_alias="@type"
)
type: str = Field(default=LinkTypes.NAVIGATION, serialization_alias="@type")
class Content(BaseModel):
type: Literal["text"] = Field(default="text", serialization_alias="@type")
@@ -170,9 +183,10 @@ class Entry(BaseModel):
data = super().model_dump(**kwargs)
return {"entry": data}
@dataclass
class PaginationResult:
next_link: Optional[Link]
prev_link: Optional[Link]
current_offset: int
total_count: int
total_count: int
backend/src/chitai/services/opds/opds.py
+57 -70
View File
@@ -1,4 +1,3 @@
from typing import Any, Callable, Sequence
from urllib.parse import quote_plus, urlencode
from litestar import Request
@@ -16,9 +15,10 @@ from .models import (
AcquisitionFeedLink,
NavigationFeed,
NavigationFeedLink,
PaginationResult
PaginationResult,
)
def get_opensearch_document(base_url: str = "/opds/search?") -> str:
search = {
"OpenSearchDescription": {
@@ -120,19 +120,20 @@ def create_navigation_feed(
pretty=True,
)
def create_library_navigation_feed(library: m.Library) -> str:
entries = [
Entry(
id=f"/opds/library/{library.id}/all-books",
title='All Books',
title="All Books",
link=[
AcquisitionFeedLink(
rel="subsection",
href=f"/opds/acquisition?libraries={library.id}&paginated=1&pageSize=50&feed_title=AllBooks&feed_id=/opds/library/{library.id}/all-books",
title="All Books",
)
]
],
),
Entry(
id=f"/opds/library/{library.id}/recently-added",
@@ -141,9 +142,9 @@ def create_library_navigation_feed(library: m.Library) -> str:
NavigationFeedLink(
rel="http://opds-spec.org/sort/new",
href=f"/opds/acquisition?libraries={library.id}&orderBy=created_at&pageSize=50&feed_title=RecentlyAdded&feed_id=/opds/library/{library.id}/recently-added",
title="Recently Added"
title="Recently Added",
)
]
],
),
Entry(
id=f"/opds/library/{library.id}/shelves",
@@ -152,9 +153,9 @@ def create_library_navigation_feed(library: m.Library) -> str:
NavigationFeedLink(
rel="subsection",
href=f"/opds/library/{library.id}/shelves?paginated=1&pageSize=10",
title="Bookshelves"
title="Bookshelves",
)
]
],
),
Entry(
id=f"/opds/library/{library.id}/tags",
@@ -163,9 +164,9 @@ def create_library_navigation_feed(library: m.Library) -> str:
NavigationFeedLink(
rel="subsection",
href=f"/opds/library/{library.id}/tags?paginated=1&pageSize=10",
title="Tags"
title="Tags",
)
]
],
),
Entry(
id=f"/opds/library/{library.id}/authors",
@@ -174,9 +175,9 @@ def create_library_navigation_feed(library: m.Library) -> str:
NavigationFeedLink(
rel="subsection",
href=f"/opds/library/{library.id}/authors?paginated=1&pageSize=10",
title="Authors"
title="Authors",
)
]
],
),
Entry(
id=f"/opds/library/{library.id}/publishers",
@@ -185,34 +186,34 @@ def create_library_navigation_feed(library: m.Library) -> str:
NavigationFeedLink(
rel="subsection",
href=f"/opds/library/{library.id}/publishers?paginated=1&pageSize=10",
title="Publishers"
title="Publishers",
)
]
],
),
]
feed = create_navigation_feed(
id=f'/library/{library.id}',
id=f"/library/{library.id}",
title=library.name,
self_url=f'/opds/library/{library.id}',
links=[
],
entries=entries
self_url=f"/opds/library/{library.id}",
links=[],
entries=entries,
)
return feed
def create_collection_navigation_feed(
library: m.Library,
collection_type: str,
items: Sequence[m.BookList | m.Tag | m.Author | m.Publisher | m.BookSeries],
links: list[Link] = list(),
# Title is usually derived from the model's name or title
get_title: Callable[[Any], str] = lambda x: getattr(x, 'title', getattr(x, 'name', str(x)))
get_title: Callable[[Any], str] = lambda x: getattr(
x, "title", getattr(x, "name", str(x))
),
) -> str:
entries = [
Entry(
id=f"/opds/library/{library.id}/{collection_type}/{item.id}",
@@ -222,53 +223,43 @@ def create_collection_navigation_feed(
href=f"/opds/acquisition?{collection_type}={item.id}&pageSize=50&paginated=1&feed_title={quote_plus(get_title(item))}&feed_id=/opds/library/{library.id}/{collection_type}/{item.id}&search=True",
title=get_title(item),
)
]
) for item in items
],
)
for item in items
]
return create_navigation_feed(
id=f"/opds/library/{library.id}/{collection_type}",
title=collection_type.title(),
self_url=f'/opds/library/{library.id}/{collection_type}',
self_url=f"/opds/library/{library.id}/{collection_type}",
entries=entries,
links=links
links=links,
)
def create_next_paginated_link(
request: Request,
total: int,
current_count: int,
offset: int,
feed_title: str
) -> Link | None:
if total <= current_count + offset:
return None
params = dict(request.query_params)
params['currentPage'] = params.get('currentPage', 1) + 1
next_url = f"{request.url.path}?{urlencode(list(params.items()), doseq=True)}"
return Link(
rel="next",
href=next_url,
title=feed_title,
type=LinkTypes.NAVIGATION
)
request: Request, total: int, current_count: int, offset: int, feed_title: str
) -> Link | None:
if total <= current_count + offset:
return None
params = dict(request.query_params)
params["currentPage"] = params.get("currentPage", 1) + 1
next_url = f"{request.url.path}?{urlencode(list(params.items()), doseq=True)}"
return Link(rel="next", href=next_url, title=feed_title, type=LinkTypes.NAVIGATION)
def create_search_link(
request: Request,
exclude_params: set[str] | None = None
request: Request, exclude_params: set[str] | None = None
) -> Link:
"""Create search link with current filters applied"""
if exclude_params is None:
exclude_params = {'currentPage', 'feed_title', 'feed_id', 'search', 'paginated'}
params = {
k: v for k, v in request.query_params.items()
if k not in exclude_params
}
exclude_params = {"currentPage", "feed_title", "feed_id", "search", "paginated"}
params = {k: v for k, v in request.query_params.items() if k not in exclude_params}
return Link(
rel="search",
href=f"/opds/opensearch?{urlencode(list(params.items()), doseq=True)}",
@@ -277,7 +268,6 @@ def create_search_link(
)
def create_pagination_links(
request: Request,
total: int,
@@ -287,38 +277,35 @@ def create_pagination_links(
link_type: str = LinkTypes.ACQUISITION,
) -> PaginationResult:
"""Create next/prev pagination links using limit/offset"""
next_link = None
prev_link = None
# Create next link if there are more items
if offset + limit < total:
params = dict(request.query_params)
# Calculate next page number
current_page = (offset // limit) + 1
params['currentPage'] = current_page + 1
params["currentPage"] = current_page + 1
next_url = f"{request.url.path}?{urlencode(params, doseq=True)}"
next_link = Link(
rel="next",
href=next_url,
title=f"{feed_title} - Next",
type=link_type
rel="next", href=next_url, title=f"{feed_title} - Next", type=link_type
)
# Create previous link if not on first page
if offset > 0:
params = dict(request.query_params)
# Calculate previous page number
current_page = (offset // limit) + 1
params['currentPage'] = max(1, current_page - 1)
params["currentPage"] = max(1, current_page - 1)
prev_url = f"{request.url.path}?{urlencode(params, doseq=True)}"
prev_link = Link(
rel="previous",
href=prev_url,
title=f"{feed_title} - Previous",
type=link_type
type=link_type,
)
return PaginationResult(next_link, prev_link, offset, total)
backend/src/chitai/services/utils.py
+4 -2
View File
@@ -213,6 +213,7 @@ async def create_directory(dir_path: Path | str) -> None:
await aios.makedirs(dir_path, exist_ok=True)
async def move_file(src_path: Path, dest_path: Path, create_dirs=True) -> None:
"""
Move a file from source to destination asynchronously.
@@ -239,6 +240,7 @@ async def move_file(src_path: Path, dest_path: Path, create_dirs=True) -> None:
# all configured separately, so they can easily be separate mounts.
shutil.move(str(src_path), str(dest_path))
async def copy_file(src_path: Path, dest_path: Path, create_dirs: bool = True) -> None:
"""
Copy a file, streaming it rather than reading it whole.
@@ -451,7 +453,7 @@ def get_file_extension(file: Path | str | UploadFile) -> str | None:
elif isinstance(file, UploadFile):
return Path(file.filename).suffix.lower()[1:]
raise ValueError("file object type is not supported")
@@ -476,7 +478,7 @@ def get_filename(file: Path | str, ext: bool = True) -> str:
filename = Path(file.name)
else:
raise ValueError("file object type is not supported")
if ext:
return str(filename)