blender-pyutils 2025.2__py3-none-any.whl

blender_pyutils/__init__.py

@@ -0,0 +1,2 @@
+#!/usr/bin/env python3
+"""Package stub."""

blender_pyutils/blender_wrapper.py

@@ -0,0 +1,229 @@
+#!/usr/bin/env python3
+"""Invoke the Blender executable."""
+
+import functools
+import logging
+import pathlib
+import shutil
+import subprocess
+import tempfile
+import textwrap
+import tomllib
+
+import tomli_w
+from xdg.BaseDirectory import xdg_config_home
+
+from .common import ENCODING
+from .exceptions import BlenderError, PipError
+from .utils import run
+
+LOGGER = logging.getLogger(__name__)
+
+
+class BlenderWrapper:
+    """
+    Simple wrapper around the Blender command-line executable.
+    """
+
+    def __init__(self, exe="blender", ext_dir=None):
+        """
+        Args:
+            exe:
+                The blender command to execute.
+
+            ext_dir:
+                The path to the directory with the extension to validate and
+                build.
+        """
+        self.exe = str(exe)
+        if ext_dir is None:
+            ext_dir = pathlib.Path.cwd()
+        else:
+            ext_dir = pathlib.Path(ext_dir).resolve()
+        self.ext_dir = ext_dir
+
+    def run_blender(self, args, **kwargs):
+        """
+        Invoke blender.
+
+        Args:
+            Arguments to pass to the blender command.
+
+        **kwargs:
+            Keyword arguments passed through to subprocess.run().
+
+        Returns:
+            The return value of subprocess.run()
+        """
+        return run((self.exe, *args), **kwargs)
+
+    @functools.cached_property
+    def info(self):
+        """
+        A dict with information about Blender and its embedded Python
+        environment. It contains the following keys:
+            Blender version:
+                The Blender version.
+
+            Python version:
+                The Python version.
+
+            Python executable:
+                The path to the Python executable.
+        """
+        delim = "###"
+        blver = "Blender version"
+        blmoddir = "Blender module directory"
+        pyver = "Python version"
+        pyexe = "Python executable"
+        code = textwrap.dedent(
+            f"""\
+            import sys
+            import bpy
+            print(f'{blver}{delim}{{bpy.app.version_string}}')
+            ver = sys.version_info
+            print(f'{pyver}{delim}{{ver.major}}.{{ver.minor}}.{{ver.micro}}')
+            print(f'{pyexe}{delim}{{sys.executable}}')
+            bpy.ops.wm.quit_blender()
+            """
+        )
+        cmd = ["--background", "--python-expr", code]
+        try:
+            response = self.run_blender(cmd, stdout=subprocess.PIPE)
+        except subprocess.CalledProcessError as err:
+            raise BlenderError(
+                f"Failed to determine Blender's Python version: {err}"
+            ) from err
+        info = {}
+        for line in response.stdout.decode(ENCODING).splitlines():
+            try:
+                key, value = line.strip().split(delim, 1)
+            except ValueError:
+                continue
+            value = value.strip()
+            if key == pyexe:
+                value = pathlib.Path(value).resolve()
+            info[key] = value
+
+        bldir = ".".join(info[blver].split(".", 2)[:2])
+        info[blmoddir] = (
+            pathlib.Path(xdg_config_home) / "blender" / bldir / "scripts/modules"
+        )
+
+        return info
+
+    def run_python(self, args, **kwargs):
+        """
+        Invoke Blender's Python interpreter.
+
+        Args:
+            Arguments to pass to the python command.
+
+        **kwargs:
+            Keyword arguments passed through to subprocess.run().
+
+        Returns:
+            The return value of subprocess.run()
+        """
+        return run((self.info["Python executable"], *args), **kwargs)
+
+    def validate(self):
+        """
+        Validate the extension.
+        """
+        try:
+            self.run_blender(["--command", "extension", "validate"])
+        except subprocess.CalledProcessError as err:
+            raise BlenderError(f"Failed to validate the extension: {err}") from err
+        LOGGER.info("The extension has been validated.")
+
+    def download_wheel_deps(self, wheels_dir="wheels"):
+        """
+        Download the wheels of all external dependencies to the local wheel
+        directory and update the manifest to point to them.
+        """
+        wheels_dir = self.ext_dir / wheels_dir
+        wheels_dir.mkdir(parents=True, exist_ok=True)
+        req_file = self.ext_dir / "requirements.txt"
+        LOGGER.info("Downloading wheels...")
+        try:
+            self.run_python(
+                (
+                    "-m",
+                    "pip",
+                    "wheel",
+                    "-w",
+                    wheels_dir,
+                    "-r",
+                    req_file,
+                )
+            )
+        except subprocess.CalledProcessError as err:
+            raise PipError(f"Failed to download dependency wheels: {err}") from err
+
+        manifest_file = self.ext_dir / "blender_manifest.toml"
+        LOGGER.info("Loading %s", manifest_file)
+        with manifest_file.open("rb") as handle:
+            manifest = tomllib.load(handle)
+        manifest["wheels"] = sorted(
+            str(p.relative_to(manifest_file.parent)) for p in wheels_dir.glob("*.whl")
+        )
+
+        # Write the updated manifest to a temporary file to avoid truncating the
+        # original on error. The temporary file is moved into place on
+        # success.
+        manifest_tmp_file = manifest_file.with_suffix(".tmp.toml")
+        with manifest_tmp_file.open("wb") as handle:
+            tomli_w.dump(manifest, handle)
+        LOGGER.info("Saving updated wheels to %s", manifest_file)
+        shutil.move(manifest_tmp_file, manifest_file)
+
+    def build(self):
+        """
+        Build the extension (i.e. the .zip file).
+        """
+        try:
+            self.run_blender(["--command", "extension", "build"])
+        except subprocess.CalledProcessError as err:
+            raise BlenderError(f"Failed to build the extension: {err}") from err
+        LOGGER.info("The extension has been built.")
+
+    def pip(self, args, path=None, uv=False):
+        """
+        Manage Python packages in Blender's module directory with pip or uv.
+
+        Args:
+            args:
+                Arguments to pass through to the pip command.
+
+            path:
+                The target directory. If None, the default location will be
+                used.
+
+            uv:
+                If True, use "uv pip" instead of pip.
+        """
+        if path is None:
+            path = self.info["Blender module directory"]
+        else:
+            path = pathlib.Path(path).resolve()
+        LOGGER.info("Pip target directory: %s", path)
+        LOGGER.info("Creating temporary Python virtual environment.")
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            tmp_dir = pathlib.Path(tmp_dir)
+            venv_dir = tmp_dir / "venv"
+            self.run_python(("-m", "venv", venv_dir))
+            py_exe = venv_dir / "bin/python"
+            LOGGER.info("Ensuring pip in the virtual environment.")
+            run([py_exe, "-m", "ensurepip", "-U"])
+            run([py_exe, "-m", "pip", "install", "-U", "pip"])
+            if uv:
+                LOGGER.info("Installing uv in virtual environment.")
+                run((py_exe, "-m", "pip", "install", "-U", "uv"))
+                cmd = ("uv", "pip")
+            else:
+                cmd = ("pip",)
+            try:
+                run((py_exe, "-m", *cmd, *args, "--target", path))
+            except subprocess.CalledProcessError as err:
+                raise PipError(f"Failed to run pip command: {err}") from err

