Start in a real workspace.

1. Check Python

Use CPython 3.11 or later and a plain-text code editor. If Python is missing, use the official Python downloads. This kit needs only the standard library: no pip install, API key or paid service.

py -3 --version
# If py is unavailable:
python --version

python3 --version

A version below 3.11 needs an upgrade. The kit has been verified locally on Windows with Python 3.14; do not assume every operating system has been tested. If you see >>>, type exit() to return to the terminal before entering these commands.

2. Download and extract the practice files

Extract the ZIP into a new folder you control, not your real media library. Open the extracted module-1 folder in your editor. Open a terminal in that folder. Do not run commands while still browsing inside the ZIP.

• README.md: setup, contracts, commands and expected results.
• asset_tools.py and asset_cli.py: complete worked references.
• practice.py and practice_cli.py: your intentionally incomplete starters.
• check_module.py: repeatable checks that exercise changed inputs and refused cases.

The kit never renames media or creates a delivery folder. A calculated destination is only a preview.

3. Verify the worked reference

python check_module.py
python asset_cli.py --help
python asset_cli.py --project Museum --shot detail --version 12 --frames 29970 --fps 29.97 --date 2026-10-08

Replace python with py -3 or python3 as appropriate. The check command reports 16 tests and OK. The CLI preview reports Museum_detail_v12.mp4, 16:40.000, a destination under your local sample-output root ending in the filename, and “No files created, renamed or overwritten.” An absolute path is machine-specific.

This verifies the reference, not your work. In the next build, python check_module.py --target practice --build 1 fails with NotImplementedError until you implement the function. That is expected.

Continue with Module 2: editorial decisions

Finish Module 1’s independent task first. Module 2 has its own kit; do not overwrite your Module 1 work. Extract the download, open a terminal in the new module-2 folder and read its README.

python -X utf8 check_module.py
python -X utf8 qc_cli.py --help
python -X utf8 qc_cli.py validate --width 1920 --codec h264 --seconds 600 --model "Google Veo"

The reference reports 16 tests and OK. The command prints one JSON report: delivery pass, canonical model veo and heuristic adherence score 100, with exit status 0. These are supplied metadata and observations, not video analysis or certification. No files change and no provider is contacted.

inspect reports any valid request with status 0. validate returns 1 when the declared acceptance rules are not met, retaining the report. Malformed input returns 2 with an error and no report. Check the last command’s status with $LASTEXITCODE in PowerShell, or echo $? on macOS/Linux.

The practice files are intentionally unfinished. Start with python -X utf8 check_module.py --target practice --build 1; a failure is expected before you implement it. Then follow Module 2, Build 1. Use python3 -X utf8 or py -3 -X utf8 where appropriate.

Continue with Module 3: process a collection

Keep your earlier modules. Extract this separate kit into a new folder, open its module-3 directory and read the README. It uses only the standard library. Its tiny text files have media suffixes for inventory practice; they are not playable clips, and no media is decoded, renamed or deleted.

python -X utf8 check_module.py
python -X utf8 demo.py --build 1
python -X utf8 demo.py --build 2
python -X utf8 demo.py --build 3
python -X utf8 demo.py --build 4 --output sample-export

The reference check reports 17 tests and OK. Demonstrations inventory four fixture files, summarize 25 invented records, plan 23 paths on four six-up pages and write/read back matching JSON/CSV exports. Build 4 needs an explicitly new output folder: sample-export remains on your computer for inspection and a second run refuses it. Choose another new name; never overwrite earlier work. An I/O failure may leave a partial new folder and is not verification.

These commands check the reference. Implement one function in practice.py, then use --target practice. The export demonstration supplies reviewed reference inventory so an unfinished earlier function does not prevent testing your writer. Start with Module 3, Build 1. Browser preparation for summaries and contact instructions is optional and does not complete your local project.

If the command fails

“Python is not recognized” or “command not found”

Try the platform command above. If none works, install Python from its official source, reopen the terminal and check the version again.

“Can’t open file check_module.py”

