Backend (LFS enabled)

.env.example

@@ -0,0 +1,9 @@
+# Google Gemini API Configuration
+# Get your API key from https://ai.google.dev/
+GROQ_API_KEY=your-groq-api-key-here
+
+# Flask Configuration
+FLASK_ENV=development
+FLASK_DEBUG=True
+FLASK_PORT=5000
+AMBEE_DATA_KEY=your-ambee-data-api-key-here

.gitattributes

@@ -33,3 +33,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.faiss filter=lfs diff=lfs merge=lfs -text
+*.xlsx filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -1,3 +1,75 @@
-papers/*.pdf
+# Environment variables and secrets
 .env
+.env.local
+.env.*.local
+*.key
+*.pem
+
+# Python
 __pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Virtual environments
+venv/
+ENV/
+env/
+.venv
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+.DS_Store
+
+# Logs
+*.log
+logs/
+
+# Database and cache
+*.db
+*.sqlite
+*.sqlite3
+
+*.cache
+
+# Node (if any Node modules in backend)
+node_modules/
+npm-debug.log
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Research papers and large files
+papers/
+*.pdf
+*.tar.gz
+*.zip
+
+# Temporary files
+*.tmp
+.temp/
+

AQI_Combined.csv

@@ -0,0 +1,2980 @@
+Date,AQI
+01-01-2017,345
+02-01-2017,337
+03-01-2017,331
+04-01-2017,381
+05-01-2017,321
+06-01-2017,351
+07-01-2017,278
+08-01-2017,288
+09-01-2017,308
+10-01-2017,247
+11-01-2017,280
+12-01-2017,323
+13-01-2017,326
+14-01-2017,384
+15-01-2017,326
+16-01-2017,355
+17-01-2017,245
+18-01-2017,317
+19-01-2017,300
+20-01-2017,216
+21-01-2017,286
+22-01-2017,365
+23-01-2017,309
+24-01-2017,336
+25-01-2017,366
+26-01-2017,324
+27-01-2017,118
+28-01-2017,212
+29-01-2017,211
+31-01-2017,366
+01-02-2017,273
+02-02-2017,327
+03-02-2017,314
+04-02-2017,336
+05-02-2017,260
+06-02-2017,306
+07-02-2017,148
+08-02-2017,254
+09-02-2017,268
+10-02-2017,249
+11-02-2017,239
+12-02-2017,274
+13-02-2017,279
+14-02-2017,303
+15-02-2017,294
+16-02-2017,284
+17-02-2017,294
+18-02-2017,236
+19-02-2017,237
+20-02-2017,243
+21-02-2017,254
+22-02-2017,236
+23-02-2017,182
+24-02-2017,226
+25-02-2017,208
+26-02-2017,256
+27-02-2017,226
+28-02-2017,266
+01-03-2017,290
+02-03-2017,258
+03-03-2017,141
+04-03-2017,173
+05-03-2017,200
+06-03-2017,177
+07-03-2017,197
+08-03-2017,194
+10-03-2017,90
+11-03-2017,68
+12-03-2017,104
+13-03-2017,150
+14-03-2017,123
+15-03-2017,214
+16-03-2017,207
+17-03-2017,226
+18-03-2017,185
+19-03-2017,222
+20-03-2017,241
+21-03-2017,251
+22-03-2017,242
+23-03-2017,246
+24-03-2017,244
+25-03-2017,197
+26-03-2017,177
+27-03-2017,164
+28-03-2017,218
+30-03-2017,151
+31-03-2017,176
+01-04-2017,223
+02-04-2017,177
+03-04-2017,154
+04-04-2017,165
+05-04-2017,108
+06-04-2017,109
+07-04-2017,351
+08-04-2017,269
+09-04-2017,130
+10-04-2017,144
+11-04-2017,162
+12-04-2017,201
+13-04-2017,282
+14-04-2017,290
+15-04-2017,307
+16-04-2017,291
+17-04-2017,276
+18-04-2017,307
+19-04-2017,262
+20-04-2017,221
+21-04-2017,234
+22-04-2017,244
+23-04-2017,193
+24-04-2017,164
+25-04-2017,189
+26-04-2017,153
+28-04-2017,183
+29-04-2017,190
+30-04-2017,186
+01-05-2017,158
+02-05-2017,240
+03-05-2017,297
+04-05-2017,214
+05-05-2017,332
+06-05-2017,284
+07-05-2017,293
+08-05-2017,278
+09-05-2017,259
+10-05-2017,187
+11-05-2017,218
+12-05-2017,365
+13-05-2017,316
+14-05-2017,284
+15-05-2017,248
+16-05-2017,272
+17-05-2017,183
+18-05-2017,235
+19-05-2017,239
+20-05-2017,221
+21-05-2017,339
+22-05-2017,228
+23-05-2017,222
+24-05-2017,224
+25-05-2017,196
+26-05-2017,250
+27-05-2017,197
+28-05-2017,136
+29-05-2017,130
+30-05-2017,162
+31-05-2017,126
+01-06-2017,200
+02-06-2017,220
+03-06-2017,215
+04-06-2017,237
+05-06-2017,204
+06-06-2017,204
+07-06-2017,126
+08-06-2017,103
+09-06-2017,141
+10-06-2017,177
+11-06-2017,118
+12-06-2017,125
+13-06-2017,139
+14-06-2017,182
+15-06-2017,231
+16-06-2017,154
+17-06-2017,100
+18-06-2017,117
+19-06-2017,210
+20-06-2017,89
+21-06-2017,102
+22-06-2017,124
+23-06-2017,148
+24-06-2017,159
+25-06-2017,195
+26-06-2017,160
+27-06-2017,135
+28-06-2017,102
+29-06-2017,92
+30-06-2017,76
+01-07-2017,114
+02-07-2017,102
+03-07-2017,97
+07-07-2017,108
+08-07-2017,93
+09-07-2017,148
+10-07-2017,117
+11-07-2017,93
+12-07-2017,62
+13-07-2017,71
+14-07-2017,64
+15-07-2017,79
+16-07-2017,90
+17-07-2017,95
+18-07-2017,100
+19-07-2017,106
+20-07-2017,88
+21-07-2017,69
+22-07-2017,55
+23-07-2017,71
+24-07-2017,60
+25-07-2017,68
+26-07-2017,63
+27-07-2017,75
+28-07-2017,70
+29-07-2017,96
+30-07-2017,43
+31-07-2017,48
+24-08-2017,116
+25-08-2017,141
+26-08-2017,114
+27-08-2017,104
+28-08-2017,70
+29-08-2017,68
+30-08-2017,77
+31-08-2017,92
+01-09-2017,69
+02-09-2017,65
+03-09-2017,80
+04-09-2017,106
+05-09-2017,91
+06-09-2017,86
+07-09-2017,82
+08-09-2017,152
+09-09-2017,125
+10-09-2017,154
+11-09-2017,149
+12-09-2017,118
+13-09-2017,141
+14-09-2017,191
+15-09-2017,215
+16-09-2017,137
+17-09-2017,126
+18-09-2017,124
+19-09-2017,152
+20-09-2017,174
+21-09-2017,175
+22-09-2017,67
+23-09-2017,59
+24-09-2017,105
+25-09-2017,143
+26-09-2017,177
+27-09-2017,206
+28-09-2017,205
+29-09-2017,208
+30-09-2017,192
+01-10-2017,170
+02-10-2017,144
+03-10-2017,159
+04-10-2017,220
+05-10-2017,254
+06-10-2017,187
+08-10-2017,234
+09-10-2017,268
+10-10-2017,238
+11-10-2017,252
+12-10-2017,273
+13-10-2017,262
+15-10-2017,272
+16-10-2017,274
+17-10-2017,316
+18-10-2017,286
+19-10-2017,293
+20-10-2017,357
+21-10-2017,396
+22-10-2017,311
+23-10-2017,287
+24-10-2017,294
+25-10-2017,352
+26-10-2017,324
+27-10-2017,332
+28-10-2017,347
+29-10-2017,336
+30-10-2017,328
+31-10-2017,335
+01-11-2017,354
+02-11-2017,285
+03-11-2017,327
+04-11-2017,357
+05-11-2017,363
+06-11-2017,356
+07-11-2017,449
+08-11-2017,487
+09-11-2017,487
+10-11-2017,470
+11-11-2017,431
+12-11-2017,491
+13-11-2017,465
+14-11-2017,384
+15-11-2017,354
+16-11-2017,363
+17-11-2017,307
+18-11-2017,299
+19-11-2017,291
+20-11-2017,325
+21-11-2017,325
+22-11-2017,328
+23-11-2017,316
+24-11-2017,335
+25-11-2017,337
+26-11-2017,361
+27-11-2017,365
+28-11-2017,327
+29-11-2017,344
+30-11-2017,368
+01-12-2017,343
+02-12-2017,333
+03-12-2017,355
+04-12-2017,391
+05-12-2017,380
+06-12-2017,296
+07-12-2017,191
+08-12-2017,217
+09-12-2017,308
+10-12-2017,378
+11-12-2017,363
+12-12-2017,225
+13-12-2017,270
+14-12-2017,285
+15-12-2017,284
+16-12-2017,223
+17-12-2017,199
+18-12-2017,236
+19-12-2017,297
+20-12-2017,372
+21-12-2017,446
+22-12-2017,321
+23-12-2017,228
+24-12-2017,309
+25-12-2017,384
+26-12-2017,342
+27-12-2017,360
+28-12-2017,383
+29-12-2017,367
+30-12-2017,400
+31-12-2017,406
+01-01-2018,406
+02-01-2018,418
+03-01-2018,382
+04-01-2018,366
+05-01-2018,390
+06-01-2018,405
+07-01-2018,355
+08-01-2018,288
+09-01-2018,359
+10-01-2018,352
+11-01-2018,309
+12-01-2018,298
+13-01-2018,359
+14-01-2018,321
+15-01-2018,331
+16-01-2018,255
+17-01-2018,353
+18-01-2018,400
+19-01-2018,406
+20-01-2018,323
+21-01-2018,276
+22-01-2018,342
+23-01-2018,324
+24-01-2018,270
+25-01-2018,243
+26-01-2018,261
+27-01-2018,286
+28-01-2018,300
+29-01-2018,302
+30-01-2018,270
+31-01-2018,244
+01-02-2018,274
+02-02-2018,293
+03-02-2018,243
+04-02-2018,256
+05-02-2018,291
+06-02-2018,287
+07-02-2018,261
+08-02-2018,308
+09-02-2018,335
+10-02-2018,341
+11-02-2018,304
+12-02-2018,178
+13-02-2018,191
+14-02-2018,187
+15-02-2018,187
+16-02-2018,235
+17-02-2018,256
+18-02-2018,257
+19-02-2018,294
+20-02-2018,296
+21-02-2018,308
+22-02-2018,300
+23-02-2018,302
+24-02-2018,320
+25-02-2018,266
+26-02-2018,156
+27-02-2018,160
+28-02-2018,272
+01-03-2018,257
+02-03-2018,260
+03-03-2018,203
+04-03-2018,178
+05-03-2018,172
+06-03-2018,167
+07-03-2018,185
+08-03-2018,245
+09-03-2018,280
+10-03-2018,170
+11-03-2018,170
+12-03-2018,214
+13-03-2018,217
+14-03-2018,267
+15-03-2018,297
+16-03-2018,256
+17-03-2018,186
+18-03-2018,169
+19-03-2018,173
+20-03-2018,217
+21-03-2018,289
+22-03-2018,186
+23-03-2018,151
+24-03-2018,175
+25-03-2018,195
+26-03-2018,183
+27-03-2018,230
+28-03-2018,255
+29-03-2018,213
+30-03-2018,218
+31-03-2018,256
+01-04-2018,195
+02-04-2018,219
+03-04-2018,207
+04-04-2018,203
+05-04-2018,290
+06-04-2018,208
+07-04-2018,143
+08-04-2018,141
+09-04-2018,120
+10-04-2018,230
+11-04-2018,141
+12-04-2018,99
+13-04-2018,188
+14-04-2018,217
+15-04-2018,224
+16-04-2018,285
+17-04-2018,244
+18-04-2018,228
+19-04-2018,244
+20-04-2018,246
+21-04-2018,356
+22-04-2018,211
+23-04-2018,160
+24-04-2018,254
+25-04-2018,266
+26-04-2018,313
+27-04-2018,310
+28-04-2018,301
+29-04-2018,248
+30-04-2018,209
+01-05-2018,177
+02-05-2018,153
+03-05-2018,160
+04-05-2018,139
+05-05-2018,173
+06-05-2018,269
+07-05-2018,211
+08-05-2018,208
+09-05-2018,163
+10-05-2018,190
+11-05-2018,256
+12-05-2018,304
+13-05-2018,215
+14-05-2018,130
+15-05-2018,164
+16-05-2018,190
+17-05-2018,243
+18-05-2018,225
+19-05-2018,242
+20-05-2018,199
+21-05-2018,183
+22-05-2018,212
+23-05-2018,301
+24-05-2018,252
+25-05-2018,251
+26-05-2018,235
+27-05-2018,277
+28-05-2018,275
+29-05-2018,285
+30-05-2018,281
+31-05-2018,208
+01-06-2018,198
+02-06-2018,173
+03-06-2018,174
+04-06-2018,183
+05-06-2018,169
+06-06-2018,136
+07-06-2018,164
+08-06-2018,179
+09-06-2018,127
+10-06-2018,158
+11-06-2018,183
+12-06-2018,296
+13-06-2018,445
+14-06-2018,431
+15-06-2018,447
+16-06-2018,369
+17-06-2018,289
+18-06-2018,171
+19-06-2018,121
+20-06-2018,177
+21-06-2018,226
+22-06-2018,236
+23-06-2018,218
+24-06-2018,183
+25-06-2018,192
+26-06-2018,110
+27-06-2018,93
+28-06-2018,76
+29-06-2018,72
+30-06-2018,96
+01-07-2018,92
+02-07-2018,106
+03-07-2018,114
+04-07-2018,137
+05-07-2018,123
+06-07-2018,147
+07-07-2018,151
+08-07-2018,182
+09-07-2018,157
+10-07-2018,134
+11-07-2018,106
+12-07-2018,143
+13-07-2018,99
+14-07-2018,76
+15-07-2018,76
+16-07-2018,87
+17-07-2018,91
+18-07-2018,106
+19-07-2018,88
+20-07-2018,80
+21-07-2018,111
+22-07-2018,61
+23-07-2018,67
+24-07-2018,90
+25-07-2018,78
+26-07-2018,74
+27-07-2018,54
+28-07-2018,57
+29-07-2018,90
+30-07-2018,115
+31-07-2018,132
+01-08-2018,153
+02-08-2018,235
+03-08-2018,213
+04-08-2018,216
+05-08-2018,241
+06-08-2018,133
+07-08-2018,113
+08-08-2018,86
+09-08-2018,88
+10-08-2018,102
+11-08-2018,96
+12-08-2018,83
+13-08-2018,94
+14-08-2018,117
+15-08-2018,120
+16-08-2018,86
+17-08-2018,84
+18-08-2018,80
+19-08-2018,89
+20-08-2018,137
+21-08-2018,87
+22-08-2018,78
+23-08-2018,69
+24-08-2018,80
+25-08-2018,89
+26-08-2018,78
+27-08-2018,62
+28-08-2018,71
+29-08-2018,68
+30-08-2018,78
+31-08-2018,127
+01-09-2018,114
+02-09-2018,106
+03-09-2018,73
+04-09-2018,112
+05-09-2018,90
+06-09-2018,137
+07-09-2018,91
+08-09-2018,86
+09-09-2018,61
+10-09-2018,84
+11-09-2018,79
+12-09-2018,90
+13-09-2018,103
+14-09-2018,102
+15-09-2018,118
+16-09-2018,121
+17-09-2018,135
+18-09-2018,150
+19-09-2018,154
+20-09-2018,164
+21-09-2018,143
+22-09-2018,54
+23-09-2018,62
+24-09-2018,52
+25-09-2018,55
+26-09-2018,88
+27-09-2018,151
+28-09-2018,197
+29-09-2018,219
+30-09-2018,158
+01-10-2018,148
+02-10-2018,202
+03-10-2018,143
+04-10-2018,201
+05-10-2018,256
+06-10-2018,209
+07-10-2018,181
+08-10-2018,246
+09-10-2018,251
+10-10-2018,241
+11-10-2018,210
+12-10-2018,154
+13-10-2018,262
+14-10-2018,204
+15-10-2018,246
+16-10-2018,291
+17-10-2018,313
+18-10-2018,297
+19-10-2018,276
+20-10-2018,326
+21-10-2018,292
+22-10-2018,272
+23-10-2018,254
+24-10-2018,328
+25-10-2018,331
+26-10-2018,361
+27-10-2018,350
+28-10-2018,366
+29-10-2018,367
+30-10-2018,401
+31-10-2018,358
+01-11-2018,393
+02-11-2018,370
+03-11-2018,340
+04-11-2018,171
+05-11-2018,426
+06-11-2018,338
+07-11-2018,281
+08-11-2018,390
+09-11-2018,423
+10-11-2018,401
+11-11-2018,405
+12-11-2018,399
+13-11-2018,409
+14-11-2018,312
+15-11-2018,217
+16-11-2018,285
+17-11-2018,267
+18-11-2018,311
+19-11-2018,330
+20-11-2018,374
+21-11-2018,374
+22-11-2018,273
+23-11-2018,337
+24-11-2018,249
+25-11-2018,262
+26-11-2018,336
+27-11-2018,352
+28-11-2018,316
+29-11-2018,358
+30-11-2018,352
+01-12-2018,306
+02-12-2018,297
+03-12-2018,328
+04-12-2018,356
+05-12-2018,331
+06-12-2018,349
+07-12-2018,348
+08-12-2018,347
+09-12-2018,374
+10-12-2018,403
+11-12-2018,413
+12-12-2018,392
+13-12-2018,194
+14-12-2018,249
+15-12-2018,261
+16-12-2018,282
+17-12-2018,337
+18-12-2018,353
+19-12-2018,353
+20-12-2018,394
+21-12-2018,386
+22-12-2018,421
+23-12-2018,450
+24-12-2018,448
+25-12-2018,409
+26-12-2018,384
+27-12-2018,399
+28-12-2018,392
+29-12-2018,385
+30-12-2018,415
+31-12-2018,420
+01-01-2019,393
+02-01-2019,430
+03-01-2019,444
+04-01-2019,386
+05-01-2019,407
+06-01-2019,336
+07-01-2019,333
+08-01-2019,320
+09-01-2019,288
+10-01-2019,292
+11-01-2019,371
+12-01-2019,423
+13-01-2019,414
+14-01-2019,247
+15-01-2019,237
+16-01-2019,371
+17-01-2019,440
+18-01-2019,397
+19-01-2019,378
+20-01-2019,404
+21-01-2019,346
+22-01-2019,104
+23-01-2019,212
+24-01-2019,311
+25-01-2019,151
+26-01-2019,233
+27-01-2019,262
+28-01-2019,267
+29-01-2019,276
+30-01-2019,327
+31-01-2019,359
+01-02-2019,306
+02-02-2019,332
+03-02-2019,289
+04-02-2019,288
+05-02-2019,382
+06-02-2019,352
+07-02-2019,176
+08-02-2019,144
+09-02-2019,158
+10-02-2019,276
+11-02-2019,309
+12-02-2019,342
+13-02-2019,367
+14-02-2019,340
+15-02-2019,245
+16-02-2019,276
+17-02-2019,222
+18-02-2019,255
+19-02-2019,221
+20-02-2019,271
+21-02-2019,144
+22-02-2019,186
+23-02-2019,113
+24-02-2019,190
+25-02-2019,217
+26-02-2019,116
+27-02-2019,100
+28-02-2019,170
+01-03-2019,225
+02-03-2019,217
+03-03-2019,117
+04-03-2019,234
+05-03-2019,140
+06-03-2019,186
+07-03-2019,217
+08-03-2019,197
+09-03-2019,187
+10-03-2019,160
+11-03-2019,187
+12-03-2019,134
+13-03-2019,178
+14-03-2019,266
+15-03-2019,154
+16-03-2019,139
+17-03-2019,192
+18-03-2019,196
+19-03-2019,216
+20-03-2019,208
+21-03-2019,242
+22-03-2019,114
+23-03-2019,132
+24-03-2019,121
+25-03-2019,139
+26-03-2019,159
+27-03-2019,171
+28-03-2019,234
+29-03-2019,232
+30-03-2019,233
+31-03-2019,182
+01-04-2019,151
+02-04-2019,198
+03-04-2019,187
+04-04-2019,254
+05-04-2019,264
+06-04-2019,266
+07-04-2019,302
+08-04-2019,264
+09-04-2019,204
+10-04-2019,238
+11-04-2019,183
+12-04-2019,212
+13-04-2019,170
+14-04-2019,137
+15-04-2019,168
+16-04-2019,180
+17-04-2019,84
+18-04-2019,114
+19-04-2019,157
+20-04-2019,198
+21-04-2019,203
+22-04-2019,236
+23-04-2019,247
+24-04-2019,221
+25-04-2019,251
+26-04-2019,215
+27-04-2019,256
+28-04-2019,264
+29-04-2019,248
+30-04-2019,250
+01-05-2019,295
+02-05-2019,257
+03-05-2019,183
+04-05-2019,182
+05-05-2019,227
+06-05-2019,249
+07-05-2019,294
+08-05-2019,357
+09-05-2019,347
+10-05-2019,277
+11-05-2019,251
+12-05-2019,334
+13-05-2019,322
+14-05-2019,153
+15-05-2019,186
+16-05-2019,187
+17-05-2019,265
+18-05-2019,105
+19-05-2019,185
+20-05-2019,206
+21-05-2019,190
+22-05-2019,158
+23-05-2019,223
+24-05-2019,123
+25-05-2019,121
+26-05-2019,142
+27-05-2019,160
+28-05-2019,177
+29-05-2019,185
+30-05-2019,218
+31-05-2019,280
+01-06-2019,264
+02-06-2019,201
+03-06-2019,261
+04-06-2019,169
+05-06-2019,192
+06-06-2019,206
+07-06-2019,173
+08-06-2019,181
+09-06-2019,239
+10-06-2019,207
+11-06-2019,307
+12-06-2019,233
+13-06-2019,175
+14-06-2019,171
+15-06-2019,224
+16-06-2019,178
+17-06-2019,123
+18-06-2019,97
+19-06-2019,199
+20-06-2019,141
+21-06-2019,177
+22-06-2019,189
+23-06-2019,148
+24-06-2019,109
+25-06-2019,133
+26-06-2019,162
+27-06-2019,184
+28-06-2019,191
+29-06-2019,231
+30-06-2019,237
+01-07-2019,183
+02-07-2019,218
+03-07-2019,136
+04-07-2019,103
+05-07-2019,106
+06-07-2019,88
+07-07-2019,91
+08-07-2019,127
+09-07-2019,126
+10-07-2019,148
+11-07-2019,317
+12-07-2019,272
+13-07-2019,275
+14-07-2019,235
+15-07-2019,168
+16-07-2019,93
+17-07-2019,73
+18-07-2019,85
+19-07-2019,145
+20-07-2019,124
+21-07-2019,108
+22-07-2019,112
+23-07-2019,148
+24-07-2019,164
+25-07-2019,78
+26-07-2019,81
+27-07-2019,61
+28-07-2019,64
+29-07-2019,65
+30-07-2019,80
+31-07-2019,80
+01-08-2019,89
+02-08-2019,84
+03-08-2019,89
+04-08-2019,87
+05-08-2019,105
+06-08-2019,76
+07-08-2019,75
+08-08-2019,79
+09-08-2019,75
+10-08-2019,59
+11-08-2019,68
+12-08-2019,57
+13-08-2019,69
+14-08-2019,63
+15-08-2019,75
+16-08-2019,53
+17-08-2019,49
+18-08-2019,49
+19-08-2019,81
+20-08-2019,97
+21-08-2019,109
+22-08-2019,123
+23-08-2019,129
+24-08-2019,147
+25-08-2019,91
+26-08-2019,66
+27-08-2019,117
+28-08-2019,105
+29-08-2019,91
+30-08-2019,101
+31-08-2019,114
+01-09-2019,108
+02-09-2019,96
+03-09-2019,141
+04-09-2019,173
+05-09-2019,95
+06-09-2019,90
+07-09-2019,82
+08-09-2019,77
+09-09-2019,108
+10-09-2019,137
+11-09-2019,168
+12-09-2019,151
+13-09-2019,86
+14-09-2019,72
+15-09-2019,72
+16-09-2019,105
+17-09-2019,135
+18-09-2019,110
+19-09-2019,66
+20-09-2019,90
+21-09-2019,114
+22-09-2019,67
+23-09-2019,83
+24-09-2019,94
+25-09-2019,90
+26-09-2019,74
+27-09-2019,63
+28-09-2019,67
+29-09-2019,60
+30-09-2019,68
+01-10-2019,93
+02-10-2019,90
+03-10-2019,136
+04-10-2019,100
+05-10-2019,98
+06-10-2019,127
+07-10-2019,130
+08-10-2019,112
+09-10-2019,173
+10-10-2019,211
+11-10-2019,216
+12-10-2019,222
+13-10-2019,270
+14-10-2019,252
+15-10-2019,270
+16-10-2019,304
+17-10-2019,284
+18-10-2019,248
+19-10-2019,161
+20-10-2019,238
+21-10-2019,249
+22-10-2019,207
+23-10-2019,242
+24-10-2019,311
+25-10-2019,284
+26-10-2019,287
+27-10-2019,337
+28-10-2019,368
+29-10-2019,400
+30-10-2019,419
+31-10-2019,410
+01-11-2019,484
+02-11-2019,399
+03-11-2019,494
+04-11-2019,407
+05-11-2019,324
+06-11-2019,214
+07-11-2019,309
+08-11-2019,330
+09-11-2019,283
+10-11-2019,321
+11-11-2019,360
+12-11-2019,425
+13-11-2019,456
+14-11-2019,463
+15-11-2019,458
+16-11-2019,357
+17-11-2019,215
+18-11-2019,214
+19-11-2019,242
+20-11-2019,301
+21-11-2019,366
+22-11-2019,360
+23-11-2019,312
+24-11-2019,234
+25-11-2019,252
+26-11-2019,270
+27-11-2019,134
+28-11-2019,106
+29-11-2019,84
+30-11-2019,193
+01-12-2019,250
+02-12-2019,279
+03-12-2019,282
+04-12-2019,296
+05-12-2019,382
+06-12-2019,404
+07-12-2019,371
+08-12-2019,391
+09-12-2019,343
+10-12-2019,369
+11-12-2019,408
+12-12-2019,430
+13-12-2019,240
+14-12-2019,163
+15-12-2019,213
+16-12-2019,186
+17-12-2019,168
+18-12-2019,292
+19-12-2019,362
+20-12-2019,432
+21-12-2019,418
+22-12-2019,322
+23-12-2019,327
+24-12-2019,383
+25-12-2019,350
+26-12-2019,349
+27-12-2019,373
+28-12-2019,409
+29-12-2019,431
+30-12-2019,446
+31-12-2019,387
+01-01-2020,437
+02-01-2020,417
+03-01-2020,352
+04-01-2020,334
+05-01-2020,330
+06-01-2020,325
+07-01-2020,254
+08-01-2020,266
+09-01-2020,203
+10-01-2020,255
+11-01-2020,288
+12-01-2020,348
+13-01-2020,366
+14-01-2020,283
+15-01-2020,218
+16-01-2020,281
+17-01-2020,265
+18-01-2020,243
+19-01-2020,277
+20-01-2020,269
+21-01-2020,364
+22-01-2020,370
+23-01-2020,211
+24-01-2020,151
+25-01-2020,250
+26-01-2020,325
+27-01-2020,345
+28-01-2020,243
+29-01-2020,194
+30-01-2020,202
+31-01-2020,190
+01-02-2020,232
+02-02-2020,244
+03-02-2020,270
+04-02-2020,310
+05-02-2020,312
+06-02-2020,231
+07-02-2020,295
+08-02-2020,289
+09-02-2020,285
+10-02-2020,309
+11-02-2020,323
+12-02-2020,320
+13-02-2020,241
+14-02-2020,173
+15-02-2020,167
+16-02-2020,247
+17-02-2020,293
+18-02-2020,252
+19-02-2020,272
+20-02-2020,230
+21-02-2020,144
+22-02-2020,100
+23-02-2020,225
+24-02-2020,142
+25-02-2020,249
+26-02-2020,274
+27-02-2020,233
+28-02-2020,198
+01-03-2020,90
+02-03-2020,205
+03-03-2020,205
+04-03-2020,195
+05-03-2020,79
+06-03-2020,64
+07-03-2020,67
+08-03-2020,164
+09-03-2020,123
+10-03-2020,188
+11-03-2020,116
+12-03-2020,127
+13-03-2020,173
+14-03-2020,108
+15-03-2020,131
+16-03-2020,139
+17-03-2020,157
+18-03-2020,151
+19-03-2020,186
+20-03-2020,192
+21-03-2020,186
+22-03-2020,191
+23-03-2020,124
+24-03-2020,122
+25-03-2020,77
+26-03-2020,92
+27-03-2020,69
+28-03-2020,45
+29-03-2020,62
+30-03-2020,71
+31-03-2020,76
+01-04-2020,73
+02-04-2020,69
+03-04-2020,79
+04-04-2020,87
+05-04-2020,102
+06-04-2020,142
+07-04-2020,90
+08-04-2020,83
+09-04-2020,86
+10-04-2020,118
+11-04-2020,124
+12-04-2020,94
+13-04-2020,126
+14-04-2020,130
+15-04-2020,155
+16-04-2020,180
+17-04-2020,105
+18-04-2020,98
+19-04-2020,85
+20-04-2020,119
+21-04-2020,87
+22-04-2020,131
+23-04-2020,122
+24-04-2020,139
+25-04-2020,98
+26-04-2020,117
+27-04-2020,89
+28-04-2020,100
+29-04-2020,125
+30-04-2020,138
+01-05-2020,146
+02-05-2020,112
+03-05-2020,93
+04-05-2020,94
+05-05-2020,119
+06-05-2020,139
+07-05-2020,127
+08-05-2020,134
+09-05-2020,144
+10-05-2020,121
+11-05-2020,116
+12-05-2020,125
+13-05-2020,150
+14-05-2020,149
+15-05-2020,123
+16-05-2020,179
+17-05-2020,200
+18-05-2020,206
+19-05-2020,212
+20-05-2020,166
+21-05-2020,147
+22-05-2020,199
+23-05-2020,181
+24-05-2020,172
+25-05-2020,153
+26-05-2020,154
+27-05-2020,156
+28-05-2020,188
+29-05-2020,101
+30-05-2020,78
+31-05-2020,72
+01-06-2020,104
+02-06-2020,124
+03-06-2020,122
+04-06-2020,153
+05-06-2020,111
+06-06-2020,102
+07-06-2020,107
+08-06-2020,108
+09-06-2020,139
+10-06-2020,152
+11-06-2020,141
+12-06-2020,153
+13-06-2020,123
+14-06-2020,154
+15-06-2020,115
+16-06-2020,118
+17-06-2020,109
+18-06-2020,95
+19-06-2020,148
+20-06-2020,149
+21-06-2020,98
+22-06-2020,92
+23-06-2020,76
+24-06-2020,66
+25-06-2020,85
+26-06-2020,105
+27-06-2020,108
+28-06-2020,209
+29-06-2020,230
+30-06-2020,102
+01-07-2020,117
+02-07-2020,127
+03-07-2020,156
+04-07-2020,105
+05-07-2020,90
+06-07-2020,90
+07-07-2020,65
+08-07-2020,51
+09-07-2020,78
+10-07-2020,67
+11-07-2020,68
+12-07-2020,71
+13-07-2020,72
+14-07-2020,127
+15-07-2020,124
+16-07-2020,72
+17-07-2020,79
+18-07-2020,92
+19-07-2020,65
+20-07-2020,60
+21-07-2020,61
+22-07-2020,59
+23-07-2020,65
+24-07-2020,100
+25-07-2020,67
+26-07-2020,78
+27-07-2020,100
+28-07-2020,72
+29-07-2020,90
+30-07-2020,55
+31-07-2020,75
+01-08-2020,81
+02-08-2020,61
+03-08-2020,67
+04-08-2020,62
+05-08-2020,86
+06-08-2020,69
+07-08-2020,54
+08-08-2020,87
+09-08-2020,74
+10-08-2020,72
+11-08-2020,75
+12-08-2020,63
+13-08-2020,50
+14-08-2020,58
+15-08-2020,67
+16-08-2020,52
+17-08-2020,66
+18-08-2020,72
+19-08-2020,57
+20-08-2020,50
+21-08-2020,57
+22-08-2020,53
+23-08-2020,53
+24-08-2020,45
+25-08-2020,61
+26-08-2020,57
+27-08-2020,64
+28-08-2020,79
+29-08-2020,77
+30-08-2020,70
+31-08-2020,41
+01-09-2020,53
+02-09-2020,69
+03-09-2020,84
+04-09-2020,82
+05-09-2020,101
+06-09-2020,70
+07-09-2020,93
+08-09-2020,79
+09-09-2020,105
+10-09-2020,108
+11-09-2020,136
+12-09-2020,144
+13-09-2020,142
+14-09-2020,152
+15-09-2020,144
+16-09-2020,151
+17-09-2020,120
+18-09-2020,108
+19-09-2020,118
+20-09-2020,148
+21-09-2020,142
+22-09-2020,115
+23-09-2020,76
+24-09-2020,104
+25-09-2020,143
+26-09-2020,165
+27-09-2020,117
+28-09-2020,159
+29-09-2020,177
+30-09-2020,156
+01-10-2020,152
+02-10-2020,180
+03-10-2020,189
+04-10-2020,184
+05-10-2020,179
+06-10-2020,178
+07-10-2020,215
+08-10-2020,208
+09-10-2020,202
+10-10-2020,221
+11-10-2020,216
+12-10-2020,261
+13-10-2020,300
+14-10-2020,276
+15-10-2020,312
+16-10-2020,237
+17-10-2020,287
+18-10-2020,254
+19-10-2020,244
+20-10-2020,223
+21-10-2020,256
+22-10-2020,296
+23-10-2020,366
+24-10-2020,345
+25-10-2020,349
+26-10-2020,353
+27-10-2020,312
+28-10-2020,297
+29-10-2020,395
+30-10-2020,374
+31-10-2020,367
+01-11-2020,364
+02-11-2020,293
+03-11-2020,302
+04-11-2020,343
+05-11-2020,450
+06-11-2020,406
+07-11-2020,427
+08-11-2020,416
+09-11-2020,477
+10-11-2020,476
+11-11-2020,344
+12-11-2020,314
+13-11-2020,339
+14-11-2020,414
+15-11-2020,435
+16-11-2020,221
+17-11-2020,171
+18-11-2020,211
+19-11-2020,283
+20-11-2020,296
+21-11-2020,251
+22-11-2020,274
+23-11-2020,295
+24-11-2020,379
+25-11-2020,413
+26-11-2020,302
+27-11-2020,137
+28-11-2020,231
+29-11-2020,256
+30-11-2020,318
+01-12-2020,367
+02-12-2020,373
+03-12-2020,341
+04-12-2020,382
+05-12-2020,404
+06-12-2020,389
+07-12-2020,400
+08-12-2020,383
+09-12-2020,358
+10-12-2020,284
+11-12-2020,295
+12-12-2020,356
+13-12-2020,305
+14-12-2020,160
+15-12-2020,230
+16-12-2020,262
+17-12-2020,256
+18-12-2020,281
+19-12-2020,290
+20-12-2020,321
+21-12-2020,332
+22-12-2020,418
+23-12-2020,433
+24-12-2020,423
+25-12-2020,357
+26-12-2020,337
+27-12-2020,396
+28-12-2020,253
+29-12-2020,265
+30-12-2020,290
+31-12-2020,347
+01-01-2021,441
+02-01-2021,443
+03-01-2021,354
+04-01-2021,151
+05-01-2021,140
+06-01-2021,226
+07-01-2021,255
+08-01-2021,234
+09-01-2021,301
+10-01-2021,245
+11-01-2021,243
+12-01-2021,293
+13-01-2021,354
+14-01-2021,429
+15-01-2021,460
+16-01-2021,407
+17-01-2021,347
+18-01-2021,372
+19-01-2021,404
+20-01-2021,283
+21-01-2021,296
+22-01-2021,364
+23-01-2021,326
+24-01-2021,364
+25-01-2021,323
+26-01-2021,330
+27-01-2021,318
+28-01-2021,357
+29-01-2021,387
+30-01-2021,309
+31-01-2021,289
+01-02-2021,352
+02-02-2021,364
+03-02-2021,330
+04-02-2021,316
+05-02-2021,133
+06-02-2021,199
+07-02-2021,232
+08-02-2021,303
+09-02-2021,305
+10-02-2021,291
+11-02-2021,330
+12-02-2021,341
+13-02-2021,334
+14-02-2021,351
+15-02-2021,313
+16-02-2021,327
+17-02-2021,324
+18-02-2021,302
+19-02-2021,311
+20-02-2021,250
+21-02-2021,296
+22-02-2021,288
+23-02-2021,250
+24-02-2021,278
+25-02-2021,298
+26-02-2021,229
+27-02-2021,203
+28-02-2021,208
+01-03-2021,177
+02-03-2021,175
+03-03-2021,188
+04-03-2021,278
+05-03-2021,255
+06-03-2021,204
+07-03-2021,256
+08-03-2021,207
+09-03-2021,283
+10-03-2021,175
+11-03-2021,242
+12-03-2021,218
+13-03-2021,209
+14-03-2021,209
+15-03-2021,206
+16-03-2021,258
+17-03-2021,311
+18-03-2021,315
+19-03-2021,279
+20-03-2021,234
+21-03-2021,244
+22-03-2021,196
+23-03-2021,244
+24-03-2021,175
+25-03-2021,148
+26-03-2021,150
+27-03-2021,199
+28-03-2021,233
+29-03-2021,225
+30-03-2021,232
+31-03-2021,203
+01-04-2021,182
+02-04-2021,176
+03-04-2021,159
+04-04-2021,171
+05-04-2021,205
+06-04-2021,279
+07-04-2021,250
+08-04-2021,153
+09-04-2021,170
+10-04-2021,181
+11-04-2021,186
+12-04-2021,241
+13-04-2021,231
+14-04-2021,199
+15-04-2021,220
+16-04-2021,238
+17-04-2021,128
+18-04-2021,154
+19-04-2021,187
+20-04-2021,191
+21-04-2021,134
+22-04-2021,140
+23-04-2021,126
+24-04-2021,125
+25-04-2021,192
+26-04-2021,256
+27-04-2021,284
+28-04-2021,312
+29-04-2021,296
+30-04-2021,287
+01-05-2021,238
+02-05-2021,174
+03-05-2021,245
+04-05-2021,173
+05-05-2021,175
+06-05-2021,156
+07-05-2021,142
+08-05-2021,173
+09-05-2021,166
+10-05-2021,136
+11-05-2021,151
+12-05-2021,115
+13-05-2021,121
+14-05-2021,132
+15-05-2021,140
+16-05-2021,166
+17-05-2021,191
+18-05-2021,93
+19-05-2021,78
+20-05-2021,58
+21-05-2021,85
+22-05-2021,94
+23-05-2021,237
+24-05-2021,169
+25-05-2021,140
+26-05-2021,149
+27-05-2021,150
+28-05-2021,106
+29-05-2021,87
+30-05-2021,101
+31-05-2021,135
+01-06-2021,115
+02-06-2021,143
+03-06-2021,159
+04-06-2021,196
+05-06-2021,124
+06-06-2021,134
+07-06-2021,180
+08-06-2021,205
+09-06-2021,305
+10-06-2021,221
+11-06-2021,145
+12-06-2021,133
+13-06-2021,83
+14-06-2021,124
+15-06-2021,113
+16-06-2021,115
+17-06-2021,108
+18-06-2021,81
+19-06-2021,70
+20-06-2021,62
+21-06-2021,84
+22-06-2021,127
+23-06-2021,218
+24-06-2021,146
+25-06-2021,163
+26-06-2021,135
+27-06-2021,168
+28-06-2021,161
+29-06-2021,195
+30-06-2021,206
+01-07-2021,266
+02-07-2021,245
+03-07-2021,139
+04-07-2021,140
+05-07-2021,149
+06-07-2021,144
+07-07-2021,178
+08-07-2021,164
+09-07-2021,144
+10-07-2021,97
+11-07-2021,94
+12-07-2021,90
+13-07-2021,80
+14-07-2021,83
+15-07-2021,83
+16-07-2021,90
+17-07-2021,117
+18-07-2021,94
+19-07-2021,62
+20-07-2021,81
+21-07-2021,74
+22-07-2021,83
+23-07-2021,68
+24-07-2021,99
+25-07-2021,107
+26-07-2021,86
+27-07-2021,98
+28-07-2021,61
+29-07-2021,63
+30-07-2021,76
+31-07-2021,57
+01-08-2021,81
+02-08-2021,95
+03-08-2021,71
+04-08-2021,69
+05-08-2021,99
+06-08-2021,104
+07-08-2021,101
+08-08-2021,109
+09-08-2021,101
+10-08-2021,101
+11-08-2021,122
+12-08-2021,114
+13-08-2021,118
+14-08-2021,116
+15-08-2021,114
+16-08-2021,121
+17-08-2021,150
+18-08-2021,152
+19-08-2021,167
+20-08-2021,111
+21-08-2021,69
+22-08-2021,59
+23-08-2021,82
+24-08-2021,100
+25-08-2021,115
+26-08-2021,114
+27-08-2021,134
+28-08-2021,147
+29-08-2021,119
+30-08-2021,81
+31-08-2021,73
+01-09-2021,64
+02-09-2021,64
+03-09-2021,70
+04-09-2021,68
+05-09-2021,88
+06-09-2021,122
+07-09-2021,98
+08-09-2021,70
+09-09-2021,75
+10-09-2021,79
+11-09-2021,61
+12-09-2021,60
+13-09-2021,89
+14-09-2021,69
+15-09-2021,70
+16-09-2021,79
+17-09-2021,62
+18-09-2021,69
+19-09-2021,82
+20-09-2021,82
+21-09-2021,83
+22-09-2021,69
+23-09-2021,68
+24-09-2021,64
+25-09-2021,80
+26-09-2021,75
+27-09-2021,108
+28-09-2021,120
+29-09-2021,81
+30-09-2021,84
+01-10-2021,108
+02-10-2021,125
+03-10-2021,105
+04-10-2021,91
+05-10-2021,115
+06-10-2021,114
+07-10-2021,127
+08-10-2021,167
+09-10-2021,171
+10-10-2021,168
+11-10-2021,166
+12-10-2021,179
+13-10-2021,171
+14-10-2021,182
+15-10-2021,198
+16-10-2021,284
+17-10-2021,298
+18-10-2021,46
+19-10-2021,69
+20-10-2021,221
+21-10-2021,199
+22-10-2021,170
+23-10-2021,173
+24-10-2021,160
+25-10-2021,82
+26-10-2021,139
+27-10-2021,232
+28-10-2021,268
+29-10-2021,283
+30-10-2021,268
+31-10-2021,289
+01-11-2021,281
+02-11-2021,303
+03-11-2021,314
+04-11-2021,382
+05-11-2021,462
+06-11-2021,437
+07-11-2021,428
+08-11-2021,390
+09-11-2021,404
+10-11-2021,372
+11-11-2021,411
+12-11-2021,471
+13-11-2021,437
+14-11-2021,330
+15-11-2021,353
+16-11-2021,403
+17-11-2021,375
+18-11-2021,347
+19-11-2021,380
+20-11-2021,374
+21-11-2021,349
+22-11-2021,311
+23-11-2021,290
+24-11-2021,361
+25-11-2021,400
+26-11-2021,406
+27-11-2021,402
+28-11-2021,405
+29-11-2021,389
+30-11-2021,328
+01-12-2021,370
+02-12-2021,429
+03-12-2021,346
+04-12-2021,362
+05-12-2021,305
+06-12-2021,322
+07-12-2021,255
+08-12-2021,237
+09-12-2021,289
+10-12-2021,314
+11-12-2021,281
+12-12-2021,254
+13-12-2021,331
+14-12-2021,367
+15-12-2021,363
+16-12-2021,368
+17-12-2021,329
+18-12-2021,291
+19-12-2021,271
+20-12-2021,332
+21-12-2021,402
+22-12-2021,407
+23-12-2021,423
+24-12-2021,415
+25-12-2021,431
+26-12-2021,459
+27-12-2021,283
+28-12-2021,305
+29-12-2021,267
+30-12-2021,286
+31-12-2021,321
+01-01-2022,362
+02-01-2022,404
+03-01-2022,387
+04-01-2022,378
+05-01-2022,397
+06-01-2022,258
+07-01-2022,182
+08-01-2022,91
+09-01-2022,69
+10-01-2022,151
+11-01-2022,224
+12-01-2022,191
+13-01-2022,321
+14-01-2022,348
+15-01-2022,258
+16-01-2022,264
+17-01-2022,327
+18-01-2022,352
+19-01-2022,322
+20-01-2022,387
+21-01-2022,365
+22-01-2022,316
+23-01-2022,202
+24-01-2022,241
+25-01-2022,234
+26-01-2022,260
+27-01-2022,262
+28-01-2022,215
+29-01-2022,251
+30-01-2022,278
+31-01-2022,338
+01-02-2022,347
+02-02-2022,319
+03-02-2022,321
+04-02-2022,152
+05-02-2022,224
+06-02-2022,285
+07-02-2022,250
+08-02-2022,270
+09-02-2022,227
+10-02-2022,172
+11-02-2022,184
+12-02-2022,191
+13-02-2022,253
+14-02-2022,239
+15-02-2022,221
+16-02-2022,272
+17-02-2022,241
+18-02-2022,252
+19-02-2022,180
+20-02-2022,173
+21-02-2022,165
+22-02-2022,252
+23-02-2022,211
+24-02-2022,307
+25-02-2022,286
+26-02-2022,102
+27-02-2022,92
+28-02-2022,107
+01-03-2022,170
+02-03-2022,225
+03-03-2022,178
+04-03-2022,199
+05-03-2022,115
+06-03-2022,162
+07-03-2022,237
+08-03-2022,283
+09-03-2022,162
+10-03-2022,150
+11-03-2022,164
+12-03-2022,160
+13-03-2022,193
+14-03-2022,231
+15-03-2022,253
+16-03-2022,218
+17-03-2022,218
+18-03-2022,293
+19-03-2022,231
+20-03-2022,242
+21-03-2022,271
+22-03-2022,180
+23-03-2022,206
+24-03-2022,280
+25-03-2022,211
+26-03-2022,207
+27-03-2022,195
+28-03-2022,251
+29-03-2022,274
+30-03-2022,276
+31-03-2022,298
+01-04-2022,218
+02-04-2022,226
+03-04-2022,245
+04-04-2022,262
+05-04-2022,233
+06-04-2022,248
+07-04-2022,264
+08-04-2022,242
+09-04-2022,261
+10-04-2022,244
+11-04-2022,258
+12-04-2022,229
+13-04-2022,286
+14-04-2022,280
+15-04-2022,201
+16-04-2022,253
+17-04-2022,251
+18-04-2022,257
+19-04-2022,317
+20-04-2022,277
+21-04-2022,296
+22-04-2022,204
+23-04-2022,245
+24-04-2022,261
+25-04-2022,244
+26-04-2022,209
+27-04-2022,287
+28-04-2022,295
+29-04-2022,299
+30-04-2022,270
+01-05-2022,256
+02-05-2022,218
+03-05-2022,227
+04-05-2022,269
+05-05-2022,146
+06-05-2022,273
+07-05-2022,206
+08-05-2022,205
+09-05-2022,171
+10-05-2022,160
+11-05-2022,156
+12-05-2022,164
+13-05-2022,176
+14-05-2022,270
+15-05-2022,242
+16-05-2022,297
+17-05-2022,239
+18-05-2022,251
+19-05-2022,202
+20-05-2022,266
+21-05-2022,285
+22-05-2022,203
+23-05-2022,136
+24-05-2022,89
+25-05-2022,166
+26-05-2022,199
+27-05-2022,206
+28-05-2022,210
+29-05-2022,273
+30-05-2022,201
+31-05-2022,215
+01-06-2022,322
+02-06-2022,202
+03-06-2022,240
+04-06-2022,227
+05-06-2022,215
+06-06-2022,195
+07-06-2022,280
+08-06-2022,346
+09-06-2022,223
+10-06-2022,303
+11-06-2022,256
+12-06-2022,249
+13-06-2022,200
+14-06-2022,222
+15-06-2022,153
+16-06-2022,132
+17-06-2022,88
+18-06-2022,79
+19-06-2022,99
+20-06-2022,124
+21-06-2022,128
+22-06-2022,139
+23-06-2022,140
+24-06-2022,197
+25-06-2022,230
+26-06-2022,169
+27-06-2022,127
+28-06-2022,137
+29-06-2022,163
+30-06-2022,116
+01-07-2022,76
+02-07-2022,95
+03-07-2022,76
+04-07-2022,113
+05-07-2022,161
+06-07-2022,104
+07-07-2022,100
+08-07-2022,94
+09-07-2022,110
+10-07-2022,71
+11-07-2022,95
+12-07-2022,100
+13-07-2022,79
+14-07-2022,87
+15-07-2022,79
+16-07-2022,81
+17-07-2022,61
+18-07-2022,92
+19-07-2022,105
+20-07-2022,98
+21-07-2022,70
+22-07-2022,140
+23-07-2022,72
+24-07-2022,72
+25-07-2022,67
+26-07-2022,69
+27-07-2022,74
+28-07-2022,68
+29-07-2022,71
+30-07-2022,58
+31-07-2022,71
+01-08-2022,71
+02-08-2022,84
+03-08-2022,122
+04-08-2022,112
+05-08-2022,72
+06-08-2022,98
+07-08-2022,118
+08-08-2022,84
+09-08-2022,112
+10-08-2022,102
+11-08-2022,75
+12-08-2022,88
+13-08-2022,80
+14-08-2022,84
+15-08-2022,62
+16-08-2022,63
+17-08-2022,60
+18-08-2022,72
+19-08-2022,71
+20-08-2022,80
+21-08-2022,117
+22-08-2022,104
+23-08-2022,83
+24-08-2022,63
+25-08-2022,96
+26-08-2022,113
+27-08-2022,105
+28-08-2022,119
+29-08-2022,144
+30-08-2022,116
+31-08-2022,124
+01-09-2022,121
+02-09-2022,110
+03-09-2022,119
+04-09-2022,115
+05-09-2022,102
+06-09-2022,119
+07-09-2022,133
+08-09-2022,136
+09-09-2022,141
+10-09-2022,110
+11-09-2022,85
+12-09-2022,84
+13-09-2022,72
+14-09-2022,71
+15-09-2022,57
+16-09-2022,47
+17-09-2022,70
+18-09-2022,119
+19-09-2022,182
+20-09-2022,130
+21-09-2022,109
+22-09-2022,66
+23-09-2022,57
+24-09-2022,54
+25-09-2022,52
+26-09-2022,100
+27-09-2022,108
+28-09-2022,140
+29-09-2022,151
+30-09-2022,173
+01-10-2022,186
+02-10-2022,181
+03-10-2022,128
+04-10-2022,150
+05-10-2022,211
+06-10-2022,79
+07-10-2022,55
+08-10-2022,56
+09-10-2022,48
+10-10-2022,44
+11-10-2022,66
+12-10-2022,143
+13-10-2022,130
+14-10-2022,154
+15-10-2022,186
+16-10-2022,232
+17-10-2022,237
+18-10-2022,241
+19-10-2022,234
+20-10-2022,232
+21-10-2022,262
+22-10-2022,265
+23-10-2022,259
+24-10-2022,312
+25-10-2022,302
+26-10-2022,271
+27-10-2022,354
+28-10-2022,357
+29-10-2022,397
+30-10-2022,352
+31-10-2022,392
+01-11-2022,424
+02-11-2022,376
+03-11-2022,450
+04-11-2022,447
+05-11-2022,381
+06-11-2022,339
+07-11-2022,354
+08-11-2022,372
+09-11-2022,260
+10-11-2022,295
+11-11-2022,346
+12-11-2022,303
+13-11-2022,303
+14-11-2022,294
+15-11-2022,227
+16-11-2022,264
+17-11-2022,260
+18-11-2022,289
+19-11-2022,280
+20-11-2022,314
+21-11-2022,310
+22-11-2022,255
+23-11-2022,237
+24-11-2022,213
+25-11-2022,294
+26-11-2022,336
+27-11-2022,328
+28-11-2022,333
+29-11-2022,369
+30-11-2022,365
+01-12-2022,368
+02-12-2022,352
+03-12-2022,370
+04-12-2022,407
+05-12-2022,347
+06-12-2022,353
+07-12-2022,304
+08-12-2022,281
+09-12-2022,314
+10-12-2022,360
+11-12-2022,306
+12-12-2022,218
+13-12-2022,177
+14-12-2022,163
+15-12-2022,189
+16-12-2022,223
+17-12-2022,304
+18-12-2022,353
+19-12-2022,410
+20-12-2022,366
+21-12-2022,328
+22-12-2022,342
+23-12-2022,359
+24-12-2022,349
+25-12-2022,308
+26-12-2022,331
+27-12-2022,339
+28-12-2022,321
+29-12-2022,306
+30-12-2022,399
+31-12-2022,349
+01-01-2023,259
+02-01-2023,357
+03-01-2023,385
+04-01-2023,343
+05-01-2023,340
+06-01-2023,400
+07-01-2023,377
+08-01-2023,375
+09-01-2023,434
+10-01-2023,407
+11-01-2023,308
+12-01-2023,371
+13-01-2023,378
+14-01-2023,353
+15-01-2023,213
+16-01-2023,270
+17-01-2023,288
+18-01-2023,306
+19-01-2023,338
+20-01-2023,226
+21-01-2023,294
+22-01-2023,407
+23-01-2023,335
+24-01-2023,237
+25-01-2023,160
+26-01-2023,298
+27-01-2023,229
+28-01-2023,236
+29-01-2023,331
+30-01-2023,207
+31-01-2023,192
+01-02-2023,164
+02-02-2023,194
+03-02-2023,199
+04-02-2023,242
+05-02-2023,244
+06-02-2023,265
+07-02-2023,285
+08-02-2023,144
+09-02-2023,212
+10-02-2023,187
+11-02-2023,275
+12-02-2023,175
+13-02-2023,135
+14-02-2023,132
+15-02-2023,190
+16-02-2023,270
+17-02-2023,367
+18-02-2023,371
+19-02-2023,331
+20-02-2023,324
+21-02-2023,245
+22-02-2023,302
+23-02-2023,227
+24-02-2023,171
+25-02-2023,225
+26-02-2023,291
+27-02-2023,260
+28-02-2023,219
+01-03-2023,181
+02-03-2023,226
+03-03-2023,152
+04-03-2023,129
+05-03-2023,142
+06-03-2023,142
+07-03-2023,173
+08-03-2023,215
+09-03-2023,119
+10-03-2023,187
+11-03-2023,200
+12-03-2023,216
+13-03-2023,231
+14-03-2023,219
+15-03-2023,213
+16-03-2023,259
+17-03-2023,188
+18-03-2023,184
+19-03-2023,162
+20-03-2023,154
+21-03-2023,75
+22-03-2023,164
+23-03-2023,151
+24-03-2023,205
+25-03-2023,78
+26-03-2023,164
+27-03-2023,146
+28-03-2023,147
+29-03-2023,198
+30-03-2023,170
+31-03-2023,73
+01-04-2023,106
+02-04-2023,128
+03-04-2023,179
+04-04-2023,109
+05-04-2023,135
+06-04-2023,142
+07-04-2023,142
+08-04-2023,172
+09-04-2023,217
+10-04-2023,195
+11-04-2023,260
+12-04-2023,213
+13-04-2023,211
+14-04-2023,249
+15-04-2023,235
+16-04-2023,229
+17-04-2023,206
+18-04-2023,235
+19-04-2023,236
+20-04-2023,159
+21-04-2023,129
+22-04-2023,141
+23-04-2023,118
+24-04-2023,160
+25-04-2023,156
+26-04-2023,210
+27-04-2023,219
+28-04-2023,150
+29-04-2023,216
+30-04-2023,132
+01-05-2023,91
+02-05-2023,76
+03-05-2023,107
+04-05-2023,113
+05-05-2023,183
+06-05-2023,234
+07-05-2023,173
+08-05-2023,131
+09-05-2023,197
+10-05-2023,203
+11-05-2023,274
+12-05-2023,227
+13-05-2023,235
+14-05-2023,259
+15-05-2023,162
+16-05-2023,259
+17-05-2023,336
+18-05-2023,149
+19-05-2023,152
+20-05-2023,186
+21-05-2023,215
+22-05-2023,199
+23-05-2023,198
+24-05-2023,158
+25-05-2023,106
+26-05-2023,98
+27-05-2023,110
+28-05-2023,134
+29-05-2023,136
+30-05-2023,115
+31-05-2023,85
+01-06-2023,96
+02-06-2023,120
+03-06-2023,121
+04-06-2023,171
+05-06-2023,166
+06-06-2023,139
+07-06-2023,239
+08-06-2023,161
+09-06-2023,152
+10-06-2023,134
+11-06-2023,130
+12-06-2023,169
+13-06-2023,205
+14-06-2023,213
+15-06-2023,154
+16-06-2023,119
+17-06-2023,119
+18-06-2023,90
+19-06-2023,75
+20-06-2023,104
+21-06-2023,91
+22-06-2023,110
+23-06-2023,132
+24-06-2023,169
+25-06-2023,71
+26-06-2023,93
+27-06-2023,86
+28-06-2023,93
+29-06-2023,101
+30-06-2023,70
+01-07-2023,69
+02-07-2023,71
+03-07-2023,118
+04-07-2023,144
+05-07-2023,96
+06-07-2023,72
+07-07-2023,77
+08-07-2023,71
+09-07-2023,64
+10-07-2023,65
+11-07-2023,69
+12-07-2023,77
+13-07-2023,77
+14-07-2023,73
+15-07-2023,100
+16-07-2023,69
+17-07-2023,85
+18-07-2023,113
+19-07-2023,77
+20-07-2023,93
+21-07-2023,109
+22-07-2023,96
+23-07-2023,73
+24-07-2023,77
+25-07-2023,102
+26-07-2023,73
+27-07-2023,92
+28-07-2023,81
+29-07-2023,59
+30-07-2023,65
+31-07-2023,89
+01-08-2023,92
+02-08-2023,91
+03-08-2023,75
+04-08-2023,105
+05-08-2023,85
+06-08-2023,101
+07-08-2023,102
+08-08-2023,110
+09-08-2023,118
+10-08-2023,133
+11-08-2023,123
+12-08-2023,126
+13-08-2023,105
+14-08-2023,114
+15-08-2023,108
+16-08-2023,109
+17-08-2023,131
+18-08-2023,153
+19-08-2023,125
+20-08-2023,91
+21-08-2023,91
+22-08-2023,106
+23-08-2023,71
+24-08-2023,85
+25-08-2023,117
+26-08-2023,152
+27-08-2023,186
+28-08-2023,144
+29-08-2023,162
+30-08-2023,154
+31-08-2023,146
+01-09-2023,140
+02-09-2023,136
+03-09-2023,136
+04-09-2023,136
+05-09-2023,121
+06-09-2023,106
+07-09-2023,105
+08-09-2023,84
+09-09-2023,55
+10-09-2023,46
+11-09-2023,54
+12-09-2023,90
+13-09-2023,106
+14-09-2023,121
+15-09-2023,100
+16-09-2023,85
+17-09-2023,63
+18-09-2023,63
+19-09-2023,73
+20-09-2023,97
+21-09-2023,113
+22-09-2023,102
+23-09-2023,108
+24-09-2023,131
+25-09-2023,118
+26-09-2023,152
+27-09-2023,129
+28-09-2023,139
+29-09-2023,157
+30-09-2023,166
+01-10-2023,146
+02-10-2023,144
+03-10-2023,154
+04-10-2023,176
+05-10-2023,177
+06-10-2023,211
+07-10-2023,215
+08-10-2023,164
+09-10-2023,174
+10-10-2023,179
+11-10-2023,191
+12-10-2023,218
+13-10-2023,255
+14-10-2023,256
+15-10-2023,232
+16-10-2023,206
+17-10-2023,87
+18-10-2023,125
+19-10-2023,118
+20-10-2023,195
+21-10-2023,246
+22-10-2023,311
+23-10-2023,263
+24-10-2023,220
+25-10-2023,243
+26-10-2023,256
+27-10-2023,259
+28-10-2023,303
+29-10-2023,324
+30-10-2023,346
+31-10-2023,357
+01-11-2023,364
+02-11-2023,392
+03-11-2023,468
+04-11-2023,415
+05-11-2023,453
+06-11-2023,421
+07-11-2023,395
+08-11-2023,426
+09-11-2023,437
+10-11-2023,278
+11-11-2023,220
+12-11-2023,218
+13-11-2023,358
+14-11-2023,396
+15-11-2023,398
+16-11-2023,418
+17-11-2023,404
+18-11-2023,318
+19-11-2023,301
+20-11-2023,348
+21-11-2023,372
+22-11-2023,395
+23-11-2023,390
+24-11-2023,415
+25-11-2023,388
+26-11-2023,397
+27-11-2023,395
+28-11-2023,311
+29-11-2023,289
+30-11-2023,398
+01-12-2023,372
+02-12-2023,352
+03-12-2023,313
+04-12-2023,310
+05-12-2023,297
+06-12-2023,285
+07-12-2023,320
+08-12-2023,325
+09-12-2023,322
+10-12-2023,314
+11-12-2023,317
+12-12-2023,355
+13-12-2023,378
+14-12-2023,326
+15-12-2023,323
+16-12-2023,355
+17-12-2023,331
+18-12-2023,330
+19-12-2023,286
+20-12-2023,285
+21-12-2023,361
+22-12-2023,409
+23-12-2023,449
+24-12-2023,411
+25-12-2023,383
+26-12-2023,377
+27-12-2023,380
+28-12-2023,358
+29-12-2023,381
+30-12-2023,400
+31-12-2023,382
+01-01-2024,346
+02-01-2024,340
+03-01-2024,341
+04-01-2024,377
+05-01-2024,333
+06-01-2024,319
+07-01-2024,333
+08-01-2024,345
+09-01-2024,343
+10-01-2024,273
+11-01-2024,348
+12-01-2024,340
+13-01-2024,398
+14-01-2024,447
+15-01-2024,359
+16-01-2024,371
+17-01-2024,368
+18-01-2024,318
+19-01-2024,348
+20-01-2024,329
+21-01-2024,349
+22-01-2024,333
+23-01-2024,368
+24-01-2024,409
+25-01-2024,332
+26-01-2024,408
+27-01-2024,356
+28-01-2024,365
+29-01-2024,356
+30-01-2024,357
+31-01-2024,391
+01-02-2024,176
+02-02-2024,215
+03-02-2024,199
+04-02-2024,274
+05-02-2024,177
+06-02-2024,140
+07-02-2024,174
+08-02-2024,161
+09-02-2024,146
+10-02-2024,295
+11-02-2024,313
+12-02-2024,300
+13-02-2024,341
+14-02-2024,340
+15-02-2024,278
+16-02-2024,268
+17-02-2024,245
+18-02-2024,270
+19-02-2024,231
+20-02-2024,226
+21-02-2024,243
+22-02-2024,150
+23-02-2024,143
+24-02-2024,193
+25-02-2024,193
+26-02-2024,172
+27-02-2024,159
+28-02-2024,141
+29-02-2024,147
+01-03-2024,208
+02-03-2024,117
+03-03-2024,126
+04-03-2024,141
+05-03-2024,125
+06-03-2024,138
+07-03-2024,181
+08-03-2024,157
+09-03-2024,145
+10-03-2024,182
+11-03-2024,201
+12-03-2024,190
+13-03-2024,165
+14-03-2024,195
+15-03-2024,128
+16-03-2024,168
+17-03-2024,193
+18-03-2024,199
+19-03-2024,222
+20-03-2024,230
+21-03-2024,171
+22-03-2024,166
+23-03-2024,232
+24-03-2024,195
+25-03-2024,197
+26-03-2024,134
+27-03-2024,178
+28-03-2024,160
+29-03-2024,176
+30-03-2024,190
+31-03-2024,243
+01-04-2024,133
+02-04-2024,144
+03-04-2024,167
+04-04-2024,173
+05-04-2024,174
+06-04-2024,168
+07-04-2024,179
+08-04-2024,191
+09-04-2024,203
+10-04-2024,222
+11-04-2024,240
+12-04-2024,232
+13-04-2024,198
+14-04-2024,141
+15-04-2024,205
+16-04-2024,228
+17-04-2024,147
+18-04-2024,164
+19-04-2024,186
+20-04-2024,219
+21-04-2024,139
+22-04-2024,129
+23-04-2024,190
+24-04-2024,178
+25-04-2024,200
+26-04-2024,197
+27-04-2024,165
+28-04-2024,176
+29-04-2024,225
+30-04-2024,189
+01-05-2024,200
+02-05-2024,197
+03-05-2024,264
+04-05-2024,282
+05-05-2024,292
+06-05-2024,248
+07-05-2024,303
+08-05-2024,225
+09-05-2024,179
+10-05-2024,180
+11-05-2024,242
+12-05-2024,184
+13-05-2024,228
+14-05-2024,235
+15-05-2024,244
+16-05-2024,236
+17-05-2024,233
+18-05-2024,262
+19-05-2024,245
+20-05-2024,228
+21-05-2024,240
+22-05-2024,193
+23-05-2024,156
+24-05-2024,157
+25-05-2024,168
+26-05-2024,191
+27-05-2024,225
+28-05-2024,246
+29-05-2024,240
+30-05-2024,230
+31-05-2024,192
+01-06-2024,245
+02-06-2024,173
+03-06-2024,155
+04-06-2024,211
+05-06-2024,251
+06-06-2024,183
+07-06-2024,231
+08-06-2024,237
+09-06-2024,182
+10-06-2024,172
+11-06-2024,223
+12-06-2024,213
+13-06-2024,195
+14-06-2024,189
+15-06-2024,186
+16-06-2024,197
+17-06-2024,169
+18-06-2024,196
+19-06-2024,306
+20-06-2024,179
+21-06-2024,175
+22-06-2024,186
+23-06-2024,145
+24-06-2024,138
+25-06-2024,134
+26-06-2024,132
+27-06-2024,74
+28-06-2024,64
+29-06-2024,118
+30-06-2024,115
+01-07-2024,105
+02-07-2024,118
+03-07-2024,108
+04-07-2024,61
+05-07-2024,77
+06-07-2024,65
+07-07-2024,56
+08-07-2024,56
+09-07-2024,84
+10-07-2024,138
+11-07-2024,113
+12-07-2024,107
+13-07-2024,102
+14-07-2024,107
+15-07-2024,109
+16-07-2024,100
+17-07-2024,90
+18-07-2024,95
+19-07-2024,124
+20-07-2024,109
+21-07-2024,103
+22-07-2024,85
+23-07-2024,93
+24-07-2024,97
+25-07-2024,109
+26-07-2024,84
+27-07-2024,131
+28-07-2024,83
+29-07-2024,76
+30-07-2024,97
+31-07-2024,96
+01-08-2024,64
+02-08-2024,76
+03-08-2024,68
+04-08-2024,64
+05-08-2024,59
+06-08-2024,61
+07-08-2024,61
+08-08-2024,54
+09-08-2024,61
+10-08-2024,71
+11-08-2024,69
+12-08-2024,56
+13-08-2024,63
+14-08-2024,79
+15-08-2024,72
+16-08-2024,63
+17-08-2024,74
+18-08-2024,83
+19-08-2024,84
+20-08-2024,66
+21-08-2024,87
+22-08-2024,85
+23-08-2024,77
+24-08-2024,105
+25-08-2024,77
+26-08-2024,72
+27-08-2024,64
+28-08-2024,70
+29-08-2024,58
+30-08-2024,102
+31-08-2024,92
+01-09-2024,101
+02-09-2024,87
+03-09-2024,89
+04-09-2024,69
+05-09-2024,83
+06-09-2024,95
+07-09-2024,71
+08-09-2024,91
+09-09-2024,114
+10-09-2024,106
+11-09-2024,71
+12-09-2024,64
+13-09-2024,52
+14-09-2024,62
+15-09-2024,107
+16-09-2024,139
+17-09-2024,172
+18-09-2024,115
+19-09-2024,56
+20-09-2024,98
+21-09-2024,116
+22-09-2024,162
+23-09-2024,165
+24-09-2024,195
+25-09-2024,233
+26-09-2024,94
+27-09-2024,80
+28-09-2024,66
+29-09-2024,74
+30-09-2024,126
+01-10-2024,149
+02-10-2024,173
+03-10-2024,162
+04-10-2024,184
+05-10-2024,145
+06-10-2024,143
+07-10-2024,126
+08-10-2024,167
+09-10-2024,164
+10-10-2024,132
+11-10-2024,141
+12-10-2024,155
+13-10-2024,224
+14-10-2024,234
+15-10-2024,198
+16-10-2024,230
+17-10-2024,285
+18-10-2024,292
+19-10-2024,278
+20-10-2024,277
+21-10-2024,310
+22-10-2024,327
+23-10-2024,364
+24-10-2024,306
+25-10-2024,270
+26-10-2024,255
+27-10-2024,356
+28-10-2024,304
+29-10-2024,268
+30-10-2024,307
+31-10-2024,328
+01-11-2024,339
+02-11-2024,318
+03-11-2024,381
+04-11-2024,380
+05-11-2024,372
+06-11-2024,351
+07-11-2024,377
+08-11-2024,379
+09-11-2024,350
+10-11-2024,334
+11-11-2024,352
+12-11-2024,334
+13-11-2024,418
+14-11-2024,424
+15-11-2024,396
+16-11-2024,417
+17-11-2024,441
+18-11-2024,494
+19-11-2024,460
+20-11-2024,419
+21-11-2024,371
+22-11-2024,393
+23-11-2024,412
+24-11-2024,318
+25-11-2024,349
+26-11-2024,343
+27-11-2024,303
+28-11-2024,325
+29-11-2024,331
+30-11-2024,346
+01-12-2024,285
+02-12-2024,280
+03-12-2024,268
+04-12-2024,178
+05-12-2024,165
+06-12-2024,197
+07-12-2024,233
+08-12-2024,302
+09-12-2024,186
+10-12-2024,234
+11-12-2024,199
+12-12-2024,288
+13-12-2024,262
+14-12-2024,193
+15-12-2024,294
+16-12-2024,379
+17-12-2024,433
+18-12-2024,445
+19-12-2024,451
+20-12-2024,429
+21-12-2024,370
+22-12-2024,409
+23-12-2024,406
+24-12-2024,369
+25-12-2024,336
+26-12-2024,345
+27-12-2024,353
+28-12-2024,139
+29-12-2024,225
+30-12-2024,173
+31-12-2024,283
+01-01-2025,328
+02-01-2025,318
+03-01-2025,371
+04-01-2025,378
+05-01-2025,339
+06-01-2025,335
+07-01-2025,296
+08-01-2025,297
+09-01-2025,357
+10-01-2025,397
+11-01-2025,327
+12-01-2025,278
+13-01-2025,248
+14-01-2025,275
+15-01-2025,386
+16-01-2025,302
+17-01-2025,289
+18-01-2025,255
+19-01-2025,368
+20-01-2025,314
+21-01-2025,289
+22-01-2025,260
+23-01-2025,257
+24-01-2025,199
+25-01-2025,174
+26-01-2025,216
+27-01-2025,268
+28-01-2025,276
+29-01-2025,365
+30-01-2025,363
+31-01-2025,351
+01-02-2025,355
+02-02-2025,326
+03-02-2025,286
+04-02-2025,264
+05-02-2025,284
+06-02-2025,210
+07-02-2025,156
+08-02-2025,152
+09-02-2025,227
+10-02-2025,271
+11-02-2025,293
+12-02-2025,212
+13-02-2025,134
+14-02-2025,131
+15-02-2025,191
+16-02-2025,294
+17-02-2025,231
+18-02-2025,209
+19-02-2025,180
+20-02-2025,160
+21-02-2025,158
+22-02-2025,155
+23-02-2025,144
+24-02-2025,186
+25-02-2025,208
+26-02-2025,247
+27-02-2025,215
+28-02-2025,121
+01-03-2025,126
+02-03-2025,125
+03-03-2025,156
+04-03-2025,148
+05-03-2025,119
+06-03-2025,124
+07-03-2025,202
+08-03-2025,158
+09-03-2025,209
+10-03-2025,197
+11-03-2025,262
+12-03-2025,228
+13-03-2025,179
+14-03-2025,198
+15-03-2025,85
+16-03-2025,99
+17-03-2025,108
+18-03-2025,145
+19-03-2025,160
+20-03-2025,156
+21-03-2025,144
+22-03-2025,161
+23-03-2025,194
+24-03-2025,206
+25-03-2025,234
+26-03-2025,231
+27-03-2025,259
+28-03-2025,205
+29-03-2025,153
+30-03-2025,138
+31-03-2025,160

app.py

@@ -0,0 +1,560 @@
+"""
+Flask API server for the policy engine.
+Endpoints for generating policies, applying them, and analyzing impacts.
+"""
+from flask import Flask, request, jsonify
+from flask_cors import CORS
+from datetime import datetime
+import json
+import traceback
+
+from policy_engine import PolicyEngine, get_graph_context_from_file
+from graph_engine import GraphState, ImpactAnalyzer
+from health_analyzer import HealthImpactAnalyzer
+from explainability import generate_policy_explanation
+from explainability import generate_policy_explanation
+from aqi import register_aqi_routes
+from emission_forecast import register_emission_routes
+import config
+import os
+
+
+# ============================================================================
+# SETUP
+# ============================================================================
+
+app = Flask(__name__)
+CORS(app)  # Enable CORS for frontend requests
+
+# Initialize engines
+policy_engine = PolicyEngine()
+health_analyzer = HealthImpactAnalyzer()
+
+# Register AQI routes
+register_aqi_routes(app)
+register_emission_routes(app)
+from aqi_history import register_aqi_history_routes
+register_aqi_history_routes(app)
+
+# Pre-initialize AQI Data & Model to prevent timeout on first request
+from aqi_history import get_aqi_history
+print("Initializing AQI History & Model...")
+get_aqi_history()
+from aqi_map import generate_aqi_map_html, render_map_to_png
+import threading
+
+# Ensure map directory exists
+STATIC_DIR = os.path.join(os.getcwd(), 'static')
+os.makedirs(STATIC_DIR, exist_ok=True)
+MAP_IMAGE_PATH = os.path.join(STATIC_DIR, 'aqi_map.png')
+
+@app.route('/api/aqi-map', methods=['GET'])
+def get_aqi_map_html():
+    """Returns the Interactive Folium Map HTML"""
+    return generate_aqi_map_html()
+
+@app.route('/api/aqi-map.png', methods=['GET'])
+def get_aqi_map_png():
+    """Returns the static PNG image of the map, regenerating if needed"""
+    from flask import send_file
+    
+    # Check if we need to regenerate (e.g. if file is old or missing)
+    # For now, we'll generate if missing, or maybe background refresh
+    if not os.path.exists(MAP_IMAGE_PATH):
+        html = generate_aqi_map_html()
+        render_map_to_png(html, MAP_IMAGE_PATH)
+        
+    return send_file(MAP_IMAGE_PATH, mimetype='image/png')
+
+# Background task to refresh map periodically (optional)
+def refresh_map_periodically():
+    while True:
+        try:
+            print("Refreshing AQI Map image...")
+            html = generate_aqi_map_html()
+            render_map_to_png(html, MAP_IMAGE_PATH)
+        except Exception as e:
+            print(f"Error refreshing map: {e}")
+        time.sleep(3600) # Every hour
+
+# Start background thread for map refresh
+# threading.Thread(target=refresh_map_periodically, daemon=True).start()
+
+
+# ============================================================================
+# HELPER FUNCTIONS
+# ============================================================================
+
+def get_graph_state():
+    """Load current graph state."""
+    try:
+        return GraphState.from_file(str(config.GRAPH_STATE_PATH))
+    except Exception as e:
+        print(f"Error loading graph: {e}")
+        return None
+
+
+# ============================================================================
+# API ENDPOINTS
+# ============================================================================
+
+@app.route('/', methods=['GET'])
+def index():
+    """Root endpoint to show server status."""
+    return jsonify({
+        'message': 'Digital Twin Policy Engine API is running',
+        'endpoints': {
+            'health': '/api/health',
+            'aqi': '/api/aqi?lat=28.7041&lon=77.1025'
+        },
+        'status': 'active'
+    })
+
+@app.route('/api/health', methods=['GET'])
+def health_check():
+    """Health check endpoint."""
+    return jsonify({
+        'status': 'ok',
+        'timestamp': datetime.now().isoformat(),
+        'service': 'policy-engine'
+    })
+
+
+@app.route('/api/graph-state', methods=['GET'])
+def get_current_graph_state():
+    """
+    Get current graph state (nodes, edges, values).
+    Used by frontend for validation and context.
+    """
+    try:
+        graph = get_graph_state()
+        if not graph:
+            return jsonify({'error': 'Could not load graph'}), 500
+        
+        return jsonify({
+            'status': 'success',
+            'graph': graph.to_dict(),
+            'timestamp': datetime.now().isoformat()
+        })
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+
+
+@app.route('/api/generate-policy', methods=['POST'])
+def generate_policy():
+    """
+    Generate policy from research query.
+    
+    Request body:
+    {
+        "research_query": "How to reduce transport emissions?"
+    }
+    
+    Returns:
+    {
+        "policy": { Policy JSON },
+        "research_evidence": ["chunk1", "chunk2", ...],
+        "status": "success"
+    }
+    """
+    try:
+        data = request.json
+        query = data.get('research_query')
+        
+        if not query:
+            return jsonify({'error': 'Missing research_query'}), 400
+        
+        # Retrieve research
+        research_chunks = policy_engine.query_research(query, k=3)
+        
+        # Get graph context for validation
+        graph_context = data.get('graph_context')
+        if not graph_context:
+            print("Using static graph context from file")
+            graph_context = get_graph_context_from_file(str(config.GRAPH_STATE_PATH))
+        else:
+            print("Using dynamic graph context from frontend")
+        
+        # Extract policy via LLM
+        policy = policy_engine.extract_policy(research_chunks, graph_context, user_query=query)
+        
+        return jsonify({
+            'status': 'success',
+            'policy': policy.dict(),
+            'research_evidence': research_chunks,
+            'timestamp': datetime.now().isoformat()
+        })
+    
+    except Exception as e:
+        print(f"Error in generate_policy: {e}")
+        traceback.print_exc()
+        return jsonify({'error': str(e)}), 500
+
+
+@app.route('/api/apply-policy', methods=['POST'])
+def apply_policy():
+    """
+    Apply policy to graph and calculate impact.
+    
+    Request body:
+    {
+        "policy": { Policy JSON from generate-policy }
+    }
+    
+    Returns:
+    {
+        "snapshot": {
+            "scenario_id": "id",
+            "policy_id": "id",
+            "impact": { CO2 and AQI changes },
+            "cascade_analysis": { affected nodes },
+            ...
+        },
+        "status": "success"
+    }
+    """
+    try:
+        data = request.json
+        policy_dict = data.get('policy')
+        
+        if not policy_dict:
+            return jsonify({'error': 'Missing policy'}), 400
+        
+        # Load baseline
+        graph_context = data.get('graph_context')
+        if graph_context:
+            print("Using dynamic graph context for baseline")
+            # Reconstruct GraphState from context
+            # Context has { node_ids: [], edges: [{source, target, weight}] }
+            # We need to map this back to the GraphState structure
+            try:
+                # Load full default graph to get default node data (values, labels) which might be missing in context list
+                file_graph = get_graph_state()
+                
+                # Reconstruct nodes with enabled status
+                context_nodes = graph_context.get('nodes', [])
+                if context_nodes and isinstance(context_nodes, list):
+                     # New format: list of dicts with enabled status
+                     reconstructed_nodes = []
+                     for n_ctx in context_nodes:
+                         # Find original node data to preserve other fields (x, y, label, etc)
+                         original = next((on for on in file_graph.nodes if on['id'] == n_ctx['id']), None)
+                         if original:
+                             new_node = original.copy()
+                             if 'data' not in new_node:
+                                 new_node['data'] = {}
+                             new_node['data']['enabled'] = n_ctx.get('enabled', True)
+                             reconstructed_nodes.append(new_node)
+                     baseline_nodes = reconstructed_nodes
+                else:
+                    # Old format: list of IDs
+                    valid_node_ids = set(graph_context.get('node_ids', context_nodes)) # fallback if context_nodes is list of strings
+                    baseline_nodes = [n for n in file_graph.nodes if n['id'] in valid_node_ids]
+                
+                # Reconstruct edges
+                context_edges = graph_context.get('edges', [])
+                reconstructed_edges = []
+                for e in context_edges:
+                    reconstructed_edges.append({
+                        'source': e['source'],
+                        'target': e['target'],
+                        'data': {'weight': e['weight']}
+                    })
+                
+                baseline = GraphState(baseline_nodes, reconstructed_edges)
+            except Exception as e:
+                print(f"Error reconstructing dynamic baseline: {e}")
+                baseline = get_graph_state()
+        else:
+            baseline = get_graph_state()
+
+        if not baseline:
+            return jsonify({'error': 'Could not load baseline graph'}), 500
+        
+        # Create post-policy state (deep copy baseline)
+        import copy
+        post_policy = GraphState(
+            copy.deepcopy(baseline.nodes),
+            copy.deepcopy(baseline.edges)
+        )
+        
+        # Apply mutations
+        mutation_results = post_policy.apply_policy(policy_dict)
+        
+        # Log mutations with before/after values
+        print(f"\n[Policy Applied]")
+        # Print transport value if it exists, safely
+        trans_node = baseline.get_node('transport')
+        if trans_node:
+            print(f"Baseline Transport value: {trans_node['data'].get('value', 'N/A')}")
+            
+        print(f"Baseline CO2 value: {baseline.get_node('co2')['data']['value']}")
+        print(f"Baseline AQI value: {baseline.get_node('aqi')['data']['value']}")
+        
+        for i, mut in enumerate(mutation_results.get('mutations_applied', [])):
+            print(f"Mutation {i+1}: {mut['type']}")
+            if 'before' in mut and 'after' in mut:
+                print(f"  Before: {mut['before']}")
+                print(f"  After: {mut['after']}")
+        
+        # Calculate impact
+        analyzer = ImpactAnalyzer(baseline, post_policy)
+        impact = analyzer.calculate_impact()
+        
+        if trans_node:
+             post_trans = post_policy.get_node('transport')
+             print(f"Post-policy Transport value: {post_trans['data'].get('value', 'N/A')}")
+             
+        print(f"Post-policy CO2 value: {post_policy.get_node('co2')['data']['value']}")
+        print(f"Post-policy AQI value: {post_policy.get_node('aqi')['data']['value']}")
+        print(f"Impact: CO₂ change {impact['co2']['change_pct']:.1f}%, AQI change {impact['aqi']['change_pct']:.1f}%\n")
+        
+        # Create snapshot
+        snapshot = {
+            'scenario_id': f"snap-{datetime.now().strftime('%Y%m%d-%H%M%S')}",
+            'policy_id': policy_dict.get('policy_id'),
+            'policy_name': policy_dict.get('name'),
+            'baseline_graph': baseline.to_dict(),
+            'post_policy_graph': post_policy.to_dict(),
+            'mutations_applied': mutation_results['mutations_applied'],
+            'impact': impact,
+            'timestamp': datetime.now().isoformat()
+        }
+        
+        return jsonify({
+            'snapshot': snapshot,
+            'status': 'success'
+        })
+    
+    except Exception as e:
+        print(f"Error in apply_policy: {e}")
+        traceback.print_exc()
+        return jsonify({'error': str(e)}), 500
+
+
+@app.route('/api/compare-scenarios', methods=['POST'])
+def compare_scenarios():
+    """
+    Compare multiple scenarios side-by-side.
+    
+    Request body:
+    {
+        "scenarios": [
+            { "name": "Scenario 1", "policy": { Policy JSON } },
+            { "name": "Scenario 2", "policy": { Policy JSON } },
+            ...
+        ]
+    }
+    
+    Returns:
+    {
+        "comparison": [ Snapshots for each scenario ],
+        "ranking": {
+            "best_co2_reduction": "Scenario name",
+            "best_aqi_improvement": "Scenario name"
+        }
+    }
+    """
+    try:
+        data = request.json
+        scenarios = data.get('scenarios', [])
+        
+        if not scenarios:
+            return jsonify({'error': 'Missing scenarios'}), 400
+        
+        results = []
+        
+        for scenario in scenarios:
+            # Apply each policy
+            baseline = get_graph_state()
+            if not baseline:
+                continue
+            
+            import copy
+            post_policy = GraphState(
+                copy.deepcopy(baseline.nodes),
+                copy.deepcopy(baseline.edges)
+            )
+            
+            post_policy.apply_policy(scenario.get('policy', {}))
+            
+            analyzer = ImpactAnalyzer(baseline, post_policy)
+            impact = analyzer.calculate_impact()
+            
+            results.append({
+                'name': scenario.get('name'),
+                'impact': impact
+            })
+        
+        # Rank by impact
+        best_co2 = max(results, key=lambda r: abs(r['impact']['co2']['change_pct']), default={})
+        best_aqi = max(results, key=lambda r: abs(r['impact']['aqi']['change_pct']), default={})
+        
+        return jsonify({
+            'status': 'success',
+            'comparison': results,
+            'ranking': {
+                'best_co2_reduction': best_co2.get('name'),
+                'best_aqi_improvement': best_aqi.get('name')
+            },
+            'timestamp': datetime.now().isoformat()
+        })
+    
+    except Exception as e:
+        print(f"Error in compare_scenarios: {e}")
+        traceback.print_exc()
+        return jsonify({'error': str(e)}), 500
+
+
+@app.route('/api/explain-policy', methods=['POST'])
+def explain_policy():
+    """
+    Generate explanation for a policy.
+    
+    Request body:
+    {
+        "policy": { Policy JSON },
+        "research_evidence": ["chunk1", "chunk2", ...]
+    }
+    
+    Returns:
+    {
+        "explanation": {
+            "policy_id": "...",
+            "narrative_intro": "...",
+            "mutations": [ { narrative, supporting_research, stakeholders } ],
+            "overall_narrative": "..."
+        }
+    }
+    """
+    try:
+        data = request.json
+        policy = data.get('policy')
+        research_evidence = data.get('research_evidence', [])
+        
+        if not policy:
+            return jsonify({'error': 'Missing policy'}), 400
+        
+        # Generate explanation
+        explanation = generate_policy_explanation(policy, research_evidence)
+        
+        return jsonify({
+            'status': 'success',
+            'explanation': explanation,
+            'timestamp': datetime.now().isoformat()
+        })
+    
+    except Exception as e:
+        print(f"Error in explain_policy: {e}")
+        traceback.print_exc()
+        return jsonify({'error': str(e)}), 500
+
+
+@app.route('/api/analyze-aqi-health', methods=['POST'])
+def analyze_aqi_health():
+    """
+    Analyze health impacts based on AQI data.
+    
+    Request body:
+    {
+        "aqi_data": {
+            "aqi": 410,
+            "city": "Delhi",
+            "pm2_5": 250,
+            "pm10": 400,
+            "no2": 85,
+            "o3": 45,
+            "so2": 15,
+            "co": 1.5
+        }
+    }
+    
+    Response:
+    {
+        "health_impact": { Health analysis from Gemini },
+        "status": "success",
+        "timestamp": "..."
+    }
+    """
+    try:
+        data = request.json
+        aqi_data = data.get('aqi_data')
+        
+        if not aqi_data:
+            return jsonify({'error': 'Missing aqi_data'}), 400
+        
+        # Analyze health impact
+        health_impact = health_analyzer.analyze_aqi_health(aqi_data)
+        
+        return jsonify({
+            'health_impact': health_impact,
+            'status': 'success',
+            'timestamp': datetime.now().isoformat()
+        })
+    
+    except Exception as e:
+        print(f"Error analyzing AQI health: {e}")
+        print(traceback.format_exc())
+        return jsonify({'error': str(e)}), 500
+
+
+@app.route('/api/chat-health', methods=['POST'])
+def chat_health():
+    """
+    Chat with health expert.
+    
+    Request:
+    {
+        "message": "Should I wear a mask?",
+        "context": { "aqi": 350, "city": "Delhi", ... }
+    }
+    """
+    try:
+        data = request.json
+        message = data.get('message')
+        context = data.get('context', {})
+        
+        if not message:
+            return jsonify({'error': 'Missing message'}), 400
+            
+        response = health_analyzer.chat_with_health_expert(message, context)
+        
+        return jsonify({
+            'response': response,
+            'status': 'success'
+        })
+    except Exception as e:
+        print(f"Error in chat_health: {e}")
+        return jsonify({'error': str(e)}), 500
+
+
+# ============================================================================
+# ERROR HANDLERS
+# ============================================================================
+
+@app.errorhandler(404)
+def not_found(error):
+    return jsonify({'error': 'Not found'}), 404
+
+
+@app.errorhandler(500)
+def internal_error(error):
+    return jsonify({'error': 'Internal server error'}), 500
+
+
+# ============================================================================
+# MAIN
+# ============================================================================
+
+if __name__ == "__main__":
+    is_hf = bool(os.getenv("HF_SPACE_ID"))
+
+    port = 7860 if is_hf else config.FLASK_PORT
+    debug = False if is_hf else config.FLASK_DEBUG
+
+    app.run(
+        host="0.0.0.0",
+        port=port,
+        debug=debug
+    )
+

aqi.py

@@ -0,0 +1,86 @@
+import requests
+import os
+from config import AMBEE_DATA_KEY
+
+
+def get_live_aqi(lat: float = 28.7041, lon: float = 77.1025) -> dict:
+    """Fetch live AQI data from Ambee Data API for Delhi"""
+    
+    # Try Ambee API first
+    if AMBEE_DATA_KEY:
+        try:
+            url = "https://api.ambeedata.com/latest/by-lat-lng"
+            headers = {
+                "x-api-key": AMBEE_DATA_KEY,
+                "Content-Type": "application/json"
+            }
+            params = {
+                "lat": lat,
+                "lng": lon
+            }
+            
+            print(f"Fetching AQI from Ambee for lat={lat}, lng={lon}")
+            response = requests.get(url, headers=headers, params=params, timeout=10)
+            print(f"Response status: {response.status_code}")
+            
+            
+            response.raise_for_status()
+            data = response.json()
+            print(f"Ambee response: {data}")
+            
+            # Parse Ambee API response
+            if data.get("stations") and len(data["stations"]) > 0:
+                station = data["stations"][0]  # Get first station
+                print(f"AQI data extracted from station: {station}")
+                
+                # Map Ambee pollution to our format
+                return {
+                    "aqi": station.get("AQI", 50),  # Actual AQI value (0-500)
+                    "aqi_category": station.get("aqiInfo", {}).get("category", "Unknown"),
+                    "pm2_5": station.get("PM25", 0),
+                    "pm10": station.get("PM10", 0),
+                    "o3": station.get("OZONE", 0),
+                    "no2": station.get("NO2", 0),
+                    "so2": station.get("SO2", 0),
+                    "co": station.get("CO", 0),
+                    "city": station.get("city", "Unknown"),
+                    "source": "Ambee Data API"
+                }
+            else:
+                print(f"No 'stations' array in response: {data}")
+        except Exception as e:
+            print(f"Error fetching from Ambee API: {type(e).__name__}: {e}")
+            import traceback
+            traceback.print_exc()
+    else:
+        print("AMBEE_API_KEY not set in environment")
+    
+    # Return mock data as fallback
+    print("Using mock AQI data (Ambee API failed or not configured)")
+    return {
+        "aqi": 50,
+        "aqi_category": "Good",
+        "pm2_5": 12.5,
+        "pm10": 25.0,
+        "o3": 45.2,
+        "no2": 28.5,
+        "so2": 8.1,
+        "co": 0.5,
+        "source": "Mock Data"
+    }
+
+# Function to register Flask routes (call this from main app file)
+def register_aqi_routes(app):
+    """Register AQI routes with Flask app"""
+    from flask import request, jsonify
+    
+    @app.route('/api/aqi', methods=['GET'])
+    def fetch_aqi():
+        try:
+            lat = request.args.get('lat', 40.7128, type=float)
+            lon = request.args.get('lon', -74.0060, type=float)
+            aqi_data = get_live_aqi(lat, lon)
+            return jsonify(aqi_data), 200
+        except Exception as e:
+            print(f"Error in fetch_aqi: {e}")
+            return jsonify({"error": str(e), "aqi_index": 2, "pm2_5": 12.5}), 200

aqi_history.py

@@ -0,0 +1,250 @@
+import pandas as pd
+import numpy as np
+import os
+from flask import jsonify, request
+from datetime import datetime, timedelta
+
+# Try importing Random Forest (Standard sklearn)
+try:
+    from sklearn.ensemble import RandomForestRegressor
+    from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score
+    HAS_MODEL = True
+except ImportError:
+    HAS_MODEL = False
+
+# Global instance
+_aqi_history = None
+
+class AQIHistory:
+    def __init__(self, data_path='AQI_Combined.csv'):
+        self.data_path = data_path
+        self.df = None
+        self.model = None
+        self.metrics = {}
+        self._load_data()
+        
+        if HAS_MODEL and self.df is not None and not self.df.empty:
+            self._train_model()
+    
+    def _load_data(self):
+        if os.path.exists(self.data_path):
+            try:
+                self.df = pd.read_csv(self.data_path)
+                # Parse date - format is DD-MM-YYYY based on user input
+                self.df['Date'] = pd.to_datetime(self.df['Date'], format='%d-%m-%Y')
+                self.df = self.df.sort_values('Date').dropna()
+            except Exception as e:
+                print(f"Error loading AQI history: {e}")
+                self.df = pd.DataFrame()
+        else:
+            print(f"AQI history file not found: {self.data_path}")
+            self.df = pd.DataFrame()
+
+    def get_history(self, start_year=None, end_year=None):
+        if self.df is None or self.df.empty:
+            return []
+            
+        data = self.df.copy()
+        
+        if start_year:
+            data = data[data['Date'].dt.year >= start_year]
+        if end_year:
+            data = data[data['Date'].dt.year <= end_year]
+            
+        # Return raw daily data instead of monthly averages
+        # This ensures the values match the CSV exactly as requested by the user
+        
+        return [
+            {
+                'date': row['Date'].strftime('%Y-%m-%d'),
+                'aqi': int(row['AQI'])
+            }
+            for _, row in data.iterrows()
+        ]
+
+    def _create_features(self, data):
+        df_feat = data.copy()
+        target_col = 'AQI'
+        
+        # Time features
+        df_feat['day_of_week'] = df_feat['Date'].dt.dayofweek
+        df_feat['month'] = df_feat['Date'].dt.month
+        df_feat['day_of_year'] = df_feat['Date'].dt.dayofyear
+        
+        # Seasonality (Cyclical)
+        df_feat['day_year_sin'] = np.sin(2 * np.pi * df_feat['day_of_year'] / 365.25)
+        df_feat['day_year_cos'] = np.cos(2 * np.pi * df_feat['day_of_year'] / 365.25)
+        df_feat['month_sin'] = np.sin(2 * np.pi * df_feat['month'] / 12)
+        df_feat['month_cos'] = np.cos(2 * np.pi * df_feat['month'] / 12)
+        
+        # Lags (Extended for long-term dependency)
+        # 365 lag is crucial for year-over-year patterns
+        lags = [1, 2, 3, 7, 14, 30, 60, 90, 365]
+        for lag in lags:
+            df_feat[f'lag_{lag}'] = df_feat[target_col].shift(lag)
+            
+        # Rolling stats
+        for window in [7, 30, 90]:
+            df_feat[f'rolling_mean_{window}'] = df_feat[target_col].shift(1).rolling(window=window).mean()
+            df_feat[f'rolling_std_{window}'] = df_feat[target_col].shift(1).rolling(window=window).std()
+            
+        return df_feat.dropna()
+
+    def _train_model(self):
+        print("Training AQI Forecast Model (Random Forest)...")
+        try:
+            df_feat = self._create_features(self.df)
+            
+            features = [c for c in df_feat.columns if c not in ['Date', 'AQI']]
+            X = df_feat[features].values
+            y = df_feat['AQI'].values
+            
+            # Split
+            # Use last 365 days as test set
+            split_idx = len(X) - 365
+            X_train, X_test = X[:split_idx], X[split_idx:]
+            y_train, y_test = y[:split_idx], y[split_idx:]
+            
+            self.model = RandomForestRegressor(
+                n_estimators=1000,
+                max_depth=20,
+                random_state=42,
+                n_jobs=-1
+            )
+            
+            self.model.fit(X_train, y_train)
+            
+            # Metrics
+            preds = self.model.predict(X_test)
+            mae = mean_absolute_error(y_test, preds)
+            mse = mean_squared_error(y_test, preds)
+            rmse = np.sqrt(mse)
+            r2 = r2_score(y_test, preds)
+            
+            self.metrics = {
+                'mae': float(mae),
+                'mse': float(mse),
+                'rmse': float(rmse),
+                'r2': float(r2)
+            }
+            print(f"AQI RF Model trained. MAE: {mae:.2f}, R2: {r2:.2f}")
+            
+        except Exception as e:
+            print(f"Error training AQI model: {e}")
+
+    def forecast_days(self, n_days=180):
+        if not HAS_MODEL or self.df is None or self.df.empty:
+            return {'error': 'Model not trained'}
+            
+        future_dates = []
+        last_date = self.df['Date'].iloc[-1]
+        
+        # Calculate gap to today
+        today = pd.Timestamp.now().normalize()
+        gap_days = (today - last_date).days
+        
+        # We want to fill the gap AND predict n_days into the future
+        total_days = max(0, gap_days) + n_days
+        
+        print(f"Bridging gap of {gap_days} days + Forecasting {n_days} days. Total: {total_days}")
+        
+        # We need to iteratively predict because of lags
+        # Start with the last known data window
+        current_data = self.df.copy()
+        
+        predictions = []
+        
+        for i in range(total_days):
+            next_date = last_date + timedelta(days=i+1)
+            
+            # Create a temporary row for feature engineering
+            temp_df = pd.concat([
+                current_data,
+                pd.DataFrame({'Date': [next_date], 'AQI': [0]}) # Dummy AQI
+            ], ignore_index=True)
+            
+            feats_df = self._create_features(temp_df)
+            if feats_df.empty:
+                break
+                
+            # Get the features for the last row (the one we want to predict)
+            last_row_feats = feats_df.iloc[-1]
+            features_cols = [c for c in feats_df.columns if c not in ['Date', 'AQI']]
+            
+            X_pred = last_row_feats[features_cols].values.reshape(1, -1)
+            pred_aqi = float(self.model.predict(X_pred)[0])
+            pred_aqi = max(0, pred_aqi) # AQI can't be negative
+            
+            predictions.append({
+                'date': next_date.strftime('%Y-%m-%d'),
+                'aqi': int(round(pred_aqi))
+            })
+            
+            # Append prediction to current_data for next iteration's lags
+            current_data = pd.concat([
+                current_data,
+                pd.DataFrame({'Date': [next_date], 'AQI': [pred_aqi]})
+            ], ignore_index=True)
+
+        return {
+            'forecast': predictions,
+            'metrics': self.metrics
+        }
+
+def get_aqi_history():
+    global _aqi_history
+    if _aqi_history is None:
+        _aqi_history = AQIHistory()
+    return _aqi_history
+
+def register_aqi_history_routes(app):
+    @app.route('/api/aqi/history', methods=['GET'])
+    def api_aqi_history():
+        try:
+            handler = get_aqi_history()
+            trends = handler.get_history()
+            return jsonify({
+                'status': 'success',
+                'data': trends
+            })
+        except Exception as e:
+            return jsonify({'error': str(e)}), 500
+
+    @app.route('/api/aqi/forecast', methods=['POST'])
+    def api_aqi_forecast():
+        try:
+            data = request.json or {}
+            days = data.get('days', 30)
+            
+            handler = get_aqi_history()
+            result = handler.forecast_days(days)
+            
+            return jsonify({
+                'status': 'success',
+                'data': result
+            })
+        except Exception as e:
+            return jsonify({'error': str(e)}), 500
+
+if __name__ == "__main__":
+    print("Initialize AQI History and Training Model...")
+    try:
+        handler = AQIHistory()
+        if handler.model:
+            print("\nModel Trained Successfully!")
+            print("-" * 30)
+            print("Performance Metrics (Test Set):")
+            for metric, value in handler.metrics.items():
+                print(f"  {metric.upper()}: {value:.4f}")
+            print("-" * 30)
+            
+            print("\nSample 5-Day Forecast:")
+            forecast_result = handler.forecast_days(5)
+            if 'forecast' in forecast_result:
+                for day in forecast_result['forecast']:
+                    print(f"  {day['date']}: {day['aqi']} (AQI)")
+        else:
+            print("Model failed to train or Scikit-learn not installed.")
+            
+    except Exception as e:
+        print(f"\nError: {e}")

aqi_map.py

@@ -0,0 +1,344 @@
+
+import folium
+import os
+import time
+import random
+from selenium import webdriver
+from selenium.webdriver.chrome.options import Options
+from selenium.webdriver.chrome.service import Service
+from webdriver_manager.chrome import ChromeDriverManager
+
+# Delhi center coordinates
+DELHI_LAT = 28.7041
+DELHI_LON = 77.1025
+
+def generate_aqi_map_html():
+    """Generates a Folium map with AQI hotspots and returns the HTML string."""
+    
+    # Create base map
+    m = folium.Map(location=[DELHI_LAT, DELHI_LON], zoom_start=11)
+    
+    # Add Delhi Boundary
+    try:
+        # Using DataMeet's Delhi Boundary GeoJSON
+        geojson_url = "https://raw.githubusercontent.com/datameet/Municipal_Spatial_Data/master/Delhi/Delhi_Boundary.geojson"
+        folium.GeoJson(
+            geojson_url,
+            name="Delhi Boundary",
+            style_function=lambda x: {
+                'fillColor': 'none',
+                'color': 'black',
+                'weight': 2,
+                'dashArray': '5, 5'
+            }
+        ).add_to(m)
+    except Exception as e:
+        print(f"Error loading Delhi GeoJSON: {e}")
+    
+    # Randomly generate some "hotspot" locations around Delhi for demo
+    # In a real app, this would come from the AQI data source
+    hotspots = [
+        {
+            "name": "Chandni Chowk",
+            "lat": 28.656,
+            "lon": 77.231,
+            "aqi": 384
+        },
+        {
+            "name": "Nehru Nagar",
+            "lat": 28.5697,
+            "lon": 77.253,
+            "aqi": 384
+        },
+        {
+            "name": "New Moti Bagh",
+            "lat": 28.582,
+            "lon": 77.1717,
+            "aqi": 377
+        },
+        {
+            "name": "Shadipur",
+            "lat": 28.6517,
+            "lon": 77.1582,
+            "aqi": 375
+        },
+        {
+            "name": "Wazirpur",
+            "lat": 28.6967,
+            "lon": 77.1658,
+            "aqi": 354
+        },
+        {
+            "name": "Ashok Vihar",
+            "lat": 28.6856,
+            "lon": 77.178,
+            "aqi": 231
+        },
+        {
+            "name": "Mundka",
+            "lat": 28.6794,
+            "lon": 77.0284,
+            "aqi": 353
+        },
+        {
+            "name": "Punjabi Bagh",
+            "lat": 28.673,
+            "lon": 77.1374,
+            "aqi": 349
+        },
+        {
+            "name": "RK Puram",
+            "lat": 28.5505,
+            "lon": 77.1849,
+            "aqi": 342
+        },
+        {
+            "name": "Jahangirpuri",
+            "lat": 28.716,
+            "lon": 77.1829,
+            "aqi": 338
+        },
+        {
+            "name": "Okhla Phase-2",
+            "lat": 28.5365,
+            "lon": 77.2803,
+            "aqi": 337
+        },
+        {
+            "name": "Dwarka Sector-8",
+            "lat": 28.5656,
+            "lon": 77.067,
+            "aqi": 336
+        },
+        {
+            "name": "Patparganj",
+            "lat": 28.612,
+            "lon": 77.292,
+            "aqi": 334
+        },
+        {
+            "name": "Bawana",
+            "lat": 28.8,
+            "lon": 77.03,
+            "aqi": 328
+        },
+        {
+            "name": "Sonia Vihar",
+            "lat": 28.7074,
+            "lon": 77.2599,
+            "aqi": 317
+        },
+        {
+            "name": "Rohini",
+            "lat": 28.7019,
+            "lon": 77.0984,
+            "aqi": 312
+        },
+        {
+            "name": "Narela",
+            "lat": 28.85,
+            "lon": 77.1,
+            "aqi": 311
+        },
+        {
+            "name": "Mandir Marg",
+            "lat": 28.6325,
+            "lon": 77.1994,
+            "aqi": 311
+        },
+        {
+            "name": "Vivek Vihar",
+            "lat": 28.6635,
+            "lon": 77.3152,
+            "aqi": 303
+        },
+        {
+            "name": "Anand Vihar",
+            "lat": 28.6508,
+            "lon": 77.3152,
+            "aqi": 335
+        },
+        {
+            "name": "Dhyanchand Stadium",
+            "lat": 28.6125,
+            "lon": 77.2372,
+            "aqi": 335
+        },
+        {
+            "name": "Sirifort",
+            "lat": 28.5521,
+            "lon": 77.2193,
+            "aqi": 326
+        },
+        {
+            "name": "Karni Singh Shooting Range",
+            "lat": 28.4998,
+            "lon": 77.2668,
+            "aqi": 323
+        },
+        {
+            "name": "ITO",
+            "lat": 28.6294,
+            "lon": 77.241,
+            "aqi": 324
+        },
+        {
+            "name": "JLN Stadium",
+            "lat": 28.5828,
+            "lon": 77.2344,
+            "aqi": 314
+        },
+        {
+            "name": "IGI Airport T3",
+            "lat": 28.5562,
+            "lon": 77.1,
+            "aqi": 305
+        },
+        {
+            "name": "Pusa IMD",
+            "lat": 28.6335,
+            "lon": 77.1651,
+            "aqi": 298
+        },
+        {
+            "name": "Burari Crossing",
+            "lat": 28.7592,
+            "lon": 77.1938,
+            "aqi": 294
+        },
+        {
+            "name": "Aurobindo Marg",
+            "lat": 28.545,
+            "lon": 77.205,
+            "aqi": 287
+        },
+        {
+            "name": "Dilshad Garden (IHBAS)",
+            "lat": 28.681,
+            "lon": 77.305,
+            "aqi": 283
+        },
+        {
+            "name": "Lodhi Road",
+            "lat": 28.5921,
+            "lon": 77.2284,
+            "aqi": 282
+        },
+        {
+            "name": "NSIT-Dwarka",
+            "lat": 28.6081,
+            "lon": 77.0193,
+            "aqi": 275
+        },
+        {
+            "name": "Alipur",
+            "lat": 28.8,
+            "lon": 77.15,
+            "aqi": 273
+        },
+        {
+            "name": "Najafgarh",
+            "lat": 28.6125,
+            "lon": 76.983,
+            "aqi": 262
+        },
+        {
+            "name": "CRRI-Mathura Road",
+            "lat": 28.5518,
+            "lon": 77.2752,
+            "aqi": 252
+        },
+        {
+            "name": "DTU",
+            "lat": 28.7501,
+            "lon": 77.1177,
+            "aqi": 219
+        },
+        {
+            "name": "DU North Campus",
+            "lat": 28.69,
+            "lon": 77.21,
+            "aqi": 298
+        },
+        {
+            "name": "Ayanagar",
+            "lat": 28.4809,
+            "lon": 77.1255,
+            "aqi": 342
+        }
+    ]
+    
+    for spot in hotspots:
+        color = "gray" # Default for NA or invalid
+        aqi = spot['aqi']
+        
+        if isinstance(aqi, (int, float)):
+             color = "green"
+             if aqi > 100: color = "yellow"
+             if aqi > 200: color = "orange"
+             if aqi > 300: color = "red"
+             if aqi > 400: color = "purple"
+        
+        # Add marker
+        folium.CircleMarker(
+            location=[spot['lat'], spot['lon']],
+            radius=20,
+            popup=f"{spot['name']}: AQI {spot['aqi']}",
+            color=color,
+            fill=True,
+            fill_color=color,
+            fill_opacity=0.7
+        ).add_to(m)
+        
+        folium.Marker(
+            location=[spot['lat'], spot['lon']],
+            icon=folium.DivIcon(html=f'<div style="font-weight: bold; color: black;">{spot["aqi"]}</div>')
+        ).add_to(m)
+        
+    return m.get_root().render()
+
+def render_map_to_png(html_content, output_path):
+    """
+    Renders the HTML content to a PNG image using Selenium headless Chrome.
+    """
+    tmp_html_path = os.path.abspath("temp_map.html")
+    
+    # Write HTML to temp file
+    with open(tmp_html_path, "w", encoding="utf-8") as f:
+        f.write(html_content)
+        
+    chrome_options = Options()
+    chrome_options.add_argument("--headless")
+    chrome_options.add_argument("--window-size=800,600")
+    chrome_options.add_argument("--disable-gpu")
+    chrome_options.add_argument("--no-sandbox")
+    
+    driver = None
+    try:
+        # Auto-install chromedriver
+        service = Service(ChromeDriverManager().install())
+        driver = webdriver.Chrome(service=service, options=chrome_options)
+        
+        # Load local HTML file
+        driver.get(f"file:///{tmp_html_path}")
+        time.sleep(2) # Wait for map to render tiles
+        
+        # Save screenshot
+        driver.save_screenshot(output_path)
+        print(f"Map image saved to {output_path}")
+        
+    except Exception as e:
+        print(f"Error rendering map to PNG: {e}")
+        import traceback
+        traceback.print_exc()
+    finally:
+        if driver:
+            driver.quit()
+        # Cleanup temp file
+        if os.path.exists(tmp_html_path):
+            os.remove(tmp_html_path)
+
+if __name__ == "__main__":
+    # Test run
+    html = generate_aqi_map_html()
+    render_map_to_png(html, "aqi_map_test.png")

config.py

@@ -0,0 +1,31 @@
+"""
+Configuration for the policy engine.
+"""
+import os
+from pathlib import Path
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# Paths
+BASE_DIR = Path(__file__).parent
+FAISS_INDEX_PATH = BASE_DIR / "faiss_index"
+GRAPH_STATE_PATH = BASE_DIR / "graph_state.json"
+SCENARIOS_PATH = BASE_DIR / "scenarios.json"
+
+AMBEE_DATA_KEY = os.getenv("AMBEE_DATA_KEY", "")
+# LLM Configuration
+GROQ_API_KEY = os.getenv("GROQ_API_KEY", "")
+LLM_MODEL = "llama-3.3-70b-versatile"
+LLM_TEMPERATURE = 0.2
+
+# FAISS Configuration
+EMBEDDINGS_MODEL = "sentence-transformers/all-MiniLM-L6-v2"
+FAISS_K_SEARCH = 3
+
+# Graph Simulation
+SIMULATION_PASSES = 6
+
+# API Configuration
+FLASK_PORT = 5000
+FLASK_DEBUG = True

emission_forecast.py

@@ -0,0 +1,323 @@
+"""
+Emission Forecasting API Routes
+Random Forest model for CO2 emission forecasting
+"""
+from flask import jsonify, request
+import pandas as pd
+import numpy as np
+# from sklearn.ensemble import RandomForestRegressor (Removed)
+from sklearn.metrics import r2_score, mean_absolute_error, mean_squared_error
+from datetime import datetime
+import os
+
+# Global model instance
+_forecaster = None
+
+class EmissionForecaster:
+    def __init__(self, data_path='new_daily_emissions_column_format.xlsx'):
+        self.data_path = data_path
+        self.model = None
+        self.df_features = None
+        self.feature_cols = None
+        self.avg_sectors = None
+        self.metrics = {}
+        self.n_lags = 14
+        self.target_col = 'Total Emissions'
+        self.sector_cols = ['Aviation (%)', 'Ground Transport (%)', 'Industry (%)', 'Power (%)', 'Residential (%)']
+        
+        if os.path.exists(data_path):
+            self._train_model()
+    
+    def _create_features(self, data):
+        df_feat = data.copy()
+        df_feat = df_feat.dropna(subset=['Date', self.target_col]).reset_index(drop=True)
+        
+        df_feat['day_of_week'] = df_feat['Date'].dt.dayofweek
+        df_feat['day_of_month'] = df_feat['Date'].dt.day
+        df_feat['month'] = df_feat['Date'].dt.month
+        df_feat['week_of_year'] = df_feat['Date'].dt.isocalendar().week.fillna(1).astype(int)
+        df_feat['is_weekend'] = (df_feat['day_of_week'] >= 5).astype(int)
+        df_feat['quarter'] = df_feat['Date'].dt.quarter
+        df_feat['day_sin'] = np.sin(2 * np.pi * df_feat['day_of_week'] / 7)
+        df_feat['day_cos'] = np.cos(2 * np.pi * df_feat['day_of_week'] / 7)
+        df_feat['month_sin'] = np.sin(2 * np.pi * df_feat['month'] / 12)
+        df_feat['month_cos'] = np.cos(2 * np.pi * df_feat['month'] / 12)
+        
+        for lag in range(1, self.n_lags + 1):
+            df_feat[f'lag_{lag}'] = df_feat[self.target_col].shift(lag)
+        df_feat['lag_7_same_day'] = df_feat[self.target_col].shift(7)
+        df_feat['lag_14_same_day'] = df_feat[self.target_col].shift(14)
+        
+        for window in [3, 7, 14]:
+            df_feat[f'rolling_mean_{window}'] = df_feat[self.target_col].shift(1).rolling(window=window).mean()
+            df_feat[f'rolling_std_{window}'] = df_feat[self.target_col].shift(1).rolling(window=window).std()
+        
+        df_feat['ema_7'] = df_feat[self.target_col].shift(1).ewm(span=7).mean()
+        df_feat['diff_1'] = df_feat[self.target_col].diff(1)
+        df_feat = df_feat.dropna().reset_index(drop=True)
+        return df_feat
+    
+    def _train_model(self):
+        df = pd.read_excel(self.data_path)
+        df['Date'] = pd.to_datetime(df['Date'], dayfirst=True)
+        df = df.sort_values('Date').reset_index(drop=True)
+        df['Year'] = df['Date'].dt.year
+        
+        self.avg_sectors = df[self.sector_cols].mean().to_dict()
+        self.df = df
+        self.df_features = self._create_features(df)
+        
+        exclude_cols = ['Date', self.target_col, 'Year'] + self.sector_cols
+        self.feature_cols = [col for col in self.df_features.columns if col not in exclude_cols]
+        
+        X = self.df_features[self.feature_cols].values
+        y = self.df_features[self.target_col].values
+        
+        test_size = int(len(X) * 0.15)
+        X_train, X_test = X[:-test_size], X[-test_size:]
+        y_train, y_test = y[:-test_size], y[-test_size:]
+        
+        # Using XGBoost for better performance
+        from xgboost import XGBRegressor
+        
+        self.model = XGBRegressor(
+            n_estimators=1000,
+            learning_rate=0.05,
+            max_depth=6,
+            subsample=0.8,
+            colsample_bytree=0.8,
+            random_state=42,
+            n_jobs=-1,
+            early_stopping_rounds=50
+        )
+        
+        # Train with early stopping
+        self.model.fit(
+            X_train, y_train,
+            eval_set=[(X_test, y_test)],
+            verbose=False
+        )
+        
+        y_pred = self.model.predict(X_test)
+        y_pred = self.model.predict(X_test)
+        self.metrics = {
+            'r2': round(float(r2_score(y_test, y_pred)), 4),
+            'mae': round(float(mean_absolute_error(y_test, y_pred)), 4),
+            'rmse': round(float(np.sqrt(mean_squared_error(y_test, y_pred))), 4)
+        }
+    
+    def _forecast_daily(self, n_days):
+        last_date = self.df_features['Date'].iloc[-1]
+        recent = self.df_features[self.target_col].values[-max(self.n_lags, 14):].tolist()
+        forecasts = []
+        
+        for step in range(1, n_days + 1):
+            fd = pd.Timestamp(last_date) + pd.Timedelta(days=step)
+            f = {
+                'day_of_week': fd.dayofweek, 'day_of_month': fd.day, 'month': fd.month,
+                'week_of_year': fd.isocalendar()[1], 'is_weekend': 1 if fd.dayofweek >= 5 else 0,
+                'quarter': fd.quarter,
+                'day_sin': np.sin(2 * np.pi * fd.dayofweek / 7),
+                'day_cos': np.cos(2 * np.pi * fd.dayofweek / 7),
+                'month_sin': np.sin(2 * np.pi * fd.month / 12),
+                'month_cos': np.cos(2 * np.pi * fd.month / 12),
+            }
+            for lag in range(1, self.n_lags + 1):
+                f[f'lag_{lag}'] = recent[-lag] if lag <= len(recent) else np.mean(recent)
+            f['lag_7_same_day'] = recent[-7] if len(recent) >= 7 else np.mean(recent)
+            f['lag_14_same_day'] = recent[-14] if len(recent) >= 14 else np.mean(recent)
+            for w in [3, 7, 14]:
+                wd = recent[-w:] if len(recent) >= w else recent
+                f[f'rolling_mean_{w}'] = np.mean(wd)
+                f[f'rolling_std_{w}'] = np.std(wd) if len(wd) > 1 else 0
+            f['ema_7'] = pd.Series(recent).ewm(span=7).mean().iloc[-1]
+            f['diff_1'] = recent[-1] - recent[-2] if len(recent) >= 2 else 0
+            
+            X_pred = np.array([f[col] for col in self.feature_cols]).reshape(1, -1)
+            pred = float(self.model.predict(X_pred)[0])
+            
+            sector_breakdown = {
+                k.replace(' (%)', '').replace(' ', '_'): round(pred * v / 100, 4)
+                for k, v in self.avg_sectors.items()
+            }
+            
+            forecasts.append({
+                'date': fd.strftime('%Y-%m-%d'),
+                'emission': round(pred, 4),
+                'sectors': sector_breakdown
+            })
+            recent.append(pred)
+        
+        return forecasts
+    
+    def forecast_days(self, n_days):
+        n_days = max(1, min(365, n_days))
+        
+        # Calculate gap from last data point to today
+        last_date = self.df_features['Date'].iloc[-1]
+        today = pd.Timestamp(datetime.now().date())
+        days_gap = (today - last_date).days
+        
+        # If there is a gap, extend forecast to cover it + requested days
+        total_days = n_days
+        if days_gap > 0:
+            total_days += days_gap
+            
+        forecasts = self._forecast_daily(total_days)
+        
+        # Determine history length: match n_days (requested forecast length)
+        # Note: 'n_days' here is the requested length, 'total_days' includes gap fill.
+        # User wants "previous 30 days if we choose 30", so we use original n_days.
+        history_days = n_days
+        
+        # Get historical data
+        history_data = []
+        if self.df is not None and not self.df.empty:
+            hist_df = self.df.tail(history_days)
+            for _, row in hist_df.iterrows():
+                # Calculate sector values from percentages
+                sector_breakdown = {}
+                for col in self.sector_cols:
+                    sector_name = col.replace(' (%)', '').replace(' ', '_')
+                    # If column exists in row, use it, otherwise use average
+                    pct = row[col] if col in row else self.avg_sectors.get(col, 0)
+                    sector_breakdown[sector_name] = round(row[self.target_col] * pct / 100, 4)
+
+                history_data.append({
+                    'date': row['Date'].strftime('%Y-%m-%d'),
+                    'emission': round(row[self.target_col], 4),
+                    'sectors': sector_breakdown,
+                    'is_historical': True
+                })
+
+        return {
+            'type': 'daily',
+            'days': n_days,
+            'forecasts': forecasts,
+            'history': history_data,
+            'metrics': self.metrics,
+            'sector_percentages': {k.replace(' (%)', ''): round(v, 2) for k, v in self.avg_sectors.items()}
+        }
+    
+    def forecast_years(self, n_years):
+        n_years = max(1, min(3, n_years))
+        n_days = 365 * (n_years + 1)
+        daily = self._forecast_daily(n_days)
+        
+        # Historical yearly averages
+        historical = self.df.groupby('Year')[self.target_col].mean().reset_index()
+        
+        # Forecasted yearly averages
+        df_forecast = pd.DataFrame(daily)
+        df_forecast['year'] = pd.to_datetime(df_forecast['date']).dt.year
+        forecast_yearly = df_forecast[df_forecast['year'] >= 2026].groupby('year')['emission'].mean()
+        forecast_yearly = forecast_yearly.head(n_years)
+        
+        years_data = []
+        for _, row in historical.iterrows():
+            years_data.append({
+                'year': int(row['Year']),
+                'avg_emission': round(row[self.target_col], 4),
+                'type': 'historical'
+            })
+        
+        for year, emission in forecast_yearly.items():
+            sector_breakdown = {
+                k.replace(' (%)', '').replace(' ', '_'): round(emission * v / 100, 4)
+                for k, v in self.avg_sectors.items()
+            }
+            years_data.append({
+                'year': int(year),
+                'avg_emission': round(emission, 4),
+                'type': 'forecast',
+                'sectors': sector_breakdown
+            })
+        
+        return {
+            'type': 'yearly',
+            'years': n_years,
+            'data': years_data,
+            'metrics': self.metrics,
+            'sector_percentages': {k.replace(' (%)', ''): round(v, 2) for k, v in self.avg_sectors.items()}
+        }
+
+
+def get_forecaster():
+    global _forecaster
+    if _forecaster is None:
+        _forecaster = EmissionForecaster()
+    return _forecaster
+
+
+def register_emission_routes(app):
+    """Register emission forecast routes with Flask app."""
+    
+    @app.route('/api/emission/metrics', methods=['GET'])
+    def emission_metrics():
+        """Get model performance metrics."""
+        try:
+            forecaster = get_forecaster()
+            return jsonify({
+                'status': 'success',
+                'metrics': forecaster.metrics,
+                'sector_percentages': {k.replace(' (%)', ''): round(v, 2) for k, v in forecaster.avg_sectors.items()},
+                'timestamp': datetime.now().isoformat()
+            })
+        except Exception as e:
+            return jsonify({'error': str(e)}), 500
+    
+    @app.route('/api/emission/forecast/days', methods=['POST'])
+    def emission_forecast_days():
+        """Forecast emissions for 1-365 days."""
+        try:
+            data = request.json or {}
+            n_days = data.get('days', 30)
+            
+            forecaster = get_forecaster()
+            result = forecaster.forecast_days(n_days)
+            
+            return jsonify({
+                'status': 'success',
+                **result,
+                'timestamp': datetime.now().isoformat()
+            })
+        except Exception as e:
+            return jsonify({'error': str(e)}), 500
+    
+    @app.route('/api/emission/forecast/years', methods=['POST'])
+    def emission_forecast_years():
+        """Forecast yearly averages for 1-3 years."""
+        try:
+            data = request.json or {}
+            n_years = data.get('years', 1)
+            
+            forecaster = get_forecaster()
+            result = forecaster.forecast_years(n_years)
+            
+            return jsonify({
+                'status': 'success',
+                **result,
+                'timestamp': datetime.now().isoformat()
+            })
+        except Exception as e:
+            return jsonify({'error': str(e)}), 500
+
+if __name__ == "__main__":
+    print("Training XGBoost Emission Model...")
+    try:
+        forecaster = EmissionForecaster()
+        print("\nModel Trained Successfully!")
+        print("-" * 30)
+        print("Performance Metrics (Test Set):")
+        for metric, value in forecaster.metrics.items():
+            print(f"  {metric.upper()}: {value}")
+        print("-" * 30)
+        
+        # Optional: Print a sample forecast
+        print("\nSample 5-Day Forecast:")
+        forecast = forecaster.forecast_days(5)
+        for day in forecast['forecasts']:
+            print(f"  {day['date']}: {day['emission']} tonnes CO2")
+            
+    except Exception as e:
+        print(f"\nError: {e}")

explainability.py

@@ -0,0 +1,277 @@
+"""
+Explainability layer: generates human-readable explanations for policy actions.
+Links mutations to research evidence and identifies trade-offs.
+"""
+import json
+from typing import List, Dict, Any, Optional
+from langchain_groq import ChatGroq
+import config
+
+
+class ExplanationGenerator:
+    """Generates narrative explanations for policy mutations."""
+    
+    def __init__(self, policy: Dict[str, Any], research_chunks: List[str]):
+        """
+        Initialize generator.
+        
+        Args:
+            policy: Policy dict with mutations
+            research_chunks: List of research excerpts supporting the policy
+        """
+        self.policy = policy
+        self.research = research_chunks
+        self.llm = ChatGroq(
+            model=config.LLM_MODEL,
+            temperature=0.5,
+            api_key=config.GROQ_API_KEY
+        )
+
+    
+    def generate_full_explanation(self) -> Dict[str, Any]:
+        """
+        Generate complete explainability output for a policy.
+        
+        Returns:
+            Dict with intro narrative, per-mutation explanations, trade-offs
+        """
+        explanations = {
+            'policy_id': self.policy.get('policy_id'),
+            'policy_name': self.policy.get('name'),
+            'narrative_intro': self._generate_intro(),
+            'mutations': [],
+            'overall_narrative': self._generate_overall_narrative()
+        }
+        
+        # Generate explanation for each mutation
+        for mutation in self.policy.get('mutations', []):
+            exp = self._explain_mutation(mutation)
+            explanations['mutations'].append(exp)
+        
+        return explanations
+    
+    def _generate_intro(self) -> str:
+        """Generate opening narrative for the policy."""
+        prompt = f"""
+Write a compelling 2-3 sentence introduction to this climate policy intervention.
+Focus on why it matters for public health and urban sustainability.
+
+Policy Name: {self.policy.get('name')}
+Number of Actions: {len(self.policy.get('mutations', []))}
+Expected CO₂ Reduction: {self.policy.get('estimated_impacts', {}).get('co2_reduction_pct', 0)}%
+Expected AQI Improvement: {self.policy.get('estimated_impacts', {}).get('aqi_improvement_pct', 0)}%
+
+Keep it concise, impactful, and accessible to policymakers.
+"""
+        
+        try:
+            response = self.llm.invoke(prompt)
+            return response.content
+        except Exception as e:
+            print(f"Error generating intro: {e}")
+            return f"Policy: {self.policy.get('name')} aims to reduce emissions and improve air quality."
+    
+    def _generate_overall_narrative(self) -> str:
+        """Generate overall policy narrative."""
+        prompt = f"""
+Summarize this climate policy in 3-4 sentences suitable for a policy brief.
+Explain WHAT the policy does, WHY it's effective, and WHO benefits.
+
+Policy: {self.policy.get('name')}
+Description: {self.policy.get('description', '')}
+Trade-offs: {json.dumps(self.policy.get('trade_offs', []))}
+
+Be concise and professional. Avoid jargon.
+"""
+        
+        try:
+            response = self.llm.invoke(prompt)
+            return response.content
+        except Exception as e:
+            print(f"Error generating overall narrative: {e}")
+            return "Policy designed to reduce urban emissions through targeted sector interventions."
+    
+    def _explain_mutation(self, mutation: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Generate explanation for a single mutation.
+        
+        Args:
+            mutation: Single mutation dict
+            
+        Returns:
+            Dict with narrative, research backing, affected stakeholders
+        """
+        # Generate narrative explaining the mutation
+        narrative = self._generate_mutation_narrative(mutation)
+        
+        # Extract relevant research quotes
+        relevant_quotes = self._extract_relevant_quotes(mutation)
+        
+        # Identify stakeholders affected
+        stakeholders = self._identify_stakeholders(mutation)
+        
+        return {
+            'mutation': {
+                'type': mutation.get('type'),
+                'target': mutation.get('node_id') or f"{mutation.get('source')} → {mutation.get('target')}",
+                'reason': mutation.get('reason', '')
+            },
+            'narrative': narrative,
+            'supporting_research': relevant_quotes,
+            'affected_stakeholders': stakeholders
+        }
+    
+    def _generate_mutation_narrative(self, mutation: Dict[str, Any]) -> str:
+        """Generate 2-3 sentence explanation of why this mutation is applied."""
+        mutation_type = mutation.get('type')
+        
+        if mutation_type == 'disable_node':
+            target = mutation.get('node_id', 'sector')
+            prompt = f"""
+Explain why disabling the {target} sector is effective for reducing emissions.
+Write 2-3 sentences suitable for a policy document.
+Focus on: causal mechanism, expected benefits, and evidence base.
+
+Research evidence available:
+{chr(10).join(self.research[:2])}
+"""
+        elif mutation_type == 'reduce_edge_weight':
+            source = mutation.get('source', 'source')
+            target = mutation.get('target', 'target')
+            new_weight = mutation.get('new_weight', 0.5)
+            reduction = ((1 - new_weight) * 100) if new_weight else 0
+            
+            prompt = f"""
+Explain why reducing the {source} → {target} relationship (by ~{reduction:.0f}%) helps reduce emissions.
+This represents implementing technology or policy to reduce the causal influence.
+
+Write 2-3 sentences. Include: HOW (technology/policy), WHY (mechanism), IMPACT (benefits).
+
+Research evidence:
+{chr(10).join(self.research[:2])}
+"""
+        elif mutation_type == 'increase_edge_weight':
+            source = mutation.get('source', 'source')
+            target = mutation.get('target', 'target')
+            new_weight = mutation.get('new_weight', 0.7)
+            increase = ((new_weight - 1) * 100) if new_weight > 1 else 0
+            
+            prompt = f"""
+Explain why strengthening the {source} → {target} relationship helps achieve climate goals.
+This might represent policy incentives or investment in beneficial activities.
+
+Write 2-3 sentences explaining the mechanism and benefits.
+
+Research evidence:
+{chr(10).join(self.research[:2])}
+"""
+        else:
+            return "This policy action adjusts system dynamics to improve environmental outcomes."
+        
+        try:
+            response = self.llm.invoke(prompt)
+            return response.content
+        except Exception as e:
+            print(f"Error generating mutation narrative: {e}")
+            return mutation.get('reason', 'Policy action targeting emissions reduction.')
+    
+    def _extract_relevant_quotes(self, mutation: Dict[str, Any]) -> List[str]:
+        """
+        Find research quotes most relevant to this mutation.
+        Simple keyword matching; can be enhanced with semantic search.
+        """
+        quotes = []
+        keywords = []
+        
+        # Determine relevant keywords based on mutation
+        if mutation.get('type') == 'disable_node':
+            keywords = [mutation.get('node_id', '')]
+        else:
+            keywords = [
+                mutation.get('source', ''),
+                mutation.get('target', '')
+            ]
+        
+        # Search for quotes containing keywords
+        for chunk in self.research:
+            for keyword in keywords:
+                if keyword.lower() in chunk.lower():
+                    if chunk not in quotes:
+                        quotes.append(chunk[:150] + "..." if len(chunk) > 150 else chunk)
+                        break
+        
+        # Return first 2 relevant quotes
+        return quotes[:2] if quotes else [
+            "Research demonstrates effectiveness of targeted emission control policies.",
+            "Evidence supports multi-sector approach to urban air quality improvement."
+        ]
+    
+    def _identify_stakeholders(self, mutation: Dict[str, Any]) -> List[Dict[str, str]]:
+        """
+        Identify sectors/groups affected by this mutation.
+        """
+        stakeholders = []
+        mutation_type = mutation.get('type')
+        
+        # Map nodes/sectors to stakeholders
+        sector_to_stakeholders = {
+            'transport': [
+                {'group': 'Transport operators', 'impact': 'operational changes'},
+                {'group': 'Auto manufacturers', 'impact': 'R&D investment'},
+                {'group': 'Urban commuters', 'impact': 'improved air quality'}
+            ],
+            'energy': [
+                {'group': 'Power utilities', 'impact': 'generation mix shift'},
+                {'group': 'Coal industry', 'impact': 'transition costs'},
+                {'group': 'Solar/wind companies', 'impact': 'growth opportunities'},
+                {'group': 'Citizens', 'impact': 'cleaner air'}
+            ],
+            'industries': [
+                {'group': 'Manufacturers', 'impact': 'efficiency improvements'},
+                {'group': 'Workers', 'impact': 'job transitions'},
+                {'group': 'Consumers', 'impact': 'potential cost changes'}
+            ],
+            'infrastructure': [
+                {'group': 'Construction sector', 'impact': 'green building standards'},
+                {'group': 'Urban planners', 'impact': 'planning considerations'},
+                {'group': 'Real estate', 'impact': 'sustainable development'}
+            ]
+        }
+        
+        # Extract stakeholders based on affected node/sector
+        if mutation_type == 'disable_node':
+            target = mutation.get('node_id', '')
+        else:
+            target = mutation.get('source', '') or mutation.get('target', '')
+        
+        for key, groups in sector_to_stakeholders.items():
+            if key in target.lower():
+                stakeholders = groups
+                break
+        
+        return stakeholders if stakeholders else [
+            {'group': 'Urban residents', 'impact': 'health and quality of life'},
+            {'group': 'Industry stakeholders', 'impact': 'economic adaptation'}
+        ]
+
+
+# ============================================================================
+# STANDALONE HELPER FUNCTIONS
+# ============================================================================
+
+def generate_policy_explanation(
+    policy: Dict[str, Any],
+    research_chunks: List[str]
+) -> Dict[str, Any]:
+    """
+    Convenience function to generate explanation for a policy.
+    
+    Args:
+        policy: Policy dict
+        research_chunks: List of research excerpts
+        
+    Returns:
+        Full explanation dict
+    """
+    generator = ExplanationGenerator(policy, research_chunks)
+    return generator.generate_full_explanation()

faiss_index/index.faiss

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:58f3a028bd783459688d8d8a61b53a6d6c595580136134e3a9783f094c1de21d
+size 205869

faiss_index/index.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8ca9101043d20234372987de2f68ff0522cc674bdd0e6c339a0b7f42e0044bc6
+size 123525

graph_engine.py

@@ -0,0 +1,318 @@
+"""
+Graph mutation and simulation engine.
+Applies policies to the causal graph and runs multi-pass propagation.
+"""
+import json
+import copy
+from typing import Dict, List, Any, Tuple
+from datetime import datetime
+
+
+class GraphState:
+    """Represents the state of the causal graph."""
+    
+    def __init__(self, nodes: List[Dict], edges: List[Dict]):
+        """
+        Initialize graph state.
+        
+        Args:
+            nodes: List of node dicts with {id, label, type, enabled, value, ...}
+            edges: List of edge dicts with {id, source, target, weight, ...}
+        """
+        self.nodes = copy.deepcopy(nodes)
+        self.edges = copy.deepcopy(edges)
+        self.history = []  # For undo/redo
+        self.baseline_snapshot = None
+    
+    @staticmethod
+    def from_file(filepath: str) -> 'GraphState':
+        """Load graph state from JSON file."""
+        with open(filepath, 'r') as f:
+            data = json.load(f)
+        
+        instance = GraphState(data.get('nodes', []), data.get('edges', []))
+        instance.baseline_snapshot = copy.deepcopy(data)
+        return instance
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Export graph state to dict."""
+        return {
+            'nodes': self.nodes,
+            'edges': self.edges,
+            'timestamp': datetime.now().isoformat()
+        }
+    
+    def get_node(self, node_id: str) -> Dict:
+        """Get a node by ID."""
+        for node in self.nodes:
+            if node['id'] == node_id:
+                return node
+        return None
+    
+    def get_edge(self, source: str, target: str) -> Dict:
+        """Get an edge by source and target."""
+        for edge in self.edges:
+            if edge['source'] == source and edge['target'] == target:
+                return edge
+        return None
+    
+    def apply_mutation(self, mutation: Dict) -> Dict:
+        """
+        Apply a single mutation, return change record.
+        
+        Args:
+            mutation: {type, node_id, source, target, new_weight, reason, ...}
+            
+        Returns:
+            Change record for audit trail
+        """
+        change = {
+            'type': mutation['type'],
+            'before': None,
+            'after': None,
+            'timestamp': datetime.now().isoformat()
+        }
+        
+        if mutation['type'] == 'disable_node':
+            node_id = mutation['node_id']
+            node = next((n for n in self.nodes if n['id'] == node_id), None)
+            
+            if not node:
+                raise ValueError(f"Node not found: {node_id}")
+            
+            change['before'] = {'id': node_id, 'enabled': node.get('enabled', True)}
+            node['enabled'] = False
+            change['after'] = {'id': node_id, 'enabled': False}
+        
+        elif mutation['type'] == 'reduce_edge_weight' or mutation['type'] == 'increase_edge_weight':
+            source = mutation['source']
+            target = mutation['target']
+            edge = next((e for e in self.edges if e['source'] == source and e['target'] == target), None)
+            
+            if not edge:
+                raise ValueError(f"Edge not found: {source} -> {target}")
+            
+            old_weight = edge.get('data', {}).get('weight', 0.5) if isinstance(edge.get('data'), dict) else 0.5
+            change['before'] = {'source': source, 'target': target, 'weight': old_weight}
+            
+            # Update edge weight
+            if 'data' not in edge:
+                edge['data'] = {}
+            edge['data']['weight'] = mutation['new_weight']
+            
+            change['after'] = {'source': source, 'target': target, 'weight': mutation['new_weight']}
+        
+        self.history.append(change)
+        return change
+    
+    def apply_policy(self, policy: Dict) -> Dict:
+        """
+        Apply all mutations in a policy.
+        
+        Args:
+            policy: Policy dict with 'mutations' list
+            
+        Returns:
+            Result dict with applied mutations and any errors
+        """
+        results = {
+            'policy_id': policy.get('policy_id'),
+            'mutations_applied': [],
+            'timestamp': datetime.now().isoformat(),
+            'errors': []
+        }
+        
+        for mutation in policy.get('mutations', []):
+            try:
+                result = self.apply_mutation(mutation)
+                results['mutations_applied'].append(result)
+            except Exception as e:
+                results['errors'].append({
+                    'mutation': mutation.get('type'),
+                    'error': str(e)
+                })
+        
+        return results
+    
+    def run_simulation(self) -> Dict[str, Any]:
+        """
+        Multi-pass value propagation through causal graph.
+        Simulates how changes cascade through the system.
+        
+        Returns:
+            Dict with node_values and output metrics (co2, aqi)
+        """
+        # Initialize node values
+        node_values = {}
+        for node in self.nodes:
+            node_id = node['id']
+            node_type = node.get('data', {}).get('type') if isinstance(node.get('data'), dict) else node.get('type', 'intermediate')
+            
+            # Sector nodes start with baseline values
+            if node_type == 'sector':
+                node_values[node_id] = node.get('data', {}).get('value', 100) if isinstance(node.get('data'), dict) else 100
+            else:
+                node_values[node_id] = 0
+        
+        # Multi-pass propagation (captures cascading effects)
+        for iteration in range(6):  # config.SIMULATION_PASSES
+            for edge in self.edges:
+                source_id = edge['source']
+                target_id = edge['target']
+                
+                # Skip if nodes disabled or not found
+                source_node = next((n for n in self.nodes if n['id'] == source_id), None)
+                target_node = next((n for n in self.nodes if n['id'] == target_id), None)
+                
+                if not source_node or not target_node:
+                    continue
+                
+                source_enabled = source_node.get('data', {}).get('enabled', True) if isinstance(source_node.get('data'), dict) else True
+                target_enabled = target_node.get('data', {}).get('enabled', True) if isinstance(target_node.get('data'), dict) else True
+                
+                if not (source_enabled and target_enabled):
+                    continue
+                
+                # Propagate value
+                source_val = node_values.get(source_id, 0)
+                weight = edge.get('data', {}).get('weight', 0.5) if isinstance(edge.get('data'), dict) else 0.5
+                
+                if source_val > 0:
+                    node_values[target_id] = node_values.get(target_id, 0) + source_val * weight
+        
+        # Extract outputs
+        return {
+            'node_values': node_values,
+            'outputs': {
+                'co2': node_values.get('co2', 0),
+                'aqi': node_values.get('aqi', 0)
+            }
+        }
+    
+    def reset(self):
+        """Reset graph to baseline state."""
+        if self.baseline_snapshot:
+            self.nodes = copy.deepcopy(self.baseline_snapshot.get('nodes', []))
+            self.edges = copy.deepcopy(self.baseline_snapshot.get('edges', []))
+            self.history = []
+    
+    def undo(self, steps: int = 1) -> bool:
+        """Revert last N mutations."""
+        for _ in range(steps):
+            if not self.history:
+                return False
+            
+            change = self.history.pop()
+            
+            # Reverse the change
+            if change['type'] == 'disable_node':
+                node_id = change['before']['id']
+                node = next((n for n in self.nodes if n['id'] == node_id), None)
+                if node:
+                    node['enabled'] = change['before']['enabled']
+            
+            elif 'weight' in str(change['type']):
+                source = change['before']['source']
+                target = change['before']['target']
+                edge = next((e for e in self.edges if e['source'] == source and e['target'] == target), None)
+                if edge:
+                    if 'data' not in edge:
+                        edge['data'] = {}
+                    edge['data']['weight'] = change['before']['weight']
+        
+        return True
+
+
+class ImpactAnalyzer:
+    """Analyzes impact of policies by comparing baseline vs post-policy states."""
+    
+    def __init__(self, baseline_state: GraphState, post_policy_state: GraphState):
+        """
+        Initialize analyzer.
+        
+        Args:
+            baseline_state: GraphState before policy
+            post_policy_state: GraphState after policy
+        """
+        self.baseline = baseline_state
+        self.post_policy = post_policy_state
+    
+    def calculate_impact(self) -> Dict[str, Any]:
+        """
+        Calculate impact metrics.
+        
+        Returns:
+            Dict with CO₂ and AQI changes, cascade analysis, etc.
+        """
+        baseline_sim = self.baseline.run_simulation()
+        post_sim = self.post_policy.run_simulation()
+        
+        baseline_co2 = baseline_sim['outputs']['co2']
+        post_co2 = post_sim['outputs']['co2']
+        baseline_aqi = baseline_sim['outputs']['aqi']
+        post_aqi = post_sim['outputs']['aqi']
+        
+        # Calculate impacts
+        impact = {
+            'co2': {
+                'baseline': baseline_co2,
+                'post_policy': post_co2,
+                'change_absolute': post_co2 - baseline_co2,
+                'change_pct': (
+                    ((post_co2 - baseline_co2) / baseline_co2 * 100)
+                    if baseline_co2 > 0 else 0
+                )
+            },
+            'aqi': {
+                'baseline': baseline_aqi,
+                'post_policy': post_aqi,
+                'change_absolute': post_aqi - baseline_aqi,
+                'change_pct': (
+                    ((post_aqi - baseline_aqi) / baseline_aqi * 100)
+                    if baseline_aqi > 0 else 0
+                )
+            }
+        }
+        
+        # Cascade analysis
+        cascade = self.analyze_cascade(baseline_sim, post_sim)
+        impact['cascade_analysis'] = cascade
+        
+        return impact
+    
+    def analyze_cascade(self, baseline_sim: Dict, post_sim: Dict) -> Dict[str, Any]:
+        """
+        Identify which nodes changed most (1st, 2nd, 3rd order effects).
+        """
+        baseline_vals = baseline_sim['node_values']
+        post_vals = post_sim['node_values']
+        
+        node_changes = {}
+        for node_id in baseline_vals:
+            baseline_val = baseline_vals[node_id]
+            post_val = post_vals.get(node_id, 0)
+            
+            if baseline_val > 0.001:  # Avoid division by very small numbers
+                pct_change = ((post_val - baseline_val) / baseline_val) * 100
+                node_changes[node_id] = {
+                    'baseline': baseline_val,
+                    'post_policy': post_val,
+                    'change_pct': pct_change
+                }
+        
+        # Sort by magnitude of change
+        sorted_changes = sorted(
+            node_changes.items(),
+            key=lambda x: abs(x[1]['change_pct']),
+            reverse=True
+        )
+        
+        return {
+            'most_affected_nodes': [(node_id, data['change_pct']) for node_id, data in sorted_changes[:10]],
+            'all_node_changes': node_changes,
+            'summary': {
+                'nodes_with_reduction': len([d for d in node_changes.values() if d['change_pct'] < 0]),
+                'nodes_with_increase': len([d for d in node_changes.values() if d['change_pct'] > 0]),
+                'avg_change_pct': sum(d['change_pct'] for d in node_changes.values()) / len(node_changes) if node_changes else 0
+            }
+        }

health_analyzer.py

@@ -0,0 +1,181 @@
+"""
+Air Quality Health Impact Analyzer
+Uses Gemini to provide health risks based on AQI levels
+"""
+from langchain_groq import ChatGroq
+import config
+from typing import Dict, Any
+
+HEALTH_IMPACT_KNOWLEDGE_BASE = """
+# SYSTEM ROLE
+You are the Air Quality Health Impact Expert. Your purpose is to provide highly specific, data-driven health advice based on Air Quality Index (AQI) levels. You must use the provided tables to determine physiological impacts, mortality risks, and required safeguards.
+
+# KNOWLEDGE BASE
+
+## 1. CORE AQI STAGES & PHYSIOLOGICAL IMPACT
+- 0–50 (Good): PM2.5 0–30. Normal pulmonary clearance.
+- 51–100 (Satisfactory): PM2.5 31–60. Mild airway irritation, asthma discomfort.
+- 101–200 (Moderate): PM2.5 61–90. Reduced lung efficiency, cardiac strain.
+- 201–300 (Poor): PM2.5 91–120. Chronic inflammation, COPD exacerbation.
+- 301–400 (Very Poor): PM2.5 121–250. Systemic oxidative stress, heart attack risk.
+- 401–500+ (Severe): PM2.5 >250. Multi-organ stress, respiratory failure, stroke.
+
+## 2. INFANT, CHILD & PREGNANCY RISKS
+- Newborns (<28 days): Wheezing risk at 101-200; Chronic inflammation at 201-300; Hypoxia/Failure at 401+.
+- Children (1-5 yrs): Lung growth delay at 201-300; Arrested alveolar development at 301-400.
+- Pregnancy: Preterm birth risk increases at 101-200. Preeclampsia/Gestational Diabetes at 301-400. Stillbirth/Placental failure risk at 401+.
+
+## 3. AGE-SPECIFIC THREATS (VITAL THRESHOLDS)
+- 16–25 yrs: Reduced VO₂ max and early lung aging starts at 201-300.
+- 26–35 yrs: Fertility markers and sperm quality decrease at 101-200+.
+- 36–50 yrs: Hypertension onset at 101-200; Heart disease/MI risk at 301+.
+- 51–65 yrs: Stroke risk increases at 101-200; Neurological deficits at 301+.
+- 66–75+ yrs: Cognitive decline/Dementia onset at 201-300; Mortality spikes at 401+.
+
+## 4. PRE-EXISTING CONDITIONS
+- Asthma: Inhaler use ↑ (101-200), ER visits (301-400), Life-threatening (401+).
+- Diabetes: Insulin resistance ↑ (201-300), Vascular damage (301-400).
+- Elderly: Infection susceptibility (101-200), Mobility loss (301-400).
+- Cardiovascular Disease: Increased risk of MI/stroke at 201-300; Exacerbation of heart failure at 301-400.
+
+## 5. LIFE EXPECTANCY LOSS (LONG-TERM)
+- Delhi Residents: 3–5 yrs lost at Poor (201-300); 10–12 yrs lost at Severe (401+).
+- Elderly (65+): Up to 15 years lost in Severe conditions.
+- Children (NCR): Permanent lifelong health deficits and lifespan reduction.
+
+## 6. EXPOSURE DIMENSIONS
+- Acute (1-7 days): Hospitalization risk at 301+.
+- Sub-chronic (Weeks): Structural lung damage begins at 301+.
+- Chronic (Years): Dementia and premature death at 401+.
+
+## 7. SAFEGUARD PROTOCOLS
+- 101–200: Use exhaust fans/filtration; N95 for long exposure.
+- 201–300: HEPA purifiers mandatory; Wet mopping; N95 mandatory outdoors.
+- 301–400: Seal rooms; Stay indoors; N95/N99 compulsory.
+- 401–500+: Full isolation; No dust sources; Emergency meds/nebulizers ready.
+
+# RESPONSE GUIDELINES
+1. If a user provides an AQI, cross-reference all tables (Age, Condition, and Safeguard).
+2. If the user is in Delhi/NCR, emphasize the Life Expectancy Loss data.
+3. Be clinical but empathetic. Use terms like "Systemic oxidative stress" or "Placental perfusion" to explain risks.
+4. Respond in numbered sections: Risk Summary, Age-Specific Impact, Immediate Actions, Long-Term Risk.
+"""
+
+
+class HealthImpactAnalyzer:
+    """Analyzes health impacts of AQI levels using Gemini"""
+    
+    def __init__(self):
+        
+        self.llm = ChatGroq(
+            model=config.LLM_MODEL,
+            temperature=0.5,
+            api_key=config.GROQ_API_KEY
+        )
+
+    
+    def analyze_aqi_health(self, aqi_data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Analyze health impacts based on AQI data
+        
+        Args:
+            aqi_data: {
+                'aqi': int (0-500),
+                'city': str,
+                'pm2_5': float,
+                'pm10': float,
+                'no2': float,
+                'o3': float,
+                'so2': float,
+                'co': float
+            }
+        
+        Returns:
+            Health impact analysis with risk assessment
+        """
+        aqi = aqi_data.get('aqi', 0)
+        city = aqi_data.get('city', 'Unknown')
+        pm2_5 = aqi_data.get('pm2_5', 0)
+        
+        prompt = f"""{HEALTH_IMPACT_KNOWLEDGE_BASE}
+
+# USER DATA
+AQI Level: {aqi}
+City: {city}
+PM2.5: {pm2_5} µg/m³
+PM10: {aqi_data.get('pm10', 0)} µg/m³
+NO₂: {aqi_data.get('no2', 0)} ppb
+O₃: {aqi_data.get('o3', 0)} ppb
+SO₂: {aqi_data.get('so2', 0)} ppb
+CO: {aqi_data.get('co', 0)} ppm
+
+Based on the AQI level ({aqi}) and the knowledge base above, provide a strict JSON response.
+
+Return ONLY valid JSON (no markdown):
+{{
+  "aqi_level": {aqi},
+  "category": "Good|Satisfactory|Moderate|Poor|Very Poor|Severe",
+  "risk_summary": "Overall assessment. Be clinical but empathetic.",
+  "age_specific_impacts": {{
+    "newborns": "Risk assessment for <28 days",
+    "children": "Risk assessment for 1-5 yrs",
+    "teenagers_young_adults": "Risk assessment for 16-35 yrs",
+    "adults_36_65": "Risk assessment for 36-65 yrs",
+    "elderly": "Risk assessment for >65 yrs"
+  }},
+  "pregnancy_risks": "Specific risks for pregnancy",
+  "pre_existing_conditions": {{
+    "asthma": "Specific advice",
+    "diabetes": "Specific advice",
+    "cardiovascular": "Specific advice"
+  }},
+  "immediate_actions": [
+    "Action 1",
+    "Action 2",
+    "Action 3"
+  ],
+  "long_term_risk": {{
+    "life_expectancy_loss": "e.g., 3-5 years",
+    "chronic_conditions": "List potential chronic issues"
+  }},
+  "safeguard_protocols": [
+    "Protocol 1",
+    "Protocol 2",
+    "Protocol 3"
+  ],
+  "urgency_level": "Low|Medium|High|Critical"
+}}"""
+
+        response = self.llm.invoke(prompt)
+        response_text = response.content
+        
+        # Extract JSON
+        import json
+        import re
+        json_match = re.search(r'\{[\s\S]*\}', response_text)
+        if not json_match:
+            raise ValueError(f"No JSON in response: {response_text}")
+        
+        return json.loads(json_match.group())
+
+    def chat_with_health_expert(self, message: str, context: Dict[str, Any] = None) -> str:
+        """
+        Chat with the expert about specific health concerns.
+        """
+        aqi = context.get('aqi', 'Unknown') if context else 'Unknown'
+        risk = context.get('risk_summary', 'Unknown') if context else 'Unknown'
+        
+        prompt = f"""You are a helpful, empathetic medical assistant specializing in Air Quality health effects.
+        
+Current Context:
+- Live AQI: {aqi}
+- Risk Level: {risk}
+- User Location: {context.get('city', 'Delhi') if context else 'Delhi'}
+
+User Question: "{message}"
+
+Provide a short, practical, and medically sound answer (2-3 sentences max unless asked for detail). 
+Focus on immediate actions and reassurance or warnings as appropriate. Do not verify the AQI yourself, assume the context is true.
+"""
+        response = self.llm.invoke(prompt)
+        return response.content

ingest.py

@@ -0,0 +1,35 @@
+import os
+
+from langchain_community.document_loaders import PyPDFLoader
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain_community.vectorstores import FAISS
+
+PDF_DIR = "papers"
+
+docs = []
+
+for file in os.listdir(PDF_DIR):
+    if file.endswith(".pdf"):
+        loader = PyPDFLoader(os.path.join(PDF_DIR, file))
+        docs.extend(loader.load())
+
+# Split into chunks
+splitter = RecursiveCharacterTextSplitter(
+    chunk_size=800,
+    chunk_overlap=150
+)
+
+chunks = splitter.split_documents(docs)
+
+# Embeddings
+embeddings = HuggingFaceEmbeddings(
+    model_name="sentence-transformers/all-MiniLM-L6-v2"
+)
+
+# FAISS index
+db = FAISS.from_documents(chunks, embeddings)
+
+db.save_local("faiss_index")
+
+print("✅ FAISS index created successfully.")

new_daily_emissions_column_format.xlsx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9c577399c88c05f4cedaf0f4926fd0cdf81a17f19936798a24ced3ebdbc86ccd
+size 119421

policy_engine.py

@@ -0,0 +1,393 @@
+"""
+Core policy engine: transforms research into structured policies.
+Uses LLM with structured prompting and Pydantic validation.
+"""
+import json
+import re
+from typing import List, Optional, Dict, Any
+from pydantic import BaseModel, ValidationError, Field
+from langchain_community.vectorstores import FAISS
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain_groq import ChatGroq
+from langchain_core.prompts import PromptTemplate
+
+import config
+
+
+# ============================================================================
+# PYDANTIC MODELS
+# ============================================================================
+
+class PolicyMutation(BaseModel):
+    """Represents a single mutation to the causal graph."""
+    type: str = Field(..., description="disable_node | reduce_edge_weight | increase_edge_weight")
+    node_id: Optional[str] = Field(None, description="For disable_node mutations")
+    source: Optional[str] = Field(None, description="For edge mutations")
+    target: Optional[str] = Field(None, description="For edge mutations")
+    new_weight: Optional[float] = Field(None, description="New edge weight [0.0, 1.0]")
+    original_weight: Optional[float] = Field(None, description="Original weight (optional)")
+    reason: str = Field(..., description="Why this mutation is applied")
+    reversible: bool = Field(True, description="Can this be undone?")
+
+
+class SourceResearch(BaseModel):
+    """Research evidence backing the policy."""
+    paper_ids: List[str] = Field(default_factory=list)
+    key_quotes: List[str] = Field(default_factory=list)
+    confidence: float = Field(0.8, description="Confidence in policy [0.0, 1.0]")
+
+
+class TradeOff(BaseModel):
+    """Trade-off from policy implementation."""
+    sector: str
+    impact: str = Field(..., description="positive | negative | neutral")
+    magnitude: str = Field(..., description="mild | moderate | strong")
+    description: str
+
+
+class EstimatedImpact(BaseModel):
+    """Estimated system-wide impacts."""
+    co2_reduction_pct: float = Field(0.0, description="% reduction in CO₂")
+    aqi_improvement_pct: float = Field(0.0, description="% reduction in AQI")
+    confidence: float = Field(0.7)
+
+
+class Policy(BaseModel):
+    """Complete structured policy JSON."""
+    policy_id: str
+    name: str
+    description: Optional[str] = None
+    mutations: List[PolicyMutation]
+    estimated_impacts: EstimatedImpact
+    trade_offs: List[TradeOff] = Field(default_factory=list)
+    source_research: SourceResearch
+    timestamp: Optional[str] = None
+
+
+# ============================================================================
+# POLICY ENGINE
+# ============================================================================
+
+class PolicyEngine:
+    """Converts research insights into structured policies via LLM."""
+
+    def __init__(self):
+        """Initialize FAISS index and LLM."""
+        self.embeddings = HuggingFaceEmbeddings(
+            model_name=config.EMBEDDINGS_MODEL
+        )
+        
+        try:
+            self.db = FAISS.load_local(
+                str(config.FAISS_INDEX_PATH),
+                self.embeddings,
+                allow_dangerous_deserialization=True
+            )
+        except Exception as e:
+            print(f"Warning: FAISS index not found at {config.FAISS_INDEX_PATH}")
+            print(f"Error: {e}")
+            self.db = None
+        
+        self.llm = ChatGroq(
+            model=config.LLM_MODEL,
+            temperature=0.5,
+            api_key=config.GROQ_API_KEY
+        )
+
+    
+    def query_research(self, question: str, k: int = None) -> tuple[List[str], bool]:
+        """
+        Retrieve research chunks from FAISS.
+        
+        Args:
+            question: Search query
+            k: Number of results (default from config)
+            
+        Returns:
+            Tuple of (research chunks or [question], is_direct_query)
+        """
+        if not self.db:
+            print(f"FAISS DB not initialized, using direct query: {question}")
+            # Return the user's query directly when FAISS is not available
+            return [question], True
+        
+        k = k or config.FAISS_K_SEARCH
+        results = self.db.similarity_search(question, k=k)
+        return [r.page_content for r in results], False
+    
+    def extract_policy(
+        self,
+        research_chunks: List[str],
+        graph_context: Dict[str, Any],
+        is_direct_query: bool = False,
+        user_query: str = ""
+    ) -> Policy:
+        """
+        Use LLM to extract structured policy from research.
+        
+        Args:
+            research_chunks: List of research excerpts or [user_query] if direct
+            graph_context: Dict with node/edge structure for validation
+            is_direct_query: True if research_chunks contains user query (no FAISS)
+            user_query: The original user query string (optional but recommended)
+            
+        Returns:
+            Validated Policy object
+        """
+        # Format content for prompt
+        # Ensure all chunks are strings (handle potential nested lists)
+        flat_chunks = []
+        for chunk in research_chunks:
+            if isinstance(chunk, list):
+                flat_chunks.extend([str(c) for c in chunk])
+            else:
+                flat_chunks.append(str(chunk))
+        
+        # Determine intent from user_query if available, otherwise check chunks
+        query_text = user_query if user_query else (flat_chunks[0] if flat_chunks else "")
+        query_lower = query_text.lower()
+        
+        increase_emissions = any(word in query_lower for word in ["increase", "raise", "boost", "expand", "grow", "worsen", "high"])
+        
+        if is_direct_query:
+            research_section = f"USER QUERY: {query_text}\n\nUse your knowledge to create a policy addressing this query."
+        else:
+            research_section = f"USER QUERY: {query_text}\n\nRESEARCH FINDINGS:\n" + "\n---\n".join(flat_chunks)
+        
+        formatted_nodes = ""
+        disabled_nodes = []
+        
+        # Handle new graph_context structure (list of dicts) vs old (list of ids)
+        if 'nodes' in graph_context and isinstance(graph_context['nodes'], list):
+            formatted_nodes = ", ".join([n['id'] for n in graph_context['nodes']])
+            disabled_nodes = [n['id'] for n in graph_context['nodes'] if not n.get('enabled', True)]
+        else:
+            formatted_nodes = ", ".join(graph_context.get("node_ids", []))
+            
+        formatted_edges = "\n".join([
+            f"  {e['source']}->{e['target']} (current weight: {e.get('weight', 0.5)})"
+            for e in graph_context.get("edges", [])
+        ])
+        
+        disabled_section = ""
+        if disabled_nodes:
+            disabled_section = f"""
+DISABLED SECTORS (User has manually disconnected these):
+{', '.join(disabled_nodes)}
+
+IMPORTANT: The above sectors are DISCONNECTED. 
+- Do NOT try to modify edges coming FROM these sectors, as they have no effect.
+- You should acknowledge that they are disabled in your reasoning.
+- Focus policies on the remaining ACTIVE sectors to achieve the goal."""
+        
+        # Determine policy direction
+        if increase_emissions:
+            task_description = "INCREASE emissions"
+            mutation_type = "increase_edge_weight"
+            mechanics_section = """TO INCREASE EMISSIONS:
+  - MUST increase the edge weight to a LARGER number
+  - Example: 0.7 → 0.9 (increases flow by 28%)
+  - Example: 0.5 → 0.75 (increases flow by 50%)
+  - Example: 0.4 → 0.7 (increases flow by 75%)
+
+CRITICAL: new_weight MUST BE GREATER THAN current weight. Do not decrease!"""
+            correct_examples = """  ✓ Change transport→co2 from 0.7 to 0.9 (increases flow)
+  ✓ Change energy→co2 from 0.8 to 0.95 (increases propagation)"""
+            estimated_field = "co2_increase_pct"
+        else:
+            task_description = "REDUCE emissions"
+            mutation_type = "reduce_edge_weight"
+            mechanics_section = """TO REDUCE EMISSIONS:
+  - MUST decrease the edge weight to a SMALLER number
+  - Example: 0.7 → 0.35 (50% reduction in flow)
+  - Example: 0.5 → 0.25 (50% reduction in flow)
+  - Example: 0.8 → 0.4 (50% reduction in flow)
+
+CRITICAL: new_weight MUST BE LESS THAN current weight. Do not increase!"""
+            correct_examples = """  ✓ Change transport→co2 from 0.7 to 0.35 (cuts in half)
+  ✓ Change transport→co2 from 0.7 to 0.49 (30% reduction)
+  ✓ Change energy→co2 from 0.8 to 0.48 (40% reduction)"""
+            estimated_field = "co2_reduction_pct"
+        
+        prompt = f"""You are a climate policy expert. Your task is to design policies that {task_description}.
+
+{research_section}
+{disabled_section}
+
+CURRENT SYSTEM EDGES (with current weights):
+{formatted_edges}
+
+Available nodes: {formatted_nodes}
+
+EMISSION MECHANICS - READ CAREFULLY:
+The system propagates emissions through edges. Each edge has a weight (0.0 to 1.0):
+  - target_value = source_value × weight
+  - A weight of 0.7 means 70% of the source value flows to the target
+  - A weight of 0.3 means 30% of the source value flows to the target
+
+{mechanics_section}
+
+CRITICAL INSTRUCTION:
+1. You MUST follow the TASK direction ({task_description}).
+2. USE ONLY THE EDGES LISTED ABOVE. Do not hallucinate connections.
+3. If a node (e.g., 'transport') is NOT in the "Available nodes" list, YOU CANNOT CREATE A POLICY FOR IT.
+4. If a node is listed in DISABLED SECTORS, do not attempt to change its edges (it is already off).
+5. If the user asks to INCREASE emissions, you MUST generate a policy that INCREASES them.
+6. Ignore research advice if it contradicts the goal to {task_description}.
+7. Use the research only for context on *what* to modify, but reverse the action if needed to match the goal.
+
+WRONG EXAMPLES (DO NOT DO THIS):
+  ✗ Change 0.7 to 0.75 (wrong direction)
+  ✗ Change 0.5 to 0.8 (wrong direction)
+  ✗ Change 0.6 to 0.7 (wrong direction)
+
+CORRECT EXAMPLES:
+{correct_examples}
+
+TASK: Create ONE policy to {task_description} by addressing: "{flat_chunks[0][:100] if flat_chunks else 'emissions policy'}..."
+If the research suggests "Promoting EV", and your task is to INCREASE emissions, your policy should be "Tax EVs / Promote Gas Cars".
+
+Return ONLY valid JSON:
+{{
+  "policy_id": "policy-slug",
+  "name": "Policy Name",
+  "description": "Description",
+  "mutations": [
+    {{
+      "type": "{mutation_type}",
+      "source": "transport",
+      "target": "vehicle-emissions",
+      "new_weight": {"0.35" if not increase_emissions else "0.9"},
+      "original_weight": 0.7,
+      "reason": "Research shows..."
+    }}
+  ],
+  "estimated_impacts": {{
+    "{estimated_field}": {"15.0" if not increase_emissions else "12.0"},
+    "aqi_improvement_pct": {"18.0" if not increase_emissions else "-15.0"},
+    "confidence": 0.8
+  }},
+  "trade_offs": [],
+  "source_research": {{
+    "paper_ids": [],
+    "key_quotes": [],
+    "confidence": 0.85
+  }}
+}}"""
+        
+        # Call LLM
+        response = self.llm.invoke(prompt)
+        response_text = response.content
+        
+        # Extract JSON (handle markdown code blocks)
+        json_match = re.search(r'\{[\s\S]*\}', response_text)
+        if not json_match:
+            raise ValueError(f"No JSON found in LLM response: {response_text}")
+        
+        json_str = json_match.group()
+        policy_dict = json.loads(json_str)
+        
+        # Clean up trade_offs - LLM sometimes returns strings instead of objects
+        if 'trade_offs' in policy_dict:
+            cleaned_trade_offs = []
+            for item in policy_dict['trade_offs']:
+                if isinstance(item, str):
+                    # Convert string to proper TradeOff object
+                    cleaned_trade_offs.append({
+                        'sector': 'general',
+                        'impact': 'neutral',
+                        'magnitude': 'mild',
+                        'description': item
+                    })
+                elif isinstance(item, dict):
+                    cleaned_trade_offs.append(item)
+            policy_dict['trade_offs'] = cleaned_trade_offs
+        
+        # Validate against schema
+        policy = Policy(**policy_dict)
+        
+        # Log the mutations for debugging
+        print(f"\n[Policy Generated]")
+        print(f"Policy: {policy.name}")
+        print(f"Description: {policy.description}")
+        print(f"Mutations: {len(policy.mutations)}")
+        for i, mut in enumerate(policy.mutations):
+            if mut.type in ["reduce_edge_weight", "increase_edge_weight"]:
+                print(f"  {i+1}. {mut.type}: {mut.source} -> {mut.target}")
+                print(f"     New weight: {mut.new_weight} (reason: {mut.reason})")
+        print(f"Estimated CO₂ reduction: {policy.estimated_impacts.co2_reduction_pct}%")
+        print(f"Estimated AQI improvement: {policy.estimated_impacts.aqi_improvement_pct}%\n")
+        
+        # Validate mutations reference real nodes/edges
+        self._validate_mutations(policy, graph_context)
+        
+        return policy
+    
+    def _validate_mutations(self, policy: Policy, graph_context: Dict) -> None:
+        """Ensure mutations reference real nodes/edges."""
+        # Handle both old (node_ids list) and new (nodes dict list) formats
+        if 'nodes' in graph_context and isinstance(graph_context['nodes'], list):
+            node_ids = set(n['id'] for n in graph_context['nodes'])
+        else:
+            node_ids = set(graph_context.get("node_ids", []))
+            
+        edge_pairs = set((e['source'], e['target']) for e in graph_context.get("edges", []))
+        
+        for mutation in policy.mutations:
+            if mutation.type == "disable_node":
+                if mutation.node_id not in node_ids:
+                    raise ValueError(f"Unknown node: {mutation.node_id}")
+            
+            elif mutation.type in ["reduce_edge_weight", "increase_edge_weight"]:
+                if (mutation.source, mutation.target) not in edge_pairs:
+                    raise ValueError(f"Unknown edge: {mutation.source} -> {mutation.target}")
+                
+                if mutation.new_weight is None or not (0.0 <= mutation.new_weight <= 1.0):
+                    raise ValueError(f"Invalid weight: {mutation.new_weight}")
+
+
+# ============================================================================
+# HELPER FUNCTIONS
+# ============================================================================
+
+def get_graph_context_from_file(filepath: str) -> Dict[str, Any]:
+    """
+    Load graph context (nodes, edges) from snapshot file.
+    Used for validation during policy extraction.
+    """
+    try:
+        with open(filepath, 'r') as f:
+            data = json.load(f)
+        
+        # Extract node IDs
+        node_ids = [n['id'] for n in data.get('nodes', [])]
+        
+        # Extract edges with weights
+        edges = [
+            {
+                'source': e['source'],
+                'target': e['target'],
+                'weight': e.get('data', {}).get('weight', 0.5)
+            }
+            for e in data.get('edges', [])
+        ]
+        
+        return {
+            'node_ids': node_ids,
+            'edges': edges,
+            'full_graph': data
+        }
+    except Exception as e:
+        print(f"Could not load graph context: {e}")
+        return {
+            'node_ids': [
+                'industries', 'transport', 'energy', 'infrastructure',
+                'moves-goods', 'uses-power', 'fuels-transport', 'co2', 'aqi'
+            ],
+            'edges': [
+                {'source': 'industries', 'target': 'transport', 'weight': 0.6},
+                {'source': 'transport', 'target': 'vehicle-emissions', 'weight': 0.7},
+                {'source': 'energy', 'target': 'co2', 'weight': 0.8},
+                {'source': 'co2', 'target': 'aqi', 'weight': 0.9}
+            ]
+        }

requirements.txt

@@ -0,0 +1,34 @@
+# Core dependencies
+langchain
+langchain-community
+langchain-huggingface
+langchain-openai
+langchain-groq
+pydantic
+
+# LLM & Embeddings
+openai
+sentence-transformers
+huggingface-hub
+
+# Vector DB
+faiss-cpu
+
+# Web framework
+flask==3.0.0
+flask-cors==4.0.0
+
+# PDF processing
+pypdf==4.1.0
+
+# Utilities
+python-dotenv==1.0.0
+openpyxl==3.1.5
+pandas
+scikit-learn
+
+gunicorn
+xgboost
+folium
+selenium
+webdriver-manager