- Changed search behavior in the built-in card search.
  - Search is now consistently case-insensitive, even for non-ASCII characters
  - The wildcard character to represent "any number of characters" is now `*` instead of `%`
- Cards can be removed from the current page via a new context menu entry

## Fixed issues


- The card lookup for "related cards" via the context menu now finds both sides of related double-faced cards or tokens.
- Fixed application hang at exit, if a card data update was previously canceled.
- Potentially fixed Scryfall card data import aborting on some systems with `IncompleteRead` errors

# Version 0.35.2 (2026-03-08)  <a name="v0_35_2"></a>

## Fixed issues

import abc
import time
from collections.abc import Generator, Sequence
import functools
import gzip
import itertools
import math
import shutil
from gzip import GzipFile
from pathlib import Path
import queue
import sqlite3
import socket
import typing

    related_id: UUID


class CardInfoDownloadTaskBase(DownloaderBase):
    """Base class for tasks that fetch card data from the Scryfall bulk-data API."""

    def get_scryfall_bulk_card_data_url(self) -> tuple[str, int]:
        """Returns the bulk data URL and item count"""
        logger.info("Obtaining the card data URL from the API bulk data end point")
        data, _ = self.read_from_url(BULK_DATA_API_END_POINT)
        with data:
            item: BulkDataType = next(ijson.items(data, "", use_float=True))

        uri = item["download_uri"]
        size = item["size"]


        logger.debug(f"Bulk data with uncompressed size {size} bytes located at: {uri}")
        return uri, size


class FileDownloadTask(CardInfoDownloadTaskBase):
    """Downloading the raw card data to a file stored in the file system."""
    def __init__(self, download_path: Path):

        logger.debug("Request bulk data URL from the Scryfall API.")
        url, size = self.get_scryfall_bulk_card_data_url()
        file_name = urllib.parse.urlparse(url).path.split("/")[-1]
        logger.debug(f"Obtained url: '{url}'")
        monitor = self._open_url(
            url,
            self.tr("Downloading card data:", "Progress bar label text"))
        # Hack: As of writing this, the CDN does not offer the size of the gzip-compressed data.
        # The API also only offers the uncompressed size. So divide the API-provided size by an empirically
        # determined compression factor to estimate the download size. Only do so, if the CDN does not offer the size.
        if monitor.content_encoding() == "gzip":
            file_name += ".gz"
            size = math.floor(size / GZIP_COMPRESSION_FACTOR)
            logger.info(f"Content length estimated as {size} bytes")
        if monitor.content_length <= 0:
            monitor.content_length = size
        download_file_path = self.download_path/file_name
        logger.debug(f"Opened URL '{url}' and target file at '{download_file_path}', about to download contents.")
        with download_file_path.open("wb") as download_file, monitor:
            self.connection = monitor
            try:

class StreamTask(CardInfoDownloadTaskBase):
    """Base class for tasks that stream data via a queue."""
    _queue_depth = 5
    _batch_size = 5000

    def __init__(self, source: str | Path | None = None, json_path: str = "item"):
        super().__init__()
        self.open_file: GzipFile | MeteredSeekableHTTPFile | None = None
        self.source = source
        self.json_path = json_path
        self.queue: CardDataQueue = queue.Queue(self._queue_depth)
        self._stream = None

    def _enqueue_stream(self, data: CardStream):
        """Put the CardStream into the queue for downstream consumption"""
        try:
            for batch in itertools.batched(data, self._batch_size):  # type: tuple[CardDataType, ...]
                self.queue.put(batch)
        except AttributeError:  # Cancelling closes and deletes the underlying file, causing an AttributeError in run()
            logger.info(f"{self.__class__.__name__}: Read operation cancelled")
        except Exception as e:
            # Cancelling also exhausts the queue to prevent deadlocks.
            # That exhaustion deliberately causes a "read from closed file".
            # So suppress any error, if the stream no longer exists, as it only disappears through cancel()
            if self._stream is not None:
                signal = self.error_occurred if isinstance(self.source, Path) else self.network_error_occurred
                logger.warning(f"{self.__class__.__name__}: Unexpected end of stream")
                signal.emit(str(e))
        else:
            logger.info(f"{self.__class__.__name__}: Card data exhausted.")
        finally:
            self.queue.put(None)

    @property
    def report_progress(self):

    def can_cancel(self) -> bool:
        return True

    def cancel(self):
        logger.debug(f"{self.__class__.__name__}: entering cancel()")
        if self.open_file is not None:
            self.open_file.close()
        self.open_file = self._stream = None
        while not self.queue.empty():
            # Flush the queue to unblock a potentially blocked writer thread:
            # The consumer thread stops immediately within it's currently processed batch,
            # so may leave the producer in a deadlock waiting for a free queue slot that will never arrive.
            try:
                self.queue.get(block=False)
            except queue.Empty:
                time.sleep(0.1)

        logger.debug(f"{self.__class__.__name__}: Cancel completed")


