JobMarketStar/JobMarketStar_codex_init.yaml at main · mengysun/JobMarketStar · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
# JobMarketStar_codex.yaml
#
# R1 University job ads search using Codex CLI.
# The Python runner is generic; all job-specific behavior is in this file.

task_name: JobMarketStar_R1_codex

input:
  # Path to the CSV of R1 universities (relative to this YAML file).
  csv_path: R1_university.csv

  # Map CSV columns -> variable names used in the prompt_template.
  csv_column_mapping:
    name: university_name
    city: city
    state: state

  # CSV columns that must be non-empty to process the row.
  required_columns:
    - name

codex:
  # Codex model to use (you can change this freely).
  model: gpt-5.1-codex-mini

  # Directory Codex will treat as the workspace (for reading/writing files).
  workspace_dir: .

  # Extra args to pass to `codex exec` (kept generic for future use).
  extra_exec_args: []

# Single natural-language prompt template.
# The Python script will only do: prompt_template.format(**vars_from_csv)
prompt_template: |
  You are an expert in using web search to find current academic job postings.

  For this run you are working on exactly one university, taken from a CSV row:
    - Name: {university_name}
    - City: {city}
    - State: {state}

  Your task:

  1. Use public web search to look for CURRENT, actively open job postings at this
     university that match ALL of the following criteria:
       - Position type: Tenure Track Assistant Professor (exclude associate/full)
       - Research areas: at least one of
         * "Evolutionary Biology"
         * "Human Genetics"
         * "Computational Biology"
         * "Population Genetics"
         * "Disease Genetics"
         * "Human Evolution"

  2. Use general web search and the university's own job portal. IMPORTANT: When
     constructing search queries, use quoted phrases for the research area subfields
     and university name to ensure more accurate results. Example queries:
       - Assistant Professor "Evolutionary Biology" "{university_name}"
       - Assistant Professor "Human Genetics" "{university_name}"
       - Assistant Professor "Computational Biology" "{university_name}"
       - Assistant Professor "Population Genetics" "{university_name}"
       - Assistant Professor "Disease Genetics" "{university_name}"
       - Assistant Professor "Human Evolution" "{university_name}"
       - Tenure Track "Evolution" "{university_name}"
       - Tenure Track "Genetics" "{university_name}"

  3. For each qualifying job posting you find:
       - Confirm that the URL is valid and currently loads.
       - Confirm that the posting is an actual job ad and not an index/portal page.
       - Confirm that it is clearly a tenure-track Assistant Professor role and
         that the topic matches at least one of the target research areas.

     Extract at least:
       - url: direct URL to the job posting page
       - field: short label describing the research area (e.g., "Evolutionary Biology")
       - title: official job title as written on the posting
       - post_date: posting date, formatted as YYYY-MM-DD when possible,
                    or a human-readable date if necessary
       - deadline: application deadline, formatted as YYYY-MM-DD when possible,
                   or "Open until filled" or a similar phrase
       - summary: 1–3 sentence plain-English summary of the position and key points

     If post_date or deadline are not stated, use the literal string "not_available"
     for that field.

  4. You have permission to read and write files inside your current workspace.
     Use those capabilities to produce a structured output file:

       - Ensure a directory named "job_ads_jsonl" exists in the workspace
         (create it if necessary).
       - Derive a safe file name for this university as follows:
           * Take the value of {university_name} exactly as given.
           * Convert it to lowercase.
           * Replace any sequence of non-alphanumeric characters with a single
             underscore.
           * Strip leading/trailing underscores.
         Call the result SAFE_NAME.
       - Write a JSON Lines (JSONL) file at:
           job_ads_jsonl/SAFE_NAME.jsonl

  5. The JSONL file must follow this format:
       - Each line is one job ad.
       - Each line is a single JSON object with exactly these keys:
           "university", "city", "state",
           "url", "field", "title",
           "post_date", "deadline", "summary"
       - For every line:
           - "university" is the original {university_name}
           - "city" is {city}
           - "state" is {state}
           - "url", "field", "title", "post_date", "deadline", "summary" are
             derived from the job posting as described above.

     The file should contain one line per qualifying job posting.

  6. If you find NO qualifying job postings:
       - Still ensure that the directory "job_ads_jsonl" exists.
       - Create an empty JSONL file at the path:
           job_ads_jsonl/SAFE_NAME.jsonl
       - Do not write any placeholder rows into that file.

  7. You may print progress and explanations to the terminal as plain text,
     but the Python runner will not parse that output. The JSONL file is the
     primary output artifact. Make sure it exists and follows the specified
     format when you are finished.

  The original CSV row (in JSON form) is:
  {row_json}

  Think step by step: plan your searches, run them, inspect the pages, and then
  write the resulting JSONL file exactly as specified above.