wiltech-labs-core 1.0.1__tar.gz

wiltech_labs_core-1.0.1/.gitignore

@@ -0,0 +1,220 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+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
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+# uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+# poetry.lock
+# poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+# pdm.lock
+# pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+# pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# Redis
+*.rdb
+*.aof
+*.pid
+
+# RabbitMQ
+mnesia/
+rabbitmq/
+rabbitmq-data/
+
+# ActiveMQ
+activemq-data/
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.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/
+
+# PyCharm
+#   JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#   be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#   and can be added to the global gitignore or merged into this file.  For a more nuclear
+#   option (not recommended) you can uncomment the following to ignore the entire idea folder.
+# .idea/
+
+# Abstra
+#   Abstra is an AI-powered process automation framework.
+#   Ignore directories containing user credentials, local state, and settings.
+#   Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#   Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#   that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#   and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#   you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+# Temporary file for partial code execution
+tempCodeRunnerFile.py
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/
+
+# Streamlit
+.streamlit/secrets.toml
+/NEXT_STEPS11111.md
+.idea/*

wiltech_labs_core-1.0.1/PKG-INFO

@@ -0,0 +1,156 @@
+Metadata-Version: 2.5
+Name: wiltech-labs-core
+Version: 1.0.1
+Summary: Runtime plumbing for Wiltech FastAPI apps: config from Worker env or .env, a portable Database (SQLite, Cloudflare D1 binding, D1 over HTTP), errors, CORS and health.
+Project-URL: Homepage, https://github.com/wilferraciolli/py-libraries/tree/main/packages/core
+Project-URL: Repository, https://github.com/wilferraciolli/py-libraries
+Project-URL: Conventions, https://github.com/wilferraciolli/py-libraries/blob/main/docs/PYTHON_APP_CONVENTIONS.md
+Author: Wiliam Ferraciolli
+License-Expression: Apache-2.0
+Keywords: cloudflare-workers,config,d1,fastapi,sqlite
+Classifier: Framework :: FastAPI
+Classifier: Programming Language :: Python :: 3
+Classifier: Typing :: Typed
+Requires-Python: >=3.13
+Requires-Dist: fastapi>=0.110
+Requires-Dist: httpx>=0.27
+Provides-Extra: sqlite
+Requires-Dist: aiosqlite>=0.20; extra == 'sqlite'
+Description-Content-Type: text/markdown
+
+# wiltech-labs-core
+
+The runtime plumbing every Wiltech FastAPI app copies into `core/`: config that reads the
+Cloudflare Worker env or `.env`, the portable `Database` protocol (SQLite locally, D1 in a
+Worker, D1 over HTTP anywhere else), the `AppError` family, per-request CORS and a health
+router. See
+[`docs/PYTHON_APP_CONVENTIONS.md`](https://github.com/wilferraciolli/py-libraries/blob/main/docs/PYTHON_APP_CONVENTIONS.md).
+
+Pure Python. `aiosqlite` is an extra, so a Cloudflare Worker (D1 only) installs nothing it
+can't load.
+
+## Install
+
+```bash
+uv add "wiltech-labs-core[sqlite]"   # apps that run locally / in Docker on SQLite (all of them)
+uv add wiltech-labs-core             # a Worker-only service that never touches SQLite
+```
+
+## Usage
+
+```python
+# main.py
+from fastapi import FastAPI
+
+from wiltech_labs_core import EnvCORSMiddleware, database_check, health_router, register_error_handlers
+
+app = FastAPI(title="My API")
+register_error_handlers(app)          # AppError subclasses -> {"detail": ...} + status
+app.add_middleware(EnvCORSMiddleware) # CORS_ORIGINS read per request (works in Workers)
+app.include_router(health_router({"db": database_check}), prefix="/api")
+```
+
+```python
+# todos/todo_router.py
+from fastapi import Depends, Request
+
+from wiltech_labs_core import Database, get_database
+
+
+def get_todo_service(request: Request) -> TodoService:
+    return TodoService(TodoRepository(get_database(request)))
+```
+
+```python
+# todos/todo_service.py
+from wiltech_labs_core import NotFoundError
+
+
+async def get(self, todo_id: str) -> TodoDTO:
+    todo = await self.repository.find(todo_id)
+    if todo is None:
+        raise NotFoundError("Todo not found")      # -> 404 {"detail": "Todo not found"}
+```
+
+```python
+# a write that must change two tables together (D1 has no interactive transactions)
+await db.batch([
+    ("UPDATE users SET role_ids = ? WHERE id = ?", (roles, user_id)),
+    ("INSERT INTO audit_events (id, action, resource_id) VALUES (?, ?, ?)", (event_id, "user.roles", user_id)),
+])
+```
+
+## Configuration
+
+| Variable | Used by | Default |
+|---|---|---|
+| `DATABASE_MODE` | `get_database` | `d1_binding` if `env.DB` exists, else `sqlite` |
+| `DATABASE_PATH` | sqlite | `./local.db` |
+| `MIGRATIONS_DIR` | sqlite migrations | `./migrations` (relative to the working directory) |
+| `CF_ACCOUNT_ID`, `CF_D1_DATABASE_ID`, `CF_D1_API_TOKEN` | d1_http | — |
+| `CORS_ORIGINS` | `EnvCORSMiddleware` | none (comma-separated) |
+
+Values come from the Worker env (`wrangler.jsonc` vars and secrets) first, then the process
+environment. `.env` in the working directory is loaded into the process environment on
+import, without overriding anything already set.
+
+## Public API
+
+| Name | What it is |
+|---|---|
+| `get_config(request, key, default=None)` | Config from the Worker env, else `os.environ` |
+| `get_binding(request, name)` | A Cloudflare binding (`env.DB`, `env.AI`, `env.BUCKET`…) or `None` outside a Worker |
+| `load_dotenv(path=None)` | Load `.env` (runs once on import) |
+| `Database` | Protocol: `fetch_all`, `fetch_one`, `execute`, `batch` |
+| `SQLiteDatabase`, `D1BindingDatabase`, `D1HttpDatabase` | The three adapters |
+| `get_database(request)` | Chooses an adapter from `DATABASE_MODE` / bindings |
+| `Statement` | `tuple[str, tuple]`, one item of `batch` |
+| `migrations_dir()` | The migrations folder, or a `RuntimeError` if it's missing |
+| `AppError`, `NotFoundError` (404), `ForbiddenError` (403), `ConflictError` (409), `InvalidInputError` (422), `TooManyRequestsError` (429 + `Retry-After`), `UpstreamError` (502), `NotConfiguredError` (503) | Business errors services raise |
+| `register_error_handlers(app)` | Maps `AppError` to its status code |
+| `EnvCORSMiddleware(app, default_origins="")`, `allowed_origins(scope, default="")` | CORS with origins read per request (fallback `default_origins`); unhandled errors still get CORS headers |
+| `health_router(checks=None, prefix="/health")`, `HealthCheck`, `database_check` | `GET /health`; 503 if any check fails |
+
+### `batch` atomicity
+
+| Adapter | Atomic? |
+|---|---|
+| `SQLiteDatabase` | Yes, one transaction |
+| `D1BindingDatabase` | Yes, D1 `batch()` |
+| `D1HttpDatabase` | **No**: one request per statement, in order |
+
+## Development
+
+```bash
+uv run --package wiltech-labs-core pytest packages/core
+```
+
+## Publishing
+
+Publish **before** `wiltech-labs-auth` and `wiltech-labs-ai`, which depend on it.
+
+```bash
+cd packages/core
+
+# 1. Test, bump, build
+uv run pytest
+uv version --bump patch                 # or minor / major; skip for the first 0.1.0
+rm -rf ../../dist && uv build           # -> ../../dist/
+
+# 2. TestPyPI (optional rehearsal), using a token from test.pypi.org
+read -rsp "TestPyPI token: " UV_PUBLISH_TOKEN && export UV_PUBLISH_TOKEN && echo
+uv publish --index testpypi ../../dist/*
+unset UV_PUBLISH_TOKEN
+
+# 3. PyPI (the real thing), using a token from pypi.org
+read -rsp "PyPI token: " UV_PUBLISH_TOKEN && export UV_PUBLISH_TOKEN && echo
+uv publish ../../dist/*
+unset UV_PUBLISH_TOKEN
+
+# 4. Commit and tag
+git commit -am "wiltech-labs-core <version>"
+git tag core-v<version> && git push && git push --tags
+```
+
+A version number can only be uploaded once to each site. To retry after a fix, bump the
+version and rebuild.

wiltech_labs_core-1.0.1/README.md

@@ -0,0 +1,136 @@
+# wiltech-labs-core
+
+The runtime plumbing every Wiltech FastAPI app copies into `core/`: config that reads the
+Cloudflare Worker env or `.env`, the portable `Database` protocol (SQLite locally, D1 in a
+Worker, D1 over HTTP anywhere else), the `AppError` family, per-request CORS and a health
+router. See
+[`docs/PYTHON_APP_CONVENTIONS.md`](https://github.com/wilferraciolli/py-libraries/blob/main/docs/PYTHON_APP_CONVENTIONS.md).
+
+Pure Python. `aiosqlite` is an extra, so a Cloudflare Worker (D1 only) installs nothing it
+can't load.
+
+## Install
+
+```bash
+uv add "wiltech-labs-core[sqlite]"   # apps that run locally / in Docker on SQLite (all of them)
+uv add wiltech-labs-core             # a Worker-only service that never touches SQLite
+```
+
+## Usage
+
+```python
+# main.py
+from fastapi import FastAPI
+
+from wiltech_labs_core import EnvCORSMiddleware, database_check, health_router, register_error_handlers
+
+app = FastAPI(title="My API")
+register_error_handlers(app)          # AppError subclasses -> {"detail": ...} + status
+app.add_middleware(EnvCORSMiddleware) # CORS_ORIGINS read per request (works in Workers)
+app.include_router(health_router({"db": database_check}), prefix="/api")
+```
+
+```python
+# todos/todo_router.py
+from fastapi import Depends, Request
+
+from wiltech_labs_core import Database, get_database
+
+
+def get_todo_service(request: Request) -> TodoService:
+    return TodoService(TodoRepository(get_database(request)))
+```
+
+```python
+# todos/todo_service.py
+from wiltech_labs_core import NotFoundError
+
+
+async def get(self, todo_id: str) -> TodoDTO:
+    todo = await self.repository.find(todo_id)
+    if todo is None:
+        raise NotFoundError("Todo not found")      # -> 404 {"detail": "Todo not found"}
+```
+
+```python
+# a write that must change two tables together (D1 has no interactive transactions)
+await db.batch([
+    ("UPDATE users SET role_ids = ? WHERE id = ?", (roles, user_id)),
+    ("INSERT INTO audit_events (id, action, resource_id) VALUES (?, ?, ?)", (event_id, "user.roles", user_id)),
+])
+```
+
+## Configuration
+
+| Variable | Used by | Default |
+|---|---|---|
+| `DATABASE_MODE` | `get_database` | `d1_binding` if `env.DB` exists, else `sqlite` |
+| `DATABASE_PATH` | sqlite | `./local.db` |
+| `MIGRATIONS_DIR` | sqlite migrations | `./migrations` (relative to the working directory) |
+| `CF_ACCOUNT_ID`, `CF_D1_DATABASE_ID`, `CF_D1_API_TOKEN` | d1_http | — |
+| `CORS_ORIGINS` | `EnvCORSMiddleware` | none (comma-separated) |
+
+Values come from the Worker env (`wrangler.jsonc` vars and secrets) first, then the process
+environment. `.env` in the working directory is loaded into the process environment on
+import, without overriding anything already set.
+
+## Public API
+
+| Name | What it is |
+|---|---|
+| `get_config(request, key, default=None)` | Config from the Worker env, else `os.environ` |
+| `get_binding(request, name)` | A Cloudflare binding (`env.DB`, `env.AI`, `env.BUCKET`…) or `None` outside a Worker |
+| `load_dotenv(path=None)` | Load `.env` (runs once on import) |
+| `Database` | Protocol: `fetch_all`, `fetch_one`, `execute`, `batch` |
+| `SQLiteDatabase`, `D1BindingDatabase`, `D1HttpDatabase` | The three adapters |
+| `get_database(request)` | Chooses an adapter from `DATABASE_MODE` / bindings |
+| `Statement` | `tuple[str, tuple]`, one item of `batch` |
+| `migrations_dir()` | The migrations folder, or a `RuntimeError` if it's missing |
+| `AppError`, `NotFoundError` (404), `ForbiddenError` (403), `ConflictError` (409), `InvalidInputError` (422), `TooManyRequestsError` (429 + `Retry-After`), `UpstreamError` (502), `NotConfiguredError` (503) | Business errors services raise |
+| `register_error_handlers(app)` | Maps `AppError` to its status code |
+| `EnvCORSMiddleware(app, default_origins="")`, `allowed_origins(scope, default="")` | CORS with origins read per request (fallback `default_origins`); unhandled errors still get CORS headers |
+| `health_router(checks=None, prefix="/health")`, `HealthCheck`, `database_check` | `GET /health`; 503 if any check fails |
+
+### `batch` atomicity
+
+| Adapter | Atomic? |
+|---|---|
+| `SQLiteDatabase` | Yes, one transaction |
+| `D1BindingDatabase` | Yes, D1 `batch()` |
+| `D1HttpDatabase` | **No**: one request per statement, in order |
+
+## Development
+
+```bash
+uv run --package wiltech-labs-core pytest packages/core
+```
+
+## Publishing
+
+Publish **before** `wiltech-labs-auth` and `wiltech-labs-ai`, which depend on it.
+
+```bash
+cd packages/core
+
+# 1. Test, bump, build
+uv run pytest
+uv version --bump patch                 # or minor / major; skip for the first 0.1.0
+rm -rf ../../dist && uv build           # -> ../../dist/
+
+# 2. TestPyPI (optional rehearsal), using a token from test.pypi.org
+read -rsp "TestPyPI token: " UV_PUBLISH_TOKEN && export UV_PUBLISH_TOKEN && echo
+uv publish --index testpypi ../../dist/*
+unset UV_PUBLISH_TOKEN
+
+# 3. PyPI (the real thing), using a token from pypi.org
+read -rsp "PyPI token: " UV_PUBLISH_TOKEN && export UV_PUBLISH_TOKEN && echo
+uv publish ../../dist/*
+unset UV_PUBLISH_TOKEN
+
+# 4. Commit and tag
+git commit -am "wiltech-labs-core <version>"
+git tag core-v<version> && git push && git push --tags
+```
+
+A version number can only be uploaded once to each site. To retry after a fix, bump the
+version and rebuild.

wiltech_labs_core-1.0.1/pyproject.toml

@@ -0,0 +1,48 @@
+[project]
+name = "wiltech-labs-core"
+version = "1.0.1"
+description = "Runtime plumbing for Wiltech FastAPI apps: config from Worker env or .env, a portable Database (SQLite, Cloudflare D1 binding, D1 over HTTP), errors, CORS and health."
+readme = "README.md"
+license = "Apache-2.0"
+requires-python = ">=3.13"
+authors = [{ name = "Wiliam Ferraciolli" }]
+keywords = ["fastapi", "cloudflare-workers", "d1", "sqlite", "config"]
+classifiers = [
+    "Framework :: FastAPI",
+    "Programming Language :: Python :: 3",
+    "Typing :: Typed",
+]
+dependencies = [
+    "fastapi>=0.110",
+    "httpx>=0.27",
+]
+
+[project.optional-dependencies]
+# Local uvicorn/Docker only. A Cloudflare Worker uses D1 and must not need it.
+sqlite = ["aiosqlite>=0.20"]
+
+[project.urls]
+Homepage = "https://github.com/wilferraciolli/py-libraries/tree/main/packages/core"
+Repository = "https://github.com/wilferraciolli/py-libraries"
+Conventions = "https://github.com/wilferraciolli/py-libraries/blob/main/docs/PYTHON_APP_CONVENTIONS.md"
+
+[dependency-groups]
+dev = [
+    "aiosqlite",
+    "pytest",
+    "pytest-asyncio",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.sdist]
+exclude = ["CLAUDE.md", ".pytest_cache"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/wiltech_labs_core"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]

wiltech_labs_core-1.0.1/src/wiltech_labs_core/__init__.py

@@ -0,0 +1,59 @@
+"""
+wiltech-labs-core: the runtime plumbing shared by Wiltech's FastAPI apps.
+
+Config that reads the Worker env or .env, the portable Database protocol
+(SQLite / D1 binding / D1 over HTTP), the AppError family, per-request CORS
+and a health router.
+
+This module is the entire public surface — import from `wiltech_labs_core`,
+not from its sub-packages.
+"""
+from wiltech_labs_core.config import get_binding, get_config, load_dotenv
+from wiltech_labs_core.database import (
+    D1BindingDatabase,
+    D1HttpDatabase,
+    Database,
+    SQLiteDatabase,
+    Statement,
+    get_database,
+    migrations_dir,
+)
+from wiltech_labs_core.errors import (
+    AppError,
+    ConflictError,
+    ForbiddenError,
+    InvalidInputError,
+    NotConfiguredError,
+    NotFoundError,
+    TooManyRequestsError,
+    UpstreamError,
+    register_error_handlers,
+)
+from wiltech_labs_core.web import EnvCORSMiddleware, HealthCheck, allowed_origins, database_check, health_router
+
+__all__ = [
+    "AppError",
+    "ConflictError",
+    "D1BindingDatabase",
+    "D1HttpDatabase",
+    "Database",
+    "EnvCORSMiddleware",
+    "ForbiddenError",
+    "HealthCheck",
+    "InvalidInputError",
+    "NotConfiguredError",
+    "NotFoundError",
+    "SQLiteDatabase",
+    "Statement",
+    "TooManyRequestsError",
+    "UpstreamError",
+    "allowed_origins",
+    "database_check",
+    "get_binding",
+    "get_config",
+    "get_database",
+    "health_router",
+    "load_dotenv",
+    "migrations_dir",
+    "register_error_handlers",
+]

wiltech_labs_core-1.0.1/src/wiltech_labs_core/config/__init__.py

@@ -0,0 +1,3 @@
+from wiltech_labs_core.config.config import get_binding, get_config, load_dotenv
+
+__all__ = ["get_binding", "get_config", "load_dotenv"]

wiltech_labs_core-1.0.1/src/wiltech_labs_core/config/config.py

@@ -0,0 +1,60 @@
+import os
+from pathlib import Path
+from typing import Optional
+
+from starlette.requests import HTTPConnection
+
+
+def load_dotenv(path: Optional[Path] = None) -> None:
+    """
+    Load the project's .env (in the working directory) for plain uvicorn/local runs, if one exists.
+
+    Values already in the environment win, so docker-compose `environment:`
+    entries override the file. Runs once on import; call it again only to load
+    a different file.
+    """
+    env_path = path or Path.cwd() / ".env"
+    if not env_path.exists():
+        return
+
+    for line in env_path.read_text().splitlines():
+        line = line.strip()
+        if not line or line.startswith("#") or "=" not in line:
+            continue
+
+        key, value = line.split("=", 1)
+        os.environ.setdefault(key.strip(), value.strip().strip('"').strip("'"))
+
+
+load_dotenv()
+
+
+def get_config(request: HTTPConnection, key: str, default: Optional[str] = None) -> Optional[str]:
+    """
+    Read config from either the Worker env object or process environment.
+
+    Cloudflare injects bindings/config into request.scope["env"], while plain
+    uvicorn/Docker uses environment variables loaded from .env/docker-compose.
+    """
+    env = request.scope.get("env")
+    if env is not None:
+        try:
+            value = getattr(env, key)
+            if value is not None:
+                return str(value)
+        except AttributeError:
+            pass
+
+    return os.environ.get(key, default)
+
+
+def get_binding(request: HTTPConnection, name: str) -> Optional[object]:
+    """
+    A Cloudflare binding (env.DB, env.AI, env.BUCKET, ...) or None outside a
+    Worker. Adapter factories use this to prefer the native binding when it
+    exists and fall back to HTTP otherwise.
+    """
+    env = request.scope.get("env")
+    if env is None:
+        return None
+    return getattr(env, name, None)