blender_pyutils/common.py

@@ -0,0 +1,5 @@
+#!/usr/bin/env python3
+"""Common constants."""
+
+
+ENCODING = "utf-8"

blender_pyutils/exceptions.py

@@ -0,0 +1,18 @@
+#!/usr/bin/env python
+"""Custom exceptions."""
+
+
+class BlenderPythonUtilsError(Exception):
+    """Base class for custom exceptions raised by this module."""
+
+
+class SubprocessError(BlenderPythonUtilsError):
+    """Errors raised by subprocess calls."""
+
+
+class BlenderError(SubprocessError):
+    """Errors raised when invoking the Blender executable."""
+
+
+class PipError(SubprocessError):
+    """Errors raised when invoking pip."""

blender_pyutils/main.py

@@ -0,0 +1,142 @@
+#!/usr/bin/env python3
+"""Utility script for validating and packaging Blender extensions."""
+
+import argparse
+import logging
+import pathlib
+import sys
+
+from .blender_wrapper import BlenderWrapper
+from .exceptions import BlenderPythonUtilsError
+
+LOGGER = logging.getLogger(__name__)
+
+
+def configure_logging(level=logging.INFO):
+    """
+    Configure logging.
+
+    Args:
+        level:
+            The logging level.
+    """
+    logging.basicConfig(
+        style="{",
+        format="[{asctime}] {levelname} {message}",
+        datefmt="%Y-%m-%d %H:%M:%S",
+        level=level,
+    )
+
+
+class CommandRunner:
+    """
+    Run selected commands. The only real purpose of this class is to avoid
+    redundant subprocess calls to retrieve Blender information.
+    """
+
+    def __init__(self):
+        self.blender = BlenderWrapper()
+
+    def info(self, _pargs):
+        """
+        Print Blender information.
+        """
+        for key, value in sorted(self.blender.info.items()):
+            print(f"{key}: {value}")
+
+    def build(self, pargs):
+        """
+        Validate and build an extension. If a requirements.txt file is found in the
+        extension directory then the wheels for its dependencies will be downloaded
+        to the wheels directory and the manifest will be updated to include them.
+        """
+        bld = self.blender
+        bld.ext_dir = pargs.path
+        bld.download_wheel_deps()
+        bld.validate()
+        bld.build()
+
+    def pip(self, pargs):
+        """
+        Install Python packages to Blender's module directory. Additional
+        arguments as passed through to pip.
+        """
+        self.blender.pip(pargs.pip_args, path=pargs.path, uv=pargs.uv)
+
+
+def main(args=None):
+    """
+    Main function.
+
+    Args:
+        args:
+            Passed through to ArgumentParser.parse_args().
+    """
+    cmd_runner = CommandRunner()
+
+    parser = argparse.ArgumentParser(description=__doc__)
+    subparsers = parser.add_subparsers(required=True)
+
+    parser_info = subparsers.add_parser("info", description=cmd_runner.info.__doc__)
+    parser_info.set_defaults(func=cmd_runner.info)
+
+    parser_build = subparsers.add_parser("build", description=cmd_runner.build.__doc__)
+    parser_build.add_argument(
+        "-p",
+        "--path",
+        type=pathlib.Path,
+        help=(
+            "The path to the extension's root directory. "
+            "If not given, the current working directory is assumed."
+        ),
+    )
+    parser_build.set_defaults(func=cmd_runner.build)
+
+    parser_pip = subparsers.add_parser("pip", description=cmd_runner.pip.__doc__)
+    parser_pip.add_argument(
+        "--path",
+        type=pathlib.Path,
+        help=(
+            "Installation directory for Python packages. "
+            "If not given, the default Blender module directory will be used. "
+            'Use the "info" command to show the path to the module directory.'
+        ),
+    )
+    parser_pip.add_argument(
+        "--uv", action="store_true", help='Use "uv pip" instead of pip.'
+    )
+    parser_pip.add_argument(
+        "pip_args",
+        nargs="+",
+        help=(
+            "Arguments to pass through to pip. "
+            'Precede these arguments with "--" if any of them begin with "-".'
+        ),
+        metavar="<PIP ARG>",
+    )
+    parser_pip.set_defaults(func=cmd_runner.pip)
+
+    pargs = parser.parse_args(args)
+    pargs.func(pargs)
+
+
+def run_main(*args, **kwargs):
+    """
+    Run the main function with exception handling.
+
+    Args:
+        *args:
+            Positional arguments passed through to main().
+
+        **kwargs:
+            Keyword arguments passed through to main().
+    """
+    configure_logging()
+    try:
+        main(*args, **kwargs)
+    except BlenderPythonUtilsError as err:
+        sys.exit(err)
+
+
+if __name__ == "__main__":
+    run_main()

