nthp_api 0.1.9__py3-none-any.whl

nthp_api/cli/__init__.py

@@ -0,0 +1,88 @@
+import logging
+from os import environ
+
+import click
+
+from nthp_api.cli import logs
+from nthp_api.nthp_build.version import get_version
+
+logs.init()
+
+
+log = logging.getLogger(__name__)
+
+
+@click.group()
+def cli():
+    pass
+
+
+@cli.command()
+def version():
+    print(f"nthp-api {get_version()}")  # noqa T201
+
+
+@click.argument("path", type=click.Path(exists=True))
+@cli.command()
+def load(path):
+    environ["CONTENT_ROOT"] = str(path)
+
+    from nthp_api.nthp_build import database, loader
+
+    database.init_db(create=True)
+    loader.run_loaders()
+
+
+@cli.command()
+def stats():
+    environ["CONTENT_ROOT"] = "does-not-matter"
+
+    from nthp_api.nthp_build import database
+
+    database.init_db()
+    database.show_stats()
+
+
+@cli.command()
+def smug():
+    environ["CONTENT_ROOT"] = "does-not-matter"
+
+    import nthp_api.smugmugger.database
+    from nthp_api.nthp_build import database, smugmug
+
+    database.init_db()
+    nthp_api.smugmugger.database.init_db()
+    smugmug.run()
+
+
+@cli.command()
+def dump():
+    environ["CONTENT_ROOT"] = "does-not-matter"
+
+    from nthp_api.nthp_build import database, dumper
+
+    database.init_db()
+    dumper.delete_output_dir()
+    dumper.dump_all()
+
+
+@click.argument("path", type=click.Path(exists=True))
+@cli.command()
+def build(path):
+    # Set settings using environment variables as workers and threads will recreate
+    # the settings object and not pick up the values if set here.
+    environ["DB_URI"] = ":memory:"
+    environ["CONTENT_ROOT"] = str(path)
+
+    log.info(f"Building from {path} using in-memory database")
+
+    import nthp_api.smugmugger.database
+    from nthp_api.nthp_build import database, dumper, loader, smugmug
+
+    database.init_db(create=True)
+    loader.run_loaders()
+    database.show_stats()
+    nthp_api.smugmugger.database.init_db()
+    smugmug.run()
+    dumper.delete_output_dir()
+    dumper.dump_all()

nthp_api/cli/logs.py

@@ -0,0 +1,20 @@
+import logging
+from os import environ
+
+import coloredlogs
+
+LOG_FORMAT = "%(asctime)s %(levelname)s %(message)s"
+DATE_FORMAT = "%H:%M:%S"
+
+
+def init():
+    nthp_build_logger = logging.getLogger("nthp_api.nthp_build")
+    smugmugger_logger = logging.getLogger("nthp_api.smugmugger")
+
+    log_level = environ.get("LOG_LEVEL", "INFO")
+    coloredlogs.install(
+        level=log_level, logger=nthp_build_logger, fmt=LOG_FORMAT, datefmt=DATE_FORMAT
+    )
+    coloredlogs.install(
+        level=log_level, logger=smugmugger_logger, fmt=LOG_FORMAT, datefmt=DATE_FORMAT
+    )

nthp_api/nthp_build/assets.py