class FileStreamTask(StreamTask):
    """Reads card data from a local file and streams the content"""

    def run(self):
        data = self.read_json_card_data_from(self.source, self.json_path)
        self._enqueue_stream(data)

    def read_json_card_data_from(self, file_path: Path, json_path: str = "item") -> CardStream:
        file_size = file_path.stat().st_size
        raw_file = file_path.open("rb")
        with self._wrap_in_metered_file(raw_file, file_size) as file:
            if file_path.suffix.casefold() == ".gz":
                self.open_file = file = gzip.open(file, "rb")
            self._stream = ijson.items(file, json_path, use_float=True)
            yield from self._stream

    def _wrap_in_metered_file(self, raw_file, file_size: int):
        monitor = mtg_proxy_printer.metered_file.MeteredFile(raw_file, file_size)
        monitor.total_bytes_processed.connect(self.set_progress)
        monitor.io_begin.connect(lambda size: self.task_begins.emit(
            size,
            self.tr("Importing card data from disk:", "Progress bar label text")))

    When used as a Task, it streams the decoded card data from the API and batches the result.
    This encapsulates requesting data via HTTPS, decryption, gzip stream decompression and parsing into dicts via ijson.
    It enqueues a single None as the last value after finishing the last batch.
    """
    def run(self):
        logger.info(f"{self.__class__.__name__}: About to stream card data in batches of {self._batch_size}")
        data = self.read_json_card_data_from(self.source, self.json_path)

        self._enqueue_stream(data)



    def read_json_card_data_from(self, url: str | None = None, json_path: str = "item") -> CardStream:
        """
        Parses the bulk card data JSON from https://scryfall.com/docs/api/bulk-data into individual objects.
        This function takes a URL pointing to the card data JSON array in the Scryfall API.

        The all cards JSON document is quite large (> 2.1GiB in 2024-10) and requires about 8GiB RAM to parse in one go.
        So use an iterative parser to generate and yield individual card objects, without having to store the whole
        document in memory.
        """
        if url is None:
            logger.debug("Request bulk data URL from the Scryfall API.")
            url, _ = self.get_scryfall_bulk_card_data_url()
            logger.debug(f"Obtained url: {url}")
        else:
            logger.debug(f"Reading from given URL {url}")
        # Ignore the monitor, because progress reporting is done in the main import loop.
        self.open_file, _ = self.read_from_url(url)  # type: GzipFile | MeteredSeekableHTTPFile, MeteredSeekableHTTPFile
        with self.open_file:
            self._stream = ijson.items(self.open_file, json_path, use_float=True)

            yield from self._stream

    @functools.cache
    def get_available_card_count(self) -> int:
        url_parameters = urllib.parse.urlencode({
            "include_multilingual": "true",
            "include_variations": "true",
            "include_extras": "true",
            "unique": "prints",
            "q": "date>1970-01-01"
        })
        url = f"https://api.scryfall.com/cards/search?{url_parameters}"
        logger.debug(f"Card data update query URL: {url}")
        try:
            total_cards_available: int = next(self.read_json_card_data_from(url, "total_cards"))
        except (urllib.error.URLError, socket.timeout, StopIteration) as e:
            logger.warning(
                "Requesting the number of available cards on Scryfall failed with a network error. "
                "Report zero available cards.")
            self.network_error_occurred.emit(
                self.tr(
                    "Requesting the number of available cards on Scryfall failed: \n{error}",
                    "Error message shown in a message box").format(error=e))

        logger.debug(f"Total cards currently available: {total_cards_available}")
        return total_cards_available

    @property
    def item_count(self):
        return self.get_available_card_count()


class AdditionalSetData(typing.NamedTuple):
    svg_icon_uri: str
    file_name: str
    parent_set_code: str | None


class SetDataImportTask(DownloaderBase):

    def __init__(self, db: sqlite3.Connection | None = None,
                 carddb_path: Path | Literal[":memory:"] = DEFAULT_DATABASE_LOCATION):
        super().__init__()
        self.carddb_path = carddb_path

        Reads a given URL and returns a file-like object that can and should be used as a context manager.
        GZip-Streams are implicitly decompressed.
        :param url: URL to fetch
        :param ui_hint: Display text shown in the UI next to the progress bar. If empty, no progress bar is shown at all
        """
        monitor = self._open_url(url, ui_hint)
        encoding = monitor.content_encoding()
        if encoding == "gzip":
            data = gzip.open(monitor, "rb")
        elif encoding in ("identity", None):  # Implicit "identity" if the Content-Encoding header is missing.
            data = monitor
        else:
            raise RuntimeError(f"Server returned unsupported encoding: {encoding}")
        return data, monitor

    def _open_url(self, url: str, ui_hint: str) -> mtg_proxy_printer.http_file.MeteredSeekableHTTPFile:
        headers = {
            "Accept": "*/*",
            "Accept-Encoding": ", ".join(supported_encodings)
        }
        response = mtg_proxy_printer.http_file.MeteredSeekableHTTPFile(url, headers, ui_hint=ui_hint)
        if (response_code := response.getcode()) >= 300:
            raise RuntimeError(f"Error from server! Error code: {response_code}")
        if ui_hint:  # Without a display text for the UI, there is no meaningful progress report. So skip if not given
            response.total_bytes_processed.connect(self.set_progress)
            response.io_begin.connect(self.task_begins)
        return response

                "include_multilingual": "true",
                "include_variations": "true",
                "include_extras": "true",
                "unique": "prints",
                "q": f"date>1970-01-01 date<={timestamp.date()}"
            })
            try:
                card_count = next(aw.read_json_card_data_from(
                    f'https://api.scryfall.com/cards/search?{url_parameters}', 'total_cards'
                ))
            except (urllib.error.URLError, socket.error):
                card_count = 0
            data.append((id_, timestamp.isoformat(), card_count))
            # Rate limit the requests to 10 per second, according to the Scryfall API usage recommendations
            time.sleep(0.1)
            progress_meter.advance_progress.emit()

        logger.debug("User about to import card tata from a previously downloaded file.")
        location, _ = QFileDialog.getOpenFileName(
            self, self.tr(
                "Import previously downloaded card data obtained from Scryfall",
                "File selection dialog caption. User should select a previously downloaded card data file.",
            ),
            QStandardPaths.locate(StandardLocation.DownloadLocation, "", LocateOption.LocateDirectory),
            self.tr("Scryfall card data (*.json *.json.gz)", "File dialog file-type filter."))
        logger.info(f"{location=}")
        if not location:
            logger.debug("User cancelled file selection. Not importing.")
            return
        if not (path := pathlib.Path(location)).is_file():
            logger.warning("User selected something that is not a file. Aborting.")
            QMessageBox.critical(

class BulkDataType(TypedDict):
    """
    The data returned by the bulk data API end point.
    See https://scryfall.com/docs/api/bulk-data
    """
    id: ShouldBeUUID
    uri: str
    type: str
    name: str
    description: str
    download_uri: str
    updated_at: str

    size: int
    content_type: str
    content_encoding: str


class SetsAPIDataType(TypedDict):
    object: Literal["set"]
    id: UUID
    code: str
    mtgo_code: NotRequired[str]