You are in the wrong folder. Open the extracted module folder for the build you are following; check its contents with dir in PowerShell or ls on macOS/Linux.

SyntaxError after entering a terminal command

You may be inside Python’s interactive prompt. Exit with exit() and run the command in the terminal.

NotImplementedError in practice.py

The starter is incomplete by design. Follow one build and implement its function; do not replace the starter with the reference just to get a green result.

Tests pass against asset_tools, qc_tools or collection_tools but fail against practice

You have checked the reference, not your implementation. Use --target practice and fix the reported behavior.

Reference and a small glossary

Parameter / argument

A parameter names an input in a function definition; an argument is the value supplied by a caller.

Return / print

Return supplies a value to calling code. Print writes text to the terminal. They are not interchangeable.

Exception

A refused operation or failure that interrupts normal execution; its type and message help explain the cause.

Dry run

A calculation and report with no file mutation. A dry run is not a completed rename.

Exit status

Zero normally means success; a nonzero value tells other programs the command failed.

Self-review / automated check

Self-review is your explanation against a rubric. Automated checks execute specified cases. Neither alone proves complete programming ability.

• Official Python guide: functions
• Official pathlib reference
• Official argparse reference
• Lab refresher: functions

Later portfolio kits introduce a virtual environment and pytest before you submit Portfolio I. Module 1 uses built-in unittest so you can begin offline without installing packages.

Continue with Module 4: Portfolio I

Keep Modules 1–3 and your own media untouched. Extract this separate kit into a new owned folder, open a terminal in module-4 and read README.md. The tiny media-suffix files are text, not playable clips; sidecars hold declared teaching metadata, not measurements. Application code is standard-library-only. pytest is a test tool.

Python 3.11+ is required. Create a virtual environment, then use its interpreter directly: this avoids activation-policy and wrong-Python problems. Initial trusted package installation needs internet or a prepared wheel cache; fixture runs and tests afterward are offline. Do not install arbitrary replacement scripts or use administrator access to force writes.

python -m venv .venv

.venv\Scripts\python.exe -m pip install ".[test]"
.venv\Scripts\python.exe -X utf8 -B -m pytest -q
.venv\Scripts\python.exe -X utf8 -B -m asset_intelligence inspect fixtures/media --dry-run --run-id first-run
$LASTEXITCODE

.venv/bin/python -m pip install ".[test]"
.venv/bin/python -X utf8 -B -m pytest -q
.venv/bin/python -X utf8 -B -m asset_intelligence inspect fixtures/media --dry-run --run-id first-run
echo $?

All 35 reference tests pass. The mixed demonstration inventories six paths: three accepted records and three metadata failures. Accepted verdicts include pass/review/block; summary rows is three and audit has eight events. Exit 1 is expected for this completed mixed report. Exit 2 means malformed/fatal input with no successful stdout report. The reference run is guided evidence, not your independent portfolio.

Use the SAME environment interpreter throughout the lessons; their shorter python commands mean that interpreter. If pytest is missing, check which Python you used. Edit practice.py, then run the relevant -m build1 through -m build4 pytest group with --target practice. NotImplementedError is expected before implementation. Build 4 edits practice_cli.py and integrates your functions.

Copy PORTFOLIO.md into your own notes. Keep setup, assistance, changed inputs, actual exports, refusal and defense visible. Export writes four real files only into a new folder outside source; an existing or partial folder is not overwritten or deleted. A manifest parity flag is not an atomic/durable transaction. No command decodes, renames or transcodes media. Start Module 4, Build 1.

Continue with Module 5: mock HTTP tools

Keep earlier kits and extract this separate download into a new folder. Open its module-5 directory and read README.md. Python 3.11+ is required. HTTPX is this kit’s HTTP library; pytest is the test tool. Create a separate environment and use its interpreter directly.

python -m venv .venv
& .\.venv\Scripts\python.exe -m pip install -e ".[test]"
& .\.venv\Scripts\python.exe -X utf8 -B -m pytest -q
& .\.venv\Scripts\python.exe -X utf8 -B demo.py --build 1