@@ -0,0 +1,229 @@
+import json
+import logging
+import mimetypes
+from collections.abc import Generator, Iterable
+from enum import Enum
+
+from nthp_api.nthp_build import database, models, schema
+from nthp_api.nthp_build.documents import DocumentPath
+from nthp_api.smugmugger import SmugMugImage
+
+log = logging.getLogger(__name__)
+
+
+class AssetTarget(database.DbCompatEnumMixin, Enum):
+    SHOW = "show"
+    PERSON = "person"
+    VENUE = "venue"
+    ALBUM = "album"
+
+
+class AssetSource(database.DbCompatEnumMixin, Enum):
+    SMUGMUG = "smugmug"
+    FILE = "file"
+
+
+class AssetType(database.DbCompatEnumMixin, Enum):
+    ALBUM = "album"  # A collection of other assets
+    IMAGE = "image"  # A single image, a photo or a scanned document
+    VIDEO = "video"  # A video
+    OTHER = "other"  # A video
+
+
+class AssetCategory(database.DbCompatEnumMixin, Enum):
+    POSTER = "poster"
+    FLYER = "flyer"
+    PROGRAMME = "programme"
+    HEADSHOT = "headshot"
+
+
+def get_mime_type(source: AssetSource, type: AssetType, id: str) -> str | None:
+    """
+    Decide or determine the mime-type of an asset.
+    :param source: Where does this asset come from?
+    :param type: Type of asset
+    :param id:
+    :return: A mime type, or None if either we can't determine one or one does not apply
+    """
+    if source is AssetSource.SMUGMUG:
+        if type is AssetType.ALBUM:
+            return None
+        if type is AssetType.IMAGE:
+            return "image/jpeg"
+        if type is AssetType.VIDEO:
+            return "video/mp4"  # TODO: check if correct
+        raise ValueError(f"Unhandled asset type {type}")
+
+    if source is AssetSource.FILE:
+        guess = mimetypes.guess_type(id)[0]
+        if guess is None:
+            raise ValueError(f"Could not guess mime type for {id}")
+        return guess
+
+    raise ValueError(f"Unhandled asset source {source}")
+
+
+def save_asset(  # noqa: PLR0913
+    target_id: str,
+    target_type: AssetTarget,
+    source: AssetSource,
+    type: AssetType,
+    id: str,
+    category: AssetCategory | str | None = None,
+    title: str | None = None,
+    page: int | None = None,
+) -> database.Asset:
+    return database.Asset.create(
+        target_id=target_id,
+        target_type=target_type,
+        asset_source=source,
+        asset_type=type,
+        asset_mime_type=get_mime_type(source, type, id),
+        asset_id=id,
+        asset_category=category,
+        title=title,
+        page=page,
+    )
+
+
+def assets_from_show_model(
+    show: models.Show,
+) -> Generator[schema.Asset, None, None]:
+    """Generate show assets (output type) from a show model (input type)"""
+    for asset in show.assets:
+        if asset.image:
+            source = AssetSource.SMUGMUG
+            type = AssetType.IMAGE
+        elif asset.video:
+            source = AssetSource.SMUGMUG
+            type = AssetType.VIDEO
+        elif asset.filename:
+            source = AssetSource.FILE
+            # We assume files are something else, but could be image or video.
+            # In reality they tend to be PDF / audio / other docs
+            type = AssetType.OTHER
+        else:
+            raise ValueError(f"Unhandled mode for asset {asset}")
+
+        asset_id = asset.image or asset.video or asset.filename
+        if not asset_id:
+            raise ValueError(f"No ID for asset {asset}")
+
+        yield schema.Asset(
+            type=str(type),
+            source=str(source),
+            mime_type=get_mime_type(source, type, asset_id),
+            id=asset_id,
+            category=asset.type,
+            # we use type for image/video/other, source uses it for category
+            title=asset.title,
+            page=asset.page,
+        )
+
+    if show.prod_shots:
+        yield schema.Asset(
+            type=str(AssetType.ALBUM),
+            source=str(AssetSource.SMUGMUG),
+            mime_type=get_mime_type(
+                AssetSource.SMUGMUG, AssetType.ALBUM, show.prod_shots
+            ),
+            id=show.prod_shots,
+        )
+
+
+def save_show_assets(
+    path: DocumentPath, show_assets: Iterable[schema.Asset]
+) -> list[database.Asset]:
+    """Write assets to the database"""
+    return [
+        save_asset(
+            target_id=path.id,
+            target_type=AssetTarget.SHOW,
+            source=AssetSource(asset.source),
+            type=AssetType(asset.type),
+            id=asset.id,
+            category=asset.category,
+            title=asset.title,
+            page=asset.page,
+        )
+        for asset in show_assets
+    ]
+
+
+def save_person_assets(
+    path: DocumentPath, person: models.Person
+) -> list[database.Asset]:
+    assets = []
+    if person.headshot:
+        assets.append(
+            save_asset(
+                target_id=path.id,
+                target_type=AssetTarget.PERSON,
+                source=AssetSource.SMUGMUG,
+                type=AssetType.IMAGE,
+                id=person.headshot,
+                category=AssetCategory.HEADSHOT,
+                title=person.title,
+            )
+        )
+    return assets
+
+
+def filter_assets_by_type(assets, type):
+    return list(filter(lambda asset: asset.type.lower() == type.value, assets))
+
+
+def pick_show_primary_image(assets: list[models.Asset]) -> str | None:
+    """
+    Pick an image to use as the primary, to be used in list views &c
+    TODO: Currently we return a SmugMug ID rather than a full Asset object.
+    """
+    image_assets = list(filter(lambda asset: asset.image is not None, assets))
+    if override_assets := list(filter(lambda asset: asset.display_image, image_assets)):
+        return override_assets[0].image
+    if posters := filter_assets_by_type(image_assets, AssetCategory.POSTER):
+        return posters[0].image
+    if flyers := filter_assets_by_type(image_assets, AssetCategory.FLYER):
+        return flyers[0].image
+    if programmes := filter_assets_by_type(image_assets, AssetCategory.PROGRAMME):
+        return programmes[0].image
+    # No suitable image found, oh well we tried
+    return None
+
+
+def smugmug_asset_to_asset(smugmug_asset: SmugMugImage) -> schema.Asset:
+    """Convert a SmugMug asset to a schema asset"""
+    asset_type = AssetType.VIDEO if smugmug_asset.IsVideo else AssetType.IMAGE
+    return schema.Asset(
+        id=smugmug_asset.ImageKey,
+        source=AssetSource.SMUGMUG.value,
+        title=smugmug_asset.Title or None,
+        type=asset_type.value,
+        mime_type=get_mime_type(
+            AssetSource.SMUGMUG, asset_type, smugmug_asset.ImageKey
+        ),
+    )
+
+
+def get_asset_collection_from_album(
+    album: database.Asset,
+) -> schema.AssetCollection | None:
+    """
+    Get AssetCollection from an asset album.
+    Currently, we only support SmugMug albums.
+    If the SmugMug data isn't present or fails to parse, we return None.
+    """
+    if album.asset_source != AssetSource.SMUGMUG.value:
+        raise ValueError(f"Album source '{album.asset_source}' unsupported")
+    if not album.asset_smugmug_data:
+        log.warning(f"No smugmug data for album {album.asset_id}")
+        return None
+    try:
+        smugmug_album_images = json.loads(album.asset_smugmug_data)
+        smugmug_assets = [SmugMugImage(**asset) for asset in smugmug_album_images]
+    except json.JSONDecodeError:
+        log.warning(f"Could not decode smugmug data for album {album.asset_id}")
+        return None
+    return schema.AssetCollection(
+        [smugmug_asset_to_asset(asset) for asset in smugmug_assets]
+    )

