Initial Hugging Face deployment

.dockerignore

@@ -0,0 +1,13 @@
+__pycache__/
+*.pyc
+*.pyo
+*.log
+_db.sqlite3
+/build
+/tmp
+node_modules
+.idea
+.vscode
+.DS_Store
+db.sqlite3
+policy_guess_anchoring.log

.gitignore

@@ -0,0 +1,14 @@
+venv
+staticfiles
+./db.sqlite3
+.idea
+*~
+*.sqlite3
+_static_root
+_bots*s
+__temp*
+__pycache__/
+*.py[cod]
+.DS_Store
+merge.ps1
+*.otreezip

Dockerfile

@@ -0,0 +1,33 @@
+FROM python:3.11-slim
+
+ENV PYTHONUNBUFFERED=1 \
+    PYTHONDONTWRITEBYTECODE=1 \
+    PIP_NO_CACHE_DIR=1
+
+WORKDIR /app
+
+COPY requirements.txt /app/requirements.txt
+
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends build-essential \
+    && pip install --no-cache-dir -r requirements.txt \
+    && apt-get purge -y build-essential \
+    && apt-get autoremove -y \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY . /app
+
+ENV OTREE_PRODUCTION=1 \
+    OTREE_ADMIN_PASSWORD=changeme \
+    OTREE_DATABASE_URL=sqlite:////data/otree.sqlite3 \
+    PYTHONPATH=/app
+
+RUN mkdir -p /data \
+    && otree collectstatic --noinput
+
+COPY docker-entrypoint.sh /app/entrypoint.sh
+RUN chmod +x /app/entrypoint.sh
+
+EXPOSE 8000
+
+CMD ["/app/entrypoint.sh"]

EXPORTS.md

@@ -0,0 +1,40 @@
+# Exports Guide (ibe-pp)
+
+This note explains the key fields you’ll see in CSV/Excel exports from the demo sessions and how to interpret them in class.
+
+## Common fields
+- session_code, participant_code: Internal identifiers for linking records.
+- app_name, round_number, page_name: Where a row came from.
+- payoff: Participant payoff in the app (points or currency units).
+
+## Classic/Policy Games
+- Prisoner’s Dilemma: `cooperate` (True/False), `payoff`.
+- Trust (simple/framed): `sent_amount`, `sent_back_amount`, `payoff`.
+- Dictator (norms): `kept` (amount P1 kept), `payoff`.
+- Public Goods (base/defaults): `contribution`, group totals (if included), `payoff`.
+
+Interpretation tips
+- Trust: reciprocity shows in `sent_back_amount` relative to `sent_amount`×multiplier.
+- Public Goods: highlight total vs. private trade-off driving `payoff`.
+- Dictator: distribution between P1 and P2 indicates fairness preferences; note framing.
+
+## Survey Biases (policy_survey_biases)
+- Overconfidence (90% CI): `oc1_low`, `oc1_high`, `oc2_low`, `oc2_high`, `oc3_low`, `oc3_high`.
+  - In class: discuss calibration by checking how often intervals would contain the true value (avoid revealing “correct” answers live).
+- Overplacement: `self_rank_policy_knowledge` (1–7).
+  - In class: look at distribution vs. mid-point 4.
+- Confirmation: `agree_statement_before`, `agree_statement_after` (1–7).
+  - In class: look at whether responses moved after the snippet; both change and no-change are informative.
+- Availability: `recall_event` (free text), `priority_energy`, `priority_public_health` (1–7).
+  - In class: discuss how salient events might shift priorities.
+
+## Exporting with bots (optional)
+- Use Make targets to run bots and then export from the admin. For quick bot runs:
+  - `make otree-test-classic`
+  - `make otree-test-policy`
+  - `make otree-test-anchoring`
+  - `make otree-test-survey`
+
+## Notes
+- Avoid showing “correct” answers for overconfidence during class; focus on calibration concepts.
+- Frame findings as illustrations; behavior varies by group, context, and incentives.

LICENSE

@@ -0,0 +1,26 @@
+Copyright (c) 2014 Daniel Li Chen, Martin Walter Schonger, Christopher Wickens.
+
+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.
+
+The Licensee undertakes to mention the name oTree, the names of the licensors
+(Daniel L. Chen, Martin Schonger and Christopher Wickens) and to cite the
+following article in all publications in which results of experiments conducted
+with the Software are  published: Chen, Daniel L., Martin Schonger, and Chris Wickens.
+2016. "oTree - An open-source platform for laboratory, online, and field experiments."
+Journal of Behavioral and Experimental Finance, vol 9: 88-97.

Procfile

@@ -0,0 +1,2 @@
+web: otree prodserver1of2
+worker: otree prodserver2of2

README.md

@@ -0,0 +1,76 @@
+# oTree HF Production Template
+
+This directory packages the IBE public policy oTree demos for deployment on a Hugging Face Space using the Docker runtime. It was cloned from `otree-projects/ibe-pp` and augmented with container and deployment assets.
+
+## Directory Overview
+
+- `Dockerfile` – builds the production image expected by Hugging Face Spaces.
+- `docker-entrypoint.sh` – runtime bootstrap that ensures SQLite initialization, collects static files, and launches the ASGI server.
+- `requirements.txt` – locked dependencies for the production image.
+- `.dockerignore` – keeps dev artifacts (`db.sqlite3`, logs, caches) out of the build context.
+- `settings.py`, apps/, tests/ – unchanged oTree project source.
+
+## Deploying to a Hugging Face Space
+
+1. **Create the Space**
+   - Runtime: `Docker`.
+   - Visibility: choose `Private` or `Public` per your needs.
+2. **Add secrets / environment variables** (Settings → Repository secrets):
+
+   | Key | Purpose | Example |
+   | --- | --- | --- |
+   | `OTREE_ADMIN_PASSWORD` | Protects the oTree admin interface | `set-a-unique-password` |
+   | `OTREE_AUTH_LEVEL` | Optional access control (`STUDY`, `DEMO`, `BASELINE`) | `STUDY` |
+   | `OTREE_DATABASE_URL` | Override DB (defaults to SQLite under `/data`) | `postgres://user:pass@host:5432/dbname` |
+
+   Additional variables such as `SENTRY_DSN`, `OTREE_SECRET_KEY`, or mail settings can also be defined here.
+
+3. **Populate the repository**
+   ```bash
+   # from repository root
+   cd otree-projects/hf-prod-ibe-pp
+   git init  # if pushing standalone
+   git add .
+   git commit -m "Initial oTree HF deployment"
+   git remote add origin https://huggingface.co/spaces/<org>/<space-name>
+   git push origin main
+   ```
+
+4. **Space build & launch**
+   - Hugging Face automatically builds the Docker image.
+   - The container starts `/app/entrypoint.sh`, which:
+     - Creates the SQLite database at `/data/otree.sqlite3` if `OTREE_DATABASE_URL` points to SQLite.
+     - Runs `otree collectstatic --noinput` so static assets are up to date.
+     - Launches `otree prodserver1of2 0.0.0.0:$PORT` (HF sets `$PORT`).
+   - The app becomes available at `https://<org>-<space-name>.hf.space/`.
+
+## Local Verification
+
+To build and run the same image locally before pushing:
+
+```bash
+cd otree-projects/hf-prod-ibe-pp
+DOCKER_BUILDKIT=1 docker build -t ibe-pp-hf .
+docker run --rm -p 8000:8000 \
+  -e OTREE_ADMIN_PASSWORD=changeme \
+  -e OTREE_AUTH_LEVEL=STUDY \
+  ibe-pp-hf
+# open http://localhost:8000/
+```
+
+For persistence, mount a volume:
+```bash
+docker run --rm -p 8000:8000 \
+  -v $(pwd)/data:/data \
+  -e OTREE_ADMIN_PASSWORD=changeme \
+  ibe-pp-hf
+```
+
+## Notes & Customization
+
+- **Database**: The default `OTREE_DATABASE_URL=sqlite:////data/otree.sqlite3` provides demo-ready storage but resets whenever the container restarts on Hugging Face. Point to an external Postgres instance for durable experiments.
+- **Static assets**: Adjust `SKIP_COLLECTSTATIC=1` in the Space secrets to skip the runtime collect step if you pre-build assets during CI.
+- **Session configs**: Update `settings.py` or add new apps as usual; rebuild the Space to apply changes.
+- **Logging / monitoring**: Set `SENTRY_DSN`, `OTREE_PRODUCTION=1` (already set), or add custom logging handlers as desired.
+
+Once pushed, you can administer the server via `https://<space-url>/otree/admin` using the password stored in `OTREE_ADMIN_PASSWORD`.