python3 -m venv .venv
./.venv/bin/python -m pip install -e ".[test]"
./.venv/bin/python -X utf8 -B -m pytest -q
./.venv/bin/python -X utf8 -B demo.py --build 1

Initial trusted package installation needs internet or a prepared wheel cache. HTTPX 0.28.1 and pytest 9.1.1 are pinned directly; transitive/build tools are not fully locked. All 155 reference tests pass. The four demos use --build 1 through --build 4; all supplied HTTP requests use MockTransport, no provider account/key or paid call. The three dated prices are invented, not live pricing or FX. Timeouts are phase limits, not a total elapsed deadline; mock tests do not measure real socket timing.

Use this environment interpreter for every shorter lesson command. Edit practice.py for all four builds, including both adapter classes, then select --target practice. Unfinished groups fail with NotImplementedError; unfinished demos return status 2, not success. Reviewed helper/fetch support is disclosed; a reference, quiz or browser pass is not an independent Portfolio II defense. Start Module 5, Build 1.

Reference: HTTPX MockTransport, phase timeouts, Decimal and Protocols. Never replace fixtures with a live paid URL merely to test these lessons.

Continue with Module 6: trustworthy data

Extract this separate kit into a new owned folder and open its module-6 directory. Keep earlier kits, source datasets and media unchanged. The application uses the standard library; pytest is a test tool. Python 3.11+ is required. Read README.md, create a separate environment and use its interpreter directly.

python -m venv .venv
& .\.venv\Scripts\python.exe -m pip install -e ".[test]"
& .\.venv\Scripts\python.exe -X utf8 -B -m pytest -q
& .\.venv\Scripts\python.exe -X utf8 -B demo.py --build 1

python3 -m venv .venv
./.venv/bin/python -m pip install -e ".[test]"
./.venv/bin/python -X utf8 -B -m pytest -q
./.venv/bin/python -X utf8 -B demo.py --build 1

Initial trusted test-tool installation needs internet or a prepared wheel cache; fixtures/tests afterward are offline. Direct pytest 9.1.1 is pinned; transitive/build tools are not fully locked. All 99 reference tests pass. The four demos use --build 1 through --build 4. Build 2 generates and verifies 10,000 actual ordered rows, not a canned count, and requires --out ./my-new-roundtrip. Choose a NEW folder each time: existing/partial outputs are not overwritten or deleted. Other demos read fixtures or mutate only owned temporary copies.

Edit practice.py for all builds and select --target practice. Unfinished groups raise NotImplementedError; unfinished demos return status 2. Use this environment interpreter throughout shorter lesson commands. Reviewed model/parser/path/hash helpers may be reused if disclosed. Source rows and quarantine may contain private text: do not upload production data or send these reports to a tutor automatically.

Fixtures are invented preferences/annotations, not a trained model or completed Dataset Toolkit. needs_review declares no winner or automatic DPO eligibility. Byte hashes are not authenticity, rights or judgment-quality certificates; record streaming still retains growing accepted-ID memory. Keep actual changed inputs, failures, helpers and explanation in your own notes. Start Module 6, Build 1.

References: dataclasses, Enum, JSON parsing/encoding, CSV and SHA-256 hashing.

Continue with Module 7: text pipelines

Keep earlier kits and source data untouched. Extract this separate kit into a new owned folder and open its module-7 directory. Read README.md. Python 3.11+ is required; application functions use the standard library, pytest is a test tool. Create a separate environment and use its interpreter directly.

python -m venv .venv
& .\.venv\Scripts\python.exe -m pip install -e ".[test]"
& .\.venv\Scripts\python.exe -X utf8 -B -m pytest -q
& .\.venv\Scripts\python.exe -X utf8 -B demo.py --build 1

python3 -m venv .venv
./.venv/bin/python -m pip install -e ".[test]"
./.venv/bin/python -X utf8 -B -m pytest -q
./.venv/bin/python -X utf8 -B demo.py --build 1

