gt-fastapi 0.0.0__tar.gz

gt_fastapi-0.0.0/LICENSE.md

@@ -0,0 +1,105 @@
+# Functional Source License, Version 1.1, ALv2 Future License
+
+## Abbreviation
+
+FSL-1.1-ALv2
+
+## Notice
+
+Copyright 2026 General Translation, Inc.
+
+## Terms and Conditions
+
+### Licensor ("We")
+
+The party offering the Software under these Terms and Conditions.
+
+### The Software
+
+The "Software" is each version of the software that we make available under
+these Terms and Conditions, as indicated by our inclusion of these Terms and
+Conditions with the Software.
+
+### License Grant
+
+Subject to your compliance with this License Grant and the Patents,
+Redistribution and Trademark clauses below, we hereby grant you the right to
+use, copy, modify, create derivative works, publicly perform, publicly display
+and redistribute the Software for any Permitted Purpose identified below.
+
+### Permitted Purpose
+
+A Permitted Purpose is any purpose other than a Competing Use. A Competing Use
+means making the Software available to others in a commercial product or
+service that:
+
+1. substitutes for the Software;
+
+2. substitutes for any other product or service we offer using the Software
+   that exists as of the date we make the Software available; or
+
+3. offers the same or substantially similar functionality as the Software.
+
+Permitted Purposes specifically include using the Software:
+
+1. for your internal use and access;
+
+2. for non-commercial education;
+
+3. for non-commercial research; and
+
+4. in connection with professional services that you provide to a licensee
+   using the Software in accordance with these Terms and Conditions.
+
+### Patents
+
+To the extent your use for a Permitted Purpose would necessarily infringe our
+patents, the license grant above includes a license under our patents. If you
+make a claim against any party that the Software infringes or contributes to
+the infringement of any patent, then your patent license to the Software ends
+immediately.
+
+### Redistribution
+
+The Terms and Conditions apply to all copies, modifications and derivatives of
+the Software.
+
+If you redistribute any copies, modifications or derivatives of the Software,
+you must include a copy of or a link to these Terms and Conditions and not
+remove any copyright notices provided in or with the Software.
+
+### Disclaimer
+
+THE SOFTWARE IS PROVIDED "AS IS" AND WITHOUT WARRANTIES OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING WITHOUT LIMITATION WARRANTIES OF FITNESS FOR A PARTICULAR
+PURPOSE, MERCHANTABILITY, TITLE OR NON-INFRINGEMENT.
+
+IN NO EVENT WILL WE HAVE ANY LIABILITY TO YOU ARISING OUT OF OR RELATED TO THE
+SOFTWARE, INCLUDING INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES,
+EVEN IF WE HAVE BEEN INFORMED OF THEIR POSSIBILITY IN ADVANCE.
+
+### Trademarks
+
+Except for displaying the License Details and identifying us as the origin of
+the Software, you have no right under these Terms and Conditions to use our
+trademarks, trade names, service marks or product names.
+
+## Grant of Future License
+
+We hereby irrevocably grant you an additional license to use the Software under
+the Apache License, Version 2.0 that is effective on the second anniversary of
+the date we make the Software available. On or after that date, you may use the
+Software under the Apache License, Version 2.0, in which case the following
+will apply:
+
+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.

gt_fastapi-0.0.0/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: gt-fastapi
+Version: 0.0.0
+Summary: FastAPI integration for General Translation
+Author: Ernest McCarter
+Author-email: Ernest McCarter <ernest@generaltranslation.com>
+License-Expression: FSL-1.1-ALv2
+License-File: LICENSE.md
+Requires-Dist: generaltranslation
+Requires-Dist: gt-i18n
+Requires-Dist: fastapi>=0.100.0
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+

gt_fastapi-0.0.0/pyproject.toml

@@ -0,0 +1,24 @@
+[project]
+name = "gt-fastapi"
+version = "0.0.0"
+description = "FastAPI integration for General Translation"
+readme = "README.md"
+authors = [
+    { name = "Ernest McCarter", email = "ernest@generaltranslation.com" }
+]
+requires-python = ">=3.10"
+license = "FSL-1.1-ALv2"
+license-files = ["LICENSE.md"]
+dependencies = [
+    "generaltranslation",
+    "gt-i18n",
+    "fastapi>=0.100.0",
+]
+
+[tool.uv.sources]
+generaltranslation = { workspace = true }
+gt-i18n = { workspace = true }
+
+[build-system]
+requires = ["uv_build>=0.10.8,<0.11.0"]
+build-backend = "uv_build"

