devart-dl 4.2.0__tar.gz → 4.3.0__tar.gz

{devart_dl-4.2.0/devart_dl.egg-info → devart_dl-4.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devart-dl
-Version: 4.2.0
+Version: 4.3.0
 Summary: 专业的 DeviantArt 作品批量下载工具 - Professional DeviantArt batch downloader with anti-ban features
 Author: DeviantArt Downloader Team
 License-Expression: MIT
@@ -61,6 +61,9 @@ devart-dl https://www.deviantart.com/username/gallery
 # 收藏夹 / 标签
 devart-dl https://www.deviantart.com/username/favourites
 devart-dl https://www.deviantart.com/tag/landscape
+
+# 解析为 JSON 描述（不下载文件）
+devart-dl resolve https://www.deviantart.com/username/art/title-123456
 ```
 
 首次下载前建议使用 OAuth 登录：
@@ -88,6 +91,7 @@ devart-dl login browser   # 打开你的 Chrome 登录，自动保存 Cookie，
 - **下载档案**：`--archive` 用 SQLite 记住已下载，跨会话自动跳过。
 - **路径模板 + 元数据 sidecar**：`--directory`/`--filename` 模板与 `--write-info-json`。
 - **代理与降级**：支持 `--proxy`；未登录 OAuth 时自动回退 Cookie。
+- **Resolve 模式**：`devart-dl resolve URL` 输出 `ResolvedDeviation`/`MediaAsset` 的 JSON 契约，不写文件。
 
 完整的安装、登录认证、下载模式、配置参数、命令速查、Python 调用与常见问题，请看**文档站点**：
 

{devart_dl-4.2.0 → devart_dl-4.3.0}/README.en.md

@@ -50,6 +50,9 @@ devart-dl https://www.deviantart.com/username/favourites
 
 # Tag
 devart-dl https://www.deviantart.com/tag/landscape
+
+# Resolve to JSON descriptors (download nothing)
+devart-dl resolve https://www.deviantart.com/username/art/title-123456
 ```
 
 ### Login (OAuth recommended)
@@ -66,6 +69,10 @@ Register a **Public** OAuth app at [deviantart.com/developers](https://www.devia
 
 ## Main Features
 
+### Resolve Mode
+
+`devart-dl resolve URL` emits a machine-consumable `ResolvedDeviation` + `MediaAsset[]` JSON contract without writing any file.
+
 ### Download Modes
 
 URL-first is the simplest entry; explicit subcommands are also kept:
@@ -86,7 +93,7 @@ devart-dl search all "digital art"
 devart-dl fav username folder_id
 ```
 
-> Note: explicit subcommands keep the old usage for compatibility. The official API has no search endpoint, so `search` uses the cookie fallback.
+> Note: explicit subcommands keep the old usage for compatibility. The official API has no search endpoint, so `search` always uses the web/cookie path. OAuth and cookies are capabilities that compose — OAuth gives the official API and cookie gives search — instead of one global "login mode".
 
 ### Authentication
 

{devart_dl-4.2.0 → devart_dl-4.3.0}/README.md

@@ -27,6 +27,9 @@ devart-dl https://www.deviantart.com/username/gallery
 # 收藏夹 / 标签
 devart-dl https://www.deviantart.com/username/favourites
 devart-dl https://www.deviantart.com/tag/landscape
+
+# 解析为 JSON 描述（不下载文件）
+devart-dl resolve https://www.deviantart.com/username/art/title-123456
 ```
 
 首次下载前建议使用 OAuth 登录：
@@ -54,6 +57,7 @@ devart-dl login browser   # 打开你的 Chrome 登录，自动保存 Cookie，
 - **下载档案**：`--archive` 用 SQLite 记住已下载，跨会话自动跳过。
 - **路径模板 + 元数据 sidecar**：`--directory`/`--filename` 模板与 `--write-info-json`。
 - **代理与降级**：支持 `--proxy`；未登录 OAuth 时自动回退 Cookie。
+- **Resolve 模式**：`devart-dl resolve URL` 输出 `ResolvedDeviation`/`MediaAsset` 的 JSON 契约，不写文件。
 
 完整的安装、登录认证、下载模式、配置参数、命令速查、Python 调用与常见问题，请看**文档站点**：
 

{devart_dl-4.2.0 → devart_dl-4.3.0}/da_downloader/__init__.py

@@ -1,16 +1,18 @@
 """DeviantArt Downloader — a reliable, focused downloader and archival CLI."""
 
-__version__ = "4.0.1"
+__version__ = "4.3.0"
 __author__ = "DeviantArt Downloader Team"
 
 from .download import Downloader, build_downloader, normalize_quality
 from .errors import DeviantArtError
-from .models import DownloadItem
+from .models import DownloadItem, MediaAsset, ResolvedDeviation
 
 __all__ = [
     "Downloader",
     "build_downloader",
     "normalize_quality",
     "DownloadItem",
+    "MediaAsset",
+    "ResolvedDeviation",
     "DeviantArtError",
 ]

{devart_dl-4.2.0 → devart_dl-4.3.0}/da_downloader/cli.py

@@ -37,6 +37,7 @@ _HELP = """DeviantArt Downloader
 
 Usage:
   devart-dl URL [options]             # URL-first: artwork/gallery/favourites/tag
+  devart-dl resolve URL [options]     # resolve to work/media JSON, download nothing
   devart-dl url URL [options]
   devart-dl artist USERNAME [options]
   devart-dl gallery USERNAME [GALLERY_ID] [options]
@@ -62,7 +63,7 @@ Run `devart-dl login oauth --help` for OAuth details.
 """
 
 _KNOWN_COMMANDS = frozenset(
-    {"help", "url", "artist", "gallery", "search", "fav", "login", "whoami", "logout"}
+    {"help", "url", "artist", "gallery", "search", "fav", "resolve", "login", "whoami", "logout"}
 )
 _REMOVED_COMMANDS = frozenset({"anti-ban", "test"})
 _UUID_RE = re.compile(
@@ -199,6 +200,39 @@ def _run_download(arguments: Sequence[str]) -> int:
     )
 
 
+
+def _run_resolve(arguments: Sequence[str]) -> int:
+    parser = argparse.ArgumentParser(
+        prog="devart-dl resolve",
+        description="Resolve a DeviantArt target to work/media JSON (download nothing)",
+    )
+    parser.add_argument("target", help="DeviantArt URL or artwork id")
+    parser.add_argument("--cookies", default=None)
+    parser.add_argument("--quality", default="best")
+    parser.add_argument("--proxy", default=None)
+    parser.add_argument("--timeout", type=float, default=60.0)
+    parser.add_argument("--retries", type=int, default=3)
+    parser.add_argument("--limit", type=int, default=24)
+    args = parser.parse_args(list(arguments))
+    try:
+        downloader = build_downloader(
+            destination=Path("."),
+            cookies=_load_cookies(args.cookies),
+            quality=args.quality,
+            proxy=args.proxy,
+            timeout=args.timeout,
+            retries=args.retries,
+            limit=args.limit,
+        )
+        works = downloader.resolve(args.target)
+    except (ValueError, DeviantArtError) as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 1
+    payload = works[0].to_dict() if len(works) == 1 else {"works": [w.to_dict() for w in works]}
+    print(json.dumps(payload, ensure_ascii=False, indent=2))
+    return 0
+
+
 def _run_subcommand(command: str, rest: Sequence[str]) -> int:
     positionals: list[str] = []
     options: dict[str, str] = {}
@@ -406,6 +440,8 @@ def main(argv: Sequence[str] | None = None) -> int:
         return 0
     if command in {"url", "artist", "gallery", "search", "fav"}:
         return _run_subcommand(command, rest)
+    if command == "resolve":
+        return _run_resolve(rest)
     if command == "login":
         if not rest or rest[0] in {"-h", "--help", "help"}:
             print("Usage: devart-dl login oauth|browser|interactive|clear")

{devart_dl-4.2.0 → devart_dl-4.3.0}/da_downloader/download.py

@@ -15,10 +15,16 @@ from .api import DeviantArtAPI
 from .archive import DownloadArchive
 from .http import HttpDownloader
 from .manager import DownloadManager, DownloadOutcome
+from .models import ResolvedDeviation, make_media_asset
 from .oauth import OAuthSession
 from .official_api import OfficialApiClient
 from .path import PathFormatter
-from .provider import DeviantArtProvider, OfficialProvider, WebProvider
+from .provider import (
+    CompositeProvider,
+    DeviantArtProvider,
+    OfficialProvider,
+    WebProvider,
+)
 from .targets import DownloadTarget, TargetParser
 
 # User-facing quality names (new) and the legacy o/f/p shorthand.
@@ -50,6 +56,50 @@ class Downloader:
         parsed = TargetParser.parse(target) if isinstance(target, str) else target
         return [self.manager.run(item) for item in self.provider.resolve(parsed)]
 
+    def resolve(self, target: str | DownloadTarget) -> list[ResolvedDeviation]:
+        """Resolve a target to DeviantArt works and media assets (no download)."""
+        parsed = TargetParser.parse(target) if isinstance(target, str) else target
+        groups: dict[str, dict] = {}
+        order: list[str] = []
+        for item in self.provider.resolve(parsed):
+            extra = item.metadata.get("index") if item.metadata else None
+            base = str(item.artwork_id)
+            if extra is not None:
+                suffix = f"-{extra}"
+                if base.endswith(suffix):
+                    base = base[: -len(suffix)]
+            if base not in groups:
+                groups[base] = {
+                    "title": item.title,
+                    "author": item.author,
+                    "mature": item.mature,
+                    "url": item.url,
+                    "assets": [],
+                }
+                order.append(base)
+            index = int(extra) if extra is not None else len(groups[base]["assets"])
+            groups[base]["assets"].append(
+                make_media_asset(
+                    base,
+                    index,
+                    item.media_url,
+                    extension=item.extension,
+                    mature=item.mature,
+                )
+            )
+        return [
+            ResolvedDeviation(
+                id=key,
+                title=groups[key]["title"],
+                author=groups[key]["author"],
+                mature=groups[key]["mature"],
+                url=groups[key]["url"],
+                media=tuple(groups[key]["assets"]),
+            )
+            for key in order
+        ]
+
+
 
 def build_downloader(
     *,
@@ -70,23 +120,20 @@ def build_downloader(
 ) -> Downloader:
     """Assemble a wired ``Downloader`` from plain configuration values.
 
-    When an OAuth session exists it is preferred (official API); otherwise the
-    cookie-based web provider is used as the fallback.
+    OAuth and cookies are capabilities, not a global provider mode: the
+    official API is preferred where it works and the web session fills the
+    capabilities it cannot cover (notably search).
     """
     normalized_quality = normalize_quality(quality)
     proxies = {"http": proxy, "https": proxy} if proxy else {}
 
     oauth_session = OAuthSession.from_store()
+    official = web = None
+    api = None
     if oauth_session is not None:
         client = OfficialApiClient(oauth_session, timeout=timeout)
-        provider: DeviantArtProvider = OfficialProvider(
-            client, quality=normalized_quality, limit=limit
-        )
-        # Official media URLs are signed CDN links and need no cookies.
-        http_session = requests.Session()
-        if proxies:
-            http_session.proxies.update(proxies)
-    else:
+        official = OfficialProvider(client, quality=normalized_quality, limit=limit)
+    if cookies or oauth_session is None:
         headers = {
             "accept": "application/json, text/plain, */*",
             "user-agent": (
@@ -99,8 +146,17 @@ def build_downloader(
         api = DeviantArtAPI(
             headers, proxies, retry_delay=int(retry_delay), max_retries=retries
         )
-        provider = WebProvider(api, quality=normalized_quality, limit=limit)
+        web = WebProvider(api, quality=normalized_quality, limit=limit)
+
+    provider: DeviantArtProvider = CompositeProvider(official, web)
+    # The web session's cookies are harmless on signed official CDN links and
+    # required for web-sourced media (search/gallery fallback), so prefer it.
+    if api is not None:
         http_session = api.session
+    else:
+        http_session = requests.Session()
+        if proxies:
+            http_session.proxies.update(proxies)
 
     http = HttpDownloader(
         session=http_session,

{devart_dl-4.2.0 → devart_dl-4.3.0}/da_downloader/models.py

@@ -113,3 +113,100 @@ class DownloadItem:
     published_at: Optional[datetime] = None
     mature: bool = False
     metadata: Mapping[str, Any] = field(default_factory=dict)
+
+
+_MIME_BY_EXT = {
+    "jpg": "image/jpeg",
+    "jpeg": "image/jpeg",
+    "png": "image/png",
+    "gif": "image/gif",
+    "webp": "image/webp",
+    "bmp": "image/bmp",
+    "svg": "image/svg+xml",
+    "mp4": "video/mp4",
+    "webm": "video/webm",
+    "mov": "video/quicktime",
+}
+
+_VIDEO_EXTS = frozenset({"mp4", "webm", "mov", "m4v"})
+
+_DEFAULT_MIME = {"image": "image/jpeg", "video": "video/mp4"}
+
+
+@dataclass(frozen=True)
+class MediaAsset:
+    """One resolute media file of a DeviantArt work (``deviantart:<uuid>:p<n>``)."""
+
+    id: str
+    deviation_id: str
+    index: int
+    kind: str  # "image" | "video"
+    source_url: str
+    extension: str | None = None
+    mime_type: str | None = None
+    width: int | None = None
+    height: int | None = None
+    mature: bool = False
+
+    def to_dict(self) -> dict:
+        data: dict = {
+            "id": self.id,
+            "kind": self.kind,
+            "sourceUrl": self.source_url,
+        }
+        for key, value in (
+            ("extension", self.extension),
+            ("mimeType", self.mime_type),
+            ("width", self.width),
+            ("height", self.height),
+            ("mature", self.mature),
+        ):
+            if value is not None:
+                data[key] = value
+        return data
+
+
+@dataclass(frozen=True)
+class ResolvedDeviation:
+    """A DeviantArt work plus its media assets, independent of downloading."""
+
+    id: str
+    title: str
+    author: str
+    mature: bool
+    media: tuple[MediaAsset, ...] = ()
+    url: str = ""
+
+    def to_dict(self) -> dict:
+        return {
+            "work": {
+                "id": self.id,
+                "title": self.title,
+                "author": self.author,
+                "url": self.url,
+                "mature": self.mature,
+            },
+            "media": [asset.to_dict() for asset in self.media],
+        }
+
+
+def make_media_asset(
+    deviation_id: str,
+    index: int,
+    source_url: str,
+    *,
+    extension: str | None = None,
+    mature: bool = False,
+) -> MediaAsset:
+    ext = (extension or "").lstrip(".").lower() or None
+    kind = "video" if ext in _VIDEO_EXTS else "image"
+    return MediaAsset(
+        id=f"deviantart:{deviation_id}:p{index}",
+        deviation_id=deviation_id,
+        index=index,
+        kind=kind,
+        source_url=source_url,
+        extension=ext,
+        mime_type=_MIME_BY_EXT.get(ext) or _DEFAULT_MIME[kind],
+        mature=mature,
+    )

{devart_dl-4.2.0 → devart_dl-4.3.0}/da_downloader/provider.py

@@ -297,4 +297,55 @@ def _parse_published(value: Any) -> Optional[datetime]:
     return datetime.fromtimestamp(timestamp, tz=timezone.utc)
 
 
-__all__ = ["DeviantArtProvider", "OfficialProvider", "WebProvider"]
+class CompositeProvider:
+    """Routes each target to the provider that can actually serve it.
+
+    OAuth and cookies are capabilities, not global provider modes: search
+    always uses the web session, artwork/tag use the official API, and
+    gallery/favorites prefer the official API with the web session as a
+    fallback when the official path is unavailable.
+    """
+
+    def __init__(
+        self,
+        official: DeviantArtProvider | None = None,
+        web: DeviantArtProvider | None = None,
+    ) -> None:
+        if official is None and web is None:
+            raise ValueError("at least one provider is required")
+        self.official = official
+        self.web = web
+
+    def resolve(self, target: DownloadTarget) -> Iterator[DownloadItem]:
+        kind = target.kind
+        if kind == TargetKind.SEARCH:
+            if self.web is None:
+                raise MediaUnavailableError(
+                    "search requires a web/cookie session "
+                    "(`devart-dl login browser`/`interactive` or --cookies)"
+                )
+            yield from self.web.resolve(target)
+            return
+        if kind in (TargetKind.ARTWORK, TargetKind.TAG):
+            if self.official is None:
+                raise MediaUnavailableError(
+                    "this target requires the official API "
+                    "(`devart-dl login oauth`)"
+                )
+            yield from self.official.resolve(target)
+            return
+        if self.official is not None:
+            try:
+                yield from self.official.resolve(target)
+            except MediaUnavailableError:
+                if self.web is not None:
+                    yield from self.web.resolve(target)
+                    return
+                raise
+        elif self.web is not None:
+            yield from self.web.resolve(target)
+        else:
+            raise MediaUnavailableError("no provider can resolve this target")
+
+
+__all__ = ["CompositeProvider", "DeviantArtProvider", "OfficialProvider", "WebProvider"]

{devart_dl-4.2.0 → devart_dl-4.3.0/devart_dl.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devart-dl
-Version: 4.2.0
+Version: 4.3.0
 Summary: 专业的 DeviantArt 作品批量下载工具 - Professional DeviantArt batch downloader with anti-ban features
 Author: DeviantArt Downloader Team
 License-Expression: MIT
@@ -61,6 +61,9 @@ devart-dl https://www.deviantart.com/username/gallery
 # 收藏夹 / 标签
 devart-dl https://www.deviantart.com/username/favourites
 devart-dl https://www.deviantart.com/tag/landscape
+
+# 解析为 JSON 描述（不下载文件）
+devart-dl resolve https://www.deviantart.com/username/art/title-123456
 ```
 
 首次下载前建议使用 OAuth 登录：
@@ -88,6 +91,7 @@ devart-dl login browser   # 打开你的 Chrome 登录，自动保存 Cookie，
 - **下载档案**：`--archive` 用 SQLite 记住已下载，跨会话自动跳过。
 - **路径模板 + 元数据 sidecar**：`--directory`/`--filename` 模板与 `--write-info-json`。
 - **代理与降级**：支持 `--proxy`；未登录 OAuth 时自动回退 Cookie。
+- **Resolve 模式**：`devart-dl resolve URL` 输出 `ResolvedDeviation`/`MediaAsset` 的 JSON 契约，不写文件。
 
 完整的安装、登录认证、下载模式、配置参数、命令速查、Python 调用与常见问题，请看**文档站点**：
 

{devart_dl-4.2.0 → devart_dl-4.3.0}/devart_dl.egg-info/SOURCES.txt

@@ -33,6 +33,7 @@ devart_dl.egg-info/top_level.txt
 tests/test_api.py
 tests/test_archive.py
 tests/test_cli.py
+tests/test_conformance.py
 tests/test_download.py
 tests/test_http_downloader.py
 tests/test_manager.py

{devart_dl-4.2.0 → devart_dl-4.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "devart-dl"
-version = "4.2.0"
+version = "4.3.0"
 description = "专业的 DeviantArt 作品批量下载工具 - Professional DeviantArt batch downloader with anti-ban features"
 readme = "README.md"
 requires-python = ">=3.10"

{devart_dl-4.2.0 → devart_dl-4.3.0}/tests/test_cli.py

@@ -97,3 +97,29 @@ def test_run_download_dry_run_summary(monkeypatch, capsys, tmp_path) -> None:
     assert rc == 0
     assert "dry-run: would download 1, skip 1, fail 0" in capsys.readouterr().out
     assert built["dry_run"] is True
+
+
+def test_resolve_command_outputs_single_work_json(monkeypatch, capsys) -> None:
+    from da_downloader.models import MediaAsset, ResolvedDeviation
+
+    class FakeResolver:
+        def resolve(self, target):
+            return [
+                ResolvedDeviation(
+                    id="u1",
+                    title="Art",
+                    author="alice",
+                    mature=False,
+                    url="https://da.test/x-1",
+                    media=(MediaAsset("deviantart:u1:p0", "u1", 0, "image", "https://img.test/1.jpg"),),
+                )
+            ]
+
+    monkeypatch.setattr(cli, "build_downloader", lambda **kw: FakeResolver())
+    monkeypatch.setattr(cli, "_load_cookies", lambda p: "")
+
+    assert cli.main(["resolve", "https://www.deviantart.com/alice/art/x-123"]) == 0
+    out = capsys.readouterr().out
+    assert '"work"' in out
+    assert '"media"' in out
+    assert "deviantart:u1:p0" in out

devart_dl-4.3.0/tests/test_conformance.py

@@ -0,0 +1,27 @@
+"""Cross-repo conformance: consume the shared sanitized DeviantArt fixture.
+
+The same JSON is checked by the deviantart-downloader Python parser and the
+DeviantDrop Node normalizer, so both sides keep agreeing on core source
+semantics (uuid/title/author/mature) even as implementations diverge.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from da_downloader.models import Deviation
+
+FIXTURE = Path(__file__).parent / "fixtures" / "deviantart_deviation.json"
+
+
+def test_shared_fixture_parses_to_consistent_core() -> None:
+    data = json.loads(FIXTURE.read_text(encoding="utf-8"))
+    deviation = Deviation.from_api_response(data)
+
+    assert deviation.deviation_id == "913624585"
+    assert deviation.title == "Conformance Sample"
+    assert deviation.author == "conformance"
+    assert deviation.is_mature is False
+    assert deviation.is_downloadable is False
+    assert data["extended"]["deviationUuid"] == "11111111-2222-3333-4444-555555555555"

{devart_dl-4.2.0 → devart_dl-4.3.0}/tests/test_download.py

@@ -91,3 +91,79 @@ def test_downloader_parses_target(tmp_path: Path) -> None:
 
     assert provider.targets[0].kind == TargetKind.GALLERY
     assert provider.targets[0].username == "alice"
+
+
+def test_build_downloader_wires_capability_router_with_oauth_and_cookies(
+    tmp_path: Path, monkeypatch
+) -> None:
+    from da_downloader.download import build_downloader
+    from da_downloader.provider import CompositeProvider, OfficialProvider, WebProvider
+
+    class FakeSession:
+        def authorization_header(self, force=False):
+            return "Bearer x"
+
+    monkeypatch.setattr(
+        "da_downloader.download.OAuthSession.from_store", classmethod(lambda cls: FakeSession())
+    )
+
+    downloader = build_downloader(
+        destination=tmp_path, cookies="auth=token; auth_secure=secret"
+    )
+
+    router = downloader.provider
+    assert isinstance(router, CompositeProvider)
+    assert router.official is not None and isinstance(router.official, OfficialProvider)
+    assert router.web is not None and isinstance(router.web, WebProvider)
+
+
+def test_build_downloader_without_oauth_uses_composite_web_only(
+    tmp_path: Path, monkeypatch
+) -> None:
+    from da_downloader.download import build_downloader
+    from da_downloader.provider import CompositeProvider, WebProvider
+
+    monkeypatch.setattr(
+        "da_downloader.download.OAuthSession.from_store", classmethod(lambda cls: None)
+    )
+
+    downloader = build_downloader(destination=tmp_path)
+
+    router = downloader.provider
+    assert isinstance(router, CompositeProvider)
+    assert router.official is None
+    assert isinstance(router.web, WebProvider)
+
+
+def test_resolve_groups_additional_media_into_one_work() -> None:
+    main = DownloadItem(
+        artwork_id="uuid-1",
+        url="https://www.deviantart.com/alice/art/x-1",
+        title="Art",
+        author="alice",
+        media_url="https://images.test/1.jpg",
+        extension="jpg",
+        mature=True,
+    )
+    extra = DownloadItem(
+        artwork_id="uuid-1-1",
+        url=main.url,
+        title=main.title,
+        author=main.author,
+        media_url="https://images.test/2.png",
+        extension="png",
+        metadata={"index": 1},
+    )
+    downloader = Downloader(FakeProvider([main, extra]), manager=None)
+
+    works = downloader.resolve("https://www.deviantart.com/alice/art/x-123")
+
+    assert len(works) == 1
+    work = works[0]
+    assert work.id == "uuid-1"
+    assert work.mature is True
+    assert [a.id for a in work.media] == ["deviantart:uuid-1:p0", "deviantart:uuid-1:p1"]
+    data = work.to_dict()
+    assert data["work"]["title"] == "Art"
+    assert data["media"][1]["sourceUrl"] == "https://images.test/2.png"
+    assert data["media"][1]["mimeType"] == "image/png"

{devart_dl-4.2.0 → devart_dl-4.3.0}/tests/test_provider.py

@@ -6,8 +6,8 @@ import pytest
 
 from da_downloader.api import ActionType
 from da_downloader.errors import MediaUnavailableError
-from da_downloader.models import Deviation
-from da_downloader.provider import WebProvider
+from da_downloader.models import Deviation, DownloadItem
+from da_downloader.provider import CompositeProvider, WebProvider
 from da_downloader.targets import TargetParser
 
 
@@ -124,3 +124,89 @@ def test_search_target_builds_search_action() -> None:
     action, username, query, folder = provider.api.build_calls[0]
     assert action == ActionType.SEARCH
     assert query == "digital art"
+
+
+class RecordingProvider:
+    def __init__(self, items=None, error=None):
+        self.items = list(items or [])
+        self.error = error
+        self.calls = []
+
+    def resolve(self, target):
+        self.calls.append(target)
+        if self.error:
+            raise self.error
+        yield from self.items
+
+
+def test_composite_search_routes_to_web_even_with_official() -> None:
+    web = make_provider(
+        pages=[([make_deviation()], False, 1, "")],
+        media_urls={"123": "https://images.test/123.jpg"},
+    )
+    official = RecordingProvider(items=[])
+    router = CompositeProvider(official=official, web=web)
+
+    items = list(router.resolve(TargetParser.parse("https://www.deviantart.com/search?q=cat")))
+
+    assert len(items) == 1
+    assert items[0].artwork_id == "123"
+    assert official.calls == []
+    assert len(web.api.build_calls) == 1
+
+
+def test_composite_artwork_routes_to_official() -> None:
+    official = RecordingProvider(items=[DownloadItem("u1", "https://da.test/x-1", "A", "alice", "https://img.test/1.jpg")])
+    web = RecordingProvider(items=[])
+    router = CompositeProvider(official=official, web=web)
+
+    list(router.resolve(TargetParser.parse("https://www.deviantart.com/alice/art/x-123456")))
+
+    assert len(official.calls) == 1
+    assert web.calls == []
+
+
+def test_composite_gallery_prefers_official() -> None:
+    official = RecordingProvider(items=[DownloadItem("u1", "https://da.test/1", "A", "alice", "https://img.test/1.jpg")])
+    web = RecordingProvider(items=[])
+    router = CompositeProvider(official=official, web=web)
+
+    items = list(router.resolve(TargetParser.parse("https://www.deviantart.com/alice/gallery")))
+
+    assert len(items) == 1
+    assert len(official.calls) == 1
+    assert web.calls == []
+
+
+def test_composite_gallery_falls_back_to_web_when_official_unavailable() -> None:
+    web = make_provider(
+        pages=[([make_deviation()], False, 1, "")],
+        media_urls={"123": "https://images.test/123.jpg"},
+    )
+    official = RecordingProvider(error=MediaUnavailableError("nope"))
+    router = CompositeProvider(official=official, web=web)
+
+    items = list(router.resolve(TargetParser.parse("https://www.deviantart.com/alice/gallery")))
+
+    assert items[0].artwork_id == "123"
+    assert len(official.calls) == 1
+    assert len(web.api.build_calls) == 1
+
+
+def test_composite_gallery_with_only_web_uses_web() -> None:
+    web = make_provider(
+        pages=[([make_deviation()], False, 1, "")],
+        media_urls={"123": "https://images.test/123.jpg"},
+    )
+    router = CompositeProvider(official=None, web=web)
+
+    items = list(router.resolve(TargetParser.parse("https://www.deviantart.com/alice/gallery")))
+
+    assert items[0].artwork_id == "123"
+
+
+def test_composite_tag_without_official_requires_official() -> None:
+    web = RecordingProvider(items=[])
+    router = CompositeProvider(official=None, web=web)
+    with pytest.raises(MediaUnavailableError):
+        list(router.resolve(TargetParser.parse("https://www.deviantart.com/tag/landscape")))