Initial trusted test-tool installation needs internet or a prepared wheel cache; supplied fixtures afterward are offline. Direct pytest 9.1.1 is pinned; build/transitive tools are not fully locked. All 91 reference tests pass. Use this environment interpreter for every shorter lesson command with -X utf8 -B. Edit practice.py, select the relevant -m build1 through -m build4 test group and --target practice. Unfinished functions raise NotImplementedError; unfinished demos return 2. Demos 1–4 operate on invented fixtures, not actual credentials or media judgments.

Module 7’s filename grammar is narrower than Module 1; ambiguous underscores are refused. Original scanner offsets are Python code points, not bytes/JavaScript units. NFC normalization retains originals and compatibility distinctions; it is not redaction. It can also expand text: corpus search refuses the whole operation if normalized text exceeds the downstream 12,000-code-point scanner budget. No flags is not share-safe evidence. Corpus counts describe per-note mentions, not verified defects: “No jitter” still matches. Diagnostic quarantine is not a source backup, and accepted-ID/evidence memory grows. Keep original source separately and never paste production secrets into the kit or tutor.

Build 4 can optionally export a real NEW JSON file:

python -X utf8 -B demo.py --build 4 --target practice --out ./my-new-practice-report.json

Choose another filename each run, with no .. parent component. Existing outputs, known links and reserved names are refused. Actual bytes/hash/typed read-back establish serialization parity, not analysis correctness/privacy/independence. A later failure can leave a partial new file: no automatic rollback, deletion or overwrite. Browser preparation does not execute this export or complete Portfolio II. Disclose any reviewed input/regex/normalization/masking helpers. Start Module 7, Build 1.

References: fullmatch, groups, spans and regex flags and Unicode NFC versus NFKC.

Continue with Module 8: domain models and Dataset Toolkit

Keep earlier kits untouched. Extract this separate kit into a new owned folder, open its module-8 directory and read README.md. Python 3.11+ is required; application code uses the standard library. Create a separate environment and use its interpreter directly.

python -m venv .venv
& .\.venv\Scripts\python.exe -m pip install -e ".[test]"
& .\.venv\Scripts\python.exe -X utf8 -B -m pytest -q
& .\.venv\Scripts\python.exe -X utf8 -B demo.py --build 1

python3 -m venv .venv
./.venv/bin/python -m pip install -e ".[test]"
./.venv/bin/python -X utf8 -B -m pytest -q
./.venv/bin/python -X utf8 -B demo.py --build 1

Initial trusted test-tool installation needs internet or a prepared wheel cache. Direct pytest 9.1.1 is pinned; build/transitive tools are not fully locked. All 88 reference tests pass; your unfinished functions still fail until implemented. Use this environment interpreter with -X utf8 -B for every shorter lesson command. Edit practice.py and, for Build 4, practice_cli.py. Select -m build1 through -m build4 and --target practice. Demos exist only for Builds 1–3 and unfinished demos return 2. The learner CLI entry point raises NotImplementedError until you implement it; it does not silently succeed.

Trace the reference CLI with the supplied offline sample:

python -X utf8 -B -m evalkit validate sample/preferences.jsonl
python -X utf8 -B -m evalkit audit sample/preferences.jsonl --manifest sample/manifest.json

The invented sample returns status 1 because a tie needs review. Status 0 means this operation completed its schema checks, not dataset approval; status 1 means completed review/provenance conditions require attention; expected input/I/O refusal returns 2 with no success report. Unexpected programming errors remain visible. training_eligibility=not_assessed is deliberate.

Build 4 uses actual local publication, not a browser export or a fourth demo:

python -X utf8 -B practice_cli.py import fixtures/annotations.csv --out ./my-new-practice-bundle
python -X utf8 -B practice_cli.py audit ./my-new-practice-bundle/preferences.jsonl --manifest ./my-new-practice-bundle/manifest.json

