callosum-sdk 0.2.1__tar.gz

callosum_sdk-0.2.1/.gitignore

@@ -0,0 +1,9 @@
+.coverage
+.pytest_cache/
+.ruff_cache/
+.venv/
+__pycache__/
+dist/*
+!dist/.gitignore
+*.egg-info/
+

callosum_sdk-0.2.1/LICENSE

@@ -0,0 +1,180 @@
+                                 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 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, as submitted to the 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, "submit" 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 tracking
+      modifications made to the Work.
+
+      "Contributor" shall mean Licensor and any Legal Entity on behalf of
+      whom a Contribution has been received by the Licensor and included
+      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 the combination of their Contributions
+      with the Work to which such Contributions were submitted. If You
+      institute patent litigation against any entity (including a cross-claim
+      or counterclaim in a lawsuit) alleging that the Work or any
+      Contribution embodied 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, You must include a readable copy of the
+          attribution notices contained within such NOTICE file, 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 in addition 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 license statement for Your modifications and
+      may provide additional grant of rights to use, copy, modify, merge,
+      publish, distribute, sublicense, and/or sell copies of the
+      Derivative Works, and to permit persons to whom the Derivative Works
+      is furnished to do so, subject to the following conditions.
+
+   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 reproducing 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 exemplary 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 all other
+      commercial damages or losses), even if such Contributor has been
+      advised of the possibility of such damages.
+
+   9. Accepting Warranty or 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 offer only obligations consistent
+      with this License, and only in a charge that is reasonable, in
+      light of the services offered.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 2026 Hamzah Chariwala
+
+   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.

callosum_sdk-0.2.1/PKG-INFO

@@ -0,0 +1,93 @@
+Metadata-Version: 2.4
+Name: callosum-sdk
+Version: 0.2.1
+Summary: AsyncOpenAI-compatible client for Callosum spot inference
+Project-URL: Homepage, https://github.com/callosumtechnologies/callosum-sdk
+Project-URL: Repository, https://github.com/callosumtechnologies/callosum-sdk
+Project-URL: Issues, https://github.com/callosumtechnologies/callosum-sdk/issues
+Author: Callosum Technologies
+License: Apache-2.0
+License-File: LICENSE
+Keywords: batch,callosum,inference,openai
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.12
+Requires-Dist: httpx>=0.27
+Requires-Dist: openai>=2.53.0
+Provides-Extra: dev
+Requires-Dist: pyright>=1.1.403; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.24; extra == 'dev'
+Requires-Dist: pytest-cov>=6; extra == 'dev'
+Requires-Dist: pytest>=8.3; extra == 'dev'
+Requires-Dist: ruff>=0.12; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# callosum-sdk
+
+callosum-sdk provides an AsyncOpenAI-compatible client for latency-insensitive
+models running on spot capacity. A familiar chat-completions call becomes a
+background submit/poll operation without holding an HTTP connection across a
+GPU cold start.
+
+## Install
+
+~~~bash
+pip install callosum-sdk
+~~~
+
+## Quickstart
+
+~~~python
+import asyncio
+import os
+
+from callosum_sdk import AsyncOpenAI
+
+
+async def main() -> None:
+    async with AsyncOpenAI(
+        api_key=os.environ["CALLOSUM_API_KEY"],
+        base_url=os.environ.get("CALLOSUM_BASE_URL", "https://api.callosum.ai/v1"),
+    ) as client:
+        response = await client.chat.completions.create(
+            model="qwen3.5-4b",
+            messages=[{"role": "user", "content": "Explain quantum computing"}],
+        )
+        print(response.choices[0].message.content)
+
+
+asyncio.run(main())
+~~~
+
+Run `uv run demo-readme` from a source checkout to execute that exact Quickstart
+block. Set `CALLOSUM_BASE_URL` to target a staging gateway or port-forward;
+otherwise it defaults to the public API.
+
+The SDK sends the public slug as `spot/qwen3.5-4b`, which selects the
+gateway's spot proxy. The gateway maps that slug through its deployed model
+catalogue and forwards to the spot orchestrator's background API. The returned
+response still reports `qwen3.5-4b`, keeping the routing namespace
+transparent to application code.
+
+## Behaviour and limits
+
+- `chat.completions.create()` is non-streaming: it submits immediately, polls
+  every five seconds, and returns a typed OpenAI `ChatCompletion` at completion.
+- The default one-hour client wait can be changed with
+  `request_timeout_seconds`; the request continues in the orchestrator if a
+  local caller is cancelled.
+- `model_prefix="spot/"` is idempotent. Passing an already namespaced model does
+  not produce `spot/spot/...`.
+- The API key identifies the tenant. A response id submitted by one tenant
+  cannot be polled by another.
+- Raw Files and Batch API batching remains available through the explicit
+  `BatchOpenAI` class for non-spot workload batches.
+
+See [the spot client guide](docs/spot/README.md) for the routing contract and
+[the batching guide](docs/batching/README.md) for `BatchOpenAI`.

callosum_sdk-0.2.1/README.md

@@ -0,0 +1,63 @@
+# callosum-sdk
+
+callosum-sdk provides an AsyncOpenAI-compatible client for latency-insensitive
+models running on spot capacity. A familiar chat-completions call becomes a
+background submit/poll operation without holding an HTTP connection across a
+GPU cold start.
+
+## Install
+
+~~~bash
+pip install callosum-sdk
+~~~
+
+## Quickstart
+
+~~~python
+import asyncio
+import os
+
+from callosum_sdk import AsyncOpenAI
+
+
+async def main() -> None:
+    async with AsyncOpenAI(
+        api_key=os.environ["CALLOSUM_API_KEY"],
+        base_url=os.environ.get("CALLOSUM_BASE_URL", "https://api.callosum.ai/v1"),
+    ) as client:
+        response = await client.chat.completions.create(
+            model="qwen3.5-4b",
+            messages=[{"role": "user", "content": "Explain quantum computing"}],
+        )
+        print(response.choices[0].message.content)
+
+
+asyncio.run(main())
+~~~
+
+Run `uv run demo-readme` from a source checkout to execute that exact Quickstart
+block. Set `CALLOSUM_BASE_URL` to target a staging gateway or port-forward;
+otherwise it defaults to the public API.
+
+The SDK sends the public slug as `spot/qwen3.5-4b`, which selects the
+gateway's spot proxy. The gateway maps that slug through its deployed model
+catalogue and forwards to the spot orchestrator's background API. The returned
+response still reports `qwen3.5-4b`, keeping the routing namespace
+transparent to application code.
+
+## Behaviour and limits
+
+- `chat.completions.create()` is non-streaming: it submits immediately, polls
+  every five seconds, and returns a typed OpenAI `ChatCompletion` at completion.
+- The default one-hour client wait can be changed with
+  `request_timeout_seconds`; the request continues in the orchestrator if a
+  local caller is cancelled.
+- `model_prefix="spot/"` is idempotent. Passing an already namespaced model does
+  not produce `spot/spot/...`.
+- The API key identifies the tenant. A response id submitted by one tenant
+  cannot be polled by another.
+- Raw Files and Batch API batching remains available through the explicit
+  `BatchOpenAI` class for non-spot workload batches.
+
+See [the spot client guide](docs/spot/README.md) for the routing contract and
+[the batching guide](docs/batching/README.md) for `BatchOpenAI`.

callosum_sdk-0.2.1/pyproject.toml

@@ -0,0 +1,66 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "callosum-sdk"
+version = "0.2.1"
+description = "AsyncOpenAI-compatible client for Callosum spot inference"
+readme = "README.md"
+license = { text = "Apache-2.0" }
+authors = [{ name = "Callosum Technologies" }]
+requires-python = ">=3.12"
+keywords = ["callosum", "openai", "batch", "inference"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: Apache Software License",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = ["httpx>=0.27", "openai>=2.53.0"]
+
+[project.optional-dependencies]
+dev = [
+  "pyright>=1.1.403",
+  "pytest>=8.3",
+  "pytest-asyncio>=0.24",
+  "pytest-cov>=6",
+  "ruff>=0.12",
+]
+
+[project.urls]
+Homepage = "https://github.com/callosumtechnologies/callosum-sdk"
+Repository = "https://github.com/callosumtechnologies/callosum-sdk"
+Issues = "https://github.com/callosumtechnologies/callosum-sdk/issues"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/callosum_sdk"]
+
+[tool.hatch.build.targets.sdist]
+include = ["/LICENSE", "/README.md", "/pyproject.toml", "/src/callosum_sdk"]
+
+[tool.uv.workspace]
+members = ["scripts"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py312"
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I", "UP"]
+
+[tool.pyright]
+pythonVersion = "3.12"
+typeCheckingMode = "basic"
+
+[tool.pytest.ini_options]
+addopts = "--import-mode=importlib"
+asyncio_mode = "auto"
+testpaths = ["tests"]
+
+[tool.coverage.run]
+source = ["callosum_sdk"]

callosum_sdk-0.2.1/src/callosum_sdk/__init__.py

@@ -0,0 +1,41 @@
+"""Public interface for the Callosum Python SDK."""
+
+from callosum_sdk.batching import (
+    BatchExpiredError,
+    BatchFailedError,
+    BatchNotEnabledError,
+    BatchOpenAI,
+    BatchRequestError,
+    CallosumSDKError,
+    ClientClosedError,
+    MissingBatchResultError,
+    NotSupportedError,
+    RequestValidationError,
+    SpotRequestError,
+    SpotTimeoutError,
+    StreamingNotSupportedError,
+)
+from callosum_sdk.spot import SpotOpenAI
+
+AsyncOpenAI = SpotOpenAI
+
+__version__ = "0.2.1"
+
+__all__ = [
+    "AsyncOpenAI",
+    "BatchExpiredError",
+    "BatchFailedError",
+    "BatchNotEnabledError",
+    "BatchOpenAI",
+    "BatchRequestError",
+    "CallosumSDKError",
+    "ClientClosedError",
+    "MissingBatchResultError",
+    "NotSupportedError",
+    "RequestValidationError",
+    "StreamingNotSupportedError",
+    "SpotOpenAI",
+    "SpotRequestError",
+    "SpotTimeoutError",
+    "__version__",
+]

callosum_sdk-0.2.1/src/callosum_sdk/batching/__init__.py

@@ -0,0 +1,34 @@
+"""Transparent batching client and its public errors."""
+
+from callosum_sdk.batching.client import AsyncOpenAI, BatchOpenAI
+from callosum_sdk.batching.errors import (
+    BatchExpiredError,
+    BatchFailedError,
+    BatchNotEnabledError,
+    BatchRequestError,
+    CallosumSDKError,
+    ClientClosedError,
+    MissingBatchResultError,
+    NotSupportedError,
+    RequestValidationError,
+    SpotRequestError,
+    SpotTimeoutError,
+    StreamingNotSupportedError,
+)
+
+__all__ = [
+    "AsyncOpenAI",
+    "BatchExpiredError",
+    "BatchFailedError",
+    "BatchNotEnabledError",
+    "BatchOpenAI",
+    "BatchRequestError",
+    "CallosumSDKError",
+    "ClientClosedError",
+    "MissingBatchResultError",
+    "NotSupportedError",
+    "RequestValidationError",
+    "StreamingNotSupportedError",
+    "SpotRequestError",
+    "SpotTimeoutError",
+]

callosum_sdk-0.2.1/src/callosum_sdk/batching/_queue.py

@@ -0,0 +1,56 @@
+"""Pending-request queue isolated by endpoint and model."""
+
+from __future__ import annotations
+
+import asyncio
+from collections import deque
+from dataclasses import dataclass
+from typing import Any
+
+QueueKey = tuple[str, str]
+
+
+@dataclass(slots=True)
+class PendingRequest[ResultT]:
+    custom_id: str
+    endpoint: str
+    model: str
+    body: dict[str, Any]
+    encoded_line: bytes
+    future: asyncio.Future[ResultT]
+    result_type: type[ResultT]
+
+
+class PendingQueue:
+    """FIFO queues keyed by the gateway's batch-homogeneity fields."""
+
+    def __init__(self) -> None:
+        self._items: dict[QueueKey, deque[PendingRequest[Any]]] = {}
+
+    def append(self, key: QueueKey, request: PendingRequest[Any]) -> int:
+        queue = self._items.setdefault(key, deque())
+        queue.append(request)
+        return len(queue)
+
+    def take(self, key: QueueKey, count: int) -> list[PendingRequest[Any]]:
+        queue = self._items.get(key)
+        if not queue:
+            return []
+        taken = [queue.popleft() for _ in range(min(count, len(queue)))]
+        if not queue:
+            self._items.pop(key, None)
+        return taken
+
+    def pop_all(self, key: QueueKey) -> list[PendingRequest[Any]]:
+        return list(self._items.pop(key, ()))
+
+    def keys(self) -> tuple[QueueKey, ...]:
+        return tuple(self._items)
+
+    def count(self, key: QueueKey) -> int:
+        return len(self._items.get(key, ()))
+
+    def clear(self) -> list[PendingRequest[Any]]:
+        requests = [request for queue in self._items.values() for request in queue]
+        self._items.clear()
+        return requests

callosum_sdk-0.2.1/src/callosum_sdk/batching/_validation.py

@@ -0,0 +1,84 @@
+"""Client-side validation for Callosum batch input files."""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Iterable, Mapping, Sequence
+from typing import Any
+
+from callosum_sdk.batching.errors import RequestValidationError
+
+CHAT_COMPLETIONS_ENDPOINT = "/v1/chat/completions"
+GATEWAY_MAX_LINES = 50_000
+GATEWAY_MAX_BYTES = 200 * 1024 * 1024
+DEFAULT_MAX_BATCH_LINES = 49_000
+DEFAULT_MAX_BATCH_BYTES = 190 * 1024 * 1024
+
+
+def validate_client_options(
+    *,
+    batch_size: int,
+    batch_window_seconds: float,
+    poll_interval_seconds: float,
+    completion_window: str,
+) -> None:
+    if batch_size <= 0:
+        raise RequestValidationError("batch_size must be greater than zero")
+    if batch_window_seconds < 0:
+        raise RequestValidationError("batch_window_seconds must not be negative")
+    if poll_interval_seconds <= 0:
+        raise RequestValidationError("poll_interval_seconds must be greater than zero")
+    if completion_window != "24h":
+        raise RequestValidationError("Callosum's Batch API requires completion_window='24h'")
+
+
+def validate_chat_request(model: object, messages: object, stream: object) -> str:
+    if not isinstance(model, str) or not model:
+        raise RequestValidationError("model must be a non-empty string")
+    if isinstance(messages, (str, bytes)) or not isinstance(messages, Iterable):
+        raise RequestValidationError("messages must be an iterable of chat messages")
+    if stream is True:
+        from callosum_sdk.batching.errors import StreamingNotSupportedError
+
+        raise StreamingNotSupportedError(
+            "Callosum batch chat completions do not support stream=True"
+        )
+    return model
+
+
+def validate_batch_lines(lines: Sequence[Mapping[str, Any]], *, endpoint: str, model: str) -> None:
+    """Validate all gateway-wide invariants before an input file is uploaded."""
+    if not lines:
+        raise RequestValidationError("A batch input file cannot be empty")
+    if len(lines) > GATEWAY_MAX_LINES:
+        raise RequestValidationError(f"A batch cannot exceed {GATEWAY_MAX_LINES} requests")
+
+    custom_ids: set[str] = set()
+    for index, line in enumerate(lines, start=1):
+        custom_id = line.get("custom_id")
+        if not isinstance(custom_id, str) or not custom_id:
+            raise RequestValidationError(f"Line {index} has no non-empty custom_id")
+        if custom_id in custom_ids:
+            raise RequestValidationError(f"Line {index} duplicates custom_id {custom_id!r}")
+        custom_ids.add(custom_id)
+        if line.get("method") != "POST":
+            raise RequestValidationError(f"Line {index} must use method='POST'")
+        if line.get("url") != endpoint:
+            raise RequestValidationError(f"Line {index} URL must match {endpoint!r}")
+        body = line.get("body")
+        if not isinstance(body, Mapping):
+            raise RequestValidationError(f"Line {index} body must be an object")
+        if body.get("model") != model:
+            raise RequestValidationError(f"Line {index} model must match {model!r}")
+        if body.get("stream") is True:
+            raise RequestValidationError(f"Line {index} must not enable streaming")
+
+
+def encoded_jsonl(lines: Sequence[Mapping[str, Any]]) -> bytes:
+    content = b"".join(
+        json.dumps(line, separators=(",", ":"), ensure_ascii=False).encode("utf-8") + b"\n"
+        for line in lines
+    )
+    if len(content) > GATEWAY_MAX_BYTES:
+        raise RequestValidationError(f"A batch input file cannot exceed {GATEWAY_MAX_BYTES} bytes")
+    return content