gt_fastapi-0.0.0/src/gt_fastapi/__init__.py

@@ -0,0 +1,6 @@
+"""FastAPI integration for General Translation."""
+
+from gt_fastapi._setup import initialize_gt
+from gt_i18n import declare_static, declare_var, decode_vars, t
+
+__all__ = ["initialize_gt", "t", "declare_var", "declare_static", "decode_vars"]

gt_fastapi-0.0.0/src/gt_fastapi/_setup.py

@@ -0,0 +1,106 @@
+"""FastAPI integration: initialize_gt() and locale detection."""
+
+from __future__ import annotations
+
+from contextlib import asynccontextmanager
+from typing import Any, AsyncGenerator, Callable
+
+from generaltranslation.locales import determine_locale
+
+from gt_i18n import I18nManager, set_i18n_manager, t  # noqa: F401
+
+
+def _detect_from_accept_language(
+    request: Any, manager: I18nManager
+) -> str:
+    """Parse Accept-Language header and resolve against configured locales."""
+    accept = request.headers.get("accept-language", "")
+    if not accept:
+        return manager.default_locale
+
+    locales: list[tuple[float, str]] = []
+    for part in accept.split(","):
+        part = part.strip()
+        if not part:
+            continue
+        if ";q=" in part:
+            lang, q = part.split(";q=", 1)
+            try:
+                quality = float(q.strip())
+            except ValueError:
+                quality = 0.0
+            locales.append((quality, lang.strip()))
+        else:
+            locales.append((1.0, part))
+
+    locales.sort(key=lambda x: x[0], reverse=True)
+    locale_list = [loc for _, loc in locales]
+
+    approved = manager.get_locales()
+    if not approved:
+        return locale_list[0] if locale_list else manager.default_locale
+
+    result = determine_locale(locale_list, approved)
+    return result or manager.default_locale
+
+
+def initialize_gt(
+    app: Any,
+    *,
+    default_locale: str = "en",
+    locales: list[str] | None = None,
+    project_id: str | None = None,
+    cache_url: str | None = None,
+    get_locale: Callable[..., str] | None = None,
+    load_translations: Callable[[str], dict[str, str]] | None = None,
+    eager_loading: bool = True,
+    **kwargs: Any,
+) -> I18nManager:
+    """Initialize General Translation for a FastAPI app.
+
+    Args:
+        app: The FastAPI application instance.
+        default_locale: Source locale.
+        locales: Target locales.
+        project_id: GT project ID for CDN loading.
+        cache_url: CDN base URL override.
+        get_locale: Custom locale detection callback ``(request) -> str``.
+        load_translations: Custom translation loader ``(locale) -> dict``.
+        eager_loading: Load all translations at startup (default True).
+        **kwargs: Additional kwargs passed to I18nManager.
+
+    Returns:
+        The configured I18nManager.
+    """
+    manager = I18nManager(
+        default_locale=default_locale,
+        locales=locales,
+        project_id=project_id,
+        cache_url=cache_url,
+        load_translations=load_translations,
+        **kwargs,
+    )
+    set_i18n_manager(manager)
+
+    # Wrap existing lifespan if present
+    existing_lifespan = getattr(app, "router", app).lifespan_context
+
+    @asynccontextmanager
+    async def _gt_lifespan(a: Any) -> AsyncGenerator[Any, None]:
+        if eager_loading and locales:
+            await manager.load_all_translations()
+        async with existing_lifespan(a) as state:
+            yield state
+
+    app.router.lifespan_context = _gt_lifespan
+
+    @app.middleware("http")
+    async def gt_middleware(request: Any, call_next: Any) -> Any:
+        if get_locale:
+            locale = get_locale(request)
+        else:
+            locale = _detect_from_accept_language(request, manager)
+        manager.set_locale(locale)
+        return await call_next(request)
+
+    return manager