arkitekt-service 1.0.0__tar.gz

arkitekt_service-1.0.0/.gitignore

@@ -0,0 +1,153 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+**/__pycache__
+*.py[cod]
+*$py.class
+*.pyc
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# static files generated from Django application using `collectstatic`
+media
+export
+static_collected
+data
+
+*.token.temp
+*.fakts.yaml
+fakts.yaml
+# Local-source override for the integration stack (see tests/conftest.py)
+tests/integration/docker-compose.local.yml

arkitekt_service-1.0.0/PKG-INFO

@@ -0,0 +1,112 @@
+Metadata-Version: 2.5
+Name: arkitekt-service
+Version: 1.0.0
+Summary: What a service of an Arkitekt hub is made with: the contract its image answers the installer, its declaration to rekuest, and its hook agent
+Author-email: jhnnsrs <jhnnsrs@gmail.com>
+License: MIT
+Requires-Python: <4,>=3.12
+Requires-Dist: django>=5
+Requires-Dist: httpx>=0.27
+Requires-Dist: joserfc>=1.7
+Requires-Dist: pydantic-settings>=2.3
+Requires-Dist: pydantic>=2.7
+Requires-Dist: pyyaml>=6
+Provides-Extra: koherent
+Requires-Dist: koherent>=4.1; extra == 'koherent'
+Description-Content-Type: text/markdown
+
+# arkitekt-service
+
+What a service of an [Arkitekt](https://arkitekt.live) hub is made with. Three parts, for three
+different things a service process does:
+
+| | |
+|---|---|
+| `arkitekt_service.contract` | What the service's **image** answers the hub's installer: what it needs, its own config written from the hub's facts, its migrations and upgrades. |
+| `arkitekt_service.service` | What the service **is** to the hub's rekuest: the structures it hosts and the signals it emits. |
+| `arkitekt_service.hook` | What can be **done** in its process: a HookAgent, whose actions rekuest reaches over HTTP. |
+
+They share `arkitekt_service.trust` — no secrets between services: every instance signs with
+its own key and the hub vouches for the public halves — and nothing else. A process uses any of
+them without the others.
+
+```
+pip install arkitekt-service
+```
+
+## The contract
+
+Every service image answers the same entry point:
+
+```
+python -m arkitekt_service describe    # what it needs from a hub and offers to it (JSON)
+python -m arkitekt_service render      # this release's config, from the hub's facts
+python -m arkitekt_service check       # does this release read a config as written?
+python -m arkitekt_service migrate     # its database migrations, as a step
+python -m arkitekt_service upgrade --from 5.2.0 --to 6.0.0
+```
+
+An installer (Konstruktor) then needs to know the hub, and nothing about a service that the
+service's image does not say. How a release spells its config, which keys it renamed, what it
+has to do to its data — all of that ships in the image, with the code it belongs to. Exit code
+`78` is a release's own refusal (facts it cannot be configured from, a setting it does not
+read), with the reason on stderr.
+
+A service declares itself in one module, named by `ARKITEKT_SERVICE` in its Dockerfile:
+
+```python
+from arkitekt_service.contract import JSON, Contract, Description, Facts, Needs, Offers, blocks
+
+
+def render(facts: Facts) -> dict[str, JSON]:
+    document = blocks.server(facts)  # django, postgres, redis, authentikate
+    document["datalayer"] = blocks.datalayer(facts, "media", "zarr")
+    return document
+
+
+contract = Contract(
+    description=Description(name="mikro", needs=Needs(storage=["media", "zarr"])),
+    settings=Settings,
+    render=render,
+)
+```
+
+The hub's facts (`arkitekt_service.contract.facts`) and a service's description
+(`arkitekt_service.contract.description`) are versioned documents; an image refuses facts it
+does not understand rather than dropping them.
+
+## A service, and a hook agent
+
+```python
+from arkitekt_service.service import Descriptor, Service, organization_of
+from arkitekt_service.hook import HookAgent
+
+service = Service("mikro", description="Microscopy data")
+dataset = service.structure(ArrayDataset, "@mikro/arraydataset", descriptors=[Descriptor("@mikro/n_channels", "INT")], describe=array_descriptors)
+service.model_signal(dataset, organization=organization_of())
+
+agent = HookAgent("mikro", description="mikro's housekeeping")
+
+
+@agent.action
+def reembed_stale(organization: str) -> dict:
+    """Re-embed stale rows."""
+    ...
+
+
+urlpatterns = [..., *service.urls, *agent.urls]
+```
+
+A service says what exists; an agent says what can be done. Neither knows the other.
+
+## Development
+
+```
+uv sync
+uv run pytest                                          # the contract and the service
+uv run pytest tests/hook --ds=hook_project.settings    # the hook agent: a process that is no service
+uv run basedpyright
+```
+
+Releases are cut from conventional commits on `main` (tag-only, like the other Arkitekt
+packages) and uploaded to PyPI.