Implement your CLI before these commands work. Choose a NEW folder each run under an existing regular parent. Existing outputs, known links, reserved names and parent traversal are refused. A later fault can leave a partial new folder: no overwrite, rollback or automatic deletion. Seven written artifacts include a manifest covering the six others. Actual typed read-back/hash verification does not prove source rights, privacy, authorship or training fitness. Source/quarantine can contain private text: keep the bundle local before sharing review.

Models and Module 6/7 helpers are disclosed reviewed assistance. Signals stay separate from authored findings; rubric scores do not select a winner. Reference tests, browser runs and quiz scores cannot award independent Portfolio II completion or observed defense. Download the Portfolio II evidence template. Start Module 8, Build 1.

References: dataclasses and frozen assignment, Decimal values and contexts and structural Protocols.

Continue with Module 9: regression, debugging and quality tools

Keep earlier kits intact. Extract the separate download into a NEW folder, open its module-9 directory and read README.md. Application code uses the standard library; the actual local test tools need a separate virtual environment. Python 3.11+ is declared; CPython 3.12.10 is verified here, not every operating system/version.

python -m venv .venv
& .\.venv\Scripts\python.exe -m pip install -e ".[test]"
& .\.venv\Scripts\python.exe -X utf8 -B -m quality_tools.gate

python3 -m venv .venv
./.venv/bin/python -m pip install -e ".[test]"
./.venv/bin/python -X utf8 -B -m quality_tools.gate

Initial trusted installation needs internet or a prepared package cache. Direct pytest 9.1.1, Ruff 0.16.10 and mypy 2.4.0 are pinned test tools; build/transitive dependencies are not fully locked. The actual reference gate runs format, lint, strict types and 97 reference tests, then prints four real zero-code steps and passed status. This checks supplied reference behavior, not your independent work. Keep this exact environment interpreter for all lesson commands, replacing python with the platform path above.

Edit practice.py, selecting -m build1 through -m build4 and --target practice with pytest. For Build 1 also author learner_tests/test_regression.py importing from candidate; the verifier supplies that module twice. Blank/print-only/skipped/syntax-error files do not establish corrected exit 0 plus specific-bug exit 1. Missing and unfinished starters remain visibly incomplete.

python -X utf8 -B -m quality_tools.regression --target practice --test learner_tests/test_regression.py
python -X utf8 -B -m quality_tools.gate --target practice

The practice gate needs your completed functions and authored regression. Its reviewed entry audits actual ordered tool execution and refuses forged green reports. Format/lint cover the configured kit files; strict mypy covers quality_tools and practice.py, not every test/example; pytest covers declared behaviors. Nonzero stops later tools, timeout remains visible and the gate never formats automatically. These are real local tools, not browser simulations or independence/portfolio certificates.

Build 2 uses an explicit NEW file under an existing parent. Existing/partial output is not overwritten or automatically deleted; faults can leave partial NEW output without a verified receipt. The synchronous debugging example deliberately raises ZeroDivisionError on missing authored reviews; async is taught later. Keep invented fixtures and raw traceback data local before sharing review. Boundary map, investigation template and actual quality-failure lab describe evidence and supplied-helper limits. Start Module 9, Build 1.

References: pytest exit meanings, Ruff configuration and mypy command scope.

Continue with Module 10: a local evaluation service

Keep earlier kits and environments intact. Extract this separate kit into a NEW owned folder, open a terminal in module-10 and read README.md. This is an actual API and SQLite database on your computer, not a browser simulation or hosted DVP service. Use invented classroom data only. Python 3.11+ is declared; Windows CPython 3.12.10 was verified, not every platform/version.

1. Create a separate environment and check the reference

python -m venv .venv
& .\.venv\Scripts\python.exe -m pip install -e ".[test]"
& .\.venv\Scripts\python.exe -X utf8 -B -m pytest -q
& .\.venv\Scripts\python.exe -X utf8 -B demo.py --build 1

python3 -m venv .venv
./.venv/bin/python -m pip install -e ".[test]"
./.venv/bin/python -X utf8 -B -m pytest -q
./.venv/bin/python -X utf8 -B demo.py --build 1

