pylara 1.0.0__tar.gz

pylara-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 The PyLara Authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pylara-1.0.0/MANIFEST.in

@@ -0,0 +1,6 @@
+include LICENSE README.md
+recursive-include pylara/stubs *
+recursive-include docs *.md
+graft tests
+graft examples
+global-exclude __pycache__ *.py[cod] *.sqlite

pylara-1.0.0/PKG-INFO

@@ -0,0 +1,86 @@
+Metadata-Version: 2.4
+Name: pylara
+Version: 1.0.0
+Summary: A Laravel-inspired web framework for Python: routing, Eloquent-style ORM, middleware, migrations and an Artisan-style CLI.
+Author-email: Dzulfikar Maulana <dzulfikar.maulana@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/gekif/pylara
+Project-URL: Documentation, https://github.com/gekif/pylara/tree/main/docs
+Project-URL: Source, https://github.com/gekif/pylara
+Project-URL: Issues, https://github.com/gekif/pylara/issues
+Keywords: laravel,framework,web,wsgi,orm,mvc,artisan
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Internet :: WWW/HTTP :: WSGI :: Application
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# PyLara
+
+A Laravel-inspired web framework for Python. Routing, an Eloquent-style ORM, middleware,
+migrations, a small template engine, validation, sessions, CSRF protection, file uploads, and an
+Artisan-style CLI, with **no dependencies** beyond the standard library.
+
+```bash
+python -m pip install pylara
+pylara new blog
+cd blog
+python -m manage migrate
+python -m manage serve
+```
+
+Open http://127.0.0.1:8000.
+
+> **Status:** 1.0 is the first release. PyLara is synchronous (WSGI), targets SQLite, and is
+> best suited to learning, prototypes, internal tools and small APIs. Read
+> [Limitations](https://github.com/YOUR-USER/pylara/blob/main/docs/limitations.md) before choosing it for production.
+
+## A taste of PyLara
+
+```python
+from pylara import Application, Controller, Model
+
+class Task(Model):
+    table = "tasks"
+    fillable = ["title", "done"]
+
+class TaskController(Controller):
+    def index(self, request):
+        return self.json([t.to_dict() for t in Task.where("done", 0).order_by("id", "DESC").get()])
+
+    def store(self, request):
+        data = request.validate({"title": "required|string|min:3|max:150"})
+        return self.json(Task.create(title=data["title"], done=0).to_dict(), 201)
+
+app = Application()
+app.group({"prefix": "/api"}, lambda r: [r.resource("tasks", TaskController)])
+```
+
+## Documentation
+
+Start at **[docs/index.md](https://github.com/YOUR-USER/pylara/blob/main/docs/index.md)**: installation, configuration, routing, controllers,
+requests, responses, views, validation, the database layer and ORM, testing, deployment and
+publishing your own package.
+
+## Development
+
+```bash
+git clone <your fork> && cd pylara
+python -m pip install -e .
+python -m tests                      # run the whole test suite
+```
+
+## License
+
+MIT. See [LICENSE](https://github.com/YOUR-USER/pylara/blob/main/LICENSE).

pylara-1.0.0/README.md

@@ -0,0 +1,58 @@
+# PyLara
+
+A Laravel-inspired web framework for Python. Routing, an Eloquent-style ORM, middleware,
+migrations, a small template engine, validation, sessions, CSRF protection, file uploads, and an
+Artisan-style CLI, with **no dependencies** beyond the standard library.
+
+```bash
+python -m pip install pylara
+pylara new blog
+cd blog
+python -m manage migrate
+python -m manage serve
+```
+
+Open http://127.0.0.1:8000.
+
+> **Status:** 1.0 is the first release. PyLara is synchronous (WSGI), targets SQLite, and is
+> best suited to learning, prototypes, internal tools and small APIs. Read
+> [Limitations](https://github.com/YOUR-USER/pylara/blob/main/docs/limitations.md) before choosing it for production.
+
+## A taste of PyLara
+
+```python
+from pylara import Application, Controller, Model
+
+class Task(Model):
+    table = "tasks"
+    fillable = ["title", "done"]
+
+class TaskController(Controller):
+    def index(self, request):
+        return self.json([t.to_dict() for t in Task.where("done", 0).order_by("id", "DESC").get()])
+
+    def store(self, request):
+        data = request.validate({"title": "required|string|min:3|max:150"})
+        return self.json(Task.create(title=data["title"], done=0).to_dict(), 201)
+
+app = Application()
+app.group({"prefix": "/api"}, lambda r: [r.resource("tasks", TaskController)])
+```
+
+## Documentation
+
+Start at **[docs/index.md](https://github.com/YOUR-USER/pylara/blob/main/docs/index.md)**: installation, configuration, routing, controllers,
+requests, responses, views, validation, the database layer and ORM, testing, deployment and
+publishing your own package.
+
+## Development
+
+```bash
+git clone <your fork> && cd pylara
+python -m pip install -e .
+python -m tests                      # run the whole test suite
+```
+
+## License
+
+MIT. See [LICENSE](https://github.com/YOUR-USER/pylara/blob/main/LICENSE).

pylara-1.0.0/docs/cheatsheet.md

@@ -0,0 +1,62 @@
+# Laravel Cheat Sheet
+
+| Laravel (PHP) | PyLara (Python) |
+|---|---|
+| `composer create-project laravel/laravel blog` | `pylara new blog` |
+| `php artisan serve` | `python -m manage serve` |
+| `php artisan route:list` | `python -m manage route:list` |
+| `php artisan make:controller PostController --resource` | `python -m manage make:controller PostController --resource` |
+| `php artisan make:model Post -m` | `python -m manage make:model Post -m` |
+| `php artisan make:middleware X` | `python -m manage make:middleware X` |
+| `php artisan migrate` / `migrate:rollback` / `migrate:status` | `python -m manage migrate` / `migrate:rollback` / `migrate:status` |
+| `Route::get('/u/{id}', [C::class, 'show'])` | `app.get("/u/{id}", [C, "show"])` |
+| `Route::resource('posts', PostController::class)` | `app.resource("posts", PostController)` |
+| `Route::get(...)->name('x')` | `app.get(...).named("x")` |
+| `Route::get(...)->middleware(M::class)` | `app.get(...).with_middleware(M)` |
+| `Route::prefix('api')->group(fn)` | `app.group({"prefix": "/api"}, fn)` |
+| `route('x', ['id' => 1])` | `route("x", id=1)` |
+| `$request->input('a')`, `$request->all()` | `request.input("a")`, `request.all()` |
+| `$request->only(['a','b'])` | `request.only("a", "b")` |
+| `$request->validate(['a' => 'required\|email'])` | `request.validate({"a": "required\|email"})` |
+| `return response()->json($x, 201)` | `return JsonResponse(x, 201)` or `self.json(x, 201)` |
+| `return redirect('/home')` | `return RedirectResponse("/home")` or `self.redirect("/home")` |
+| `abort(404)` | `abort(404)` |
+| `view('welcome', ['a' => 1])` | `view("welcome", a=1)` |
+| Blade `{{ $x }}`, `{!! $x !!}` | `{{ x }}`, `{!! x !!}` |
+| Blade `@if`, `@foreach`, `@extends`, `@section`, `@include` | `{% if %}`, `{% for %}`, `{% extends %}`, `{% block %}`, `{% include %}` |
+| `config('app.name')` | `config("app.name")` |
+| `env('APP_DEBUG', false)` | `env("APP_DEBUG", False)` |
+| `User::find(1)`, `User::findOrFail(1)` | `User.find(1)`, `User.find_or_fail(1)` |
+| `User::where('a', 1)->first()` | `User.where("a", 1).first()` |
+| `User::create([...])` | `User.create(**data)` |
+| `$user->save()`, `$user->delete()` | `user.save()`, `user.delete()` |
+| `$fillable`, `$hidden`, `$casts`, `SoftDeletes` | `fillable`, `hidden`, `casts`, `soft_deletes = True` |
+| `$this->hasMany(Post::class)` | `self.has_many(Post)` |
+| `$this->belongsTo(User::class)` | `self.belongs_to(User)` |
+| `User::paginate(15)` | `User.query().paginate(per_page=15, page=1)` |
+| `Schema::create('t', fn (Blueprint $t) => ...)` | `Schema.create("t", lambda t: [...])` |
+| `$table->string('name')->nullable()` | `t.string("name").nullable()` |
+| `$table->foreignId('user_id')->constrained()` | `t.integer("user_id")` + `t.foreign("user_id").references("id").on("users")` |
+| `Hash::make($p)` / `Hash::check($p, $h)` | `Hash.make(p)` / `Hash.check(p, h)` |
+| `collect($items)->pluck('a')` | `collect(items).pluck("a")` |
+| `session('cart')`, `session(['cart' => 1])` | `request.session.get("cart")`, `request.session.put("cart", 1)` |
+| `redirect()->with('status', 'Saved')` | `request.session.flash("status", "Saved")` |
+| `@csrf` | `{!! csrf_field !!}` |
+| `VerifyCsrfToken` / `$except` | `VerifyCsrfToken` / `except_paths = [...]` |
+| `auth` middleware | `RequireLogin` |
+| `php artisan key:generate` | `python -m manage key:generate` |
+| `$request->file('a')->store('dir')` | `request.file("a").save("dir")` |
+| `'photo' => 'required\|image\|max:2048'` | `"photo": "required\|file\|mimes:png,jpg\|max_kb:2048"` |
+| `View::share('k', $v)` | `app.share("k", v)` |
+| `$this->get('/')->assertStatus(200)` | `client.get("/").status_code == 200` |
+| `app()->bind(...)`, `app()->singleton(...)`, `app()->make(...)` | `app.bind(...)`, `app.singleton(...)`, `app.make(...)` |
+| Service providers `register()` / `boot()` | `ServiceProvider.register()` / `boot()` |
+| `App\Http\Middleware\X` `handle($request, Closure $next)` | `class X(Middleware): def handle(self, request, next)` |
+
+## Concepts that differ
+
+- **Parameters are named after your function arguments**, and arrive as strings.
+- **No facades**: you import functions and classes directly.
+- **`fillable` is required** for mass assignment (closed by default).
+- **`except` is `except_`** because `except` is a Python keyword.
+- **No Eloquent magic properties for relations**: call the relationship method, `user.posts()`.

pylara-1.0.0/docs/configuration.md

@@ -0,0 +1,84 @@
+# Configuration
+
+PyLara has two configuration mechanisms: **environment variables** (`.env`) for things that
+change between machines, and **JSON config files** in `config/` for everything else.
+
+## Environment configuration
+
+When the `Application` is created it loads `.env` from the project root (the `base_path`).
+
+```dotenv
+APP_NAME="Blog"
+APP_ENV=local
+APP_DEBUG=true
+DB_DATABASE=storage/database.sqlite
+```
+
+Rules:
+
+- Lines starting with `#` are comments. A value may be quoted (`"two words"`). An unquoted value
+  may end with ` # comment`.
+- **Real environment variables always win** over `.env`. `DB_DATABASE=:memory: python -m manage migrate`
+  overrides the file.
+- Never commit `.env`; commit `.env.example` instead. New projects already contain both, and
+  `.env` is in `.gitignore`.
+
+### Reading values
+
+```python
+app.env("APP_NAME", "PyLara")        # on the application
+from pylara.support.helpers import env
+env("APP_DEBUG", False)              # helper (uses the most recently created application)
+```
+
+`env()` converts the strings `true`, `false`, `null` and `empty` (also `(true)`, `(false)`,
+`(null)`, `(empty)`) into `True`, `False`, `None` and `""`, like Laravel. Everything else is
+returned as a string, so convert numbers yourself: `int(env("WORKERS", 2))`.
+
+### Variables PyLara itself understands
+
+| Variable | Used by | Meaning |
+|---|---|---|
+| `APP_DEBUG` | error handling | `true` shows tracebacks in the browser. **Must be `false` in production.** |
+| `DB_DATABASE` | `bootstrap/app.py` (generated project) | SQLite file path, or `:memory:` |
+| `APP_KEY` | [sessions](sessions.md) | secret that signs session cookies. Create it with `python -m manage key:generate`. |
+| `SESSION_DRIVER` | sessions | `file` (default) or `memory` |
+| `SESSION_LIFETIME` | sessions | minutes of inactivity before a session expires (default `120`) |
+| `SESSION_SECURE` | sessions | `true` on HTTPS: the cookie is never sent over plain HTTP |
+| `MAX_BODY_MB` | requests | largest accepted request body in megabytes (default `10`); larger requests get 413 |
+| `APP_NAME`, `APP_ENV` | your code | Free to use. The welcome page shows `APP_NAME`. |
+
+Add your own freely (`MAIL_HOST`, `STRIPE_KEY`, ...).
+
+## Configuration files
+
+Every `config/<file>.json` is loaded on demand and read with **dot notation**: the first segment
+is the file name.
+
+`config/app.json`
+```json
+{ "name": "Blog", "per_page": 15, "mail": { "host": "smtp.example.com" } }
+```
+
+```python
+app.config.get("app.per_page")             # 15
+app.config.get("app.mail.host")            # "smtp.example.com"
+app.config.get("app.missing", "fallback")  # "fallback"
+app.config.set("app.per_page", 25)         # runtime override (in memory only)
+
+from pylara.support.helpers import config
+config("app.name")
+```
+
+JSON files cannot read the environment. If a value depends on the machine, use `env()` in
+`bootstrap/app.py` or a provider instead.
+
+## Debug mode
+
+With `APP_DEBUG=true` an unhandled exception renders a page with the traceback, and JSON requests
+receive the exception message. With `APP_DEBUG=false` users only see a generic "Server Error".
+**In both modes the traceback is printed to stderr**, so your server log always has it.
+
+## Database configuration
+
+The database connection is created in `bootstrap/app.py`; see [Database](database.md).

pylara-1.0.0/docs/console.md

@@ -0,0 +1,85 @@
+# Console (Command Line)
+
+PyLara has two command line entry points.
+
+| Command | Where | Purpose |
+|---|---|---|
+| `pylara new <name>` | anywhere | create a new application |
+| `python -m manage <command>` | inside a project | everything else (the equivalent of `php artisan`) |
+
+`python -m pylara ...` is the same as `pylara ...` and works even when the scripts folder is not on
+your `PATH`.
+
+## Built-in commands
+
+Run `python -m manage` (or `python -m manage help`) to list them.
+
+| Command | Description |
+|---|---|
+| `serve [--host H] [--port P]` | development server (default 127.0.0.1:8000) |
+| `key:generate [--force] [--show]` | create `APP_KEY` in `.env` (signs session cookies) |
+| `route:list` | table of methods, URIs, route names and actions |
+| `make:controller Name [--resource]` | create `app/controllers/<name>.py` |
+| `make:model Name [-m]` | create `app/models/<name>.py` (and a migration with `-m`) |
+| `make:middleware Name` | create `app/middleware/<name>.py` |
+| `make:migration name` | create a timestamped file in `database/migrations/` |
+| `migrate` | run pending migrations |
+| `migrate:status` | list migrations as Ran / Pending |
+| `migrate:rollback [--steps N]` | undo the last N batches (default 1) |
+
+Generators refuse to overwrite an existing file, and names must be plain identifiers (letters,
+digits, `_`), so `make:controller ../x` is rejected. Exit codes: `0` success, `1` error.
+
+## Custom commands
+
+```python
+# app/commands/greet.py
+from pylara.console.console import Command, CommandError, load_app
+
+
+class GreetCommand(Command):
+    name = "greet"
+    description = "Say hello"
+
+    def configure(self, parser):                  # an argparse.ArgumentParser
+        parser.add_argument("name")
+        parser.add_argument("--shout", action="store_true")
+
+    def handle(self, args):
+        if not args.name.strip():
+            raise CommandError("Name must not be empty")    # prints an error, exit code 1
+        text = f"Hello, {args.name}!"
+        self.info(text.upper() if args.shout else text)
+        return 0
+```
+
+Register it in `manage.py`:
+
+```python
+from app.commands.greet import GreetCommand
+console.register(GreetCommand())
+```
+
+```bash
+python -m manage greet Ana --shout
+```
+
+Output helpers on `Command`: `info()` (green), `warn()` (yellow), `error()` (red, stderr), `line()`.
+Colors are used only on a terminal and are disabled when `NO_COLOR` is set.
+
+### Using the application inside a command
+
+```python
+def handle(self, args):
+    app = load_app()          # imports bootstrap.app from the current directory
+    ...                       # models are ready to use, the database is connected
+```
+
+`load_app()` raises a friendly `CommandError` outside a project.
+
+## Running the console from code
+
+```python
+from pylara.console.console import Console
+exit_code = Console().run(["migrate:status"])
+```

pylara-1.0.0/docs/container.md

@@ -0,0 +1,80 @@
+# Service Container
+
+The service container is a registry that knows how to build objects. The `Application` **is** a
+container, so `app.bind(...)`, `app.make(...)` and friends are all available.
+
+## Binding
+
+```python
+class Mailer:
+    def __init__(self, host): self.host = host
+
+# A factory that runs every time make() is called
+app.bind("mailer", lambda: Mailer("smtp.example.com"))
+
+# A factory that runs once; the result is reused
+app.singleton("mailer", lambda: Mailer("smtp.example.com"))
+
+# An object you already built
+app.instance("mailer", Mailer("smtp.example.com"))
+```
+
+**Factory contract.** A factory that accepts a parameter receives the container; a factory with no
+parameters is called bare:
+
+```python
+app.singleton("mailer", lambda app: Mailer(app.env("MAIL_HOST", "localhost")))
+```
+
+You may bind by name (`"mailer"`) or by class. Classes are stored under their class name:
+
+```python
+app.singleton(Mailer, lambda app: Mailer(app.env("MAIL_HOST")))
+app.make(Mailer)          # same as app.make("Mailer")
+```
+
+## Resolving
+
+```python
+mailer = app.make("mailer")       # KeyError if nothing is bound
+app.bound("mailer")               # True / False
+app["mailer"]                     # shorthand for make()
+```
+
+`app.make("app")`, `app.make("router")` and `app.make("config")` are pre-registered.
+
+## Automatic injection
+
+`app.build(SomeClass)` instantiates a class and fills its constructor from **type hints**: each
+annotated parameter whose type is bound in the container is resolved. Parameters with a default
+value use it. Anything else raises a `KeyError` that names the parameter.
+
+```python
+class Reports:
+    def __init__(self, mailer: Mailer, limit: int = 10):
+        self.mailer, self.limit = mailer, limit
+
+reports = app.build(Reports)
+```
+
+Controllers get this treatment automatically: the router builds them with `app.build`.
+
+```python
+class ReportController(Controller):
+    def __init__(self, mailer: Mailer):
+        self.mailer = mailer
+
+    def send(self, request):
+        ...
+```
+
+Register `Mailer` in a [service provider](providers.md) and the controller receives it.
+
+## Binding is not global state
+
+Everything is attached to the application object you create, so tests can build a fresh
+`Application`, bind fakes, and run against it:
+
+```python
+app.instance("mailer", FakeMailer())
+```

pylara-1.0.0/docs/contributing.md

@@ -0,0 +1,57 @@
+# Contributing
+
+Thank you for helping improve PyLara.
+
+## Setup
+
+```bash
+git clone <your fork>
+cd pylara
+python -m venv .venv
+.venv\Scripts\activate            # Windows   (Linux/macOS: source .venv/bin/activate)
+python -m pip install -e .
+python -m tests
+```
+
+`python -m tests` runs both suites:
+
+- `tests/test_framework.py` is the original script-style suite for the core (ORM, router, request,
+  response, middleware, migrations, collections).
+- `tests/test_features.py` is a `unittest` suite for 1.0 features, including integration tests that
+  generate a project with `pylara new` and run it.
+
+Run one file or test: `python -m unittest tests.test_features.RoutingTest -v`.
+
+## Layout
+
+```
+pylara/
+├── application.py        Application: container, env, static files, WSGI, dev server
+├── cli.py / __main__.py  global `pylara` command (pylara new)
+├── version.py            the only place the version is written
+├── testing.py            TestClient
+├── http/                 request, response, kernel (middleware + errors), controller, exceptions
+├── routing/router.py     Route, Router
+├── middleware/           Middleware base and built-ins
+├── orm/model.py          QueryBuilder and Model
+├── database/migration.py Blueprint, Schema, Migrator, discover
+├── console/console.py    manage.py commands
+├── support/              container, config, helpers/Collection, hashing, view engine, providers
+└── stubs/project/        files copied by `pylara new` (*.stub; __UPPER__ tokens are replaced)
+examples/demo/            a small users/posts/auth demo application
+```
+
+## Guidelines
+
+- Keep PyLara **dependency-free** (standard library only).
+- Every behaviour change needs a test, and the documentation in `docs/` must stay accurate: if you
+  change an API, change its page.
+- Be conservative with security: values are always SQL parameters, column names go through the
+  identifier check, HTML output is escaped, static paths cannot leave `public/`.
+- Run the suite with warnings as errors: `python -W error -m tests`.
+- Files in `pylara/stubs/project` end with `.stub` so they are not treated as Python modules when
+  the package is installed. New stub files are picked up automatically.
+
+## Releasing
+
+See [Publishing to PyPI](publishing.md).

pylara-1.0.0/docs/controllers.md

@@ -0,0 +1,87 @@
+# Controllers
+
+Controllers group request-handling logic into classes.
+
+## Generating a controller
+
+```bash
+python -m manage make:controller PostController              # one index() method
+python -m manage make:controller PostController --resource   # CRUD methods
+```
+
+This writes `app/controllers/post_controller.py` and prints the import line to use.
+
+## Writing controllers
+
+```python
+from pylara import Controller, Request
+from app.models.post import Post
+
+
+class PostController(Controller):
+
+    def index(self, request: Request):
+        return self.json([p.to_dict() for p in Post.all()])
+
+    def show(self, request: Request, id: str):
+        return self.json(Post.find_or_fail(int(id)).to_dict())
+
+    def store(self, request: Request):
+        data = request.validate({"title": "required|string|max:150", "body": "required"})
+        return self.json(Post.create(**data).to_dict(), 201)
+```
+
+Every action receives the `request` first, followed by the route parameters it declares (by
+name). Route them:
+
+```python
+app.get("/posts/{id}", [PostController, "show"])
+app.resource("posts", PostController)
+```
+
+## What you can return
+
+A `Response`, a `dict`/`list` (JSON), a `str` (HTML) or `None`. See
+[Responses](responses.md).
+
+## Helpers on the base class
+
+| Method | Does |
+|---|---|
+| `self.json(data, status=200)` | JSON response |
+| `self.view(name, data=None, status=200, **context)` | render a [view](views.md) |
+| `self.response(content="", status=200)` | plain response |
+| `self.redirect(url, status=302)` | redirect |
+| `self.abort(status, message="")` | stop with an HTTP error |
+| `self.not_found(message="Not Found")` | `abort(404)` |
+| `self.unauthorized(message="Unauthorized")` | `abort(401)` |
+
+## Dependency injection
+
+Controllers are created through the [container](container.md), so type-hinted constructor
+parameters that are bound in the container are injected:
+
+```python
+class ReportController(Controller):
+    def __init__(self, mailer: Mailer):
+        self.mailer = mailer
+```
+
+A new controller instance is built **for every request**.
+
+## Resource controllers
+
+Implement any of `index create store show edit update destroy` and call `app.resource(...)`. See
+[Routing](routing.md#resource-routes). The controller may implement only the methods it needs.
+
+## Single-action routes
+
+Not every endpoint needs a class: a function or lambda is a perfectly good action.
+
+```python
+@app.post("/subscribe")
+def subscribe(request):
+    data = request.validate({"email": "required|email"})
+    ...
+    return {"subscribed": data["email"]}
+```