TESTING.md

@@ -0,0 +1,72 @@
+# Testing Guide (ibe-pp)
+
+This project ships with a complete test suite covering cloned apps and full-session flows. Tests never modify oTree core and run against the local project only.
+
+## Test Types
+- Unit-lite: config and import sanity checks (no DB writes).
+- App bots (oTree): app-level flows in each cloned app (`tests.py` inside the app).
+- E2E sessions (pytest): spins up full sessions via `otree test <session>` using fresh SQLite DBs.
+- Matrix/infra checks: participant-count matrix, rooms/labels, static assets.
+
+## Layout
+- `policy_*/tests.py` – Bot specs per app:
+  - `policy_public_goods_defaults`, `policy_trust_framed`, `policy_dictator_norms`, `policy_guess_anchoring`, `policy_survey_biases`
+  - Patterns used: `expect()` to assert payoffs and `SubmissionMustFail(...)` to test validation failures (see `policy_survey_biases`).
+- `payment_info/tests.py` – No-op bot to satisfy multi-app sessions.
+- `tests/test_integration_settings.py` – Verifies session configs and app folders.
+- `tests/test_e2e_bots.py` – Runs E2E bots for configured sessions (`policy_nudges`, `anchoring_demo`, `survey_biases_full`).
+
+Survey Biases (policy_survey_biases) modules and tests
+- Module A (Information and Views): randomized order `order_a ∈ {info_before, info_after}` with a comprehension check. Bots cover both branches and include a negative case via `SubmissionMustFail` for a wrong comprehension answer.
+- Module B (Statements and Evidence): randomized order `order_b ∈ {support_first, eval_first}`. Bots cover both branches.
+- Module C (Topics and News): randomized order `order_c ∈ {recall_first, opinion_first}` with validation requiring ~20 characters for each recall text. Bots assert negative cases (short input) then submit valid responses.
+- Results page safely handles optional fields using `field_maybe_none(...)` to avoid null access during rendering.
+
+Running just the survey biases suite
+- `make otree-test-survey` (fresh SQLite DB) or:
+  - `source scripts/activate_venv.sh && cd otree-projects/ibe-pp && OTREE_DATABASE_URL=sqlite:///tmp_survey.sqlite3 otree test survey_biases_full`
+- `tests/test_session_matrix_and_rooms.py` – Participant-count matrix (valid/invalid), rooms label file presence, and static file presence.
+- `tests/test_static_http.py` – Optional HTTP check for `/_static/custom.css` when `RUN_OTREE_HTTP_TESTS=1`.
+
+## How To Run
+- Quick run (recommended):
+  - `make test-ibe-pp` (pytest over `tests/`)
+  - `make test-otree-e2e` (serial bot runs across key sessions)
+- Manual (from project root):
+  - `source scripts/activate_venv.sh`
+  - `cd otree-projects/ibe-pp && pytest -q tests`
+- Single E2E:
+  - `cd otree-projects/ibe-pp && pytest -q tests/test_e2e_bots.py::test_bots_policy_nudges_sequence`
+- Optional HTTP static check:
+  - `RUN_OTREE_HTTP_TESTS=1 cd otree-projects/ibe-pp && pytest -q tests/test_static_http.py`
+
+## Dependencies
+- Added to root `requirements.txt`: `pytest`, `requests`, `httpx`, `starlette==0.14.1`.
+- Pin rationale: oTree 5.11.4 bots expect Starlette 0.14.x; newer Starlette breaks bot TestClient.
+- If running FastAPI tooling simultaneously, consider a dedicated test requirements file or separate venv.
+
+## E2E Strategy
+- Tests set `OTREE_DATABASE_URL=sqlite:///test_db_<name>.sqlite3` to isolate DBs.
+- If you run `otree test` manually and see “delete your database”, remove `db.sqlite3` or set `OTREE_DATABASE_URL`.
+- Participant-count matrix asserts success/failure for group-size compatibility.
+
+## Adding Tests
+- New app: add `tests.py` alongside `__init__.py` with a `PlayerBot(Bot)` and yields for each page.
+- Use `expect()` to assert key state (e.g., payoffs), and `SubmissionMustFail(...)` for invalid input branches.
+- New session: add a test in `tests/test_e2e_bots.py` invoking `run_otree_test('<session_name>')`.
+
+## Common Issues
+- Missing dependencies for bots: install `requests` and `httpx` (already in `requirements.txt`).
+- Name collisions: cloned apps set unique `NAME_IN_URL` values; keep this when adding apps.
+- Timeouts: `prisoner.Introduction` now uses `get_timeout_seconds`; override with `session.config['prisoner_intro_timeout']` in `settings.py` if needed, for example:
+
+  ```python
+  SESSION_CONFIGS = [
+      dict(
+          name='classic_baseline',
+          app_sequence=['sequence_welcome', 'prisoner', 'trust_simple', 'public_goods_simple', 'payment_info'],
+          num_demo_participants=6,
+          prisoner_intro_timeout=30,  # seconds (optional)
+      ),
+  ]
+  ```