Initial trusted installation needs internet or a prepared package cache. Direct runtime pins are FastAPI 0.142.2, Pydantic 2.13.5, Starlette 1.7.0 and Uvicorn 0.54.0; test-only pins are pytest 9.1.1 and HTTPX2 2.13.1. Current Starlette TestClient uses HTTPX2; do not replace it with the earlier module’s HTTPX or install into that earlier environment. Build/transitive tooling is not fully locked. All 136 reference cases pass. This verifies the supplied reference, not your own implementation.

Use the exact environment interpreter above for every shorter python command below, keeping -X utf8 -B. Edit practice.py for all four builds and select --target practice with the relevant pytest -m build1 through -m build4 group and demo. Unfinished work raises NotImplementedError or returns a visible nonzero refusal. Demos 1–4 use actual in-process APIs or an owned temporary database; they do not launch a TCP server. Reviewed routes/models/transport/path helpers are disclosed assistance.

2. Start your own reference server

python -X utf8 -B -m evaluation_service init --db ./my-new-reference.db
python -X utf8 -B -m evaluation_service serve --db ./my-new-reference.db --fixture-auth --port 8765

Choose a NEW explicit database filename under an existing owned parent. A second NEW initialization refuses an existing file. Later failures can leave a partial NEW file; inspect it and choose another name, never overwrite or automatically delete it. The server command stays running on 127.0.0.1 only. Open a second terminal for requests; stop only your own server with Ctrl+C. A used port fails visibly: choose another rather than killing an unrelated process. To observe persistence, restart serve on the same database without rerunning NEW initialization.

3. Send an invented request from the second terminal

Public fixture credentials fixture-author-a, fixture-author-b and fixture-reviewer-a are not your DVP tutor login or authenticated human identities. All configured fixture actors can read the classroom records; no tenant/privacy model is supplied. Never substitute a real token or customer data.

$fixtureHeaders = @{Authorization='Bearer fixture-author-a'}
$fixtureBody = '{"asset_id":"Museum_detail","width":1920,"height":1080,"frames":240,"fps":24}'
Invoke-RestMethod -Uri 'http://127.0.0.1:8765/evaluations' -Method Post -Headers $fixtureHeaders -ContentType 'application/json' -Body $fixtureBody

curl --fail-with-body -i http://127.0.0.1:8765/evaluations -H 'Authorization: Bearer fixture-author-a' -H 'Content-Type: application/json' --data '{"asset_id":"Museum_detail","width":1920,"height":1080,"frames":240,"fps":24}'

The actual response is 201 with a fresh 32-character hexadecimal ID and Location; generated IDs are not fixed answers. PowerShell displays the parsed body; curl’s -i includes status/headers. /health/live reports process liveness, not database readiness. /openapi.json exposes the generated schema; interactive /docs uses remote Swagger assets and is not an offline guarantee. API/status/review contract includes reads, finding creation, submit and distinct-reviewer approval/rejection.

4. Build your own boundaries

python -X utf8 -B -m pytest -q -m build1 --target practice
python -X utf8 -B demo.py --build 1 --target practice

Begin with Module 10, Build 1. Complete transformation, safe errors, actual Repository and state transitions before running the full practice suite or practice server. Build 4 exposes those commands explicitly. Keep changed-input results, refusal/migration/rollback/restart evidence and helper disclosure. The service/quiz does not analyze video, authenticate humans, certify a production service or award independent Portfolio III completion.

References: FastAPI testing, Starlette TestClient, Pydantic strict validation and SQLite transactions and parameters.

Continue with Module 11: local operations

Keep earlier kits and environments intact. Download and extract this kit into a NEW owned folder, open a terminal in module-11 and read README.md. Application Python uses the standard library; pytest 9.1.1 is a test tool. Python 3.11+ is declared; Windows CPython 3.12.10 was verified, not every platform/version. Initial trusted installation needs internet or a prepared package cache; build/transitive tools are not fully locked.

