codex 1.7.15__py3-none-any.whl → 1.8.0a2__py3-none-any.whl

codex/status.py

@@ -1,35 +0,0 @@
-"""Librarian Status dataclass."""
-
-from dataclasses import dataclass
-from enum import Enum
-
-
-@dataclass
-class Status:
-    """Args for passing into import functions."""
-
-    status_type: str | Enum
-    complete: int | None = None
-    total: int | None = None
-    since: float = 0.0
-    subtitle: str = ""
-
-    def __post_init__(self):
-        """Convert enums to values."""
-        if isinstance(self.status_type, Enum):
-            self.status_type = self.status_type.value
-
-    def add_complete(self, count: int):
-        """Add count to complete."""
-        if self.complete is None:
-            self.complete = 0
-        self.complete += count
-
-    def increment_complete(self):
-        """Increment complete handling None."""
-        self.add_complete(1)
-
-    def decrement_total(self):
-        """Decreent total if not not."""
-        if self.total is not None:
-            self.total = max(self.total - 1, 0)

codex/status_controller.py

@@ -1,153 +0,0 @@
-"""Librarian Status."""
-
-from enum import Enum
-from logging import DEBUG
-from time import time
-
-from django.db.models.functions.datetime import Now
-from django.utils.timezone import datetime, now, timedelta
-
-from codex.choices.admin import ADMIN_STATUS_TITLES
-from codex.librarian.notifier.tasks import LIBRARIAN_STATUS_TASK
-from codex.librarian.tasks import DelayedTasks
-from codex.logger_base import LoggerBaseMixin
-from codex.models import LibrarianStatus
-from codex.status import Status
-
-
-def get_default(field):
-    """Get the default value for the model field."""
-    return LibrarianStatus._meta.get_field(field).get_default()
-
-
-DEFAULT_FIELDS = ("preactive", "complete", "total", "active", "subtitle")
-STATUS_DEFAULTS = {field: get_default(field) for field in DEFAULT_FIELDS}
-
-
-class StatusController(LoggerBaseMixin):
-    """Run operations on the LibrarianStatus table."""
-
-    _UPDATE_DELTA = 5
-
-    def __init__(self, log_queue, librarian_queue):
-        """Iinitialize logger and librarian queue."""
-        self.init_logger(log_queue)
-        self.librarian_queue = librarian_queue
-
-    def _enqueue_notifier_task(self, notify: bool, until=0.0):
-        """Notify the status has changed."""
-        if not notify:
-            return
-        if until:
-            task = DelayedTasks(until, (LIBRARIAN_STATUS_TASK,))
-        else:
-            task = LIBRARIAN_STATUS_TASK
-        self.librarian_queue.put(task)
-
-    def _loggit(self, level, status):
-        """Log with a ? in place of none."""
-        type_title = ADMIN_STATUS_TITLES[status.status_type]
-        msg = f"{type_title} {status.subtitle}".strip()
-        msg += ": "
-        if status.complete is None and status.total is None:
-            msg += "In progress"
-        else:
-            count = "?" if status.complete is None else status.complete
-            total = "?" if status.total is None else status.total
-            msg += f"{count}/{total}"
-
-        self.log.log(level, msg)
-
-    @staticmethod
-    def _to_status_type_value(status):
-        """Convert Status and Enums to str types."""
-        if isinstance(status, Status):
-            status = status.status_type
-        elif isinstance(status, Enum):
-            status = status.value
-        return status
-
-    def _update(
-        self,
-        status,
-        notify: bool,
-        active: datetime | None = None,
-        preactive: datetime | None = None,
-    ):
-        """Start a librarian status."""
-        try:
-            if not status.status_type:
-                reason = f"Bad status type: {status.status_type}"
-                raise ValueError(reason)  # noqa: TRY301
-            updates = {
-                "complete": status.complete,
-                "total": status.total,
-                "updated_at": Now(),
-            }
-            if preactive is not None:
-                updates["preactive"] = preactive
-            if active:
-                updates["active"] = active
-            if status.subtitle:
-                updates["subtitle"] = status.subtitle
-            LibrarianStatus.objects.filter(status_type=status.status_type).update(
-                **updates
-            )
-            self._enqueue_notifier_task(notify)
-            self._loggit(DEBUG, status)
-            status.since = time()
-        except Exception:
-            title = ADMIN_STATUS_TITLES[status.status_type]
-            self.log.exception(f"Update status: {title}")
-
-    def start(
-        self,
-        status,
-        notify: bool = True,  # noqa: FBT002
-        preactive: datetime | None = None,
-    ):
-        """Start a librarian status."""
-        self._update(status, notify=notify, preactive=preactive, active=now())
-
-    def start_many(self, status_iterable):
-        """Start many librarian statuses."""
-        for index, status in enumerate(status_iterable):
-            pad_ms = index * 100
-            preactive = now() + timedelta(milliseconds=pad_ms)
-            self._update(status, notify=False, preactive=preactive)
-        self._enqueue_notifier_task(notify=True)
-
-    def update(self, status, notify: bool = True):  # noqa: FBT002
-        """Update a librarian status."""
-        if time() - status.since < self._UPDATE_DELTA:
-            # noop unless time has expired.
-            return
-        self._update(status, notify=notify)
-
-    def finish_many(self, statii, notify: bool = True, until=0.0):  # noqa: FBT002
-        """Finish all librarian statuses."""
-        try:
-            types = []
-            for status in statii:
-                types += [self._to_status_type_value(status)]
-            ls_filter = {"status_type__in": types} if types else {}
-            updates = {**STATUS_DEFAULTS, "updated_at": Now()}
-            lses = LibrarianStatus.objects.filter(**ls_filter)
-            update_ls = []
-            for ls in lses.iterator():
-                for key, value in updates.items():
-                    setattr(ls, key, value)
-                update_ls.append(ls)
-            LibrarianStatus.objects.bulk_update(update_ls, tuple(updates.keys()))
-            self._enqueue_notifier_task(notify, until)
-            if not ls_filter:
-                self.log.info("Cleared all librarian statuses")
-        except Exception as exc:
-            self.log.warning(f"Finish status {statii}: {exc}")
-
-    def finish(self, status, notify: bool = True, until=0.0):  # noqa: FBT002
-        """Finish a librarian status."""
-        try:
-            self.finish_many((status,), notify=notify, until=until)
-        except Exception as exc:
-            self.log.warning(exc)