nthp_api/nthp_build/config.py

@@ -0,0 +1,22 @@
+import datetime
+from pathlib import Path
+
+from pydantic_settings import BaseSettings
+
+
+class Settings(BaseSettings):
+    db_uri: str = "nthp.db"
+    branch: str = "master"
+    content_root: Path
+
+    year_start: int = 1940
+    year_end: int = datetime.datetime.now().year
+
+    # How many years to wait until guessing someone has left, if it's not been this
+    # long we can assume they may still be a student.
+    graduation_recency_limit: int = 2
+    # What month (1-12) do people tend to graduate in?
+    graduation_month: int = 6
+
+
+settings = Settings()

nthp_api/nthp_build/content.py

@@ -0,0 +1,39 @@
+from io import StringIO
+
+import markdown
+from markdown import Markdown
+
+
+def unmark_element(element, stream=None):
+    if stream is None:
+        stream = StringIO()
+    if element.text:
+        stream.write(element.text)
+    for sub in element:
+        unmark_element(sub, stream)
+    if element.tail:
+        stream.write(element.tail)
+    return stream.getvalue()
+
+
+# Make a markdown parser that outputs plaintext
+# Stole from https://stackoverflow.com/a/54923798/1345360
+Markdown.output_formats["plain"] = unmark_element  # type: ignore
+_markdown_unmarker = Markdown(output_format="plain")  # type: ignore
+_markdown_unmarker.stripTopLevelTags = False  # type: ignore
+
+
+def markdown_to_html(markdown_text: str | None) -> str | None:
+    if not markdown_text:
+        return None
+    if not markdown_text.strip():
+        return None
+    return markdown.markdown(markdown_text)
+
+
+def markdown_to_plaintext(markdown_text: str | None) -> str | None:
+    if not markdown_text:
+        return None
+    if not markdown_text.strip():
+        return None
+    return _markdown_unmarker.convert(markdown_text)

nthp_api/nthp_build/database.py

