bhushanj221/Ai_interview

Edudiagno published catalogue

Everything the desktop app downloads. Upload this whole folder to the Hugging Face dataset; the app reads it from https://huggingface.co/datasets/<user>/<name>/resolve/main/.

The JSON in this folder is generated. Do not hand-edit it. The source of truth is gen/. Edit the Python there, then run python gen/build_dataset.py && python build_catalog.py. Hand edits are silently overwritten on the next build, and hand-written coding test cases break the guarantee below.

Current size: 1,017 MCQs, 1,071 coding problems (5,337 test cases), 25 interview pools of 500 questions each (12,500 total).

Every coding expected value is produced by executing that problem's reference solution at build time. This is why the generator exists: a hand-typed expected output that is subtly wrong fails a candidate who wrote correct code, and you would not find out.

catalog.json                    the index — browsed first, always
assessment_<key>.json           one per assessment  (downloaded only when a teacher adds it)
<position>.json                 interview question pool for that role
mcq_common.json                 shared MCQ pool      (common to every assessment)
coding_common.json              shared coding pool   (common to every assessment)
index.csv                       position -> pool lookup

Bundled (not downloaded) content

Three folders here are compiled into the .exe by PyInstaller rather than fetched over the network, so they work with no connection at all. They live in this repo so the same authoring workflow covers everything, but uploading them to Hugging Face has no effect on the app:

Folder	Used by
sql/	SQL Lab datasets + challenges
dsa/	DSA practice bank for the Code Playground
python_course/	the "Learn Python from Scratch" course

python_course/index.json lists the modules; each module is one file under python_course/lessons/, with its exercises, interview questions and narration in the matching python_course/practice/<module-id>.json. Every lesson's code and every exercise's reference solution is executed by core/tests/test_python_course.py — a snippet that raises, prints nothing, or calls input() fails the suite, because students load these straight into the Visual Runner. Lesson and exercise ids must be globally unique.

PythonNotesForProfessionals.pdf — reference only, do not copy from it

PythonNotesForProfessionals.pdf (GoalKicker) sits in this folder as a curriculum reference. Page 26 states it is compiled from Stack Overflow Documentation and that "Text content is released under Creative Commons BY-SA".

CC BY-SA requires attribution and ShareAlike — licensing derivative work under the same terms — which does not fit a proprietary product. It is also exactly what the "write original questions" rule in core/question_pools/README.md exists to prevent.

So: mine its table of contents to find topics worth covering, then write our own examples. Never paste its text or code into a lesson. Original examples are also the only ones we can guarantee are correct, because ours are executed by the test suite.

Two kinds of pool

	Interview pools	Common pools
Files	frontend.json, java-backend.json, …	mcq_common.json, coding_common.json
Scope	Per role — tied to one job	Shared by every assessment
Downloaded	only with an assessment that uses it	always, on every sync
Used by	the AI interview round	the MCQ and coding rounds

Common pools are imported into the app's shared question tables, and each exam draws a fresh random subset, so two candidates sitting the same assessment do not get the same paper.

---

Adding a new assessment

1. Write the interview pool — <position>.json

A JSON array of question strings. Aim for 50+; a bigger pool means less overlap between candidates.

[
  "How would you design a REST endpoint that returns a large collection?",
  "What is the difference between an index and a primary key?"
]

Rules: under ~40 words, one concept each, answerable out loud (no "write a function that…"), avoid yes/no phrasing, and write them yourself — copying from interview sites is copyright infringement.

2. Write the assessment — assessment_<key>.json

{
  "assessment_key": "backend-python",
  "title": "Python Backend Developer Assessment",
  "job_title": "Backend Developer",
  "specialization": "Python, APIs, SQL",
  "position_id": "backend-python",
  "difficulty": "any",
  "job_description": "We are hiring a Python Backend Developer to …",
  "has_mcq": true, "has_coding": true, "has_interview": true,
  "mcq_count": 20, "coding_count": 1, "interview_count": 10,
  "mcq_minutes": 10, "coding_minutes": 15, "interview_minutes": 15
}

position_id must match the pool filename (backend-python → backend-python.json). assessment_key is permanent — changing it creates a second assessment instead of updating. The counts and minutes are only defaults; each teacher can change them afterwards.

3. Rebuild catalog.json and index.csv

Checksums must match or the app rejects the download. Run from this folder:

python build_catalog.py

4. Upload

Upload the changed files to the Hugging Face dataset. Every install picks the new assessment up on its next sync (within 6 hours, or immediately when a teacher opens the catalogue) — but nothing is downloaded to a college's machine until a teacher actually adds it.

---

How updates reach installed machines

Appending questions to a published pool is the supported way to grow the bank, and it needs no special handling. Rewriting a file changes its bytes, so build_catalog.py writes a new sha256, and every install notices on its next sync.

The sync is checksum-driven in both directions:

• Unchanged file → not downloaded at all. Each install records the sha256 of every file it has imported (sync_state table). If the catalogue still publishes that checksum, the file is skipped. This matters now that coding_common.json is close to a megabyte — without it, every install pulled ~1.3 MB four times a day forever to learn nothing had changed.
• Changed file → downloaded, verified, merged. Import is idempotent and matches on question text (MCQ), problem title (coding) and question text (interview pools), so only genuinely new entries are inserted. Re-syncing a pool that grew from 45 to 1,017 questions adds 972 rows and leaves the original 45 alone.

Known limitation: because matching is on text, editing an existing question in place does not propagate — a corrected correct_index on a question whose wording is unchanged will not reach machines that already imported it. Adding and removing work; in-place correction does not. If you need to fix a wrong answer, change the question's wording too, or the fix will not land.

---

Editing an existing assessment

• Job description / title / role → edit assessment_<key>.json, rebuild, upload. Installed copies update on the next sync. Teacher settings (counts, durations, priority) are never overwritten.
• Add interview questions → append to <position>.json, rebuild, upload. New questions merge into installed pools; duplicates are ignored.
• Add MCQs or coding problems → append to mcq_common.json / coding_common.json, rebuild, upload. They become available to every assessment.

Common MCQ format

{"text": "Which data structure uses FIFO ordering?",
 "options": ["Queue", "Stack", "Tree", "Graph"],
 "correct_index": 0, "category": "Data structures", "difficulty": "easy"}

Vary correct_index — build_catalog.py shuffles options so the answer is not always first.

Common coding format

{"title": "Sum of numbers", "category": "Arrays", "difficulty": "easy",
 "statement": "Read a line of space-separated integers and print their sum.",
 "starter_code": "import sys\n\ndef main():\n    ...\n",
 "time_limit_secs": 5,
 "tests": [{"input": "3 7 11\n", "expected": "21"}]}

input goes to stdin; stdout is compared to expected after trimming. Compute expected outputs by running a reference solution — never write them by hand, or a correct submission will fail.