_rooms/econ101.txt

@@ -0,0 +1,3 @@
+Alice
+Bob
+Charlie

_rooms/lab_demo.txt

@@ -0,0 +1,10 @@
+# Optional participant labels for lab demo (one per line).
+# You can leave this file empty to allow unlabeled participants.
+alpha
+bravo
+charlie
+delta
+echo
+foxtrot
+golf
+hotel

_static/custom.css

@@ -0,0 +1,47 @@
+/* Accessibility & readability tweaks for oTree pages */
+
+html, body {
+  font-size: 18px; /* larger base for readability */
+  line-height: 1.5;
+}
+
+.container, .otree-body {
+  max-width: 900px;
+}
+
+/* Buttons */
+.btn, button, input[type=submit] {
+  padding: 0.6rem 1rem;
+  font-size: 1rem;
+  border-radius: 6px;
+}
+
+.btn-primary {
+  background-color: #0a58ca; /* higher contrast */
+  border-color: #0a58ca;
+}
+
+.btn-primary:hover, .btn-primary:focus {
+  background-color: #084298;
+  border-color: #084298;
+}
+
+/* Inputs */
+input[type=number], input[type=text], textarea, select {
+  padding: 0.5rem 0.75rem;
+  font-size: 1rem;
+}
+
+/* Focus visibility */
+a:focus, button:focus, .btn:focus, input:focus, select:focus, textarea:focus {
+  outline: 3px solid #ffbf47; /* distinct focus ring */
+  outline-offset: 2px;
+}
+
+/* Cards spacing */
+.card.bg-light.m-3 .card-body { font-size: 0.98rem; }
+
+/* Lists in instructions */
+ul { margin-top: 0.25rem; }
+li { margin-bottom: 0.25rem; }
+

_templates/global/Page.html

@@ -0,0 +1,8 @@
+{{ extends "otree/Page.html" }}
+{{ load otree static }}
+
+{{ block global_styles  }}
+  <link rel="stylesheet" href="{{ static 'custom.css' }}">
+{{ endblock }}
+{{ block global_scripts  }}
+{{ endblock }}

bargaining/Introduction.html

@@ -0,0 +1,7 @@
+{{ block title }}Introduction{{ endblock }}
+{{ block content }}
+
+  <p class="alert alert-info small" role="note"><strong>Note:</strong> Points convert to a bonus at the end of the study.</p>
+    {{ include_sibling 'instructions.html' }}
+    {{ next_button }}
+{{ endblock }}

bargaining/Request.html

@@ -0,0 +1,12 @@
+{{ block title }}Request{{ endblock }}
+{{ block content }}
+
+    <p>How much will you demand for yourself?</p>
+
+    {{ formfields }}
+
+    <p>{{ next_button }}</p>
+
+    {{ include_sibling 'instructions.html' }}
+    
+{{ endblock }}

bargaining/Results.html

@@ -0,0 +1,26 @@
+{{ block title }}Results{{ endblock }}
+{{ block content }}
+    <table class=table style="width: auto">
+        <tr>
+            <th>You demanded</th>
+            <td>{{ player.request }}</td>
+        </tr>
+        <tr>
+            <th>The other participant demanded</th>
+            <td>{{ other_player_request }}</td>
+        </tr>
+        <tr>
+            <th>Sum of your demands</th>
+            <td>{{ group.total_requests }}</td>
+        </tr>
+        <tr>
+            <th>Thus you earn</th>
+            <td>{{ player.payoff }}</td>
+        </tr>
+    </table>
+
+    <p>{{ next_button }}</p>
+
+    {{ include_sibling 'instructions.html' }}
+
+{{ endblock }}

bargaining/__init__.py

@@ -0,0 +1,75 @@
+from otree.api import *
+
+
+
+
+doc = """
+This bargaining game involves 2 players. Each demands for a portion of some
+available amount. If the sum of demands is no larger than the available
+amount, both players get demanded portions. Otherwise, both get nothing.
+"""
+
+
+class C(BaseConstants):
+    NAME_IN_URL = 'bargaining'
+    PLAYERS_PER_GROUP = 2
+    NUM_ROUNDS = 1
+    AMOUNT_SHARED = cu(100)
+
+
+class Subsession(BaseSubsession):
+    pass
+
+
+class Group(BaseGroup):
+    total_requests = models.CurrencyField()
+
+
+class Player(BasePlayer):
+    request = models.CurrencyField(
+        doc="""
+        Amount requested by this player.
+        """,
+        min=0,
+        max=C.AMOUNT_SHARED,
+        label="Please enter an amount from 0 to 100",
+    )
+
+
+# FUNCTIONS
+def set_payoffs(group: Group):
+    players = group.get_players()
+    group.total_requests = sum([p.request for p in players])
+    if group.total_requests <= C.AMOUNT_SHARED:
+        for p in players:
+            p.payoff = p.request
+    else:
+        for p in players:
+            p.payoff = cu(0)
+
+
+def other_player(player: Player):
+    return player.get_others_in_group()[0]
+
+
+# PAGES
+class Introduction(Page):
+    pass
+
+
+class Request(Page):
+    form_model = 'player'
+    form_fields = ['request']
+
+
+class ResultsWaitPage(WaitPage):
+    after_all_players_arrive = set_payoffs
+
+
+class Results(Page):
+    @staticmethod
+    def vars_for_template(player: Player):
+        return dict(other_player_request=other_player(player).request)
+
+
+page_sequence = [Introduction, Request, ResultsWaitPage, Results]

bargaining/instructions.html

@@ -0,0 +1,20 @@
+
+<div class="card bg-light m-3">
+
+    <div class="card-body">
+        <h3>
+            Instructions
+        </h3>
+
+        <p>
+            You have been randomly and anonymously paired with another participant.
+            There is {{ C.AMOUNT_SHARED }} for you to divide.
+            Both of you have to simultaneously and independently demand a portion
+            of the {{ C.AMOUNT_SHARED }} for yourselves. If the sum of your
+            demands is smaller or equal to {{ C.AMOUNT_SHARED }}, both of
+            you get what you demanded. If the sum of your demands is larger
+            than {{ C.AMOUNT_SHARED }},
+            both of you get nothing.
+        </p>
+    </div>
+</div>

bertrand/Decide.html

@@ -0,0 +1,11 @@
+{{ block title }}Set Your Price{{ endblock }}
+{{ block content }}
+
+    {{ formfields }}
+
+
+    <p>{{ next_button }}</p>
+
+    {{ include_sibling 'instructions.html' }}
+
+{{ endblock }}

