added an as_is import option, e.g. for bootlegs that

have no online metadata, but manually cleaned data in tags

Author: pSpitzner

backend/beets_flask/beets_sessions.py

@@ -2,6 +2,7 @@
 import logging
 import os
 import sys
+import taglib
 
 from beets import importer, plugins
 from beets.autotag import AlbumMatch, TrackMatch
@@ -216,7 +217,7 @@ def choose_match(self, task: importer.ImportTask):
         duplicates = task.find_duplicates(self.lib)
         if duplicates:
             print_(
-                f'\nThis {"album" if task.is_album else "item"} is already in the library!'
+                f"\nThis {'album' if task.is_album else 'item'} is already in the library!"
             )
             self.status = "duplicate"
         for duplicate in duplicates:
@@ -246,13 +247,14 @@ def __init__(
         tag_id: str | None = None,
     ):
         # make sure to start with clean slate
+        # apply all tweaks to global config before initializing the basesession!
         set_config_defaults()
         config["import"]["search_ids"].set([match_url])
 
         if tag_id is not None:
             config["import"]["set_fields"]["gui_import_id"] = tag_id
 
-        # this also merged config_overlay into the global config
+        # this also merges config_overlay into the global config
         super(MatchedImportSession, self).__init__(path, config_overlay)
 
         # inconvenient: beets does not invoke a sessions resolve_duplicates() method if config["import"]["duplicate_action"] is set meaningfully (anything except 'ask'?).
@@ -315,7 +317,7 @@ def resolve_duplicate(self, task: importer.ImportTask, found_duplicates):
         config or config_overlay.
         """
         print_(
-            f'\nThis {"album" if task.is_album else "item"} is already in the library!'
+            f"\nThis {'album' if task.is_album else 'item'} is already in the library!"
         )
         for duplicate in found_duplicates:
             old_dir = colorize("import_path", duplicate.item_dir().decode("utf-8"))
@@ -394,6 +396,92 @@ def track_paths_after_import(self) -> list[str]:
             return []
 
 
+class AsIsImportSession(MatchedImportSession):
+    """
+    Import session to import without modifyin metadata.
+
+    Essentially `beet import --group-albums -A`, ideal for bootlegs and
+    just getting a folder into your library where you are sure the metadata is correct.
+
+    This is a quick-and-dirty version before we rework with the newer sessions that
+    are used for interactive imports.
+    I derived this from MatchedImportSession, because it has some bits we need,
+    but yeah, we should rethink this.
+
+    """
+
+    def __init__(
+        self,
+        path: str,
+        tag_id: str | None = None,
+    ):
+
+        config_overlay = {
+            "import": {
+                "group_albums": True,
+                "autotag": False,
+                "search_ids": [],
+            }
+        }
+
+        super().__init__(
+            path=path,
+            match_url=None,
+            config_overlay=config_overlay,
+            tag_id=tag_id,
+        )
+
+        self.match_url = None
+        self.match_album = None
+        self.match_artist = None
+        self.match_dist = None
+
+        # getting track_paths_after_import does not work, because
+        # afaik the import_task only gives paths when we _copied_
+        # so, because with as_is data its more likely that people
+        # _move_ the files, we keep track of the paths before import
+        self.track_paths_before_import = list(self.track_paths_before_import)
+        self.taglib_tags = [
+            taglib.File(fp).tags for fp in self.track_paths_before_import
+        ]
+
+    def debug(self):
+        return config
+
+    def choose_match(self, task: importer.ImportTask):
+        raise NotImplementedError(
+            "AsIsImportSession should not need to choose matches."
+        )
+
+    def run_and_capture_output(self) -> tuple[str, str]:
+        err, out = super().run_and_capture_output()
+
+        # add some basic info of the added items to the preview
+        # I do not know how to get a quick dump of file metadata using beets,
+        # so we simply use taglib for now
+        self.preview += "\n\n"
+        if len(self.track_paths_before_import) == 0:
+            self.preview += "No files to import."
+        else:
+            self.preview += f"Metadata in {len(self.track_paths_before_import)} file(s)\n\n"
+            for fp in self.track_paths_before_import:
+                self.preview += f"  {fp}\n"
+                tags = taglib.File(fp).tags
+                for tag in tags.keys():
+                    self.preview += f"  {tag.lower()}: {tags[tag][0]}\n"
+                self.preview += "--------------------------------------------\n"
+
+
+        self.preview += "\n\n (This is no guarantee the import worked)"
+        # ... and this is a major TODO. How to get track paths _after_ an import,
+        # even when using as is?
+        self.preview = self.preview.strip()
+
+        return out, err
+
+
+
+
 def cli_command(beets_args: list[str], key: str = "s") -> tuple[str, str]:
     """Simulate a cli interaction.
 