arkitekt_service-1.0.0/README.md

@@ -0,0 +1,95 @@
+# arkitekt-service
+
+What a service of an [Arkitekt](https://arkitekt.live) hub is made with. Three parts, for three
+different things a service process does:
+
+| | |
+|---|---|
+| `arkitekt_service.contract` | What the service's **image** answers the hub's installer: what it needs, its own config written from the hub's facts, its migrations and upgrades. |
+| `arkitekt_service.service` | What the service **is** to the hub's rekuest: the structures it hosts and the signals it emits. |
+| `arkitekt_service.hook` | What can be **done** in its process: a HookAgent, whose actions rekuest reaches over HTTP. |
+
+They share `arkitekt_service.trust` — no secrets between services: every instance signs with
+its own key and the hub vouches for the public halves — and nothing else. A process uses any of
+them without the others.
+
+```
+pip install arkitekt-service
+```
+
+## The contract
+
+Every service image answers the same entry point:
+
+```
+python -m arkitekt_service describe    # what it needs from a hub and offers to it (JSON)
+python -m arkitekt_service render      # this release's config, from the hub's facts
+python -m arkitekt_service check       # does this release read a config as written?
+python -m arkitekt_service migrate     # its database migrations, as a step
+python -m arkitekt_service upgrade --from 5.2.0 --to 6.0.0
+```
+
+An installer (Konstruktor) then needs to know the hub, and nothing about a service that the
+service's image does not say. How a release spells its config, which keys it renamed, what it
+has to do to its data — all of that ships in the image, with the code it belongs to. Exit code
+`78` is a release's own refusal (facts it cannot be configured from, a setting it does not
+read), with the reason on stderr.
+
+A service declares itself in one module, named by `ARKITEKT_SERVICE` in its Dockerfile:
+
+```python
+from arkitekt_service.contract import JSON, Contract, Description, Facts, Needs, Offers, blocks
+
+
+def render(facts: Facts) -> dict[str, JSON]:
+    document = blocks.server(facts)  # django, postgres, redis, authentikate
+    document["datalayer"] = blocks.datalayer(facts, "media", "zarr")
+    return document
+
+
+contract = Contract(
+    description=Description(name="mikro", needs=Needs(storage=["media", "zarr"])),
+    settings=Settings,
+    render=render,
+)
+```
+
+The hub's facts (`arkitekt_service.contract.facts`) and a service's description
+(`arkitekt_service.contract.description`) are versioned documents; an image refuses facts it
+does not understand rather than dropping them.
+
+## A service, and a hook agent
+
+```python
+from arkitekt_service.service import Descriptor, Service, organization_of
+from arkitekt_service.hook import HookAgent
+
+service = Service("mikro", description="Microscopy data")
+dataset = service.structure(ArrayDataset, "@mikro/arraydataset", descriptors=[Descriptor("@mikro/n_channels", "INT")], describe=array_descriptors)
+service.model_signal(dataset, organization=organization_of())
+
+agent = HookAgent("mikro", description="mikro's housekeeping")
+
+
+@agent.action
+def reembed_stale(organization: str) -> dict:
+    """Re-embed stale rows."""
+    ...
+
+
+urlpatterns = [..., *service.urls, *agent.urls]
+```
+
+A service says what exists; an agent says what can be done. Neither knows the other.
+
+## Development
+
+```
+uv sync
+uv run pytest                                          # the contract and the service
+uv run pytest tests/hook --ds=hook_project.settings    # the hook agent: a process that is no service
+uv run basedpyright
+```
+
+Releases are cut from conventional commits on `main` (tag-only, like the other Arkitekt
+packages) and uploaded to PyPI.

arkitekt_service-1.0.0/arkitekt_service/__init__.py

@@ -0,0 +1,20 @@
+"""What a service of an Arkitekt hub is made with.
+
+Three parts, for three different things a service process does:
+
+:mod:`arkitekt_service.contract`
+    What its *image* answers the hub's installer, before and around the service running: what
+    it needs, its own config written from the hub's facts, its migrations and upgrades.
+    ``python -m arkitekt_service <verb>``.
+
+:mod:`arkitekt_service.service`
+    What the service *is* to the hub's rekuest: the structures it hosts and the signals it
+    emits.
+
+:mod:`arkitekt_service.hook`
+    What can be *done* in its process: a HookAgent, whose actions rekuest reaches over HTTP.
+
+They share :mod:`arkitekt_service.trust` — no secrets between services: every instance signs
+with its own key, and the hub vouches for the public halves — and nothing else. A process uses
+any of them without the others; only ``contract`` is imported without Django.
+"""