bertrand/Introduction.html

@@ -0,0 +1,7 @@
+{{ block title }}Introduction{{ endblock }}
+{{ block content }}
+
+  <p class="alert alert-info small" role="note"><strong>Note:</strong> Points convert to a bonus at the end of the study.</p>
+    {{ include_sibling 'instructions.html' }}
+    {{ next_button }}
+{{ endblock }}

bertrand/Results.html

@@ -0,0 +1,26 @@
+{{ block title }}Results{{ endblock }}
+{{ block content }}
+    <table class="table">
+        <tr>
+            <th>Your price</th>
+            <td>{{ player.price }}</td>
+        </tr>
+        <tr>
+            <th>Lowest price</th>
+            <td>{{ group.winning_price }}</td>
+        </tr>
+        <tr>
+            <th>Was your product sold?</th>
+            <td>{{ if player.is_winner }} Yes {{ else }} No {{ endif }}</td>
+        </tr>
+        <tr>
+            <th>Your payoff</th>
+            <td>{{ player.payoff }}</td>
+        </tr>
+    </table>
+
+    {{ next_button }}
+
+    {{ include_sibling 'instructions.html' }}
+
+{{ endblock }}

bertrand/__init__.py

@@ -0,0 +1,73 @@
+from otree.api import *
+
+
+
+doc = """
+2 firms complete in a market by setting prices for homogenous goods.
+See "Kruse, J. B., Rassenti, S., Reynolds, S. S., & Smith, V. L. (1994).
+Bertrand-Edgeworth competition in experimental markets.
+Econometrica: Journal of the Econometric Society, 343-371."
+"""
+
+
+class C(BaseConstants):
+    PLAYERS_PER_GROUP = 2
+    NAME_IN_URL = 'bertrand'
+    NUM_ROUNDS = 1
+    MAXIMUM_PRICE = cu(100)
+
+
+class Subsession(BaseSubsession):
+    pass
+
+
+class Group(BaseGroup):
+    winning_price = models.CurrencyField()
+
+
+class Player(BasePlayer):
+    price = models.CurrencyField(
+        min=0,
+        max=C.MAXIMUM_PRICE,
+        doc="""Price player offers to sell product for""",
+        label="Please enter an amount from 0 to 100 as your price",
+    )
+    is_winner = models.BooleanField()
+
+
+# FUNCTIONS
+def set_payoffs(group: Group):
+    import random
+
+    players = group.get_players()
+    group.winning_price = min([p.price for p in players])
+    winners = [p for p in players if p.price == group.winning_price]
+    winner = random.choice(winners)
+    for p in players:
+        if p == winner:
+            p.is_winner = True
+            p.payoff = p.price
+        else:
+            p.is_winner = False
+            p.payoff = cu(0)
+
+
+# PAGES
+class Introduction(Page):
+    pass
+
+
+class Decide(Page):
+    form_model = 'player'
+    form_fields = ['price']
+
+
+class ResultsWaitPage(WaitPage):
+    after_all_players_arrive = set_payoffs
+
+
+class Results(Page):
+    pass
+
+
+page_sequence = [Introduction, Decide, ResultsWaitPage, Results]

bertrand/instructions.html

@@ -0,0 +1,19 @@
+
+<div class="instructions well well-lg" style="">
+
+    <h3>
+        Instructions
+    </h3>
+    <p>
+        You have been randomly and anonymously paired with another participant.
+        Each of you will represent a firm. Each firm manufactures one unit of
+        the same product at no cost.
+    </p>
+    <p>
+        Each of you privately sets your price, anything from 0 to {{ C.MAXIMUM_PRICE }}.
+        The buyer in the market will always buy one unit of the product at the
+        lower price. In case of a tie, the buyer will buy from one of you at
+        random. Your profit is your price if your product is sold and zero
+        otherwise.
+    </p>
+</div>

common_value_auction/Bid.html

@@ -0,0 +1,19 @@
+{{ block title }}Bid{{ endblock }}
+{{ block content }}
+
+    <p>
+        The value of the item is estimated to be {{ player.item_value_estimate }}.
+        This estimate may deviate from the actual value by at most {{ C.BID_NOISE }}.
+    </p>
+
+    <p>
+        Please make your bid now. The amount can be between {{ C.BID_MIN }} and {{ C.BID_MAX }}, inclusive.
+    </p>
+
+    {{ formfields }}
+
+    {{ next_button }}
+
+    {{ include_sibling 'instructions.html' }}
+
+{{ endblock }}

common_value_auction/Introduction.html

@@ -0,0 +1,10 @@
+{{ block title }}Introduction{{ endblock }}
+{{ block content }}
+
+    <p class="alert alert-info small" role="note"><strong>Note:</strong> Points convert to a bonus at the end of the study.</p>
+
+    {{ include_sibling 'instructions.html' }}
+
+    {{ next_button }}
+
+{{ endblock }}

common_value_auction/Results.html

@@ -0,0 +1,37 @@
+{{ block title }}Results{{ endblock }}
+{{ block content }}
+
+    <p>
+        {{ if player.is_winner }}
+            You won the auction!
+            {{ if is_greedy }}
+                However, your bid amount was higher than the actual value of the item. Your payoff is therefore zero.
+            {{ elif player.payoff == 0 }}
+                Your payoff, however, is zero.
+            {{ endif }}
+        {{ else }}
+            You did not win the auction.
+        {{ endif }}
+    </p>
+
+    <table class="table" style="width:400px">
+
+        <tr>
+            <th>Your bid</th>
+            <th>Winning bid</th>
+            <th>Actual value</th>
+            <th>Your payoff</th>
+        </tr>
+
+    <tr>
+        <td>{{ player.bid_amount }}</td>
+        <td>{{ group.highest_bid }}</td>
+        <td>{{ group.item_value }}</td>
+        <td>{{ player.payoff }}</td>
+    </tr>
+
+    </table>
+
+    {{ next_button }}
+
+{{ endblock }}

common_value_auction/__init__.py