backend/beets_flask/config/beets_config.py

@@ -92,6 +92,7 @@ def reset(self):
         if ib_folder is None:
             ib_folder = os.path.expanduser("~/.config/beets-flask")
         ib_config_path = os.path.join(ib_folder, "config.yaml")
+        print(f"{ib_config_path=}")
 
         # Check if the user config exists
         # if not, copy the example config to the user config location

backend/beets_flask/config/config_bf_example.yaml

@@ -30,11 +30,15 @@ gui:
             Lorem:
                 name: "Awesome Inbox"
                 path: "/music/inbox"
-                autotag: no # no | "preview" | "import" | "auto"
+                autotag: no # no | "preview" | "import" | "import_as_is" | "auto"
                 # autotag controls what should happen with newly added album folders.
                 # no: do nothing
                 # "preview": fetch data but do not import (recommended)
                 # "import": fetch data and always import (not recommended)
+                # "import_as_is": import as is, do not fetch data, but groups albums
+                #                 useful for bootlegs, where you manually clean metadata
+                #                 and beets wont be able to find any online
+                #                 same as `beet import --group-albums -A`
                 # "auto": fetch data and import if a good match is found (recommended for established libraries,
                 #         but not for a big initial import when you start with beets for the first time)
             Ipsum:

backend/beets_flask/database/models/tag.py

@@ -41,6 +41,7 @@ class Tag(Base):
     _valid_kinds = [
         "preview",
         "import",
+        "import_as_is",
         "auto",  # generates a preview, and depending on user config, imports if good match
     ]
 

backend/beets_flask/invoker.py

@@ -15,7 +15,12 @@
 from rq.decorators import job
 from sqlalchemy import delete
 
-from beets_flask.beets_sessions import MatchedImportSession, PreviewSession, colorize
+from beets_flask.beets_sessions import (
+    AsIsImportSession,
+    MatchedImportSession,
+    PreviewSession,
+    colorize,
+)
 from beets_flask.config import config
 from beets_flask.database import Tag, db_session
 from beets_flask.redis import import_queue, preview_queue, redis_conn, tag_queue
@@ -57,6 +62,8 @@ def enqueue(id: str, session: Session | None = None):
                 preview_queue.enqueue(runPreview, id)
             elif tag.kind == "import":
                 import_queue.enqueue(runImport, id)
+            elif tag.kind == "import_as_is":
+                import_queue.enqueue(runImport, id, as_is=True)
             elif tag.kind == "auto":
                 preview_job = preview_queue.enqueue(runPreview, id)
                 import_queue.enqueue(AutoImport, id, depends_on=preview_job)