arkitekt_service-1.0.0/arkitekt_service/__main__.py

@@ -0,0 +1,7 @@
+"""``python -m arkitekt_service <verb>``: what this image answers a hub's installer."""
+
+import sys
+
+from arkitekt_service.contract.cli import main
+
+sys.exit(main())

arkitekt_service-1.0.0/arkitekt_service/contract/__init__.py

@@ -0,0 +1,30 @@
+"""What a service image answers a hub's installer.
+
+A hub is a set of service images run together by an installer. The installer knows the hub —
+where the database is, which other services run, which keys they trust — and should know
+nothing about a service beyond what the service's own image tells it. This package is how an
+image tells it: one entry point (``python -m arkitekt_service <verb>``), the same in every image.
+
+==============  ================================================================
+``describe``    what the service needs from a hub and offers to it
+``render``      this release's config, written from the hub's facts
+``check``       whether this release reads a config as written
+``migrate``     the release's database migrations, as a step with an answer
+``upgrade``     what the release does to its data between two versions
+==============  ================================================================
+
+A service declares itself once, in a module named by ``ARKITEKT_SERVICE`` (set in its image)::
+
+    contract = Contract(description=..., settings=Settings, render=render)
+
+See :mod:`arkitekt_service.contract.facts` for what a hub says, :mod:`arkitekt_service.contract.description` for what a
+service says, and :mod:`arkitekt_service.contract.cli` for the verbs and their exit codes.
+"""
+
+from arkitekt_service.contract import blocks
+from arkitekt_service.contract.contract import Contract, Refused
+from arkitekt_service.contract.description import Description, Needs, Offers, Scope
+from arkitekt_service.contract.facts import Facts, Peer
+from arkitekt_service.contract.json_types import JSON
+
+__all__ = ["JSON", "Contract", "Description", "Facts", "Needs", "Offers", "Peer", "Refused", "Scope", "blocks"]

arkitekt_service-1.0.0/arkitekt_service/contract/blocks.py

@@ -0,0 +1,83 @@
+"""The config blocks most services share, written from a hub's facts.
+
+Every service of a hub is a Django server on the same Postgres, redis and object store, and
+spells those four blocks the same way. They are here so that a service's ``render`` says only
+what is its own. A release that spells one of them differently writes that block itself.
+"""
+
+from __future__ import annotations
+
+from arkitekt_service.contract.contract import Refused
+from arkitekt_service.contract.facts import Facts
+from arkitekt_service.contract.json_types import JSON
+
+#: The offer a hub's rekuest makes to the services that report to it: the agents' endpoint.
+AGENT = "agent"
+
+
+def django(facts: Facts) -> dict[str, JSON]:
+    """``django``: the server's own settings."""
+    admin = facts.me.admin
+    return {
+        "admin": {"username": admin.username, "password": admin.password, "email": admin.email} if admin else None,
+        "csrf_trusted_origins": [*facts.hub.origins],
+        "debug": facts.me.debug,
+        "force_script_name": facts.me.path,
+        "hosts": [*facts.me.allowed_hosts],
+        "secret_key": facts.me.secret_key,
+    }
+
+
+def postgres(facts: Facts) -> dict[str, JSON]:
+    """``postgres``: the service's database."""
+    if facts.database is None:
+        raise Refused("it needs a database, and this hub gives it none")
+    database = facts.database
+    return {"host": database.host, "port": database.port, "db_name": database.name, "username": database.username, "password": database.password}
+
+
+def redis(facts: Facts) -> dict[str, JSON]:
+    """``redis``: the hub's redis."""
+    if facts.redis is None:
+        raise Refused("it needs a redis, and this hub gives it none")
+    return {"host": facts.redis.host, "port": facts.redis.port}
+
+
+def datalayer(facts: Facts, *required: str) -> dict[str, JSON]:
+    """``datalayer``: the object store, and a ``<purpose>: {bucket: …}`` entry per bucket made for the service."""
+    if facts.storage is None:
+        raise Refused("it needs object storage, and this hub gives it none")
+    storage = facts.storage
+    missing = [purpose for purpose in required if purpose not in storage.buckets]
+    if missing:
+        raise Refused(f"it needs a bucket for {', '.join(missing)}, and this hub made none")
+    return {
+        "access_key": storage.access_key,
+        "secret_key": storage.secret_key,
+        "host": storage.host,
+        "port": storage.port,
+        "protocol": storage.protocol,
+        "region": storage.region,
+        **({"role_arn": storage.role_arn} if storage.role_arn else {}),
+        **({"session_duration_seconds": storage.session_duration_seconds} if storage.session_duration_seconds else {}),
+        **{purpose: {"bucket": bucket} for purpose, bucket in storage.buckets.items()},
+    }
+
+
+def instance(facts: Facts) -> dict[str, JSON]:
+    """``instance``: the service's own key, and whom it trusts."""
+    if facts.instance is None:
+        raise Refused("it needs an instance key, and this hub gives it none")
+    return {"private_key": facts.instance.private_key, "trust": facts.instance.trust.model_dump(exclude_none=True)}
+
+
+def rekuest_hook(facts: Facts) -> dict[str, JSON] | None:
+    """``rekuest_hook``: where the service reports to, when the hub runs a rekuest."""
+    for peer in facts.offering(AGENT).values():
+        return {"rekuest_url": peer.offers[AGENT]}
+    return None
+
+
+def server(facts: Facts) -> dict[str, JSON]:
+    """The four blocks every service has: ``django``, ``postgres``, ``redis``, ``authentikate``."""
+    return {"django": django(facts), "postgres": postgres(facts), "redis": redis(facts), "authentikate": facts.hub.auth}