@@ -0,0 +1,122 @@
+from otree.api import *
+
+
+doc = """
+In a common value auction game, players simultaneously bid on the item being
+auctioned.<br/>
+Prior to bidding, they are given an estimate of the actual value of the item.
+This actual value is revealed after the bidding.<br/>
+Bids are private. The player with the highest bid wins the auction, but
+payoff depends on the bid amount and the actual value.<br/>
+"""
+
+
+class C(BaseConstants):
+    NAME_IN_URL = 'common_value_auction'
+    PLAYERS_PER_GROUP = None
+    NUM_ROUNDS = 1
+    BID_MIN = cu(0)
+    BID_MAX = cu(10)
+    # Error margin for the value estimates shown to the players
+    BID_NOISE = cu(1)
+
+
+class Subsession(BaseSubsession):
+    pass
+
+
+class Group(BaseGroup):
+    item_value = models.CurrencyField(
+        doc="""Common value of the item to be auctioned, random for treatment"""
+    )
+    highest_bid = models.CurrencyField()
+
+
+class Player(BasePlayer):
+    item_value_estimate = models.CurrencyField(
+        doc="""Estimate of the common value, may be different for each player"""
+    )
+    bid_amount = models.CurrencyField(
+        min=C.BID_MIN,
+        max=C.BID_MAX,
+        doc="""Amount bidded by the player""",
+        label="Bid amount",
+    )
+    is_winner = models.BooleanField(
+        initial=False, doc="""Indicates whether the player is the winner"""
+    )
+
+
+# FUNCTIONS
+def creating_session(subsession: Subsession):
+    for g in subsession.get_groups():
+        import random
+
+        item_value = random.uniform(C.BID_MIN, C.BID_MAX)
+        g.item_value = round(item_value, 1)
+
+
+def set_winner(group: Group):
+    import random
+
+    players = group.get_players()
+    group.highest_bid = max([p.bid_amount for p in players])
+    players_with_highest_bid = [p for p in players if p.bid_amount == group.highest_bid]
+    winner = random.choice(
+        players_with_highest_bid
+    )  # if tie, winner is chosen at random
+    winner.is_winner = True
+    for p in players:
+        set_payoff(p)
+
+
+def generate_value_estimate(group: Group):
+    import random
+
+    estimate = group.item_value + random.uniform(-C.BID_NOISE, C.BID_NOISE)
+    estimate = round(estimate, 1)
+    if estimate < C.BID_MIN:
+        estimate = C.BID_MIN
+    if estimate > C.BID_MAX:
+        estimate = C.BID_MAX
+    return estimate
+
+
+def set_payoff(player: Player):
+    group = player.group
+
+    if player.is_winner:
+        player.payoff = group.item_value - player.bid_amount
+        if player.payoff < 0:
+            player.payoff = 0
+    else:
+        player.payoff = 0
+
+
+# PAGES
+class Introduction(Page):
+    @staticmethod
+    def before_next_page(player: Player, timeout_happened):
+        group = player.group
+
+        player.item_value_estimate = generate_value_estimate(group)
+
+
+class Bid(Page):
+    form_model = 'player'
+    form_fields = ['bid_amount']
+
+
+class ResultsWaitPage(WaitPage):
+    after_all_players_arrive = set_winner
+
+
+class Results(Page):
+    @staticmethod
+    def vars_for_template(player: Player):
+        group = player.group
+
+        return dict(is_greedy=group.item_value - player.bid_amount < 0)
+
+
+page_sequence = [Introduction, Bid, ResultsWaitPage, Results]

common_value_auction/instructions.html

@@ -0,0 +1,35 @@
+
+<div class="card bg-light m-3">
+<div class="card-body">
+    <h3>
+        Instructions
+    </h3>
+    <p>
+        You have been randomly and anonymously grouped with other players.
+        All players see these same instructions.
+    </p>
+
+    <p>
+        Your task will be to bid for an item that is being auctioned.
+        Prior to bidding, each player will be given an estimate of the actual
+        value of the item. The estimates may be different between players.
+        The actual value of the item, which is common to all players, will be
+        revealed after the bidding has taken place.
+    </p>
+
+    <p>
+        Based on the value estimate, each player will submit a single bid
+        within a given range.
+        All bids are private and submitted at the same time.
+    </p>
+
+    <p>
+        The highest bidder will receive the actual value of the item as payoff
+        minus their own bid amount.
+        If the winner's bid amount is higher than the actual value of the item,
+        the payoff will be zero.
+        In the event of a tie between two or more players, the winner will be
+        chosen at random. Other players will receive nothing.
+    </p>
+</div>
+</div>

cournot/Decide.html

@@ -0,0 +1,10 @@
+{{ block title }}Production{{ endblock }}
+{{ block content }}
+
+    {{ formfields }}
+
+    {{ next_button }}
+
+    {{ include_sibling 'instructions.html' }}
+
+{{ endblock }}

cournot/Introduction.html

@@ -0,0 +1,10 @@
+{{ block title }}Introduction{{ endblock }}
+{{ block content }}
+
+    <p class="alert alert-info small" role="note"><strong>Note:</strong> Points convert to a bonus at the end of the study.</p>
+
+    {{ include_sibling 'instructions.html' }}
+
+    {{ next_button }}
+
+{{ endblock }}

cournot/Results.html

@@ -0,0 +1,39 @@
+{{ block title }}Results{{ endblock }}
+{{ block content }}
+
+    <p>The results are shown in the following table.</p>
+
+    <table class="table">
+
+        <tr>
+            <td>Your firm produced:</td>
+            <td>{{ player.units }} units</td>
+        </tr>
+
+        <tr>
+            <td>The other firm produced:</td>
+            <td>{{ other_player_units }} units</td>
+        </tr>
+
+        <tr>
+            <td>Total production:</td>
+            <td>{{ group.total_units }} units</td>
+        </tr>
+
+        <tr>
+            <td style="border-top-width:4px">Unit selling price:</td>
+            <td style="border-top-width:4px">{{ C.TOTAL_CAPACITY }} – {{ group.total_units }} = {{ group.unit_price }}</td>
+        </tr>
+
+        <tr>
+            <td>Your profit:</td>
+            <td>{{ player.payoff }}</td>
+        </tr>
+
+    </table>
+
+    {{ next_button }}
+
+    {{ include_sibling 'instructions.html' }}
+
+{{ endblock }}

cournot/__init__.py

@@ -0,0 +1,73 @@
+from otree.api import *
+
+
+
+doc = """
+In Cournot competition, firms simultaneously decide the units of products to
+manufacture. The unit selling price depends on the total units produced. In
+this implementation, there are 2 firms competing for 1 period.
+"""
+
+
+class C(BaseConstants):
+    NAME_IN_URL = 'cournot'
+    PLAYERS_PER_GROUP = 2
+    NUM_ROUNDS = 1
+    # Total production capacity of all players
+    TOTAL_CAPACITY = 60
+    MAX_UNITS_PER_PLAYER = int(TOTAL_CAPACITY / PLAYERS_PER_GROUP)
+
+
+class Subsession(BaseSubsession):
+    pass
+
+
+class Group(BaseGroup):
+    unit_price = models.CurrencyField()
+    total_units = models.IntegerField(doc="""Total units produced by all players""")
+
+
+class Player(BasePlayer):
+    units = models.IntegerField(
+        min=0,
+        max=C.MAX_UNITS_PER_PLAYER,
+        doc="""Quantity of units to produce""",
+        label="How many units will you produce (from 0 to 30)?",
+    )
+
+
+# FUNCTIONS
+def set_payoffs(group: Group):
+    players = group.get_players()
+    group.total_units = sum([p.units for p in players])
+    group.unit_price = C.TOTAL_CAPACITY - group.total_units
+    for p in players:
+        p.payoff = group.unit_price * p.units
+
+
+def other_player(player: Player):
+    return player.get_others_in_group()[0]
+
+
+# PAGES
+class Introduction(Page):
+    pass
+
+
+class Decide(Page):
+    form_model = 'player'
+    form_fields = ['units']
+
+
+class ResultsWaitPage(WaitPage):
+    body_text = "Waiting for the other participant to decide."
+    after_all_players_arrive = set_payoffs
+
+
+class Results(Page):
+    @staticmethod
+    def vars_for_template(player: Player):
+        return dict(other_player_units=other_player(player).units)
+
+
+page_sequence = [Introduction, Decide, ResultsWaitPage, Results]