codex/templates/README.md

@@ -1,3 +0,0 @@
-# templates
-
-Django Templates for serving the codex app index and special generated files.

codex/threads.py

@@ -1,130 +0,0 @@
-"""Abstract Thread worker for doing queued tasks."""
-
-import time
-from abc import ABC, abstractmethod
-from queue import Empty, SimpleQueue
-from threading import Thread
-
-from codex.worker_base import WorkerBaseMixin
-
-
-class BreakLoopError(Exception):
-    """Simple way to break out of function nested loop."""
-
-
-class NamedThread(Thread, WorkerBaseMixin, ABC):
-    """A thread that sets its name for ps."""
-
-    def __init__(self, *args, **kwargs):
-        """Initialize queues."""
-        librarian_queue = kwargs.pop("librarian_queue")
-        log_queue = kwargs.pop("log_queue")
-        self.init_worker(log_queue, librarian_queue)
-        super().__init__(*args, name=self.__class__.__name__, **kwargs)
-
-    def run_start(self):
-        """First thing to do when running a new thread."""
-        self.log.debug(f"Started {self.name}")
-
-
-class QueuedThread(NamedThread, ABC):
-    """Abstract Thread worker for doing queued tasks."""
-
-    SHUTDOWN_MSG = "shutdown"
-    SHUTDOWN_TIMEOUT = 5
-
-    def __init__(self, *args, **kwargs):
-        """Initialize with overridden name and as a daemon thread."""
-        self.queue = kwargs.pop("queue", SimpleQueue())
-        super().__init__(*args, daemon=True, **kwargs)
-
-    @abstractmethod
-    def process_item(self, item):
-        """Process one item from the queue."""
-        raise NotImplementedError
-
-    def get_timeout(self) -> float | None:
-        """Set no timeout by default."""
-        return
-
-    def timed_out(self):
-        """Override to things on queue timeout."""
-
-    def _check_item(self):
-        """Get items, with timeout. Check for shutdown and Empty."""
-        timeout = self.get_timeout()
-        try:
-            item = self.queue.get(timeout=timeout)
-            if item == self.SHUTDOWN_MSG:
-                raise BreakLoopError  # TRY301
-            self.process_item(item)
-        except Empty:
-            self.timed_out()
-
-    def run(self):
-        """Run thread loop."""
-        self.run_start()
-        while True:
-            try:
-                self._check_item()
-            except BreakLoopError:
-                break
-            except Exception:
-                self.log.exception(f"{self.__class__.__name__} crashed:")
-        self.log.debug(f"Stopped {self.__class__.__name__}")
-
-    def stop(self):
-        """Stop the thread."""
-        self.queue.put(self.SHUTDOWN_MSG)
-
-    def join(self, timeout=None):  # noqa: ARG002
-        """End the thread."""
-        self.log.debug(f"Waiting for {self.__class__.__name__} to join.")
-        super().join(self.SHUTDOWN_TIMEOUT)
-        self.log.debug(f"{self.__class__.__name__} joined.")
-
-
-class AggregateMessageQueuedThread(QueuedThread, ABC):
-    """Abstract Thread worker for buffering and aggregating messages."""
-
-    FLOOD_DELAY = 1.0
-    MAX_DELAY = 5.0
-
-    def __init__(self, *args, **kwargs):
-        """Initialize the cache."""
-        self.cache = {}
-        self._last_timed_out = time.time()
-        super().__init__(*args, **kwargs)
-
-    def get_timeout(self):
-        """Aggregate queue has a conditional timeout."""
-        return self.FLOOD_DELAY if self.cache else None
-
-    @abstractmethod
-    def aggregate_items(self, item):
-        """Abstract method for aggregating items."""
-        raise NotImplementedError
-
-    @abstractmethod
-    def send_all_items(self):
-        """Abstract method for sending all items."""
-        raise NotImplementedError
-
-    def cleanup_cache(self, keys):
-        """Remove sent messages from the cache and record send times."""
-        for key in keys:
-            self.cache.pop(key, None)
-        self._last_send = time.time()
-
-    def process_item(self, item):
-        """Aggregate items and sleep in case there are more."""
-        self.aggregate_items(item)
-        since_last_timed_out = time.time() - self._last_timed_out
-        waited_too_long = since_last_timed_out > self.MAX_DELAY
-        if waited_too_long:
-            self.timed_out()
-
-    def timed_out(self):
-        """Send the items and set when we did this."""
-        self.send_all_items()
-        self._last_timed_out = time.time()