@@ -0,0 +1,142 @@
+import logging
+
+import peewee
+
+from nthp_api.nthp_build.config import settings
+
+log = logging.getLogger(__name__)
+db = peewee.SqliteDatabase(settings.db_uri)
+
+
+class NthpDbModel(peewee.Model):
+    class Meta:
+        database = db
+
+
+class DbCompatEnumMixin:
+    def __str__(self):
+        return self.value
+
+
+class TargetType:
+    SHOW = "show"
+
+
+class PersonRoleType:
+    CAST = "CAST"
+    CREW = "CREW"
+    COMMITTEE = "COMMITTEE"
+
+
+class PersonRole(NthpDbModel):
+    target_id = peewee.CharField(index=True)
+    target_type = peewee.CharField(index=True)
+    # Uses YYYY, not YY_YY, 2000 means 2000-2001
+    target_year = peewee.IntegerField(index=True)
+
+    person_id = peewee.CharField(index=True, null=True)
+    person_name = peewee.CharField(null=True)
+    role = peewee.CharField(null=True, index=True)
+    is_person = peewee.BooleanField(index=True)
+    data = peewee.TextField()
+
+
+class Show(NthpDbModel):
+    id = peewee.CharField(primary_key=True)
+    source_path = peewee.CharField()
+    year = peewee.IntegerField()
+    year_id = peewee.CharField(index=True)
+    title = peewee.CharField()
+    venue_id = peewee.CharField(index=True, null=True)
+    season_sort = peewee.IntegerField(null=True, index=True)
+    date_start = peewee.DateField(null=True, index=True)
+    date_end = peewee.DateField(null=True)
+    primary_image = peewee.CharField(null=True)
+    assets = peewee.TextField()
+    data = peewee.TextField()
+    content = peewee.TextField(null=True)
+    plaintext = peewee.TextField(null=True)
+
+
+class PlaywrightShow(NthpDbModel):
+    play_id = peewee.CharField(index=True)
+    play_name = peewee.CharField()
+    playwright_id = peewee.CharField(index=True)
+    playwright_name = peewee.CharField()
+    show_id = peewee.CharField(index=True)
+    person_id = peewee.CharField(null=True, index=True)
+
+
+class Venue(NthpDbModel):
+    id = peewee.CharField(primary_key=True)
+    name = peewee.CharField()
+    data = peewee.TextField()
+    content = peewee.TextField(null=True)
+    plaintext = peewee.TextField(null=True)
+
+
+class Person(NthpDbModel):
+    id = peewee.CharField(primary_key=True)
+    title = peewee.CharField()
+    graduated = peewee.IntegerField(index=True, null=True)
+    headshot = peewee.CharField(null=True)
+    data = peewee.TextField()
+    content = peewee.TextField(null=True)
+    plaintext = peewee.TextField(null=True)
+
+
+class Trivia(NthpDbModel):
+    target_id = peewee.CharField(index=True)
+    target_type = peewee.CharField(index=True)
+    target_name = peewee.CharField()
+    target_image_id = peewee.CharField(null=True)
+    # Uses YYYY, not YY_YY, 2000 means 2000-2001
+    target_year = peewee.IntegerField(index=True, null=True)
+
+    person_id = peewee.CharField(index=True, null=True)
+    person_name = peewee.CharField(null=True)
+
+    quote = peewee.TextField()
+    submitted = peewee.DateField(null=True, index=True)
+
+    data = peewee.TextField()
+
+
+class HistoryRecord(NthpDbModel):
+    year = peewee.CharField()
+    academic_year = peewee.CharField(null=True, index=True)
+    title = peewee.CharField()
+    description = peewee.TextField()
+
+
+class Asset(NthpDbModel):
+    target_id = peewee.CharField(index=True)
+    target_type = peewee.CharField(index=True)
+
+    asset_source = peewee.CharField(index=True)
+    asset_type = peewee.CharField(index=True)
+    asset_mime_type = peewee.CharField(null=True)
+    asset_id = peewee.CharField(index=True)
+
+    asset_category = peewee.CharField(null=True)
+    asset_title = peewee.CharField(null=True)
+    asset_page = peewee.IntegerField(null=True)
+
+    asset_smugmug_data = peewee.CharField(null=True)
+
+
+MODELS = [Show, PlaywrightShow, Venue, PersonRole, Person, Trivia, HistoryRecord, Asset]
+
+
+def init_db(create: bool = False):
+    log.info(f"Initializing database: {db.database}")
+
+    db.connect()
+    if create:
+        db.drop_tables(MODELS)
+    db.create_tables(MODELS)
+
+
+def show_stats():
+    for model in MODELS:
+        log.info(f"{model.__name__} has {model.select().count()} records")

nthp_api/nthp_build/documents.py

@@ -0,0 +1,55 @@
+import logging
+from collections.abc import Iterable
+from pathlib import Path
+from typing import Any, NamedTuple
+
+import frontmatter
+import yaml
+
+from nthp_api.nthp_build.config import settings
+
+log = logging.getLogger(__name__)
+
+
+class DocumentPath(NamedTuple):
+    path: Path
+    id: str
+    content_path: Path
+    filename: str
+    basename: str
+
+
+def find_documents(content_directory: Path | str) -> Iterable[DocumentPath]:
+    def map_path(path: Path) -> DocumentPath | None:
+        if path.name.startswith("_"):
+            return None
+        return DocumentPath(
+            path=path,
+            id=str(
+                path.relative_to(settings.content_root / content_directory).parent
+                / path.stem
+            ).lstrip("_"),
+            content_path=path.relative_to(settings.content_root),
+            filename=path.name,
+            basename=path.stem,
+        )
+
+    return [
+        doc_path
+        for doc_path in map(
+            map_path, (settings.content_root / Path(content_directory)).rglob("*.md")
+        )
+        if doc_path is not None
+    ]
+
+
+def load_document(path: Path) -> frontmatter.Post:
+    return frontmatter.load(path)
+
+
+def load_yaml(path: Path | str) -> Any:
+    with (settings.content_root / Path(path)).open() as stream:
+        try:
+            return yaml.safe_load(stream)
+        except yaml.YAMLError:
+            log.exception("Error loading YAML file %s", path)