Metadata-Version: 2.4
Name: brixta-core
Version: 0.1.3
Summary: Reusable core primitives for BRIXTA services
Author: BRIXTA
License: MIT
Project-URL: Homepage, https://github.com/habibieebhy/brixtafoundation
Project-URL: Repository, https://github.com/habibieebhy/brixtafoundation
Project-URL: Issues, https://github.com/habibieebhy/brixtafoundation/issues
Keywords: brixta,fastapi,cement,digital-twin
Classifier: Development Status :: 3 - Alpha
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Programming Language :: Python :: 3.13
Classifier: Programming Language :: Python :: 3.14
Classifier: Typing :: Typed
Requires-Python: >=3.11
Description-Content-Type: text/markdown
License-File: LICENSE
Requires-Dist: pydantic<3,>=2.11
Requires-Dist: pydantic-settings<3,>=2.10
Requires-Dist: sqlalchemy<2.2,>=2.0
Requires-Dist: starlette<1,>=0.47
Dynamic: license-file

brixta-core

Reusable infrastructure primitives for BRIXTA FastAPI services.

Documented API: 0.1.2Python: >=3.11

Install

python -m pip install "brixta-core==0.1.2"

Verify:

python - <<'PY'
import brixta_core
print(brixta_core.__version__)
PY

Public API

from brixta_core import (
    Base,
    CoreSettings,
    RequestIDMiddleware,
    SecurityHeadersMiddleware,
    TimestampMixin,
    UUIDPrimaryKeyMixin,
    create_database,
    new_uuid,
)

API

Purpose

CoreSettings

BRIXTA configuration from environment variables / .env

create_database()

SQLAlchemy engine + session factory

Base

Shared SQLAlchemy declarative base

UUIDPrimaryKeyMixin

Adds UUID id

TimestampMixin

Adds created_at / updated_at

new_uuid()

New UUID4

RequestIDMiddleware

Adds/preserves X-Request-ID

SecurityHeadersMiddleware

Adds baseline HTTP security headers

Configuration

from brixta_core import CoreSettings
settings = CoreSettings()

Supported environment variables:

BRIXTA_ENVIRONMENT=development
BRIXTA_DATABASE_URL=sqlite:///./app.db
BRIXTA_CACHE_URL=redis://localhost:6379/0
BRIXTA_AUTO_CREATE_TABLES=true

Production example:

BRIXTA_ENVIRONMENT=production
BRIXTA_DATABASE_URL=postgresql+psycopg://user:password@db:5432/app
BRIXTA_CACHE_URL=redis://valkey:6379/0
BRIXTA_AUTO_CREATE_TABLES=false

Use migrations in production instead of automatic table creation.

Database

from brixta_core import CoreSettings, create_database

settings = CoreSettings()
engine, SessionLocal = create_database(settings.database_url)

FastAPI session dependency:

from collections.abc import Iterator
from sqlalchemy.orm import Session

def get_session() -> Iterator[Session]:
    with SessionLocal() as session:
        yield session

Application models

from brixta_core import Base, TimestampMixin, UUIDPrimaryKeyMixin
from sqlalchemy import String
from sqlalchemy.orm import Mapped, mapped_column

class Plant(UUIDPrimaryKeyMixin, TimestampMixin, Base):
    __tablename__ = "plants"
    name: Mapped[str] = mapped_column(String(200), nullable=False)

The model gets:

id
created_at
updated_at

For local development:

Base.metadata.create_all(engine)

Request IDs

from fastapi import FastAPI
from brixta_core import RequestIDMiddleware

app = FastAPI()
app.add_middleware(RequestIDMiddleware)

Responses receive:

X-Request-ID: <incoming-id-or-generated-uuid>

Inside a route:

from fastapi import Request

@app.get("/debug")
def debug(request: Request):
    return {"request_id": request.state.request_id}

Security headers

from brixta_core import SecurityHeadersMiddleware

app.add_middleware(
    SecurityHeadersMiddleware,
    hsts=False,
)

Adds baseline headers including:

X-Content-Type-Options: nosniff
X-Frame-Options: DENY
Referrer-Policy: no-referrer
Permissions-Policy: camera=(), microphone=(), geolocation=()

For HTTPS production only:

app.add_middleware(SecurityHeadersMiddleware, hsts=True)

Minimal service

from contextlib import asynccontextmanager
from fastapi import FastAPI

from brixta_core import (
    Base,
    CoreSettings,
    RequestIDMiddleware,
    SecurityHeadersMiddleware,
    create_database,
)

settings = CoreSettings()
engine, SessionLocal = create_database(settings.database_url)

@asynccontextmanager
async def lifespan(app: FastAPI):
    if settings.auto_create_tables:
        Base.metadata.create_all(engine)
    yield
    engine.dispose()

app = FastAPI(lifespan=lifespan)
app.add_middleware(RequestIDMiddleware)
app.add_middleware(
    SecurityHeadersMiddleware,
    hsts=settings.environment.casefold() == "production",
)

What brixta-core does NOT do

It does not provide authentication, login UI, users, roles, CRUD generation, app migrations, cement-domain logic, or frontend components.

LLM IMPLEMENTATION CONTRACT

Copy this into an LLM prompt:

Use brixta-core as an installed dependency. Do not copy its source into the application.

Prefer only these public APIs:
Base
CoreSettings
RequestIDMiddleware
SecurityHeadersMiddleware
TimestampMixin
UUIDPrimaryKeyMixin
create_database
new_uuid

Rules:
1. Use CoreSettings for shared BRIXTA infrastructure configuration.
2. Use create_database() for the SQLAlchemy engine/session factory.
3. Make application ORM models inherit from brixta_core.Base.
4. Reuse UUIDPrimaryKeyMixin and TimestampMixin instead of recreating those columns.
5. Add RequestIDMiddleware to FastAPI services.
6. Add SecurityHeadersMiddleware; only enable HSTS on HTTPS production deployments.
7. Do not use Base.metadata.create_all() as the production migration strategy.
8. Do not invent brixta-core APIs not listed above.
9. Domain/business logic stays in the consuming application.
10. When brixta-auth is used, share the same Base/engine/session infrastructure.