arkitekt_service-1.0.0/arkitekt_service/contract/cli.py

@@ -0,0 +1,174 @@
+"""The verbs an installer runs in a service's image: ``python -m arkitekt_service <verb>``.
+
+``describe``
+    Prints the service's :class:`~arkitekt_service.contract.description.Description` as JSON. Needs no
+    config. An image that cannot answer this has no contract, and an installer treats it as it
+    treated images before there was one.
+
+``render [--facts FILE] [--overrides FILE]``
+    Prints this release's config, as YAML, written from a hub's facts (``/hub/facts.yaml``)
+    with what the hub's operator set laid over it (``/hub/overrides.yaml``, if there). The
+    result is loaded the way the service loads it at start before it is printed, so what comes
+    out is a config this release starts on.
+
+``check [--config FILE]``
+    Judges a config as it stands — the file the service would start on.
+
+``migrate [--plan]``
+    The release's database migrations (``manage.py migrate``); ``--plan`` lists what would run.
+
+``upgrade --from A --to B``
+    What the release does to its data between two versions (``manage.py upgrade``), if it
+    ships anything of the kind.
+
+Exit codes: ``0`` done. ``78`` (``EX_CONFIG``) is this release's own no — facts it cannot be
+configured from, an override it does not read, an invalid config — with the reason on stderr,
+and nothing on stdout. Anything else is the command failing.
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+import tempfile
+import typing
+from collections.abc import Sequence
+from pathlib import Path
+
+import yaml
+from pydantic import ValidationError
+
+from arkitekt_service.contract.contract import Contract, Refused, load
+from arkitekt_service.contract.facts import Facts
+from arkitekt_service.contract.json_types import JSON
+from arkitekt_service.contract.merge import merge
+from arkitekt_service.contract.unread import unread
+
+#: The release's own no (sysexits' EX_CONFIG).
+REFUSED = 78
+
+FACTS = "/hub/facts.yaml"
+OVERRIDES = "/hub/overrides.yaml"
+#: What every service reads its config file's path from.
+CONFIG_FILE = "ARKITEKT_CONFIG_FILE"
+
+
+class No(Exception):
+    """This release's refusal, as the lines to say."""
+
+    def __init__(self, headline: str, reasons: Sequence[str]) -> None:
+        """What is refused, and each reason."""
+        super().__init__(headline)
+        self.headline = headline
+        self.reasons = list(reasons)
+
+
+def _document(path: Path, what: str) -> dict[str, JSON]:
+    """A YAML file that holds a mapping."""
+    try:
+        loaded = typing.cast("object", yaml.safe_load(path.read_text(encoding="utf-8")))
+    except (OSError, yaml.YAMLError) as error:
+        raise No(f"{what} could not be read", [f"{path}: {error}"]) from error
+    if loaded is None:
+        return {}
+    if not isinstance(loaded, dict):
+        raise No(f"{what} is not a mapping", [str(path)])
+    return typing.cast("dict[str, JSON]", loaded)
+
+
+def _errors(error: ValidationError) -> list[str]:
+    return [f"{'.'.join(str(part) for part in problem['loc'])}: {problem['msg']}" for problem in error.errors()]
+
+
+def judge(contract: Contract, document: dict[str, JSON]) -> None:
+    """Refuse a config this release does not read as written, or does not start on.
+
+    Loaded exactly as at start: from a file named by ``ARKITEKT_CONFIG_FILE``, with the
+    environment over it.
+    """
+    found = unread(contract.settings, document)
+    if found.unknown:
+        raise No("this release does not read", found.unknown)
+    with tempfile.NamedTemporaryFile("w", suffix=".yaml", encoding="utf-8") as file:
+        yaml.safe_dump(document, file, sort_keys=False)
+        file.flush()
+        before = os.environ.get(CONFIG_FILE)
+        os.environ[CONFIG_FILE] = file.name
+        try:
+            contract.settings()
+        except ValidationError as error:
+            raise No("this release cannot start on that config", _errors(error)) from error
+        finally:
+            if before is None:
+                del os.environ[CONFIG_FILE]
+            else:
+                os.environ[CONFIG_FILE] = before
+
+
+def render(contract: Contract, facts: Path, overrides: Path) -> dict[str, JSON]:
+    """This release's config from the facts at ``facts``, with ``overrides`` laid over if there."""
+    try:
+        said = Facts.model_validate(_document(facts, "the hub's facts"))
+    except ValidationError as error:
+        raise No("this release does not understand the hub's facts", _errors(error)) from error
+    try:
+        document = contract.render(said)
+    except Refused as error:
+        raise No("this release cannot be configured for this hub", [str(error)]) from error
+    if overrides.is_file():
+        document = merge(document, _document(overrides, "what the operator set"))
+    judge(contract, document)
+    return document
+
+
+def _manage(*arguments: str) -> int:
+    """Hand over to the service's own ``manage.py``: its exit code is the answer."""
+    os.execvp(sys.executable, [sys.executable, "manage.py", *arguments])
+
+
+def main(arguments: Sequence[str] | None = None) -> int:
+    """Run one verb; the exit code is its answer."""
+    parser = argparse.ArgumentParser(prog="python -m arkitekt_service", description="What this service's image answers a hub's installer.")
+    verbs = parser.add_subparsers(dest="verb", required=True)
+    verbs.add_parser("describe", help="What the service needs from a hub and offers to it, as JSON.")
+    rendering = verbs.add_parser("render", help="This release's config, from a hub's facts.")
+    rendering.add_argument("--facts", type=Path, default=Path(FACTS))
+    rendering.add_argument("--overrides", type=Path, default=Path(OVERRIDES))
+    checking = verbs.add_parser("check", help="Whether this release reads a config as written.")
+    checking.add_argument("--config", type=Path, default=None)
+    migrating = verbs.add_parser("migrate", help="The release's database migrations.")
+    migrating.add_argument("--plan", action="store_true", help="List what would run, and run nothing.")
+    upgrading = verbs.add_parser("upgrade", help="What the release does to its data between two versions.")
+    upgrading.add_argument("--from", dest="left", required=True)
+    upgrading.add_argument("--to", dest="reached", required=True)
+    asked = parser.parse_args(arguments)
+
+    contract = load()
+    verb: str = asked.verb  # pyright: ignore[reportAny]  argparse's namespace
+    try:
+        if verb == "describe":
+            print(contract.description.model_dump_json(indent=2))
+        elif verb == "render":
+            facts: Path = asked.facts  # pyright: ignore[reportAny]
+            overrides: Path = asked.overrides  # pyright: ignore[reportAny]
+            print(yaml.safe_dump(render(contract, facts, overrides), sort_keys=False), end="")
+        elif verb == "check":
+            given: Path | None = asked.config  # pyright: ignore[reportAny]
+            path = given or Path(os.environ.get(CONFIG_FILE, "config.yaml"))
+            judge(contract, _document(path, "the config"))
+        elif verb == "migrate":
+            plan: bool = asked.plan  # pyright: ignore[reportAny]
+            return _manage("migrate", "--plan") if plan else _manage("migrate", "--noinput")
+        elif verb == "upgrade":
+            left: str = asked.left  # pyright: ignore[reportAny]
+            reached: str = asked.reached  # pyright: ignore[reportAny]
+            if contract.upgrades:
+                return _manage("upgrade", "--from", left, "--to", reached)
+            print(f"Nothing to upgrade between {left} and {reached}.")
+    except No as refusal:
+        print(f"{contract.description.name}: {refusal.headline}:", file=sys.stderr)
+        for reason in refusal.reasons:
+            print(f"  {reason}", file=sys.stderr)
+        return REFUSED
+    return 0