1. Create a separate environment

python -m venv .venv
& .\.venv\Scripts\python.exe -m pip install -e ".[test]"
& .\.venv\Scripts\python.exe -X utf8 -B -m pytest -q
& .\.venv\Scripts\python.exe -X utf8 -B demo.py --build 1

python3 -m venv .venv
./.venv/bin/python -m pip install -e ".[test]"
./.venv/bin/python -X utf8 -B -m pytest -q
./.venv/bin/python -X utf8 -B demo.py --build 1

The supplied reference has 469 cases. Use this exact environment interpreter for shorter lesson commands, keeping -X utf8 -B. Edit your extracted practice.py and select --target practice with -m build1 through -m build4. Unfinished boundaries raise NotImplementedError; reference success does not complete your work. Demos exist for Builds 1–3 only. Build 4 uses the actual incident exercise.

2. Configure the trusted inspection tool

Install FFprobe from a trusted FFmpeg distribution yourself; it is not bundled or automatically downloaded. Set DVP_FFPROBE to your executable’s absolute path. Replace the example placeholder below with that real path. The Windows development check used FFprobe 9.0; compatibility with every binary/version is not claimed. No OpenSSL installation is required for learner practice.

$env:DVP_FFPROBE='C:/YOUR/TRUSTED/ffprobe.exe'
& $env:DVP_FFPROBE -version
& .\.venv\Scripts\python.exe -X utf8 -B demo.py --build 3 --ffprobe $env:DVP_FFPROBE --quarantine "$PWD/NEW-reference-quarantine"
& .\.venv\Scripts\python.exe -X utf8 -B incident.py --ffprobe $env:DVP_FFPROBE --output "$PWD/NEW-reference-incident"

export DVP_FFPROBE=/absolute/trusted/ffprobe
"$DVP_FFPROBE" -version
./.venv/bin/python -X utf8 -B demo.py --build 3 --ffprobe "$DVP_FFPROBE" --quarantine "$PWD/NEW-reference-quarantine"
./.venv/bin/python -X utf8 -B incident.py --ffprobe "$DVP_FFPROBE" --output "$PWD/NEW-reference-incident"

Choose a NEW directory each run under an existing owned parent. Existing/partial output is not overwritten or automatically deleted. The media demo measures the included WAV; accepted still means quarantined. The incident runs actual healthy/schema-failure/recovery probes and declared owned-child timeout/fault fixtures, not a real provider outage. Timings and run IDs vary. Operator checklist and fresh-input defense explains the evidence and limits. Never use real keys or private media in this classroom exercise.

3. Optional actual HTTP observation

Only after completing Module 10, use its separate environment for the optional adapter. Do not install Module 11 into it: both kits own practice.py. From the Module 11 folder, replace the Module 10 Python placeholder below and explicitly expose this folder. Keep any previous PYTHONPATH value and restore it afterward. Use the NEW incident database you just created; this adapter does not initialize or repair it. Read README.md for the equivalent macOS/Linux command with command-local PYTHONPATH.

$module10Python='C:/YOUR/EXTRACTED/module-10/.venv/Scripts/python.exe'
$previousModulePath=$env:PYTHONPATH
$env:PYTHONPATH=(Get-Location).Path
try {
  & $module10Python -X utf8 -B -m operation_tools.service --db "$PWD/NEW-reference-incident/owned-incident.db" --ffprobe $env:DVP_FFPROBE --fixture-auth --port 8765
} finally {
  $env:PYTHONPATH=$previousModulePath
}

The server stays on 127.0.0.1; use a second terminal for requests and stop only your own server with Ctrl+C. If the port is used, choose another. From that second terminal, inspect the actual endpoints:

curl.exe -i http://127.0.0.1:8765/health/live
curl.exe -i http://127.0.0.1:8765/health/ready
curl.exe -i http://127.0.0.1:8765/observability/metrics
curl.exe -i http://127.0.0.1:8765/observability/events