codex/views/README.md

@@ -1,4 +0,0 @@
-# views
-
-The Django Rest Framework views.
-[API Docs](https://www.django-rest-framework.org/api-guide/views/).

codex/views/browser/filters/search/aliases.py

@@ -1,81 +0,0 @@
-"""Field aliases and types maps."""
-
-from types import MappingProxyType
-
-from django.db.models.fields import CharField
-from django.db.models.fields.related import ManyToManyField
-
-from codex.models.comic import Comic
-
-
-def gen_multipart_field_aliases(field):
-    """Generate aliases for fields made of snake_case words."""
-    bits = field.split("_")
-    aliases = []
-
-    # Singular from plural
-    if field.endswith("s"):
-        aliases += [field[:-1]]
-
-    # Alternate delimiters
-    for connector in ("", "-"):
-        joined = connector.join(bits)
-        aliases += [joined, joined[:-1]]
-
-    return tuple(sorted(frozenset(aliases)))
-
-
-FIELDMAP = MappingProxyType(
-    {
-        "characters": ("category", "character"),
-        "community_rating": gen_multipart_field_aliases("community_rating"),
-        "contributors": (
-            *gen_multipart_field_aliases("authors"),
-            "contributor",
-            *gen_multipart_field_aliases("creators"),
-            *gen_multipart_field_aliases("credits"),
-            *gen_multipart_field_aliases("people"),
-            *gen_multipart_field_aliases("persons"),
-        ),
-        "created_at": ("created",),
-        "critical_rating": gen_multipart_field_aliases("critical_rating"),
-        "genres": ("genre",),
-        "file_type": (
-            "filetype",
-            "type",
-        ),
-        "identifiers": ("id", "nss", "identifier"),
-        "identifier_types": ("idtype", "id_type", "nid", "identifier_type"),
-        "issue_number": ("number",),
-        "locations": ("location",),
-        "monochrome": gen_multipart_field_aliases("black_and_white"),
-        "name": ("title",),
-        "original_format": ("format",),
-        "page_count": ("pages",),
-        "reading_direction": ("direction",),
-        "path": (
-            "filename",
-            *gen_multipart_field_aliases("folders"),
-        ),
-        "series_groups": gen_multipart_field_aliases("series_groups"),
-        "scan_info": ("scan",),
-        "stories": ("story",),
-        "story_arcs": gen_multipart_field_aliases("story_arcs"),
-        "summary": ("comments", "description"),
-        "tags": ("tag",),
-        "teams": ("team",),
-        "updated_at": ("updated",),
-    }
-)
-
-
-ALIAS_FIELD_MAP = MappingProxyType(
-    {value: key for key, values in FIELDMAP.items() for value in values}
-)
-FIELD_TYPE_MAP = MappingProxyType(
-    {
-        **{field.name: field.__class__ for field in Comic._meta.get_fields()},
-        "role": ManyToManyField,
-        "issue": CharField,
-    }
-)

codex/views/browser/metadata/metadata.py

@@ -1,83 +0,0 @@
-"""Aggregate Group and Comic Metadata View."""
-
-from types import MappingProxyType
-
-from drf_spectacular.utils import extend_schema
-from rest_framework.exceptions import NotFound
-from rest_framework.response import Response
-
-from codex.logger.logger import get_logger
-from codex.models import AdminFlag
-from codex.serializers.browser.metadata import MetadataSerializer
-from codex.serializers.browser.settings import BrowserFilterChoicesInputSerilalizer
-from codex.views.browser.metadata.copy_intersections import (
-    MetadataCopyIntersectionsView,
-)
-
-LOG = get_logger(__name__)
-
-
-class MetadataView(MetadataCopyIntersectionsView):
-    """Aggregate Group and Comic Metadata View."""
-
-    serializer_class = MetadataSerializer
-    input_serializer_class = BrowserFilterChoicesInputSerilalizer
-    TARGET = "metadata"
-    ADMIN_FLAG_VALUE_KEY_MAP = MappingProxyType(
-        {
-            AdminFlag.FlagChoices.FOLDER_VIEW.value: "folder_view",
-        }
-    )
-
-    def _get_valid_browse_nav_groups(self, valid_top_groups):  # noqa: ARG002
-        """Limited allowed nav groups for metadata."""
-        # Overrides method in browser.validate
-        group = self.kwargs["group"]
-        return (group,)
-
-    def _raise_not_found(self, exc=None):
-        """Raise an exception if the object is not found."""
-        pks = self.kwargs["pks"]
-        group = self.kwargs["group"]
-        detail = f"Filtered metadata for {group}/{pks} not found"
-        raise NotFound(detail=detail) from exc
-
-    def get_object(self):
-        """Create a comic-like object from the current browser group."""
-        # Comic model goes through the same code path as groups because
-        # values dicts don't copy relations to the serializer. The values
-        # dict is necessary because of the folders view union in browser.py.
-
-        qs = self.get_filtered_queryset(self.model)
-        filtered_qs = qs
-
-        # Annotate
-        qs = self.annotate_order_aggregates(qs)
-        qs = self.annotate_card_aggregates(qs)
-        qs = self.annotate_values_and_fks(qs, filtered_qs)
-        qs = self.add_group_by(qs)
-        qs = self.force_inner_joins(qs)
-
-        # Get Object
-        try:
-            obj = qs[0]
-            if not obj:
-                reason = "Empty obj"
-                raise ValueError(reason)  # noqa: TRY301
-        except (IndexError, ValueError) as exc:
-            return self._raise_not_found(exc)
-
-        # Hacks to add to object after query
-        groups, m2m_intersections = self.query_intersections(filtered_qs)
-        return self.copy_intersections_into_comic_fields(obj, groups, m2m_intersections)
-
-    @extend_schema(parameters=[input_serializer_class])
-    def get(self, *_args, **_kwargs):
-        """Get metadata for a filtered browse group."""
-        # Init
-        try:
-            obj = self.get_object()
-            serializer = self.get_serializer(obj)
-            return Response(serializer.data)
-        except Exception:
-            LOG.exception(f"Getting metadata {self.kwargs}")

codex/websockets/README.md

@@ -1,4 +0,0 @@
-# Why Channels?
-
-I use only a fraction of django channels' functionality, but,
-`channels.auth.AuthMiddlewareStack`is nice.

codex/worker_base.py

@@ -1,14 +0,0 @@
-"""General worker class inherits queues."""
-
-from codex.logger_base import LoggerBaseMixin
-from codex.status_controller import StatusController
-
-
-class WorkerBaseMixin(LoggerBaseMixin):
-    """General worker class for inheriting queues."""
-
-    def init_worker(self, log_queue, librarian_queue):
-        """Initialize queues."""
-        self.init_logger(log_queue)
-        self.librarian_queue = librarian_queue
-        self.status_controller = StatusController(log_queue, librarian_queue)