cournot/instructions.html

@@ -0,0 +1,42 @@
+
+<div class="card bg-light m-3">
+    <div class="card-body">
+
+    <h3>
+        Instructions
+    </h3>
+
+    <p>
+        You have been randomly and anonymously paired with another participant.
+        Each of you will represent a firm. Both firms manufacture the same product.
+    </p>
+
+    <p>
+        The two of you decide simultaneously and independently how many units to manufacture.
+        Your choices can be any number from 0 to {{ C.MAX_UNITS_PER_PLAYER }}.
+        All produced units will be sold, but the more is produced, the lower the unit selling price will be.
+    </p>
+
+
+    <p>
+        The unit selling price is:
+    </p>
+
+    <ul>
+        <strong>Unit selling price = {{ C.TOTAL_CAPACITY }} – Units produced by your firm – Units produced by the other firm</strong>
+    </ul>
+
+    <p>
+        Your profit is therefore:
+    </p>
+
+    <ul>
+        <strong>Your profit = Unit selling price × Units produced by your firm</strong>
+    </ul>
+
+    <p>
+        For your convenience, these instructions will remain available to you on all subsequent screens of this study.
+    </p>
+
+</div>
+</div>

dictator/Introduction.html

@@ -0,0 +1,7 @@
+{{ block title }}Introduction{{ endblock }}
+{{ block content }}
+
+  <p class="alert alert-info small" role="note"><strong>Note:</strong> Points convert to a bonus at the end of the study.</p>
+    {{ include_sibling 'instructions.html' }}
+    {{ next_button }}
+{{ endblock }}

dictator/Offer.html

@@ -0,0 +1,15 @@
+{{ block title }}Your Decision{{ endblock }}
+{{ block content }}
+    <p>
+        You are <strong>Participant 1</strong>.
+        Please decide how much of the {{ C.ENDOWMENT }}
+        you will keep for yourself.
+    </p>
+
+    {{ formfields }}
+
+    {{ next_button }}
+
+    {{ include_sibling 'instructions.html' }}
+
+{{ endblock }}

dictator/Results.html

@@ -0,0 +1,15 @@
+{{ block title }}Results{{ endblock }}
+{{ block content }}
+    <p>
+
+        {{ if player.id_in_group == 1 }}
+            You decided to keep <strong>{{ group.kept }}</strong> for yourself.
+        {{ else }}
+            Participant 1 decided to keep <strong>{{ group.kept }}</strong>, so
+            you got <strong>{{ offer }}</strong>.
+        {{ endif }}
+
+        {{ next_button }}
+    </p>
+    {{ include_sibling 'instructions.html' }}
+{{ endblock }}

dictator/__init__.py

@@ -0,0 +1,73 @@
+from otree.api import *
+
+
+
+doc = """
+One player decides how to divide a certain amount between himself and the other
+player.
+See: Kahneman, Daniel, Jack L. Knetsch, and Richard H. Thaler. "Fairness
+and the assumptions of economics." Journal of business (1986):
+S285-S300.
+"""
+
+
+class C(BaseConstants):
+    NAME_IN_URL = 'dictator'
+    PLAYERS_PER_GROUP = 2
+    NUM_ROUNDS = 1
+    # Initial amount allocated to the dictator
+    ENDOWMENT = cu(100)
+
+
+class Subsession(BaseSubsession):
+    pass
+
+
+class Group(BaseGroup):
+    kept = models.CurrencyField(
+        doc="""Amount dictator decided to keep for himself""",
+        min=0,
+        max=C.ENDOWMENT,
+        label="I will keep",
+    )
+
+
+class Player(BasePlayer):
+    pass
+
+
+# FUNCTIONS
+def set_payoffs(group: Group):
+    p1 = group.get_player_by_id(1)
+    p2 = group.get_player_by_id(2)
+    p1.payoff = group.kept
+    p2.payoff = C.ENDOWMENT - group.kept
+
+
+# PAGES
+class Introduction(Page):
+    pass
+
+
+class Offer(Page):
+    form_model = 'group'
+    form_fields = ['kept']
+
+    @staticmethod
+    def is_displayed(player: Player):
+        return player.id_in_group == 1
+
+
+class ResultsWaitPage(WaitPage):
+    after_all_players_arrive = set_payoffs
+
+
+class Results(Page):
+    @staticmethod
+    def vars_for_template(player: Player):
+        group = player.group
+
+        return dict(offer=C.ENDOWMENT - group.kept)
+
+
+page_sequence = [Introduction, Offer, ResultsWaitPage, Results]

dictator/instructions.html

@@ -0,0 +1,20 @@
+
+<div class="card bg-light m-3">
+<div class="card-body">
+    <h3>
+        Instructions
+    </h3>
+
+    <p>
+        You will be paired randomly and anonymously with another participant.
+        In this study, one of you will be Participant 1 and the other
+        Participant 2. Prior to making a decision, you will learn your role,
+        which will be randomly assigned.
+    </p>
+    <p>
+        There is {{ C.ENDOWMENT }} to split. Participant 1 will
+        decide how much she or he will retain. Then the rest will go to
+        Participant 2.
+    </p>
+</div>
+</div>

docker-entrypoint.sh