@@ -180,6 +187,7 @@ def runPreview(
 def runImport(
     tagId: str,
     match_url: str | None = None,
+    as_is: bool = False,
     callback_url: str | None = None,
 ) -> list[str]:
     """Start Import session for a tag.
@@ -190,6 +198,14 @@ def runImport(
 
     Parameters
     ----------
+    tagId:str
+        The ID of the tag to be imported, used to load info from db.
+    as_is: bool, optional
+        If true, we import as-is, **grouping albums** and ignoring the match_url.
+        Effectively like `beet import --group-albums -A`.
+        Default False.
+    match_url: str, optional
+        The match url to use for import, if we have it.
     callback_url: str, optional
         Called when the import status changes.
 
@@ -199,7 +215,7 @@ def runImport(
 
     """
     with db_session() as session:
-        log.info(f"Import task on {tagId}")
+        log.info(f"Import task: {as_is=} {tagId=}")
         bt = Tag.get_by(Tag.id == tagId, session=session)
         if bt is None:
             raise InvalidUsage(f"Tag {tagId} not found in database")
@@ -220,22 +236,31 @@ def runImport(
             message="Importing started",
         )
 
-        match_url = match_url or _get_or_gen_match_url(tagId, session)
-        if not match_url:
-            if callback_url:
-                requests.post(
-                    callback_url,
-                    json={
-                        "status": "beets import failed: no match url found.",
-                        "tag": bt.to_dict(),
-                    },
-                )
-            return []
+        if not as_is:
+            match_url = match_url or _get_or_gen_match_url(tagId, session)
+            if not match_url:
+                if callback_url:
+                    requests.post(
+                        callback_url,
+                        json={
+                            "status": "beets import failed: no match url found.",
+                            "tag": bt.to_dict(),
+                        },
+                    )
+                return []
 
         try:
-            bs = MatchedImportSession(
-                path=bt.album_folder, match_url=match_url, tag_id=bt.id
-            )
+            if as_is:
+                bs = AsIsImportSession(
+                    path=bt.album_folder,
+                    tag_id=bt.id,
+                )
+            else:
+                bs = MatchedImportSession(
+                    path=bt.album_folder,
+                    match_url=match_url,
+                    tag_id=bt.id,
+                )
             bs.run_and_capture_output()
 
             bt.preview = bs.preview
@@ -244,7 +269,7 @@ def runImport(
             bt.match_album = bs.match_album
             bt.match_artist = bs.match_artist
             bt.num_tracks = bs.match_num_tracks
-            bt.track_paths_after = bs.track_paths_after_import
+            bt.track_paths_after = bs.track_paths_before_import
             bt.status = "imported" if bs.status == "ok" else bs.status
             log.debug(f"tried import {bt.status=}")
         except Exception as e:

backend/beets_flask/utility.py

@@ -5,7 +5,6 @@
 from math import floor
 
 from flask import current_app
-from rq import Worker
 
 from .logger import log
 
@@ -25,6 +24,7 @@ def wrapper(*args, **kwargs):
 
 def get_running_jobs():
     running_jobs = []
+    from rq import Worker
     workers = Worker.all()
     for worker in workers:
         job = worker.get_current_job()

backend/pyproject.toml

@@ -31,6 +31,8 @@ dependencies = [
     "eventlet>=0.32.0",
     # beets plugin dependencies
     "pylast>=5.2.0",
+    # taglib for as-is imports, temporary
+    "pytaglib>=3.0.0",
 ]
 
 [project.optional-dependencies]

frontend/src/components/common/contextMenu.tsx

@@ -83,6 +83,7 @@ export const defaultActions = [
     <RetagAction key="action-retag" />,
     <ImportAction key="action-import" />,
     <InteractiveImportAction key="action-interactive-import" />,
+    <ImportAsIsAction key="action-import-as-is" />,
     <TerminalImportAction key="action-terminal-import" />,
     <UndoImportAction key="action-undo-import" />,
     <CopyPathAction key="action-copy-path" />,
@@ -552,6 +553,46 @@ export function ImportAction(props: Partial<ActionProps>) {
     );
 }
 
+export function ImportAsIsAction(props: Partial<ActionProps>) {
+    const { closeMenu } = useContextMenu();
+    const { getSelected } = useSelection();
+    const importOptions: UseMutationOptions = {
+        mutationFn: async () => {
+            await fetch(`/tag/add`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    folders: getSelected(),
+                    kind: "import_as_is",
+                }),
+            });
+        },
+        onSuccess: async () => {
+            closeMenu();
+            const selected = getSelected();
+            for (const tagPath of selected) {
+                await queryClient.setQueryData(["tag", tagPath], (old: TagI) => {
+                    return { ...old, status: "pending" };
+                });
+            }
+        },
+        onError: (error: Error) => {
+            console.error(error);
+        },
+    };
+
+    return (
+        <ActionWithMutation
+            {...props}
+            icon={<ImportAutoSvg />}
+            text={"Import (as is)"}
+            mutationOption={importOptions}
+        />
+    );
+}
+
 export function DeleteAction(props: Partial<ActionProps>) {
     const { closeMenu } = useContextMenu();
     const { getSelected } = useSelection();

frontend/src/components/tags/similarityBadge.module.scss

@@ -17,6 +17,7 @@
     border: var(--bs-border-width) solid var(--bs-border-color);
     height: 1.1rem;
     padding: 0.1rem 0.3rem;
+    min-width: 2.1rem; // this is roughly 4 chars
     -webkit-touch-callout: none;
     -webkit-user-select: none;
     -khtml-user-select: none;