On macOS/Linux use curl instead of curl.exe. Liveness is not readiness: actual readiness is 200/503, unexpected observation fault is controlled 500. X-Operation-Run-ID correlates bounded events; fourteen metric cells are process-local and reset on restart. Public fixture credentials are not your DVP tutor login. The site tutor sends nothing until you choose Send. Reference observations and quiz scores do not award independent Portfolio III work or human defense. Begin Module 11, Build 1.

References: asyncio tasks, timeouts and cancellation, FFprobe and TLS certificate verification.

Continue with Module 12: integrate and defend

Finish Modules 9–11. Extract this separate ten-file kit into a NEW owned folder. Use your separately installed Module 10 environment and explicitly expose the extracted Module 11 folder through PYTHONPATH. Do not install Module 11 into Module 10: both own practice.py. Module 12 adds no application dependency. Windows Python 3.12.10 and trusted FFprobe 9.0 were checked; every platform/version is not claimed.

Download complete Windows/macOS/Linux setup and actual commands. Replace the absolute placeholders below with your own paths; keep existing work unchanged. Initial trusted Module 10 installation needs internet or a prepared cache. No paid provider, real key or OpenSSL installation is required.

1. Reference checks and owned server · Windows PowerShell

Run from the extracted module-12 folder. This starts your owned loopback server; use a second terminal for the integration, then Ctrl+C only your own process. If the port is used, choose another consistently. The public cases report 17 passed for reference; --target practice exposes the unfinished integration.

$module10Python='C:/YOUR/EXTRACTED/module-10/.venv/Scripts/python.exe'
$module11Folder='C:/YOUR/EXTRACTED/module-11'
$env:DVP_FFPROBE='C:/YOUR/TRUSTED/ffprobe.exe'
$previousModulePath=$env:PYTHONPATH
$env:PYTHONPATH=$module11Folder
try {
  & $module10Python -X utf8 -B -m pytest -q test_capstone.py
  & $module10Python -X utf8 -B -m evaluation_service init --db "$PWD/NEW-owned.db"
  & $module10Python -X utf8 -B capstone_service.py --db "$PWD/NEW-owned.db" --ffprobe $env:DVP_FFPROBE --fixture-auth --port 8765
} finally {
  $env:PYTHONPATH=$previousModulePath
}

2. Actual workflow · second terminal in module-12

$module10Python='C:/YOUR/EXTRACTED/module-10/.venv/Scripts/python.exe'
$module11Folder='C:/YOUR/EXTRACTED/module-11'
$env:DVP_FFPROBE='C:/YOUR/TRUSTED/ffprobe.exe'
$previousModulePath=$env:PYTHONPATH
$env:PYTHONPATH=$module11Folder
try {
  & $module10Python -X utf8 -B capstone.py --port 8765 --asset Gallery_changed --media "$module11Folder/fixtures/one-second.wav" --mime audio/wav --ffprobe $env:DVP_FFPROBE --output "$PWD/NEW-reference-run"
} finally {
  $env:PYTHONPATH=$previousModulePath
}

The actual NEW export retains accepted-but-quarantined media, supplied metadata, approved revision 3, unreviewed creation snapshot and four audit events. Generated IDs vary. For restart, rerun only capstone_service.py on the SAME DB; never reinitialize it. Partial failures can retain earlier effects without a completed export. Existing output is refused, not overwritten or deleted.

3. Own the system and its explanation

Edit capstone_practice.py and select --target practice explicitly. For your own completed Module 10/11 service use --module10-practice with the absolute trusted file YOU wrote/reviewed and --operation-target practice; see README for exact environment boundaries. The launcher executes only your explicitly selected local Python code and does not initialize, migrate or repair a database. Readiness/liveness is not a learner competence test.

Author SPEC.md, DEFENSE.md and CASE_STUDY.md. These are document tasks, not runnable Python or automatic certificates. No quiz awards an independent defense; keep missing evidence pending. The public fixture credentials are not your DVP tutor login, and the optional tutor sends nothing before explicit Send. Begin Module 12, Build 1.