@@ -0,0 +1,33 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+log() {
+  echo "[entrypoint] $*"
+}
+
+DB_URL="${OTREE_DATABASE_URL:-sqlite:////data/otree.sqlite3}"
+DB_PATH=""
+
+if [[ "$DB_URL" == sqlite:////* ]]; then
+  DB_PATH="/${DB_URL#sqlite:////}"
+elif [[ "$DB_URL" == sqlite:///* ]]; then
+  DB_PATH="${DB_URL#sqlite:///}"
+fi
+
+if [[ -n "$DB_PATH" ]]; then
+  DB_DIR=$(dirname "$DB_PATH")
+  mkdir -p "$DB_DIR"
+  if [[ ! -f "$DB_PATH" ]]; then
+    log "Initializing SQLite database at $DB_PATH"
+    otree resetdb --noinput
+  fi
+fi
+
+if [[ "${SKIP_COLLECTSTATIC:-0}" != "1" ]]; then
+  log "Collecting static assets"
+  otree collectstatic --noinput
+fi
+
+PORT="${PORT:-8000}"
+log "Starting oTree prodserver on 0.0.0.0:${PORT}"
+exec otree prodserver1of2 0.0.0.0:${PORT}

guess_two_thirds/Guess.html

@@ -0,0 +1,16 @@
+{{ block title }}Your Guess{{ endblock }}
+{{ block content }}
+
+    {{ if player.round_number > 1 }}
+        <p>
+            Here were the two-thirds-average values in previous rounds:
+            {{ two_thirds_avg_history }}
+        </p>
+    {{ endif }}
+
+    {{ formfields }}
+    {{ next_button }}
+
+    {{ include_sibling 'instructions.html' }}
+
+{{ endblock }}

guess_two_thirds/Introduction.html

@@ -0,0 +1,10 @@
+{{ block title }}Introduction{{ endblock }}
+{{ block content }}
+
+  <p class="alert alert-info small" role="note"><strong>Note:</strong> Points convert to a bonus at the end of the study.</p>
+
+    {{ include_sibling 'instructions.html' }}
+
+    {{ next_button }}
+
+{{ endblock }}

guess_two_thirds/Results.html

@@ -0,0 +1,35 @@
+{{ block title }}Results{{ endblock }}
+{{ block content }}
+
+    <p>Here were the numbers guessed:</p>
+
+    <p>
+        {{ sorted_guesses }}
+    </p>
+
+    <p>
+        Two-thirds of the average of these numbers is {{ group.two_thirds_avg }};
+        the closest guess was {{ group.best_guess }}.
+    </p>
+
+    <p>Your guess was {{ player.guess }}.</p>
+
+    <p>
+        {{ if player.is_winner }}
+            {{ if group.num_winners > 1 }}
+                Therefore, you are one of the {{ group.num_winners }} winners
+                who tied for the best guess.
+            {{ else }}
+                Therefore, you win!
+            {{ endif }}
+        {{ else }}
+            Therefore, you did not win.
+        {{ endif }}
+    Your payoff is {{ player.payoff }}.
+    </p>
+
+    {{ next_button }}
+
+    {{ include_sibling 'instructions.html' }}
+
+{{ endblock }}

guess_two_thirds/__init__.py

@@ -0,0 +1,86 @@
+from otree.api import *
+
+
+doc = """
+a.k.a. Keynesian beauty contest.
+Players all guess a number; whoever guesses closest to
+2/3 of the average wins.
+See https://en.wikipedia.org/wiki/Guess_2/3_of_the_average
+"""
+
+
+class C(BaseConstants):
+    PLAYERS_PER_GROUP = 3
+    NUM_ROUNDS = 3
+    NAME_IN_URL = 'guess_two_thirds'
+    JACKPOT = cu(100)
+    GUESS_MAX = 100
+
+
+class Subsession(BaseSubsession):
+    pass
+
+
+class Group(BaseGroup):
+    two_thirds_avg = models.FloatField()
+    best_guess = models.IntegerField()
+    num_winners = models.IntegerField()
+
+
+class Player(BasePlayer):
+    guess = models.IntegerField(
+        min=0, max=C.GUESS_MAX, label="Please pick a number from 0 to 100:"
+    )
+    is_winner = models.BooleanField(initial=False)
+
+
+# FUNCTIONS
+def set_payoffs(group: Group):
+    players = group.get_players()
+    guesses = [p.guess for p in players]
+    two_thirds_avg = (2 / 3) * sum(guesses) / len(players)
+    group.two_thirds_avg = round(two_thirds_avg, 2)
+    group.best_guess = min(guesses, key=lambda guess: abs(guess - group.two_thirds_avg))
+    winners = [p for p in players if p.guess == group.best_guess]
+    group.num_winners = len(winners)
+    for p in winners:
+        p.is_winner = True
+        p.payoff = C.JACKPOT / group.num_winners
+
+
+def two_thirds_avg_history(group: Group):
+    return [g.two_thirds_avg for g in group.in_previous_rounds()]
+
+
+# PAGES
+class Introduction(Page):
+    @staticmethod
+    def is_displayed(player: Player):
+        return player.round_number == 1
+
+
+class Guess(Page):
+    form_model = 'player'
+    form_fields = ['guess']
+
+    @staticmethod
+    def vars_for_template(player: Player):
+        group = player.group
+
+        return dict(two_thirds_avg_history=two_thirds_avg_history(group))
+
+
+class ResultsWaitPage(WaitPage):
+    after_all_players_arrive = set_payoffs
+
+
+class Results(Page):
+    @staticmethod
+    def vars_for_template(player: Player):
+        group = player.group
+
+        sorted_guesses = sorted(p.guess for p in group.get_players())
+        return dict(sorted_guesses=sorted_guesses)
+
+
+page_sequence = [Introduction, Guess, ResultsWaitPage, Results]

guess_two_thirds/instructions.html

@@ -0,0 +1,27 @@
+
+<div class="card bg-light m-3">
+    <div class="card-body">
+
+    <h3>
+        Instructions
+    </h3>
+
+    <p>
+        You are in a group of {{ C.PLAYERS_PER_GROUP }} people.
+        Each of you will be asked to choose a
+        number between 0 and {{ C.GUESS_MAX }}.
+        The winner will be the participant whose
+        number is closest to 2/3 of the
+        average of all chosen numbers.
+    </p>
+
+    <p>
+        The winner will receive {{ C.JACKPOT }}.
+        In case of a tie, the {{ C.JACKPOT }}
+        will be equally divided among winners.
+    </p>
+
+    <p>This game will be played for {{ C.NUM_ROUNDS }} rounds.</p>
+
+</div>
+</div>

matching_pennies/Choice.html

@@ -0,0 +1,43 @@
+{{ block title }}Round {{ subsession.round_number }} of {{ C.NUM_ROUNDS }}{{ endblock }}
+{{ block content }}
+
+    <h4>Instructions</h4>
+    <p>
+        This is a matching pennies game.
+        Player 1 is the 'Mismatcher' and wins if the choices mismatch;
+        Player 2 is the 'Matcher' and wins if they match.
+
+    </p>
+
+    <p>
+        At the end, a random round will be chosen for payment.
+    </p>
+
+    <p>
+
+    <h4>Round history</h4>
+    <table class="table">
+        <tr>
+            <th>Round</th>
+            <th>Player and outcome</th>
+        </tr>
+        {{ for p in player_in_previous_rounds }}
+            <tr>
+                <td>{{ p.round_number }}</td>
+                <td>
+                  You were the {{ p.role }}
+                  and {{ if p.is_winner }} won {{ else }} lost {{ endif }}
+                </td>
+            </tr>
+        {{ endfor }}
+    </table>
+
+    <p>
+        In this round, you are the {{ player.role }}.
+    </p>
+
+    {{ formfields }}
+
+    {{ next_button }}
+
+{{ endblock }}

matching_pennies/ResultsSummary.html

@@ -0,0 +1,25 @@
+{{ block title }}Final results{{ endblock }}
+{{ block content }}
+
+    <table class="table">
+        <tr>
+            <th>Round</th>
+            <th>Player and outcome</th>
+        </tr>
+        {{ for p in player_in_all_rounds }}
+            <tr>
+                <td>{{ p.round_number }}</td>
+                <td>
+                  You were the {{ p.role }}
+                  and {{ if p.is_winner }} won {{ else }} lost {{ endif }}
+                </td>
+            </tr>
+        {{ endfor }}
+    </table>
+
+    <p>
+        The paying round was {{ paying_round }}.
+        Your total payoff is therefore {{ total_payoff }}.
+    </p>
+
+{{ endblock }}

matching_pennies/__init__.py

@@ -0,0 +1,100 @@
+from otree.api import *
+
+
+doc = """
+A demo of how rounds work in oTree, in the context of 'matching pennies'
+"""
+
+
+class C(BaseConstants):
+    NAME_IN_URL = 'matching_pennies'
+    PLAYERS_PER_GROUP = 2
+    NUM_ROUNDS = 4
+    STAKES = cu(100)
+
+    MATCHER_ROLE = 'Matcher'
+    MISMATCHER_ROLE = 'Mismatcher'
+
+
+class Subsession(BaseSubsession):
+    pass
+
+
+class Group(BaseGroup):
+    pass
+
+
+class Player(BasePlayer):
+    penny_side = models.StringField(
+        choices=[['Heads', 'Heads'], ['Tails', 'Tails']],
+        widget=widgets.RadioSelect,
+        label="I choose:",
+    )
+    is_winner = models.BooleanField()
+
+
+# FUNCTIONS
+def creating_session(subsession: Subsession):
+    session = subsession.session
+    import random
+
+    if subsession.round_number == 1:
+        paying_round = random.randint(1, C.NUM_ROUNDS)
+        session.vars['paying_round'] = paying_round
+    if subsession.round_number == 3:
+        # reverse the roles
+        matrix = subsession.get_group_matrix()
+        for row in matrix:
+            row.reverse()
+        subsession.set_group_matrix(matrix)
+    if subsession.round_number > 3:
+        subsession.group_like_round(3)
+
+
+def set_payoffs(group: Group):
+    subsession = group.subsession
+    session = group.session
+
+    p1 = group.get_player_by_id(1)
+    p2 = group.get_player_by_id(2)
+    for p in [p1, p2]:
+        is_matcher = p.role == C.MATCHER_ROLE
+        p.is_winner = (p1.penny_side == p2.penny_side) == is_matcher
+        if subsession.round_number == session.vars['paying_round'] and p.is_winner:
+            p.payoff = C.STAKES
+        else:
+            p.payoff = cu(0)
+
+
+# PAGES
+class Choice(Page):
+    form_model = 'player'
+    form_fields = ['penny_side']
+
+    @staticmethod
+    def vars_for_template(player: Player):
+        return dict(player_in_previous_rounds=player.in_previous_rounds())
+
+
+class ResultsWaitPage(WaitPage):
+    after_all_players_arrive = set_payoffs
+
+
+class ResultsSummary(Page):
+    @staticmethod
+    def is_displayed(player: Player):
+        return player.round_number == C.NUM_ROUNDS
+
+    @staticmethod
+    def vars_for_template(player: Player):
+        session = player.session
+
+        player_in_all_rounds = player.in_all_rounds()
+        return dict(
+            total_payoff=sum([p.payoff for p in player_in_all_rounds]),
+            paying_round=session.vars['paying_round'],
+            player_in_all_rounds=player_in_all_rounds,
+        )
+
+
+page_sequence = [Choice, ResultsWaitPage, ResultsSummary]

payment_info/PaymentInfo.html

@@ -0,0 +1,30 @@
+{{ block title }}Thank you{{ endblock }}
+{{ block content }}
+
+    <p>
+        <em>Below are examples of messages that could be displayed for different experimental settings.</em>
+    </p>
+
+    <div class="panel panel-default" style="margin-bottom:10px">
+        <div class="panel-body">
+            <p><b>Laboratory:</b></p>
+            <p>Please remain seated until your number is called. Then take your number card, and proceed to the cashier.</p>
+            <p><em>Note: For the cashier in the laboratory, oTree can print a list of payments for all participants as a PDF.</em></p>
+        </div>
+    </div>
+
+    <div class="panel panel-default" style="margin-bottom:10px">
+        <div class="panel-body">
+            <p><b>Classroom:</b></p>
+            <p><em>If you want to keep track of how students did, the easiest thing is to assign the starting links to students by name.
+                It is even possible to give each student a single permanent link for a whole semester using Rooms;
+                so no need to waste time in each lecture with handing out new links and keeping track of which student uses which link.
+                Alternatively, you may just give
+                students anonymous links or secret nicknames.</em>
+            </p>
+        </div>
+    </div>
+
+
+{{ endblock }}
+

payment_info/__init__.py

@@ -0,0 +1,38 @@
+from otree.api import *
+
+
+
+doc = """
+This application provides a webpage instructing participants how to get paid.
+Examples are given for the lab and Amazon Mechanical Turk (AMT).
+"""
+
+
+class C(BaseConstants):
+    NAME_IN_URL = 'payment_info'
+    PLAYERS_PER_GROUP = None
+    NUM_ROUNDS = 1
+
+
+class Subsession(BaseSubsession):
+    pass
+
+
+class Group(BaseGroup):
+    pass
+
+
+class Player(BasePlayer):
+    pass
+
+
+# FUNCTIONS
+# PAGES
+class PaymentInfo(Page):
+    @staticmethod
+    def vars_for_template(player: Player):
+        participant = player.participant
+        return dict(redemption_code=participant.label or participant.code)
+
+
+page_sequence = [PaymentInfo]

payment_info/tests.py

@@ -0,0 +1,8 @@
+from otree.api import Bot
+
+
+class PlayerBot(Bot):
+    def play_round(self):
+        # No inputs; placeholder bot to satisfy session testing
+        pass
+