codex 1.6.14__py3-none-any.whl → 1.6.16__py3-none-any.whl

codex/librarian/cron/crond.py

@@ -30,21 +30,23 @@ class CronThread(NamedThread):
         self._task_times = ()
         super().__init__(*args, name=self.__class__.__name__, daemon=True, **kwargs)
 
-    def _update_task_times(self):
+    def _create_task_times(self):
         task_times = {}
         for task_class, func in _TASK_TIME_FUNCTION_MAP.items():
             if dttm := func(self.log):
                 task_times[dttm] = task_class
 
-        task_tuple = tuple(sorted(task_times.items()))
-
-        # There's always at least the janitor job
-        self._next_time = task_tuple[0][0]
-        self._task_times = task_tuple
+        self._task_times = tuple(sorted(task_times.items()))
 
     def _get_timeout(self):
+        if not self._task_times or not self._task_times[0]:
+            self.log.warning("No scheduled jobs found. Not normal! Waiting a minute.")
+            return 60
+
+        next_time = self._task_times[0][0]
         now = django_timezone.now()
-        delta = self._next_time - now
+        delta = next_time - now
+        self.log.debug(f"Next scheduled job at {next_time} in {delta}.")
         return max(0, int(delta.total_seconds()))
 
     def _run_expired_jobs(self):
@@ -53,6 +55,7 @@ class CronThread(NamedThread):
             if dttm < now:
                 self.librarian_queue.put(task_class())
             else:
+                # Times are always ordered so stop checking at the first future job.
                 break
 
     def run(self):
@@ -62,13 +65,13 @@ class CronThread(NamedThread):
             with self._cond:
                 while not self._stop_event.is_set():
                     self._run_expired_jobs()
-                    self._update_task_times()
+                    self._create_task_times()
+                    sleep(2)  # try to fix double jobs
                     timeout = self._get_timeout()
-                    self.log.debug(f"Next scheduled job at {self._next_time}.")
                     self._cond.wait(timeout=timeout)
                     if self._stop_event.is_set():
                         break
-                    sleep(2)  # fixes any time rounding problems
+                    sleep(2)  # fix time rounding problems
         except Exception:
             self.log.exception(f"In {self.__class__.__name__}")
         self.log.debug(f"Stopped {self.__class__.__name__}.")

codex/librarian/importer/importerd.py

@@ -1,5 +1,7 @@
 """Bulk import and move comics and folders."""
 
+from pathlib import Path
+
 from django.utils import timezone
 
 from codex.librarian.importer.importer import ComicImporter
@@ -46,6 +48,15 @@ class ComicImporterThread(QueuedThread):
             )
             self._import(task)
 
+    def _update_groups(self, task):
+        pks = Library.objects.filter(covers_only=False).values_list("pk", flat=True)
+        start_time = task.start_time if task.start_time else timezone.now()
+        for pk in pks:
+            task = ImportDBDiffTask(library_id=pk)
+            importer = self._create_importer(task)
+            importer.update_all_groups({}, start_time)
+        self.librarian_queue.put(LIBRARY_CHANGED_TASK)
+
     def _adopt_orphan_folders_for_library(self, library):
         """Adopt orphan folders for one library."""
         orphan_folder_paths = (
@@ -53,17 +64,20 @@ class ComicImporterThread(QueuedThread):
             .exclude(path=library.path)
             .values_list("path", flat=True)
         )
-        if not orphan_folder_paths:
+        # Move in place
+        # Exclude deleted folders
+        folders_moved = {
+            path: path for path in orphan_folder_paths if Path(path).is_dir()
+        }
+
+        if folders_moved:
+            self.log.debug(
+                f"{len(folders_moved)} orphan folders found in {library.path}"
+            )
+        else:
             self.log.debug(f"No orphan folders in {library.path}")
             return False
 
