diffusers-workflow 0.4.0__py3-none-any.whl

diffusers_workflow-0.4.0.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

diffusers_workflow-0.4.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+dw
+dw_mcp

dw/__init__.py

@@ -0,0 +1,440 @@
+from .settings import resolve_path, load_settings
+from .log_setup import setup_logging
+import os
+import re
+import logging
+import warnings
+from dotenv import load_dotenv
+
+load_dotenv()  # Loads .env from current directory
+
+# Allow MPS to use all available unified memory by default
+# This prevents "MPS backend out of memory" errors with large models
+# Users can override by setting these env vars before import
+if "PYTORCH_MPS_HIGH_WATERMARK_RATIO" not in os.environ:
+    os.environ["PYTORCH_MPS_HIGH_WATERMARK_RATIO"] = "0.0"
+
+# Let the CUDA allocator grow segments instead of fragmenting fixed-size ones.
+# Multi-step workflows churn differently-shaped allocations (generate, upscale,
+# interpolate), and fragmentation is what OOMs a card that nominally has room
+if "PYTORCH_CUDA_ALLOC_CONF" not in os.environ:
+    os.environ["PYTORCH_CUDA_ALLOC_CONF"] = "expandable_segments:True"
+
+# Load sharded checkpoints in parallel - a pure cold-start win
+if "HF_ENABLE_PARALLEL_LOADING" not in os.environ:
+    os.environ["HF_ENABLE_PARALLEL_LOADING"] = "true"
+
+# Suppress all common library warnings before any imports
+warnings.filterwarnings("ignore", category=FutureWarning)
+warnings.filterwarnings("ignore", category=UserWarning)
+warnings.filterwarnings("ignore", category=DeprecationWarning)
+
+# Eager (but guarded) import of torch. This module's own top-level code needs
+# torch's exceptions/types unconditionally to detect its absence gracefully
+# (see _TORCH_AVAILABLE below) rather than deferring the try/except to first
+# use everywhere torch is touched. It would be nice for a torch-free path like
+# `python -m dw.validate` (pure JSON schema validation) to skip this multi-
+# second import, but that isn't achievable by changing dw/__init__.py alone:
+# dw/validate.py imports dw/workflow.py, which does its own unconditional
+# `import torch` at module scope (Workflow.run() uses torch.Generator() for
+# seeding) - so torch loads regardless of what this module does. Making the
+# import here lazy without also restructuring dw/workflow.py's random-seed
+# handling would just move the cost around, not remove it, and touching
+# dw/workflow.py's import structure is a larger, riskier change than this
+# fix pass is meant to make. Left eager on purpose; see the audit notes for
+# why a real fix needs to start in dw/workflow.py, not here.
+try:
+    import torch
+    import diffusers
+    from packaging import version
+
+    _TORCH_AVAILABLE = True
+except ImportError as e:
+    _TORCH_AVAILABLE = False
+    _TORCH_IMPORT_ERROR = e
+    # Create dummy objects to prevent AttributeError
+    torch = None
+    diffusers = None
+    version = None
+
+
+def _read_version():
+    # Single-sourced from pyproject.toml. Read as text rather than TOML:
+    # tomllib is 3.11+ and this project supports 3.10. In a wheel install
+    # there is no pyproject on disk - the package metadata carries it.
+    try:
+        pyproject = os.path.join(os.path.dirname(__file__), "..", "pyproject.toml")
+        with open(pyproject, encoding="utf-8") as f:
+            match = re.search(r'^version = "([^"]+)"$', f.read(), re.MULTILINE)
+        if match:
+            return match.group(1)
+    except OSError:
+        pass
+    try:
+        from importlib.metadata import version
+
+        return version("diffusers-workflow")
+    except Exception:
+        return "unknown"
+
+
+__version__ = _read_version()
+
+settings = load_settings()
+
+
+def detect_device():
+    """
+    Detect the best device available on this machine.
+    Priority: CUDA > MPS > CPU
+
+    Returns:
+        str: Device identifier ('cuda', 'mps', or 'cpu')
+    """
+    if not _TORCH_AVAILABLE:
+        return "cpu"
+
+    if torch.cuda.is_available():
+        return "cuda"
+
+    if hasattr(torch.backends, "mps") and torch.backends.mps.is_available():
+        return "mps"
+
+    return "cpu"
+
+
+def get_device():
+    """
+    Get the device to run on.
+
+    An explicit choice wins over detection - the DW_DEVICE environment variable for a
+    single run, or the 'device' setting for a standing one. Either can name a specific
+    accelerator ('cuda:1'), force a CPU run to rule out a GPU-specific problem, or pin
+    a machine that has both to one backend.
+
+    Returns:
+        str: Device identifier ('cuda', 'cuda:1', 'mps', 'cpu', ...)
+    """
+    if not _TORCH_AVAILABLE:
+        return "cpu"
+
+    configured_device = os.environ.get("DW_DEVICE") or settings.device
+    if configured_device:
+        try:
+            # Only checks that torch understands the name - whether the machine has
+            # that device surfaces when a model is loaded onto it
+            torch.device(configured_device)
+            return configured_device
+        except (RuntimeError, TypeError, ValueError) as e:
+            logging.warning(f"Ignoring invalid configured device: {e}")
+
+    return detect_device()
+
+
+def get_device_type(device=None):
+    """
+    Get the backend a device belongs to - 'cuda' for 'cuda:1', 'mps' for 'mps'.
+
+    A device identifier can carry an index, so comparisons against a backend name have
+    to be made on the type alone or a device like 'cuda:1' matches nothing.
+
+    Args:
+        device: Device identifier, or None to use the device dw is running on
+
+    Returns:
+        str: Backend name ('cuda', 'mps', 'xpu', 'cpu', ...)
+    """
+    if not _TORCH_AVAILABLE:
+        return "cpu"
+
+    return torch.device(device if device is not None else get_device()).type
+
+
+def backend_available(device_type):
+    """
+    Whether this machine can actually run on a backend.
+
+    Only the backends dw knows how to probe get an answer. An unrecognized one is
+    reported available rather than guessed at, so a device torch understands and dw
+    does not is left alone instead of being rewritten.
+
+    Args:
+        device_type: Backend name ('cuda', 'mps', 'cpu', ...)
+
+    Returns:
+        bool: Whether the backend is usable here
+    """
+    if not _TORCH_AVAILABLE:
+        return device_type == "cpu"
+
+    if device_type == "cpu":
+        return True
+
+    if device_type == "cuda":
+        return torch.cuda.is_available()
+
+    if device_type == "mps":
+        return hasattr(torch.backends, "mps") and torch.backends.mps.is_available()
+
+    is_available = getattr(getattr(torch, device_type, None), "is_available", None)
+    return bool(is_available()) if callable(is_available) else True
+
+
+def resolve_device(requested):
+    """
+    Translate a device a workflow asked for into one this machine has.
+
+    A device named in a workflow is nearly always the author saying 'the accelerator'
+    rather than 'specifically NVIDIA', so a workflow written on a CUDA box runs on a
+    Mac and back again. The backend is what gets translated - an index is left alone
+    when the backend matches, since 'cuda:1' on a single-GPU CUDA box is a genuine
+    mistake and not a portability problem. A CPU device is never rewritten: pinning a
+    step to the CPU is how a GPU-specific problem gets ruled out.
+
+    Args:
+        requested: Device identifier from a workflow, or None for no override
+
+    Returns:
+        The device to use, or None if None was passed
+    """
+    if requested is None or not _TORCH_AVAILABLE:
+        return requested
+
+    try:
+        device = torch.device(requested)
+    except (RuntimeError, TypeError, ValueError):
+        # Not a device torch understands - let the failure surface where it is used
+        return requested
+
+    if device.type == "cpu" or backend_available(device.type):
+        return requested
+
+    target = get_device()
+    if device.index is not None:
+        logging.warning(
+            f"Workflow asks for '{requested}', which this machine has no {device.type} "
+            f"backend for - running on {target}. The device index is dropped, so a "
+            "workflow that meant to spread work across accelerators will not."
+        )
+    else:
+        logging.warning(
+            f"Workflow asks for '{requested}', which this machine has no {device.type} "
+            f"backend for - running on {target}"
+        )
+
+    return target
+
+
+def get_autocast_device_type():
+    """
+    Get the device type to use for torch.autocast.
+    MPS doesn't support autocast, so use 'cpu' for MPS devices.
+
+    Returns:
+        str: Device type for autocast ('cuda' or 'cpu')
+    """
+    if get_device_type() == "cuda":
+        return "cuda"
+
+    # MPS and CPU both use 'cpu' for autocast
+    return "cpu"
+
+
+def preferred_task_dtype(device=None):
+    """
+    Get the preferred torch dtype for a lightweight inference task (captioning,
+    text generation, diffusion upscaling, depth estimation).
+
+    fp16 produces NaN values on MPS and is unsupported by many CPU operations,
+    so only CUDA gets it - everything else runs in fp32.
+
+    Args:
+        device: Device identifier, or None to use the device dw is running on
+
+    Returns:
+        torch.dtype: torch.float16 on CUDA, torch.float32 otherwise (or None
+            if torch isn't available)
+    """
+    if not _TORCH_AVAILABLE:
+        return None
+
+    return torch.float16 if get_device_type(device) == "cuda" else torch.float32
+
+
+def empty_device_cache(synchronize=False):
+    """
+    Empty the allocator cache of the device dw is configured for, if its
+    backend has one. A no-op on CPU.
+
+    Dispatch honors the DW_DEVICE/settings override (via get_device_type())
+    but also checks the backend's own availability before calling into it,
+    matching the belt-and-suspenders checks the call sites used to do
+    individually.
+
+    Args:
+        synchronize: Also block until pending device work completes before
+            returning. Skipped by default - it's expensive and callers on a
+            hot path (e.g. between-run cleanup) don't need it.
+    """
+    if not _TORCH_AVAILABLE:
+        return
+
+    device_type = get_device_type()
+    if device_type == "cuda" and torch.cuda.is_available():
+        torch.cuda.empty_cache()
+        if synchronize:
+            torch.cuda.synchronize()
+    elif (
+        device_type == "mps"
+        and hasattr(torch.backends, "mps")
+        and torch.backends.mps.is_available()
+    ):
+        if hasattr(torch.mps, "empty_cache"):
+            torch.mps.empty_cache()
+        if synchronize and hasattr(torch.mps, "synchronize"):
+            torch.mps.synchronize()
+
+
+def device_memory_stats():
+    """
+    Snapshot of allocator memory usage for the device dw is configured for.
+
+    Only CUDA exposes free/total figures (via torch.cuda.mem_get_info); MPS
+    has no equivalent API, so its snapshot reports zeroed, "known" values
+    instead. CPU, or a CUDA/MPS backend that isn't actually available despite
+    being the configured device type, results in an "unavailable" snapshot.
+
+    Returns:
+        dict with keys:
+            available (bool): whether the backend could be queried
+            device_name (str or None)
+            allocated_mb (float)
+            reserved_mb (float)
+            free_mb (float or None): None only when CUDA's mem_get_info call
+                itself fails
+            total_mb (float or None): None only when CUDA's mem_get_info call
+                itself fails
+    """
+    stats = {
+        "available": False,
+        "device_name": None,
+        "allocated_mb": 0.0,
+        "reserved_mb": 0.0,
+        "free_mb": None,
+        "total_mb": None,
+    }
+
+    if not _TORCH_AVAILABLE:
+        return stats
+
+    device_type = get_device_type()
+    if device_type == "cuda" and torch.cuda.is_available():
+        stats["available"] = True
+        stats["device_name"] = torch.cuda.get_device_name(0)
+        stats["allocated_mb"] = torch.cuda.memory_allocated() / 1024 / 1024
+        stats["reserved_mb"] = torch.cuda.memory_reserved() / 1024 / 1024
+        try:
+            free, total = torch.cuda.mem_get_info()
+            stats["free_mb"] = free / 1024 / 1024
+            stats["total_mb"] = total / 1024 / 1024
+        except (RuntimeError, AttributeError):
+            pass
+    elif (
+        device_type == "mps"
+        and hasattr(torch.backends, "mps")
+        and torch.backends.mps.is_available()
+    ):
+        # MPS doesn't provide detailed memory stats like CUDA
+        stats["available"] = True
+        stats["device_name"] = "Apple Silicon (MPS)"
+        stats["free_mb"] = 0.0
+        stats["total_mb"] = 0.0
+
+    return stats
+
+
+def startup(log_level=None):
+    if not _TORCH_AVAILABLE:
+        raise ImportError(
+            f"PyTorch is not available. {_TORCH_IMPORT_ERROR}\n"
+            "Please ensure you're using the virtual environment where torch is installed.\n"
+            "Activate the venv: source venv/bin/activate"
+        )
+
+    # The default torch device is deliberately left alone. Diffusers loads weights into
+    # system memory and then places them - moving them to the device, or hooking them
+    # for offloading. A default device of 'cuda' pre-empts that by building every module
+    # directly in VRAM, which runs a large pipeline out of memory before its offload
+    # hooks are ever installed. Device placement is explicit throughout dw instead.
+    device = get_device()
+    device_type = get_device_type(device)
+
+    # MPS-specific configuration (Apple Silicon)
+    if device_type == "mps":
+        # Suppress autocast warnings (MPS doesn't support autocast,
+        # and libraries may try to use it with 'cuda' device_type)
+        warnings.filterwarnings(
+            "ignore",
+            message=".*User provided device_type of 'cuda'.*",
+            category=UserWarning,
+            module="torch.amp.autocast_mode",
+        )
+
+        logging.info(
+            f"MPS backend - watermark ratio: "
+            f"{os.environ.get('PYTORCH_MPS_HIGH_WATERMARK_RATIO', 'default')}"
+        )
+
+    # Check if we have a GPU backend (CUDA or MPS)
+    if device_type == "cpu":
+        logging.warning(
+            "No GPU backend available (CUDA or MPS). Running on CPU may be slow."
+        )
+
+    if version.parse(torch.__version__) < version.parse("2.0.0"):
+        raise Exception(
+            f"Pytorch must be 2.0 or greater (found {torch.__version__}). Run install script. Quitting."
+        )
+
+    if log_level is not None:
+        settings.log_level = log_level
+
+    setup_logging(
+        resolve_path(settings.log_filename),
+        settings.log_level,
+        log_to_console=settings.log_to_console,
+    )
+
+    logging.info(f"Version {__version__}")
+    logging.debug(f"Torch version {torch.__version__}")
+    logging.info(f"Using device: {device}")
+
+    diffusers.logging.set_verbosity_error()
+
+    # TF32 optimization (Ampere+ GPUs: RTX 30/40 series, A100, H100)
+    # Provides ~2x speedup for matmul operations with minimal precision loss
+    if settings.enable_tf32:
+        torch.set_float32_matmul_precision("high")
+        if device_type == "cuda":
+            torch.backends.cuda.matmul.allow_tf32 = True
+        logging.debug("TF32 precision enabled for faster matmul operations")
+    else:
+        logging.debug("TF32 precision disabled (full FP32 precision)")
+
+    # CUDA-specific optimizations
+    if device_type == "cuda":
+        # cuDNN autotuner - benchmarks algorithms and selects fastest
+        # Best for fixed input sizes, may slow down variable-size workflows
+        torch.backends.cudnn.benchmark = settings.cudnn_benchmark
+
+        # Always enable cuDNN (default anyway)
+        torch.backends.cudnn.enabled = True
+
+        # Deterministic mode - set True for reproducibility (same seed = same output)
+        # False prioritizes performance over strict reproducibility
+        torch.backends.cudnn.deterministic = settings.cudnn_deterministic
+
+        logging.debug(
+            f"CUDA optimizations - benchmark: {settings.cudnn_benchmark}, "
+            f"deterministic: {settings.cudnn_deterministic}"
+        )