blender_pyutils/utils.py

@@ -0,0 +1,29 @@
+#!/usr/bin/env python3
+"""Utility functions."""
+
+
+import logging
+import subprocess
+
+LOGGER = logging.getLogger(__name__)
+
+
+def run(cmd, **kwargs):
+    """
+    Run a command with subprocess.run.
+
+    Args:
+        cmd:
+            The command to run.
+
+        **kwargs:
+            Keyword arguments passed through to subprocess.run().
+
+    Returns:
+        The return value of subprocess.run().
+    """
+    cmd = [str(w) for w in cmd]
+    LOGGER.debug("Running command: %s", cmd)
+    kwargs["check"] = kwargs.get("check", True)
+    # pylint: disable=subprocess-run-check
+    return subprocess.run(cmd, **kwargs)

blender_pyutils/version.py

@@ -0,0 +1,9 @@
+#!/usr/bin/env python3
+'''
+Version file automatically generated by setuptools-scm via hatch-vcs.
+https://pypi.org/project/setuptools-scm/
+https://github.com/ofek/hatch-vcs
+Do not track this file and do not edit it manually.
+'''
+VERSION = '2025.2'
+VERSION_TUPLE = (2025, 2)

blender_pyutils-2025.2.dist-info/METADATA

@@ -0,0 +1,191 @@
+Metadata-Version: 2.4
+Name: blender-pyutils
+Version: 2025.2
+Summary: Simple utilities for building and installing Python extensions for Blender.
+Project-URL: Homepage, https://gitlab.inria.fr/jrye/blender-pyutils
+Project-URL: Source, https://gitlab.inria.fr/jrye/blender-pyutils.git
+Project-URL: Documentation, https://jrye.gitlabpages.inria.fr/blender-pyutils
+Project-URL: Issues, https://gitlab.inria.fr/jrye/blender-pyutils/issues
+Author-email: Jan-Michael Rye <jan-michael.rye@inria.fr>
+License: MIT License
+        
+        Copyright (c) 2025, Inria
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+License-File: LICENSE.txt
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.7
+Requires-Dist: pyxdg
+Requires-Dist: tomli-w
+Description-Content-Type: text/markdown
+
+[insert: badges gitlab]: #
+
+[![Hatch](https://img.shields.io/badge/%F0%9F%A5%9A-Hatch-4051b5.svg)](https://github.com/pypa/hatch) [![Latest Release](https://gitlab.inria.fr/jrye/blender-pyutils/-/badges/release.svg)](https://gitlab.inria.fr/jrye/blender-pyutils/-/tags) [![License](https://img.shields.io/badge/license-MIT-9400d3.svg)](https://spdx.org/licenses/MIT.html) [![Pipeline Status](https://gitlab.inria.fr/jrye/blender-pyutils/badges/main/pipeline.svg)](https://gitlab.inria.fr/jrye/blender-pyutils/-/commits/main) [![Pylint](https://gitlab.inria.fr/jrye/blender-pyutils/-/jobs/artifacts/main/raw/pylint/pylint.svg?job=pylint)](https://gitlab.inria.fr/jrye/blender-pyutils/-/jobs/artifacts/main/raw/pylint/pylint.txt?job=pylint)
+
+[/insert: badges gitlab]: #
+
+# Synopsis
+
+This is a small Python package that installs a command-line utility to facilitate extension installation in [Blender](https://www.blender.org/). It currently provides the following functionality:
+
+
+* Print information about Blender and its internal Python environment.
+* Validate and build Blender extensions, including their dependency wheels.
+* Install Python packages directly into Blender's modules directory.
+
+## Links
+
+[insert: links 2]: #
+
+### GitLab
+
+* [Homepage](https://gitlab.inria.fr/jrye/blender-pyutils)
+* [Source](https://gitlab.inria.fr/jrye/blender-pyutils.git)
+* [Issues](https://gitlab.inria.fr/jrye/blender-pyutils/issues)
+* [Documentation](https://jrye.gitlabpages.inria.fr/blender-pyutils)
+* [GitLab package registry](https://gitlab.inria.fr/jrye/blender-pyutils/-/packages)
+
+### Other Repositories
+
+* [Software Heritage](https://archive.softwareheritage.org/browse/origin/?origin_url=https%3A//gitlab.inria.fr/jrye/blender-pyutils.git)
+
+[/insert: links 2]: #
+
+
+
+# Usage
+
+Install this package, preferably in a Python virtual environment.
+
+~~~sh
+# Create the virtual environment.
+python3 -m venv
+
+# Activate it.
+source venv/bin/activate
+
+# Ensure that pip is installed and up-to-date.
+python3 -m ensure pip
+pip install -U pip
+
+# Install this package.
+pip install -U Blender Python Utils
+~~~
+
+## blender-pytuils Executable
+
+The package will install the `blender-pyutils` command that accepts different subcommands as arguments.
+
+[insert: command_output: blender-pyutils --help]: #
+
+~~~
+usage: blender-pyutils [-h] {info,build,pip} ...
+
+Utility script for validating and packaging Blender extensions.
+
+positional arguments:
+  {info,build,pip}
+
+options:
+  -h, --help        show this help message and exit
+
+~~~
+
+[/insert: command_output: blender-pyutils --help]: #
+
+### `info` Subcommand
+
+The `info` subcommand will print information about Blender's version, module directory path and configured Python executable.
+
+[insert: command_output: blender-pyutils info --help]: #
+
+~~~
+usage: blender-pyutils info [-h]
+
+Print Blender information.
+
+options:
+  -h, --help  show this help message and exit
+
+~~~
+
+[/insert: command_output: blender-pyutils info --help]: #
+
+
+### `build` Subcommand
+
+The `build` subommand will validate and build a Blender extension. If a `requirements.txt` file is found in the extension directory then it will also download the dependency wheels to the `wheels` subdirectory and add them to the `blender_manifest.toml`.
+
+[insert: command_output: blender-pyutils build --help]: #
+
+~~~
+usage: blender-pyutils build [-h] [-p PATH]
+
+Validate and build an extension. If a requirements.txt file is found in the
+extension directory then the wheels for its dependencies will be downloaded to
+the wheels directory and the manifest will be updated to include them.
+
+options:
+  -h, --help       show this help message and exit
+  -p, --path PATH  The path to the extension's root directory. If not given,
+                   the current working directory is assumed.
+
+~~~
+
+[/insert: command_output: blender-pyutils build --help]: #
+
+### `pip` Subcommand
+
+The `pip` subcommand will install Python packages directly to Blender's modules directory. It accepts the same commands as `pip`.
+
+~~~sh
+# Example: install scipy using pip
+blender-pyutils pip install scipy
+
+# Example: install scipy using uv
+blender-pyutils pip --uv install scipy
+
+# Example: use "--" to pass through options to pip, such as a requirements.txt file
+blender-pyutils pip -- install -U -r requirements.txt
+~~~
+
+[insert: command_output: blender-pyutils pip --help]: #
+
+~~~
+usage: blender-pyutils pip [-h] [--path PATH] [--uv] <PIP ARG> [<PIP ARG> ...]
+
+Install Python packages to Blender's module directory. Additional arguments as
+passed through to pip.
+
+positional arguments:
+  <PIP ARG>    Arguments to pass through to pip. Precede these arguments with
+               "--" if any of them begin with "-".
+
+options:
+  -h, --help   show this help message and exit
+  --path PATH  Installation directory for Python packages. If not given, the
+               default Blender module directory will be used. Use the "info"
+               command to show the path to the module directory.
+  --uv         Use "uv pip" instead of pip.
+
+~~~
+
+[/insert: command_output: blender-pyutils pip --help]: #
+
+#### Caveats
+
+* At the time or writing, Blender does not recognize packages installed with [pip's editable option (-e/--editiable)](https://pip.pypa.io/en/stable/cli/pip_install/).
+* Packages must be installed before launching Blender.
+
+
+#### Legacy Script
+
+This repository originally only provided [blender-pip_install.sh](blender-pip_install.sh) as a wrapper around `pip install` and `uv pip install`. It has been superceded by `blender-pyutils pip` and users should migrate accordingly.
+

blender_pyutils-2025.2.dist-info/RECORD

@@ -0,0 +1,12 @@
+blender_pyutils/__init__.py,sha256=NX3VQ0ZDvrZ_aLmHCQaSPLL38yArwPpRDoC5Cyb-k7g,43
+blender_pyutils/blender_wrapper.py,sha256=TENBESp6acgEcYf_G_99TkDd7c_lD184YVxpU0CxEnc,7509
+blender_pyutils/common.py,sha256=hjVPhkcEvbtbIJbyM5P0yqqTc5GAi1dnsBYb2Re-sTY,68
+blender_pyutils/exceptions.py,sha256=L4ytXmhq_faO2h2aqLA8wXxxbL1cWmGHcP7Ue9Rijv0,431
+blender_pyutils/main.py,sha256=BJsptA4I-ewYeKnNsUEVOJjwYMt3jvAItHijkGkcHVM,3822
+blender_pyutils/utils.py,sha256=ljuFuXEV8s2BzX2R8sTTKh_WS5ifUw0RbR8td-LmHzI,612
+blender_pyutils/version.py,sha256=MyfNAMQbnFV-0l7nVy1e9fhTwBwxxmPyDXqo0BVw5a4,273
+blender_pyutils-2025.2.dist-info/METADATA,sha256=21H2yeoNElOyxl3niT76yS5QQYOtLDkhsHnWW6DNB-Q,7462
+blender_pyutils-2025.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+blender_pyutils-2025.2.dist-info/entry_points.txt,sha256=Wa1uzefC5LtB5KrQg0lMDHT8Tv8rNUPz8SwgjcHgxfg,66
+blender_pyutils-2025.2.dist-info/licenses/LICENSE.txt,sha256=vmijgBBvVdO2IJ1lTOrkBE98NnHVf7Ek6JA9Uc9do0g,1063
+blender_pyutils-2025.2.dist-info/RECORD,,

blender_pyutils-2025.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

blender_pyutils-2025.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+blender-pyutils = blender_pyutils.main:run_main

blender_pyutils-2025.2.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2025, Inria
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.