-        self.log.debug(
-            f"{len(orphan_folder_paths)} orphan folders found in {library.path}"
-        )
-
-        # Move in place
-        folders_moved = {path: path for path in orphan_folder_paths}
-
         # An abridged import task.
         task = ImportDBDiffTask(
             library_id=library.pk,
@@ -89,15 +103,6 @@ class ComicImporterThread(QueuedThread):
 
         self.status_controller.finish_many((moved_status, status))
 
-    def _update_groups(self, task):
-        pks = Library.objects.filter(covers_only=False).values_list("pk", flat=True)
-        start_time = task.start_time if task.start_time else timezone.now()
-        for pk in pks:
-            task = ImportDBDiffTask(library_id=pk)
-            importer = self._create_importer(task)
-            importer.update_all_groups({}, start_time)
-        self.librarian_queue.put(LIBRARY_CHANGED_TASK)
-
     def process_item(self, item):
         """Run the updater."""
         task = item
@@ -105,9 +110,9 @@ class ComicImporterThread(QueuedThread):
             self._import(task)
         elif isinstance(task, LazyImportComicsTask):
             self._lazy_import_metadata(task)
-        elif isinstance(task, AdoptOrphanFoldersTask):
-            self._adopt_orphan_folders()
         elif isinstance(task, UpdateGroupsTask):
             self._update_groups(task)
+        elif isinstance(task, AdoptOrphanFoldersTask):
+            self._adopt_orphan_folders()
         else:
             self.log.warning(f"Bad task sent to library updater {task}")

codex/librarian/importer/moved.py

@@ -2,6 +2,7 @@
 
 from pathlib import Path
 
+from bidict import bidict
 from django.db.models.functions import Now
 
 from codex.librarian.importer.aggregate import AggregateMetadataImporter
@@ -23,20 +24,42 @@ from codex.status import Status
 class MovedImporter(AggregateMetadataImporter):
     """Methods for moving comics and folders."""
 
-    def _bulk_comics_moved(self):
-        """Move comcis."""
-        num_files_moved = len(self.task.files_moved)
-        if not num_files_moved:
+    def _bulk_comics_moved_ensure_folders(self):
+        """Ensure folders we're moving to exist."""
+        dest_comic_paths = self.task.files_moved.values()
+        if not dest_comic_paths:
             return
-        status = Status(ImportStatusTypes.FILES_MOVED, 0, num_files_moved)
-        self.status_controller.start(status)
-
-        # Prepare FKs
-        create_folder_paths = set()
-        self.query_missing_folder_paths(create_folder_paths, status)
-        self.bulk_folders_create(frozenset(create_folder_paths), status)
+        # Not sending statues to the controller for now.
+        status = Status(ImportStatusTypes.QUERY_MISSING_FKS)
+        create_folder_paths = self.query_missing_folder_paths(dest_comic_paths, status)
+        if not create_folder_paths:
+            return
+        status = Status(ImportStatusTypes.CREATE_FKS, 0, len(create_folder_paths))
+        self.log.debug(
+            "Creating {len(create_folder_paths)} folders for {len(dest_comic_paths)} moved comics."
+        )
+        self.bulk_folders_create(create_folder_paths, status)
 
-        # Update Comics
+    def _prepare_moved_comic(self, comic, folder_m2m_links, updated_comics):
+        """Prepare one comic for bulk update."""
+        try:
+            new_path = self.task.files_moved[comic.path]
+            comic.path = new_path
+            new_path = Path(new_path)
+            comic.parent_folder = Folder.objects.get(  # type: ignore
+                path=new_path.parent
+            )
+            comic.updated_at = Now()
+            comic.presave()
+            folder_m2m_links[comic.pk] = Folder.objects.filter(
+                path__in=new_path.parents
+            ).values_list("pk", flat=True)
+            updated_comics.append(comic)
+        except Exception:
+            self.log.exception(f"moving {comic.path}")
+
+    def _bulk_comics_move_prepare(self):
+        """Prepare Update Comics."""
         comics = Comic.objects.filter(
             library=self.library, path__in=self.task.files_moved.keys()
         ).only("pk", "path", PARENT_FOLDER, FOLDERS_FIELD)
@@ -44,29 +67,29 @@ class MovedImporter(AggregateMetadataImporter):
         folder_m2m_links = {}
         updated_comics = []
         for comic in comics.iterator():
-            try:
-                new_path = self.task.files_moved[comic.path]
-                comic.path = new_path
-                new_path = Path(new_path)
-                comic.parent_folder = Folder.objects.get(  # type: ignore
-                    path=new_path.parent
-                )
-                comic.updated_at = Now()
-                comic.presave()
-                folder_m2m_links[comic.pk] = Folder.objects.filter(
-                    path__in=new_path.parents
-                ).values_list("pk", flat=True)
-                updated_comics.append(comic)
-            except Exception:
-                self.log.exception(f"moving {comic.path}")
+            self._prepare_moved_comic(comic, folder_m2m_links, updated_comics)
         self.task.files_moved = {}
+        self.log.debug(f"Prepared {len(updated_comics)} for move...")
+        return updated_comics, folder_m2m_links
 
-        Comic.objects.bulk_update(updated_comics, MOVED_BULK_COMIC_UPDATE_FIELDS)
+    def _bulk_comics_moved(self):
+        """Move comcis."""
+        num_files_moved = len(self.task.files_moved)
+        if not num_files_moved:
+            return
+        status = Status(ImportStatusTypes.FILES_MOVED, 0, num_files_moved)
+        self.status_controller.start(status)
 
-        # Update m2m field
+        # Prepare
+        self._bulk_comics_moved_ensure_folders()
+        updated_comics, folder_m2m_links = self._bulk_comics_move_prepare()
+
+        # Update comics
+        Comic.objects.bulk_update(updated_comics, MOVED_BULK_COMIC_UPDATE_FIELDS)
         if folder_m2m_links:
             self.bulk_fix_comic_m2m_field(FOLDERS_FIELD, folder_m2m_links, status)
-        count = len(comics)
+
+        count = len(updated_comics)
         if count:
             self.log.info(f"Moved {count} comics.")
 
@@ -140,60 +163,32 @@ class MovedImporter(AggregateMetadataImporter):
         self.changed += count
         self.status_controller.finish(status)
 
-    def _get_parent_folders(self, dest_folder_paths, status):
-        """Get destination parent folders."""
-        # Determine parent folder paths.
-        dest_parent_folder_paths = set()
-        for dest_folder_path in dest_folder_paths:
-            dest_parent_path = str(Path(dest_folder_path).parent)
-            if dest_parent_path not in dest_folder_paths:
-                dest_parent_folder_paths.add(dest_parent_path)
-
-        # Create only intermediate subfolders.
-        existing_folder_paths = Folder.objects.filter(
-            library=self.library, path__in=dest_parent_folder_paths
-        ).values_list("path", flat=True)
-        create_folder_paths = frozenset(
-            dest_parent_folder_paths - frozenset(existing_folder_paths)
+    def _bulk_move_folders(
+        self, src_folder_paths, dest_parent_folders_map, dirs_moved: bidict, status
+    ):
+        """Bulk move folders."""
+        folders_to_move = (
+            Folder.objects.filter(library=self.library, path__in=src_folder_paths)
+            .only(*MOVED_BULK_FOLDER_UPDATE_FIELDS)
+            .order_by("path")
         )
-        self.bulk_folders_create(create_folder_paths, status)
 
-        # get parent folders path to model obj dict
-        dest_parent_folders_objs = Folder.objects.filter(
-            path__in=dest_parent_folder_paths
-        ).only("path", "pk")
-        dest_parent_folders = {}
-        for folder in dest_parent_folders_objs.iterator():
-            dest_parent_folders[folder.path] = folder
-        return dest_parent_folders
-
-    def bulk_folders_moved(self):
-        """Move folders in the database instead of recreating them."""
-        num_dirs_moved = len(self.task.dirs_moved)
-        if not num_dirs_moved:
-            return
-        status = Status(ImportStatusTypes.DIRS_MOVED, None, num_dirs_moved)
-        self.status_controller.start(status)
-
-        dest_folder_paths = frozenset(self.task.dirs_moved.values())
-        dest_parent_folders = self._get_parent_folders(dest_folder_paths, status)
-
-        src_folder_paths = frozenset(self.task.dirs_moved.keys())
-        folders_to_move = Folder.objects.filter(
-            library=self.library, path__in=src_folder_paths
-        ).order_by("path")
+        # TODO what if a folder with that path already exists in the db?
 
+        new_paths = set()
         update_folders = []
         for folder in folders_to_move.iterator():
-            new_path = self.task.dirs_moved[folder.path]
+            new_path = dirs_moved[folder.path]
+            new_paths.add(new_path)
             folder.name = Path(new_path).name
             folder.path = new_path
             parent_path_str = str(Path(new_path).parent)
-            folder.parent_folder = dest_parent_folders.get(parent_path_str)
+            folder.parent_folder = dest_parent_folders_map.get(parent_path_str)
             folder.presave()
             folder.updated_at = Now()
             update_folders.append(folder)
-        self.task.dirs_moved = {}
+
+        # delete_folders = Folder.objects.filter(library=self.library, path__in=new_paths)
 
         update_folders = sorted(update_folders, key=lambda x: len(Path(x.path).parts))
 
@@ -202,6 +197,112 @@ class MovedImporter(AggregateMetadataImporter):
         if count:
             self.log.info(f"Moved {count} folders.")
         self.changed += count
+        status.add_complete(count)
+        self.status_controller.update(status, notify=False)
+
+    def _bulk_move_folders_under_existing_parents(
+        self, dest_parent_folder_paths_map, dirs_moved, status
+    ):
+        """Move folders under existing folders."""
+        while True:
+            # Get existing parent folders
+            # dest_parent_paths = tuple(str(path) for path in dest_parent_folder_paths_map)
+            dest_parent_paths = tuple(dest_parent_folder_paths_map.keys())
+            extant_parent_folders = Folder.objects.filter(
+                library=self.library, path__in=dest_parent_paths
+            ).only("path")
+
+            # Create a list of folders than can be moved under existing folders.
+            dest_parent_folders_map = {}
+            src_folder_paths = []
+            for extant_parent_folder in extant_parent_folders:
+                dest_parent_folders_map[extant_parent_folder.path] = (
+                    extant_parent_folder
+                )
+                if dest_folder_paths := dest_parent_folder_paths_map.pop(
+                    extant_parent_folder.path
+                ):
+                    for dest_folder_path in dest_folder_paths:
+                        src_path = dirs_moved.inverse[dest_folder_path]
+                        src_folder_paths.append(src_path)
+
+            if not src_folder_paths:
+                return
+            src_folder_paths = sorted(src_folder_paths)
+            self.log.debug(f"Moving folders under existing parents: {src_folder_paths}")
+
+            self._bulk_move_folders(
+                src_folder_paths, dest_parent_folders_map, dirs_moved, status
+            )
+
+    def _get_move_create_folders_one_layer(self, dest_parent_folder_paths_map):
+        """Find the next layer of folder paths to create."""
+        create_folder_paths_one_layer = set()
+        library_parts_len = len(Path(self.library.path).parts)
+        for parent_path_str in sorted(dest_parent_folder_paths_map.keys()):
+            parts = Path(parent_path_str).parts
+            # Get one layer of folders from existing layers.
+            possible_create_folder_path = ""
+            for index in range(library_parts_len, len(parts) + 1):
+                layer_parts = parts[:index]
+                possible_create_folder_path = str(Path(*layer_parts))
+                if (
+                    possible_create_folder_path in create_folder_paths_one_layer
+                    or not Folder.objects.filter(
+                        library=self.library, path=possible_create_folder_path
+                    ).exists()
+                ):
+                    break
+            else:
+                possible_create_folder_path = ""
+            if possible_create_folder_path:
+                create_folder_paths_one_layer.add(possible_create_folder_path)
+
+        return frozenset(create_folder_paths_one_layer)
+
+    def _bulk_move_folders_and_create_parents(self, status):
+        """Find folders that can be moved without creating parents."""
+        dirs_moved = bidict(self.task.dirs_moved)
+
+        dest_parent_folder_paths_map = {}
+        for dest_path in sorted(set(dirs_moved.values())):
+            parent = str(Path(dest_path).parent)
+            if parent not in dest_parent_folder_paths_map:
+                dest_parent_folder_paths_map[parent] = set()
+            dest_parent_folder_paths_map[parent].add(dest_path)
+
+        create_status = Status(ImportStatusTypes.CREATE_FKS)
+        layer = 1
+        while True:
+            self._bulk_move_folders_under_existing_parents(
+                dest_parent_folder_paths_map, dirs_moved, status
+            )
+
+            # All folders movable without creation have moved.
+            if not dest_parent_folder_paths_map:
+                break
+            self.log.debug(
+                f"Creating intermediate folder layer {layer} to move folders."
+            )
+            create_folder_paths_one_layer = self._get_move_create_folders_one_layer(
+                dest_parent_folder_paths_map
+            )
+
+            # Create one layer of folders
+            self.bulk_folders_create(create_folder_paths_one_layer, create_status)
+            layer += 1
+
+    def bulk_folders_moved(self):
+        """Move folders in the database instead of recreating them."""
+        num_dirs_moved = len(self.task.dirs_moved)
+        if not num_dirs_moved:
+            return
+        status = Status(ImportStatusTypes.DIRS_MOVED, None, num_dirs_moved)
+        self.status_controller.start(status)
+
+        self._bulk_move_folders_and_create_parents(status)
+        self.task.dirs_moved = {}
+
         self.status_controller.finish(status)
 
     def _bulk_folders_modified(self):
@@ -233,6 +334,8 @@ class MovedImporter(AggregateMetadataImporter):
 
     def move_and_modify_dirs(self):
         """Move files and dirs and modify dirs."""
+        # It would be nice to move folders instead of recreating them but it would require
+        # an inode map from the snapshots to do correctly.
         self.bulk_folders_moved()
         self._bulk_comics_moved()
         self._bulk_covers_moved()

codex/librarian/importer/query_fks.py

@@ -544,19 +544,22 @@ class QueryForeignKeysImporter(QueryCustomCoversImporter):
             base_cls = Comic
         fk_data = self.metadata[FK_CREATE][FKC_CREATE_FKS], base_cls, fk_field, "name"
         names = self.metadata[FKS].pop(fk_field)
-        status.add_complete(
-            self._query_missing_simple_models(
-                names,
-                fk_data,
-                status,
-            )
+        count = self._query_missing_simple_models(
+            names,
+            fk_data,
+            status,
         )
+        status.add_complete(count)
         self.status_controller.update(status, notify=False)
 
     ###########
     # FOLDERS #
     ###########
-    def query_missing_folder_paths(self, comic_paths, status):
+    def query_missing_folder_paths(
+        self,
+        comic_paths,
+        status,
+    ):
         """Find missing folder paths."""
         # Get the proposed folder_paths
         library_path = Path(self.library.path)
@@ -575,15 +578,18 @@ class QueryForeignKeysImporter(QueryCustomCoversImporter):
             status,
         )
         create_folder_paths = create_folder_paths_dict.get(Folder, set())
+        return frozenset(create_folder_paths)
+
+    def _add_missing_folder_paths(self, comic_paths, status):
+        create_folder_paths = self.query_missing_folder_paths(comic_paths, status)
+        """Add missing folder_paths to create fks."""
         if FK_CREATE not in self.metadata:
             self.metadata[FK_CREATE] = {}
         if FKC_FOLDER_PATHS not in self.metadata[FK_CREATE]:
             self.metadata[FK_CREATE][FKC_FOLDER_PATHS] = set()
         self.metadata[FK_CREATE][FKC_FOLDER_PATHS] |= create_folder_paths
-        count = len(create_folder_paths)
-        if count:
+        if count := len(create_folder_paths):
             self.log.info(f"Prepared {count} new Folders.")
-        return count
 
     def _get_create_fks_totals(self):
         fkc = self.metadata[FK_CREATE]
@@ -634,7 +640,7 @@ class QueryForeignKeysImporter(QueryCustomCoversImporter):
                     status,
                 )
 
-            self.query_missing_folder_paths(
+            self._add_missing_folder_paths(
                 self.metadata[FKS].pop(COMIC_PATHS, ()), status
             )
 

codex/librarian/telemeter/telemeter.py

@@ -6,7 +6,7 @@ from logging import getLogger
 from lzma import compress
 from uuid import uuid4
 
-from requests import post
+from requests import Session
 
 from codex.librarian.telemeter.stats import CodexStats
 from codex.models.admin import AdminFlag, Timestamp
@@ -52,8 +52,11 @@ def _post_stats(log, data):
         msg = f"{_POST} {len(compressed_data)}, {_HEADERS}, {_TIMEOUT}"
         log.debug(msg)
     else:
-        response = post(_POST, data=compressed_data, headers=_HEADERS, timeout=_TIMEOUT)
-        response.raise_for_status()
+        with Session() as session:
+            response = session.post(
+                _POST, data=compressed_data, headers=_HEADERS, timeout=_TIMEOUT
+            )
+            response.raise_for_status()
 
 
 def _send_telemetry(log):

codex/librarian/watchdog/dir_snapshot_diff.py

@@ -21,9 +21,9 @@ class SnapshotDiffData:
 class CodexDirectorySnapshotDiff(DirectorySnapshotDiff):
     """Custom Diff allows inode only changes to be 'modified'."""
 
-    def _get_inode(self, directory, full_path):
+    def _get_inode(self, snapshot, full_path):
         """Get inode optionally ignoring device stats."""
-        result = directory.inode(full_path)
+        result = snapshot.inode(full_path)
         if self._ignore_device:
             result = result[0]
         return result
@@ -33,7 +33,7 @@ class CodexDirectorySnapshotDiff(DirectorySnapshotDiff):
         return self._get_inode(data.ref, path) == self._get_inode(data.snapshot, path)
 
     def _is_stats_equal(self, data, old_path, new_path):
-        """Return if the mtimze and size are equal.
+        """Return if the mtime and size are equal.
 
         For old paths in the ref and new paths in the snapshot.
         """
@@ -48,25 +48,27 @@ class CodexDirectorySnapshotDiff(DirectorySnapshotDiff):
                 if self._inode_only_modified:
                     data.modified.add(path)
                 else:
+                    # Add these to created and deleted. But...
+                    # The _find_moved_paths() inode tracker should
+                    #  sort them out.
+                    # This is the same as in upstream dirsnapshot.py
                     data.created.add(path)
                     data.deleted.add(path)
 
     def _find_moved_paths(self, data):
-        """Find moved paths."""
-        for path in tuple(data.deleted):
-            inode = data.ref.inode(path)
-            new_path = data.snapshot.path(inode)
-            if new_path:
+        """Find moved paths in deleted and created."""
+        for old_path in tuple(data.deleted):
+            inode = self._get_inode(data.ref, old_path)
+            if new_path := data.snapshot.path(inode):
                 # file is not deleted but moved
-                data.deleted.remove(path)
-                data.moved.add((path, new_path))
+                data.deleted.remove(old_path)
+                data.moved.add((old_path, new_path))
 
-        for path in tuple(data.created):
-            inode = data.snapshot.inode(path)
-            old_path = data.ref.path(inode)
-            if old_path:
-                data.created.remove(path)
-                data.moved.add((old_path, path))
+        for new_path in tuple(data.created):
+            inode = self._get_inode(data.snapshot, new_path)
+            if old_path := data.ref.path(inode):
+                data.created.remove(new_path)
+                data.moved.add((old_path, new_path))
 
     def _find_modified_paths(self, data):
         """Find modified paths."""
@@ -80,7 +82,7 @@ class CodexDirectorySnapshotDiff(DirectorySnapshotDiff):
         # Check moved paths for modificiations.
         for old_path, new_path in data.moved:
             if not self._is_stats_equal(data, old_path, new_path):
-                data.modified.add(old_path)
+                data.modified.add(new_path)
 
     def __init__(  # C901, PLR0912
         self, ref, snapshot, ignore_device=False, inode_only_modified=False

codex/search/backend.py

@@ -122,7 +122,10 @@ class CodexSearchBackend(CodexBackendSearchMixin, WhooshSearchBackend, WorkerBas
             "created_at": ("created",),
             "critical_rating": gen_multipart_field_aliases("critical_rating"),
             "genres": ("genre",),
-            "file_type": ("type",),
+            "file_type": (
+                "filetype",
+                "type",
+            ),
             "identifier": ("id", "nss"),
             "identifier_type": ("idtype", "id_type", "nid"),
             "issue_number": ("number",),
@@ -132,7 +135,11 @@ class CodexSearchBackend(CodexBackendSearchMixin, WhooshSearchBackend, WorkerBas
             "original_format": ("format",),
             "page_count": ("pages",),
             "reading_direction": ("direction",),
-            "search_path": ("path", *gen_multipart_field_aliases("folders")),
+            "search_path": (
+                "path",
+                "filename",
+                *gen_multipart_field_aliases("folders"),
+            ),
             "series_groups": gen_multipart_field_aliases("series_groups"),
             "scan_info": ("scan",),
             "stories": ("story",),

codex/settings/settings.py

@@ -81,6 +81,7 @@ if not DEBUG:
             "asyncio": {
                 "level": "INFO",
             },
+            "urllib3.connectionpool": {"level": "INFO"},
             "watchdog": {
                 "level": "INFO",
             },

codex/static_root/assets/{VCheckbox-Bf5gdxZe.7edc318a8f33.js → VCheckbox-B_KxeHW4.83cc6be08a2f.js}

@@ -1 +1 @@
-import{m as g,V as t}from"./VCheckboxBtn-8Kva6jyD.js";import{a as A,u as I,V as l}from"./VSelectionControl-DKw4TKuO.js";import{F as B,am as U,P as D,au as R,G as q,h as G,S as M,cD as N,T as u,aq as r}from"./admin-drawer-panel-THbQH8zq.js";const S=B({...A(),...U(g(),["inline"])},"VCheckbox"),w=D()({name:"VCheckbox",inheritAttrs:!1,props:S(),emits:{"update:modelValue":e=>!0,"update:focused":e=>!0},setup(e,c){let{attrs:d,slots:a}=c;const s=R(e,"modelValue"),{isFocused:n,focus:i,blur:m}=I(e),V=q(),p=G(()=>e.id||`checkbox-${V}`);return M(()=>{const[b,f]=N(d),v=l.filterProps(e),k=t.filterProps(e);return u(l,r({class:["v-checkbox",e.class]},b,v,{modelValue:s.value,"onUpdate:modelValue":o=>s.value=o,id:p.value,focused:n.value,style:e.style}),{...a,default:o=>{let{id:h,messagesId:x,isDisabled:P,isReadonly:C,isValid:y}=o;return u(t,r(k,{id:h.value,"aria-describedby":x.value,disabled:P.value,readonly:C.value},f,{error:y.value===!1,modelValue:s.value,"onUpdate:modelValue":F=>s.value=F,onFocus:i,onBlur:m}),a)}})}),{}}});export{w as V};
+import{m as g,V as t}from"./VCheckboxBtn-D_7rfm4C.js";import{a as A,u as I,V as l}from"./VSelectionControl-B7a_kuaA.js";import{F as B,am as U,P as D,au as R,G as q,h as G,S as M,cD as N,T as u,aq as r}from"./admin-drawer-panel-CoRl2h5W.js";const S=B({...A(),...U(g(),["inline"])},"VCheckbox"),w=D()({name:"VCheckbox",inheritAttrs:!1,props:S(),emits:{"update:modelValue":e=>!0,"update:focused":e=>!0},setup(e,c){let{attrs:d,slots:a}=c;const s=R(e,"modelValue"),{isFocused:n,focus:i,blur:m}=I(e),V=q(),p=G(()=>e.id||`checkbox-${V}`);return M(()=>{const[b,f]=N(d),v=l.filterProps(e),k=t.filterProps(e);return u(l,r({class:["v-checkbox",e.class]},b,v,{modelValue:s.value,"onUpdate:modelValue":o=>s.value=o,id:p.value,focused:n.value,style:e.style}),{...a,default:o=>{let{id:h,messagesId:x,isDisabled:P,isReadonly:C,isValid:y}=o;return u(t,r(k,{id:h.value,"aria-describedby":x.value,disabled:P.value,readonly:C.value},f,{error:y.value===!1,modelValue:s.value,"onUpdate:modelValue":F=>s.value=F,onFocus:i,onBlur:m}),a)}})}),{}}});export{w as V};

codex/static_root/assets/{VCheckbox-Bf5gdxZe.js → VCheckbox-B_KxeHW4.js}

@@ -1 +1 @@
-import{m as g,V as t}from"./VCheckboxBtn-8Kva6jyD.js";import{a as A,u as I,V as l}from"./VSelectionControl-DKw4TKuO.js";import{F as B,am as U,P as D,au as R,G as q,h as G,S as M,cD as N,T as u,aq as r}from"./admin-drawer-panel-THbQH8zq.js";const S=B({...A(),...U(g(),["inline"])},"VCheckbox"),w=D()({name:"VCheckbox",inheritAttrs:!1,props:S(),emits:{"update:modelValue":e=>!0,"update:focused":e=>!0},setup(e,c){let{attrs:d,slots:a}=c;const s=R(e,"modelValue"),{isFocused:n,focus:i,blur:m}=I(e),V=q(),p=G(()=>e.id||`checkbox-${V}`);return M(()=>{const[b,f]=N(d),v=l.filterProps(e),k=t.filterProps(e);return u(l,r({class:["v-checkbox",e.class]},b,v,{modelValue:s.value,"onUpdate:modelValue":o=>s.value=o,id:p.value,focused:n.value,style:e.style}),{...a,default:o=>{let{id:h,messagesId:x,isDisabled:P,isReadonly:C,isValid:y}=o;return u(t,r(k,{id:h.value,"aria-describedby":x.value,disabled:P.value,readonly:C.value},f,{error:y.value===!1,modelValue:s.value,"onUpdate:modelValue":F=>s.value=F,onFocus:i,onBlur:m}),a)}})}),{}}});export{w as V};
+import{m as g,V as t}from"./VCheckboxBtn-D_7rfm4C.js";import{a as A,u as I,V as l}from"./VSelectionControl-B7a_kuaA.js";import{F as B,am as U,P as D,au as R,G as q,h as G,S as M,cD as N,T as u,aq as r}from"./admin-drawer-panel-CoRl2h5W.js";const S=B({...A(),...U(g(),["inline"])},"VCheckbox"),w=D()({name:"VCheckbox",inheritAttrs:!1,props:S(),emits:{"update:modelValue":e=>!0,"update:focused":e=>!0},setup(e,c){let{attrs:d,slots:a}=c;const s=R(e,"modelValue"),{isFocused:n,focus:i,blur:m}=I(e),V=q(),p=G(()=>e.id||`checkbox-${V}`);return M(()=>{const[b,f]=N(d),v=l.filterProps(e),k=t.filterProps(e);return u(l,r({class:["v-checkbox",e.class]},b,v,{modelValue:s.value,"onUpdate:modelValue":o=>s.value=o,id:p.value,focused:n.value,style:e.style}),{...a,default:o=>{let{id:h,messagesId:x,isDisabled:P,isReadonly:C,isValid:y}=o;return u(t,r(k,{id:h.value,"aria-describedby":x.value,disabled:P.value,readonly:C.value},f,{error:y.value===!1,modelValue:s.value,"onUpdate:modelValue":F=>s.value=F,onFocus:i,onBlur:m}),a)}})}),{}}});export{w as V};