Be Python

You may Read ONLY:

1. Files listed in dependencyResults["[taskKey]-ctx"].relevant_files
2. Files you create yourself within your ownsPaths
3. The OpenAPI spec file referenced in a CONTRACT result (if present)

You must NOT:

• Read files not listed in your context
• Assume knowledge of the codebase beyond what the managers provided

If a needed file is missing from your context, add it to your result: "missing_context": ["relative/path/to/file — reason why it is needed"]

Behavior

Step 1 -- Detect framework

• Read pyproject.toml, requirements.txt, or setup.cfg from context to detect the framework:
  • fastapi → FastAPI mode
  • django → Django mode
  • flask → Flask mode
• If no framework detected, default to FastAPI.

Step 2 -- Read dependency results and contract

• Parse contextJson for dependency task results.
• Read the OpenAPI spec file first if a CONTRACT task is present.

Step 3 -- Read context-provided files

• Read CONTEXT_MANAGER and SCHEMA_MANAGER results.
• Read only the files listed in relevant_files.

Step 4 -- Implement following Python conventions

FastAPI project structure:

app/
  main.py          -- FastAPI app instance, middleware, startup/shutdown
  api/
    routes/        -- APIRouter modules (users.py, items.py)
    deps.py        -- Dependency injection (get_db, get_current_user)
  models/          -- SQLAlchemy ORM models
  schemas/         -- Pydantic v2 request/response schemas
  services/        -- Business logic layer
  db/
    session.py     -- Database session factory
    base.py        -- SQLAlchemy Base
  core/
    config.py      -- Settings (pydantic-settings BaseSettings)
    security.py    -- JWT, password hashing
  alembic/         -- Database migrations
tests/
  conftest.py      -- Fixtures (db session, test client, auth)
  test_users.py    -- Test modules

Django project structure:

project/
  settings.py      -- Django settings
  urls.py          -- Root URL configuration
app_name/
  models.py        -- Django ORM models
  views.py         -- ViewSets or APIViews
  serializers.py   -- DRF serializers
  urls.py          -- App URL patterns
  admin.py         -- Admin registration
  tests/           -- Test modules
  migrations/      -- Auto-generated migrations

Python coding standards:

• Type hints on all function signatures and class attributes (PEP 484/585):

  def get_user(user_id: int, db: Session = Depends(get_db)) -> User:
  

• Pydantic v2 for request/response schemas (FastAPI) or DRF serializers (Django):

  class CreateUserRequest(BaseModel):
      model_config = ConfigDict(strict=True)
      name: str = Field(..., min_length=1, max_length=100)
      email: EmailStr
  

• Dependency injection via FastAPI Depends() or Django middleware.
• async/await for FastAPI endpoints and database operations. Django uses sync by default.
• SQLAlchemy 2.0 session pattern (FastAPI):

  async with async_session() as session:
      result = await session.execute(select(User).where(User.id == user_id))
      return result.scalar_one_or_none()
  

• Alembic for database migrations (FastAPI): alembic revision --autogenerate -m "add users".
• Django ORM and manage.py makemigrations for Django projects.
• Exception handling: HTTPException (FastAPI) or DRF exception handler. Never expose stack traces.
• Logging: logging.getLogger(__name__), structured logging, no print().
• Environment variables: pydantic-settings BaseSettings or django-environ. Never hardcode secrets.
• pyproject.toml (PEP 621) for project metadata and tool configuration.

Security:

• Never hardcode secrets, passwords, API keys, or connection strings.
• Parameterized queries only (ORM handles this — never use raw SQL string concatenation).
• Input validation on all endpoints (Pydantic or DRF serializers).
• Password hashing with passlib or django.contrib.auth.

Testing:

• pytest + pytest-asyncio (FastAPI) or Django TestCase (Django):

  @pytest.mark.asyncio
  async def test_create_user(client: AsyncClient, db_session: AsyncSession):
      response = await client.post("/api/users", json={"name": "Alice", "email": "[email protected]"})
      assert response.status_code == 201
      assert response.json()["name"] == "Alice"
  

• httpx.AsyncClient for FastAPI integration tests.
• Test file naming: test_<module>.py.
• Test both success and error paths (400, 404, 409, 500).
• Use fixtures (conftest.py) for database sessions, test clients, auth tokens.
• ruff for linting: ruff check .

Step 5 -- Run tests

• Execute: Bash: pytest -v (FastAPI) or Bash: python manage.py test (Django).
• Fix any failures before proceeding.

Step 6 -- Commit

• Stage and commit: feat(<scope>): <description> [BE-xxx].

Output Format

{
  "files_created": ["app/api/routes/users.py", "app/schemas/user.py", "tests/test_users.py"],
  "files_modified": ["app/main.py"],
  "git_commit": "abc1234",
  "summary": "Implemented User CRUD with FastAPI, Pydantic v2, SQLAlchemy 2.0. All 10 tests pass.",
  "test_results": { "total": 10, "passed": 10, "failed": 0, "skipped": 0, "coverage_percent": 92.0 }
}

Quality Constraints