quantified.uncertainty/metaforecast
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #79 from quantified-uncertainty/stricter-typescript

Browse Source 
Strict typescript & platform/cli arguments
This commit is contained in:
Vyacheslav Matyukhin 2022-05-12 17:32:22 +03:00 committed by GitHub
commit 6fbeea2267
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
69 changed files with 1196 additions and 2089 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

757
package-lock.json generated
View File

File diff suppressed because it is too large Load Diff

6
package.json
View File

@ -33,13 +33,18 @@
"@pothos/plugin-prisma": "^3.4.0",
"@pothos/plugin-relay": "^3.10.0",
"@prisma/client": "^3.11.1",
"@quri/squiggle-lang": "^0.2.8",
"@tailwindcss/forms": "^0.4.0",
"@tailwindcss/typography": "^0.5.1",
"@types/chroma-js": "^2.1.3",
"@types/dom-to-image": "^2.6.4",
"@types/google-spreadsheet": "^3.2.1",
"@types/jsdom": "^16.2.14",
"@types/nprogress": "^0.2.0",
"@types/react": "^17.0.39",
"@types/react-copy-to-clipboard": "^5.0.2",
"@types/textversionjs": "^1.1.1",
"@types/tunnel": "^0.0.3",
"airtable": "^0.11.1",
"algoliasearch": "^4.10.3",
"autoprefixer": "^10.1.0",
@ -86,7 +91,6 @@
"react-safe": "^1.3.0",
"react-select": "^5.2.2",
"remark-gfm": "^3.0.1",
"squiggle-experimental": "^0.1.9",
"tabletojson": "^2.0.4",
"tailwindcss": "^3.0.22",
"textversionjs": "^1.1.3",

9
src/backend/flow/doEverything.ts
View File

@ -3,14 +3,7 @@ import { executeJobByName } from "./jobs";
/* Do everything */
export async function doEverything() {
let jobNames = [
...platforms.map((platform) => platform.name),
"merge",
"algolia",
"history",
"netlify",
];
// Removed Good Judgment from the fetcher, doing it using cron instead because cloudflare blocks the utility on heroku.
let jobNames = [...platforms.map((platform) => platform.name), "algolia"];
console.log("");
console.log("");

11
src/backend/flow/history/updateHistory.ts
View File

@ -1,11 +0,0 @@
import { prisma } from "../../database/prisma";
export async function updateHistory() {
const questions = await prisma.question.findMany({});
await prisma.history.createMany({
data: questions.map((q) => ({
...q,
idref: q.id,
})),
});
}

55
src/backend/flow/jobs.ts
View File

@ -1,38 +1,29 @@
import { doEverything } from "../flow/doEverything";
import { updateHistory } from "../flow/history/updateHistory";
import { rebuildNetlifySiteWithNewData } from "../flow/rebuildNetliftySiteWithNewData";
import { rebuildFrontpage } from "../frontpage";
import { platforms, processPlatform } from "../platforms";
import { rebuildAlgoliaDatabase } from "../utils/algolia";
import { sleep } from "../utils/sleep";
interface Job {
interface Job<ArgNames extends string = ""> {
name: string;
message: string;
run: () => Promise<void>;
args?: ArgNames[];
run: (args?: { [k in ArgNames]: string }) => Promise<void>;
separate?: boolean;
}
export const jobs: Job[] = [
export const jobs: Job<string>[] = [
...platforms.map((platform) => ({
name: platform.name,
message: `Download predictions from ${platform.name}`,
run: () => processPlatform(platform),
...(platform.version === "v2" ? { args: platform.fetcherArgs } : {}),
run: (args: any) => processPlatform(platform, args),
})),
{
name: "algolia",
message: 'Rebuild algolia database ("index")',
run: rebuildAlgoliaDatabase,
},
{
name: "history",
message: "Update history",
run: updateHistory,
},
{
name: "netlify",
message: `Rebuild netlify site with new data`,
run: rebuildNetlifySiteWithNewData,
},
{
name: "frontpage",
message: "Rebuild frontpage",
@ -46,31 +37,39 @@ export const jobs: Job[] = [
},
];
function sleep(ms: number) {
return new Promise((resolve) => setTimeout(resolve, ms));
}
async function tryCatchTryAgain(fun: () => Promise<void>) {
async function tryCatchTryAgain<T extends object = never>(
fun: (args: T) => Promise<void>,
args: T
) {
try {
console.log("Initial try");
await fun();
await fun(args);
} catch (error) {
sleep(10000);
console.log("Second try");
console.log(error);
try {
await fun();
await fun(args);
} catch (error) {
console.log(error);
}
}
}
export const executeJobByName = async (option: string) => {
const job = jobs.find((job) => job.name === option);
export const executeJobByName = async (
jobName: string,
jobArgs: { [k: string]: string } = {}
) => {
const job = jobs.find((job) => job.name === jobName);
if (!job) {
console.log(`Error, job ${option} not found`);
} else {
await tryCatchTryAgain(job.run);
console.log(`Error, job ${jobName} not found`);
return;
}
for (const key of Object.keys(jobArgs)) {
if (!job.args || job.args.indexOf(key) < 0) {
throw new Error(`Job ${jobName} doesn't accept ${key} argument`);
}
}
await tryCatchTryAgain(job.run, jobArgs);
};

15
src/backend/flow/rebuildNetliftySiteWithNewData.ts
View File

@ -1,15 +0,0 @@
import axios from "axios";
import { applyIfSecretExists } from "../utils/getSecrets";
async function rebuildNetlifySiteWithNewData_inner(cookie) {
let payload = {};
let response = await axios.post(cookie, payload);
let data = response.data;
console.log(data);
}
export async function rebuildNetlifySiteWithNewData() {
let cookie = process.env.REBUIDNETLIFYHOOKURL;
await applyIfSecretExists(cookie, rebuildNetlifySiteWithNewData_inner);
}

64
src/backend/index.ts
View File

@ -2,11 +2,10 @@
import "dotenv/config";
import readline from "readline";
import util from "util";
import { executeJobByName, jobs } from "./flow/jobs";
let generateWhatToDoMessage = () => {
const generateWhatToDoMessage = () => {
const color = "\x1b[36m";
const resetColor = "\x1b[0m";
let completeMessages = [
@ -23,27 +22,56 @@ let generateWhatToDoMessage = () => {
return completeMessages;
};
let whattodoMessage = generateWhatToDoMessage();
const whattodoMessage = generateWhatToDoMessage();
/* BODY */
let commandLineUtility = async () => {
const pickOption = async () => {
if (process.argv.length === 3) {
return process.argv[2]; // e.g., npm run cli polymarket
}
const askForJobName = async () => {
const rl = readline.createInterface({
input: process.stdin,
output: process.stdout,
});
const rl = readline.createInterface({
input: process.stdin,
output: process.stdout,
const question = (query: string) => {
return new Promise((resolve: (s: string) => void) => {
rl.question(query, resolve);
});
const question = util.promisify(rl.question).bind(rl);
const answer = await question(whattodoMessage);
rl.close();
return answer;
};
await executeJobByName(await pickOption());
const answer = await question(whattodoMessage);
rl.close();
return answer;
};
const pickJob = async (): Promise<[string, { [k: string]: string }]> => {
if (process.argv.length < 3) {
const jobName = await askForJobName();
return [jobName, {}]; // e.g., npm run cli polymarket
}
const jobName = process.argv[2];
if ((process.argv.length - 3) % 2) {
throw new Error("Number of extra arguments must be even");
}
const args: { [k: string]: string } = {};
for (let i = 3; i < process.argv.length; i += 2) {
let argName = process.argv[i];
const argValue = process.argv[i + 1];
if (argName.slice(0, 2) !== "--") {
throw new Error(`${argName} should start with --`);
}
argName = argName.slice(2);
args[argName] = argValue;
}
return [jobName, args];
};
/* BODY */
const commandLineUtility = async () => {
const [jobName, jobArgs] = await pickJob();
await executeJobByName(jobName, jobArgs);
process.exit();
};

15
src/backend/platforms/_example.ts
View File

@ -1,7 +1,6 @@
/* Imports */
import axios from "axios";
import { calculateStars } from "../utils/stars";
import { FetchedQuestion, Platform } from "./";
/* Definitions */
@ -22,11 +21,11 @@ async function fetchData() {
return response;
}
async function processPredictions(predictions) {
async function processPredictions(predictions: any[]) {
let results = await predictions.map((prediction) => {
const id = `${platformName}-${prediction.id}`;
const probability = prediction.probability;
const options = [
const options: FetchedQuestion["options"] = [
{
name: "Yes",
probability: probability,
@ -41,14 +40,10 @@ async function processPredictions(predictions) {
const result: FetchedQuestion = {
id,
title: prediction.title,
url: `https://example.com`,
platform: platformName,
url: "https://example.com",
description: prediction.description,
options,
qualityindicators: {
stars: calculateStars(platformName, {
/* some: somex, factors: factors */
}),
// other: prediction.otherx,
// indicators: prediction.indicatorx,
},
@ -64,9 +59,13 @@ export const example: Platform = {
name: platformName,
label: "Example platform",
color: "#ff0000",
version: "v1",
async fetcher() {
let data = await fetchData();
let results = await processPredictions(data); // somehow needed
return results;
},
calculateStars(data) {
return 2;
},
};

73
src/backend/platforms/betfair.ts
View File

@ -2,16 +2,16 @@
import axios from "axios";
import https from "https";
import { calculateStars } from "../utils/stars";
import { average } from "../../utils";
import { FetchedQuestion, Platform } from "./";
const platformName = "betfair";
/* Definitions */
let endpoint = process.env.SECRET_BETFAIR_ENDPOINT;
const endpoint = process.env.SECRET_BETFAIR_ENDPOINT;
/* Utilities */
let arraysEqual = (a, b) => {
const arraysEqual = (a: string[], b: string[]) => {
if (a === b) return true;
if (a == null || b == null) return false;
if (a.length !== b.length) return false;
@ -26,7 +26,8 @@ let arraysEqual = (a, b) => {
}
return true;
};
let mergeRunners = (runnerCatalog, runnerBook) => {
const mergeRunners = (runnerCatalog: any, runnerBook: any) => {
let keys = Object.keys(runnerCatalog);
let result = [];
for (let key of keys) {
@ -41,19 +42,16 @@ async function fetchPredictions() {
const agent = new https.Agent({
rejectUnauthorized: false,
});
let response = await axios({
const response = await axios({
url: endpoint,
method: "GET",
headers: {
"Content-Type": "text/html",
},
httpsAgent: agent,
}).then((response) => response.data);
return response;
}
async function whipIntoShape(data) {
async function whipIntoShape(data: any) {
let catalogues = data.market_catalogues;
let books = data.market_books;
let keys1 = Object.keys(catalogues).sort();
@ -77,7 +75,7 @@ async function whipIntoShape(data) {
return results;
}
async function processPredictions(data) {
async function processPredictions(data: any) {
let predictions = await whipIntoShape(data);
// console.log(JSON.stringify(predictions, null, 4))
let results: FetchedQuestion[] = predictions.map((prediction) => {
@ -86,13 +84,17 @@ async function processPredictions(data) {
} */
let id = `${platformName}-${prediction.marketId}`;
let normalizationFactor = prediction.options
.filter((option) => option.status == "ACTIVE" && option.totalMatched > 0)
.map((option) => option.lastPriceTraded)
.map((x) => 1 / x)
.reduce((a, b) => a + b, 0);
.filter(
(option: any) => option.status == "ACTIVE" && option.totalMatched > 0
)
.map((option: any) => option.lastPriceTraded)
.map((x: any) => 1 / x)
.reduce((a: any, b: any) => a + b, 0);
let options = prediction.options
.filter((option) => option.status == "ACTIVE" && option.totalMatched > 0)
.map((option) => ({
.filter(
(option: any) => option.status == "ACTIVE" && option.totalMatched > 0
)
.map((option: any) => ({
name: option.runnerName,
probability:
option.lastPriceTraded != 0
@ -114,22 +116,19 @@ async function processPredictions(data) {
if (rules == undefined) {
// console.log(prediction.description)
}
let title = rules.split("? ")[0] + "?";
let description = rules.split("? ")[1].trim();
if (title.includes("of the named")) {
title = prediction.marketName + ": " + title;
}
let result = {
id: id,
title: title,
const result: FetchedQuestion = {
id,
title,
url: `https://www.betfair.com/exchange/plus/politics/market/${prediction.marketId}`,
platform: platformName,
description: description,
options: options,
description,
options,
qualityindicators: {
stars: calculateStars(platformName, {
volume: prediction.totalMatched,
}),
volume: prediction.totalMatched,
},
};
@ -142,9 +141,31 @@ export const betfair: Platform = {
name: platformName,
label: "Betfair",
color: "#3d674a",
version: "v1",
async fetcher() {
const data = await fetchPredictions();
const results = await processPredictions(data); // somehow needed
const results = await processPredictions(data);
return results;
},
calculateStars(data) {
const volume = data.qualityindicators.volume || 0;
let nuno = () => (volume > 10000 ? 4 : volume > 1000 ? 3 : 2);
let eli = () => (volume > 10000 ? null : null);
let misha = () => null;
let starsDecimal = average([nuno()]); //, eli(), misha()])
const firstOption = data.options[0];
// Substract 1 star if probability is above 90% or below 10%
if (
firstOption &&
((firstOption.probability || 0) < 0.1 ||
(firstOption.probability || 0) > 0.9)
) {
starsDecimal = starsDecimal - 1;
}
let starsInteger = Math.round(starsDecimal);
return starsInteger;
},
};

13
src/backend/platforms/fantasyscotus.ts
View File

@ -1,7 +1,6 @@
/* Imports */
import axios from "axios";
import { calculateStars } from "../utils/stars";
import { FetchedQuestion, Platform } from "./";
const platformName = "fantasyscotus";
@ -30,7 +29,7 @@ async function fetchData() {
return response;
}
async function getPredictionsData(caseUrl) {
async function getPredictionsData(caseUrl: string) {
let newCaseUrl = `https://fantasyscotus.net/user-predictions${caseUrl}?filterscount=0&groupscount=0&sortdatafield=username&sortorder=asc&pagenum=0&pagesize=20&recordstartindex=0&recordendindex=20&_=${unixtime}`;
//console.log(newCaseUrl)
let predictions = await axios({
@ -50,7 +49,7 @@ async function getPredictionsData(caseUrl) {
}).then((res) => res.data);
let predictionsAffirm = predictions.filter(
(prediction) => prediction.percent_affirm > 50
(prediction: any) => prediction.percent_affirm > 50
);
//console.log(predictions)
//console.log(predictionsAffirm.length/predictions.length)
@ -62,7 +61,7 @@ async function getPredictionsData(caseUrl) {
};
}
async function processData(data) {
async function processData(data: any) {
let events = data.object_list;
let historicalPercentageCorrect = data.stats.pcnt_correct;
let historicalProbabilityCorrect =
@ -79,7 +78,6 @@ async function processData(data) {
id: id,
title: `In ${event.short_name}, the SCOTUS will affirm the lower court's decision`,
url: `https://fantasyscotus.net/user-predictions${event.docket_url}`,
platform: platformName,
description: `${(pAffirm * 100).toFixed(2)}% (${
predictionData.numAffirm
} out of ${
@ -101,7 +99,6 @@ async function processData(data) {
],
qualityindicators: {
numforecasts: Number(predictionData.numForecasts),
stars: calculateStars(platformName, {}),
},
};
results.push(eventObject);
@ -116,9 +113,13 @@ export const fantasyscotus: Platform = {
name: platformName,
label: "FantasySCOTUS",
color: "#231149",
version: "v1",
async fetcher() {
let rawData = await fetchData();
let results = await processData(rawData);
return results;
},
calculateStars(data) {
return 2;
},
};

39
src/backend/platforms/foretold.ts
View File

@ -1,7 +1,7 @@
/* Imports */
import axios from "axios";
import { calculateStars } from "../utils/stars";
import { average } from "../../utils";
import { FetchedQuestion, Platform } from "./";
/* Definitions */
@ -18,8 +18,10 @@ let highQualityCommunities = [
];
/* Support functions */
async function fetchAllCommunityQuestions(communityId) {
let response = await axios({
async function fetchAllCommunityQuestions(communityId: string) {
// TODO - fetch foretold graphql schema to type the result properly?
// (should be doable with graphql-code-generator, why not)
const response = await axios({
url: graphQLendpoint,
method: "POST",
headers: { "Content-Type": "application/json" },
@ -30,10 +32,10 @@ async function fetchAllCommunityQuestions(communityId) {
channelId: "${communityId}",
states: OPEN,
first: 500
){
) {
total
edges{
node{
edges {
node {
id
name
valueType
@ -52,14 +54,15 @@ async function fetchAllCommunityQuestions(communityId) {
})
.then((res) => res.data)
.then((res) => res.data.measurables.edges);
//console.log(response)
return response;
return response as any[];
}
export const foretold: Platform = {
name: platformName,
label: "Foretold",
color: "#62520b",
version: "v1",
async fetcher() {
let results: FetchedQuestion[] = [];
for (let community of highQualityCommunities) {
@ -67,10 +70,11 @@ export const foretold: Platform = {
questions = questions.map((question) => question.node);
questions = questions.filter((question) => question.previousAggregate); // Questions without any predictions
questions.forEach((question) => {
let id = `${platformName}-${question.id}`;
let options = [];
const id = `${platformName}-${question.id}`;
let options: FetchedQuestion["options"] = [];
if (question.valueType == "PERCENTAGE") {
let probability = question.previousAggregate.value.percentage;
const probability = question.previousAggregate.value.percentage;
options = [
{
name: "Yes",
@ -84,16 +88,15 @@ export const foretold: Platform = {
},
];
}
let result: FetchedQuestion = {
const result: FetchedQuestion = {
id,
title: question.name,
url: `https://www.foretold.io/c/${community}/m/${question.id}`,
platform: platformName,
description: "",
options,
qualityindicators: {
numforecasts: Math.floor(Number(question.measurementCount) / 2),
stars: calculateStars(platformName, {}),
},
/*liquidity: liquidity.toFixed(2),
tradevolume: tradevolume.toFixed(2),
@ -105,4 +108,12 @@ export const foretold: Platform = {
}
return results;
},
calculateStars(data) {
let nuno = () => 2;
let eli = () => null;
let misha = () => null;
let starsDecimal = average([nuno()]); //, eli(), misha()])
let starsInteger = Math.round(starsDecimal);
return starsInteger;
},
};

19
src/backend/platforms/givewellopenphil.ts
View File

@ -2,14 +2,14 @@
import axios from "axios";
import fs from "fs";
import { calculateStars } from "../utils/stars";
import { average } from "../../utils";
import { Platform } from "./";
const platformName = "givewellopenphil";
/* Support functions */
async function fetchPage(url: string) {
let response = await axios({
async function fetchPage(url: string): Promise<string> {
const response = await axios({
url: url,
method: "GET",
headers: {
@ -53,9 +53,7 @@ async function main1() {
platform: platformName,
description,
options: [],
qualityindicators: {
stars: calculateStars(platformName, {}),
},
qualityindicators: {},
}; // Note: This requires some processing afterwards
// console.log(result)
results.push(result);
@ -70,6 +68,7 @@ export const givewellopenphil: Platform = {
name: platformName,
label: "GiveWell/OpenPhilanthropy",
color: "#32407e",
version: "v1",
async fetcher() {
// main1()
return; // not necessary to refill the DB every time
@ -84,4 +83,12 @@ export const givewellopenphil: Platform = {
}));
return dataWithDate;
},
calculateStars(data) {
let nuno = () => 2;
let eli = () => null;
let misha = () => null;
let starsDecimal = average([nuno()]); //, eli(), misha()])
let starsInteger = Math.round(starsDecimal);
return starsInteger;
},
};

69
src/backend/platforms/goodjudgment.ts
View File

@ -1,27 +1,24 @@
/* Imports */
import axios from "axios";
import { Tabletojson } from "tabletojson";
import tunnel from "tunnel";
import { average } from "../../utils";
import { hash } from "../utils/hash";
import { calculateStars } from "../utils/stars";
import { FetchedQuestion, Platform } from "./";
/* Definitions */
const platformName = "goodjudgment";
let endpoint = "https://goodjudgment.io/superforecasts/";
String.prototype.replaceAll = function replaceAll(search, replace) {
return this.split(search).join(replace);
};
const endpoint = "https://goodjudgment.io/superforecasts/";
/* Body */
export const goodjudgment: Platform = {
name: platformName,
label: "Good Judgment",
color: "#7d4f1b",
version: "v1",
async fetcher() {
// Proxy fuckery
let proxy;
// let proxy;
/*
* try {
proxy = await axios
@ -32,19 +29,19 @@ export const goodjudgment: Platform = {
console.log("Proxy generation failed; using backup proxy instead");
// hard-coded backup proxy
*/
proxy = {
ip: process.env.BACKUP_PROXY_IP,
port: process.env.BACKUP_PROXY_PORT,
};
// }
let agent = tunnel.httpsOverHttp({
proxy: {
host: proxy.ip,
port: proxy.port,
},
});
// proxy = {
// ip: process.env.BACKUP_PROXY_IP,
// port: process.env.BACKUP_PROXY_PORT,
// };
// // }
// let agent = tunnel.httpsOverHttp({
// proxy: {
// host: proxy.ip,
// port: proxy.port,
// },
// });
let content = await axios
const content = await axios
.request({
url: "https://goodjudgment.io/superforecasts/",
method: "get",
@ -61,17 +58,16 @@ export const goodjudgment: Platform = {
let jsonTable = Tabletojson.convert(content, { stripHtmlFromCells: false });
jsonTable.shift(); // deletes first element
jsonTable.pop(); // deletes last element
// console.log(jsonTable)
for (let table of jsonTable) {
// console.log(table)
let title = table[0]["0"].split("\t\t\t").splice(3)[0];
if (title != undefined) {
title = title.replaceAll("</a>", "");
let id = `${platformName}-${hash(title)}`;
let description = table
.filter((row) => row["0"].includes("BACKGROUND:"))
.map((row) => row["0"])
.map((text) =>
const id = `${platformName}-${hash(title)}`;
const description = table
.filter((row: any) => row["0"].includes("BACKGROUND:"))
.map((row: any) => row["0"])
.map((text: any) =>
text
.split("BACKGROUND:")[1]
.split("Examples of Superforecaster")[0]
@ -83,16 +79,16 @@ export const goodjudgment: Platform = {
.replaceAll(" ", "")
.replaceAll("<br> ", "")
)[0];
let options = table
.filter((row) => "4" in row)
.map((row) => ({
const options = table
.filter((row: any) => "4" in row)
.map((row: any) => ({
name: row["2"]
.split('<span class="qTitle">')[1]
.replace("</span>", ""),
probability: Number(row["3"].split("%")[0]) / 100,
type: "PROBABILITY",
}));
let analysis = table.filter((row) =>
let analysis = table.filter((row: any) =>
row[0] ? row[0].toLowerCase().includes("commentary") : false
);
// "Examples of Superforecaster Commentary" / Analysis
@ -104,12 +100,9 @@ export const goodjudgment: Platform = {
id,
title,
url: endpoint,
platform: platformName,
description,
options,
qualityindicators: {
stars: calculateStars(platformName, {}),
},
qualityindicators: {},
extra: {
superforecastercommentary: analysis || "",
},
@ -124,4 +117,12 @@ export const goodjudgment: Platform = {
return results;
},
calculateStars(data) {
let nuno = () => 4;
let eli = () => 4;
let misha = () => 3.5;
let starsDecimal = average([nuno()]); //, eli(), misha()])
let starsInteger = Math.round(starsDecimal);
return starsInteger;
},
};

72
src/backend/platforms/goodjudgmentopen.ts
View File

@ -2,16 +2,17 @@
import axios from "axios";
import { Tabletojson } from "tabletojson";
import { average } from "../../utils";
import { applyIfSecretExists } from "../utils/getSecrets";
import { calculateStars } from "../utils/stars";
import { sleep } from "../utils/sleep";
import toMarkdown from "../utils/toMarkdown";
import { Platform } from "./";
import { FetchedQuestion, Platform } from "./";
/* Definitions */
const platformName = "goodjudgmentopen";
let htmlEndPoint = "https://www.gjopen.com/questions?page=";
let annoyingPromptUrls = [
const htmlEndPoint = "https://www.gjopen.com/questions?page=";
const annoyingPromptUrls = [
"https://www.gjopen.com/questions/1933-what-forecasting-questions-should-we-ask-what-questions-would-you-like-to-forecast-on-gjopen",
"https://www.gjopen.com/questions/1779-are-there-any-forecasting-tips-tricks-and-experiences-you-would-like-to-share-and-or-discuss-with-your-fellow-forecasters",
"https://www.gjopen.com/questions/2246-are-there-any-forecasting-tips-tricks-and-experiences-you-would-like-to-share-and-or-discuss-with-your-fellow-forecasters-2022-thread",
@ -22,12 +23,11 @@ const id = () => 0;
/* Support functions */
async function fetchPage(page, cookie) {
let response = await axios({
async function fetchPage(page: number, cookie: string) {
const response: string = await axios({
url: htmlEndPoint + page,
method: "GET",
headers: {
"Content-Type": "text/html",
Cookie: cookie,
},
}).then((res) => res.data);
@ -35,12 +35,11 @@ async function fetchPage(page, cookie) {
return response;
}
async function fetchStats(questionUrl, cookie) {
let response = await axios({
async function fetchStats(questionUrl: string, cookie: string) {
let response: string = await axios({
url: questionUrl + "/stats",
method: "GET",
headers: {
"Content-Type": "text/html",
Cookie: cookie,
Referer: questionUrl,
},
@ -50,7 +49,7 @@ async function fetchStats(questionUrl, cookie) {
// Is binary?
let isbinary = response.includes("binary?&quot;:true");
let options = [];
let options: FetchedQuestion["options"] = [];
if (isbinary) {
// Crowd percentage
let htmlElements = response.split("\n");
@ -74,7 +73,7 @@ async function fetchStats(questionUrl, cookie) {
let optionsHtmlElement = "<table" + response.split("tbody")[1] + "table>";
let tablesAsJson = Tabletojson.convert(optionsHtmlElement);
let firstTable = tablesAsJson[0];
options = firstTable.map((element) => ({
options = firstTable.map((element: any) => ({
name: element["0"],
probability: Number(element["1"].replace("%", "")) / 100,
type: "PROBABILITY",
@ -107,21 +106,12 @@ async function fetchStats(questionUrl, cookie) {
.split(",")[0];
//console.log(numpredictors)
// Calculate the stars
let minProbability = Math.min(...options.map((option) => option.probability));
let maxProbability = Math.max(...options.map((option) => option.probability));
let result = {
description: description,
options: options,
description,
options,
qualityindicators: {
numforecasts: Number(numforecasts),
numforecasters: Number(numforecasters),
stars: calculateStars("Good Judgment Open", {
numforecasts,
minProbability,
maxProbability,
}),
},
// this mismatches the code below, and needs to be fixed, but I'm doing typescript conversion and don't want to touch any logic for now
} as any;
@ -129,7 +119,7 @@ async function fetchStats(questionUrl, cookie) {
return result;
}
function isSignedIn(html) {
function isSignedIn(html: string) {
let isSignedInBool = !(
html.includes("You need to sign in or sign up before continuing") ||
html.includes("Sign up")
@ -142,7 +132,7 @@ function isSignedIn(html) {
return isSignedInBool;
}
function reachedEnd(html) {
function reachedEnd(html: string) {
let reachedEndBool = html.includes("No questions match your filter");
if (reachedEndBool) {
//console.log(html)
@ -151,13 +141,9 @@ function reachedEnd(html) {
return reachedEndBool;
}
function sleep(ms: number) {
return new Promise((resolve) => setTimeout(resolve, ms));
}
/* Body */
async function goodjudgmentopen_inner(cookie) {
async function goodjudgmentopen_inner(cookie: string) {
let i = 1;
let response = await fetchPage(i, cookie);
@ -185,7 +171,11 @@ async function goodjudgmentopen_inner(cookie) {
}
}
let questionNumRegex = new RegExp("questions/([0-9]+)");
let questionNum = url.match(questionNumRegex)[1]; //.split("questions/")[1].split("-")[0];
const questionNumMatch = url.match(questionNumRegex);
if (!questionNumMatch) {
throw new Error(`Couldn't find question num in ${url}`);
}
let questionNum = questionNumMatch[1];
let id = `${platformName}-${questionNum}`;
let question = {
id: id,
@ -241,8 +231,26 @@ export const goodjudgmentopen: Platform = {
name: platformName,
label: "Good Judgment Open",
color: "#002455",
version: "v1",
async fetcher() {
let cookie = process.env.GOODJUDGMENTOPENCOOKIE;
return await applyIfSecretExists(cookie, goodjudgmentopen_inner);
return (await applyIfSecretExists(cookie, goodjudgmentopen_inner)) || null;
},
calculateStars(data) {
let minProbability = Math.min(
...data.options.map((option) => option.probability || 0)
);
let maxProbability = Math.max(
...data.options.map((option) => option.probability || 0)
);
let nuno = () => ((data.qualityindicators.numforecasts || 0) > 100 ? 3 : 2);
let eli = () => 3;
let misha = () =>
minProbability > 0.1 || maxProbability < 0.9 ? 3.1 : 2.5;
let starsDecimal = average([nuno(), eli(), misha()]);
let starsInteger = Math.round(starsDecimal);
return starsInteger;
},
};

27
src/backend/platforms/guesstimate.ts
View File

@ -1,12 +1,10 @@
import axios from "axios";
import { parseISO } from "date-fns";
/* Imports */
import { Question } from "@prisma/client";
import { AlgoliaQuestion } from "../../backend/utils/algolia";
import { prisma } from "../database/prisma";
import { Platform } from "./";
import { AlgoliaQuestion } from "../utils/algolia";
import { FetchedQuestion, Platform, prepareQuestion } from "./";
/* Definitions */
const searchEndpoint =
@ -14,25 +12,20 @@ const searchEndpoint =
const apiEndpoint = "https://guesstimate.herokuapp.com";
/* Body */
const modelToQuestion = (model: any): Question => {
const modelToQuestion = (model: any): ReturnType<typeof prepareQuestion> => {
const { description } = model;
// const description = model.description
// ? model.description.replace(/\n/g, " ").replace(/ /g, " ")
// : "";
const stars = description.length > 250 ? 2 : 1;
const timestamp = parseISO(model.created_at);
const q: Question = {
// const timestamp = parseISO(model.created_at);
const fq: FetchedQuestion = {
id: `guesstimate-${model.id}`,
title: model.name,
url: `https://www.getguesstimate.com/models/${model.id}`,
timestamp,
platform: "guesstimate",
// timestamp,
description,
options: [],
qualityindicators: {
stars,
numforecasts: 1,
numforecasters: 1,
},
@ -41,6 +34,7 @@ const modelToQuestion = (model: any): Question => {
},
// ranking: 10 * (index + 1) - 0.5, //(model._rankingInfo - 1*index)// hack
};
const q = prepareQuestion(fq, guesstimate);
return q;
};
@ -68,7 +62,7 @@ async function search(query: string): Promise<AlgoliaQuestion[]> {
});
// filter for duplicates. Surprisingly common.
let uniqueTitles = [];
let uniqueTitles: string[] = [];
let uniqueModels: AlgoliaQuestion[] = [];
for (let model of mappedModels) {
if (!uniqueTitles.includes(model.title) && !model.title.includes("copy")) {
@ -83,12 +77,11 @@ async function search(query: string): Promise<AlgoliaQuestion[]> {
const fetchQuestion = async (id: number): Promise<Question> => {
const response = await axios({ url: `${apiEndpoint}/spaces/${id}` });
let q = modelToQuestion(response.data);
q = await prisma.question.upsert({
return await prisma.question.upsert({
where: { id: q.id },
create: q,
update: q,
});
return q;
};
export const guesstimate: Platform & {
@ -99,5 +92,7 @@ export const guesstimate: Platform & {
label: "Guesstimate",
color: "#223900",
search,
version: "v1",
fetchQuestion,
calculateStars: (q) => (q.description.length > 250 ? 2 : 1),
};

143
src/backend/platforms/index.ts
View File

@ -1,5 +1,6 @@
import { Question } from "@prisma/client";
import { QuestionOption } from "../../common/types";
import { prisma } from "../database/prisma";
import { betfair } from "./betfair";
import { fantasyscotus } from "./fantasyscotus";
@ -41,32 +42,51 @@ export interface QualityIndicators {
export type FetchedQuestion = Omit<
Question,
"extra" | "qualityindicators" | "timestamp"
"extra" | "qualityindicators" | "timestamp" | "platform" | "options"
> & {
timestamp?: Date;
extra?: object; // required in DB but annoying to return empty; also this is slightly stricter than Prisma's JsonValue
qualityindicators: QualityIndicators; // slightly stronger type than Prisma's JsonValue
options: QuestionOption[]; // stronger type than Prisma's JsonValue
qualityindicators: Omit<QualityIndicators, "stars">; // slightly stronger type than Prisma's JsonValue
};
// fetcher should return null if platform failed to fetch questions for some reason
export type PlatformFetcher = () => Promise<FetchedQuestion[] | null>;
type PlatformFetcherV1 = () => Promise<FetchedQuestion[] | null>;
export interface Platform {
type PlatformFetcherV2Result = {
questions: FetchedQuestion[];
// if partial is true then we won't cleanup old questions from the database; this is useful when manually invoking a fetcher with arguments for updating a single question
partial: boolean;
} | null;
type PlatformFetcherV2<ArgNames extends string> = (opts: {
args?: { [k in ArgNames]: string };
}) => Promise<PlatformFetcherV2Result>;
export type PlatformFetcher<ArgNames extends string> =
| PlatformFetcherV1
| PlatformFetcherV2<ArgNames>;
// using "" as ArgNames default is technically incorrect, but shouldn't cause any real issues
// (I couldn't find a better solution for signifying an empty value, though there probably is one)
export type Platform<ArgNames extends string = ""> = {
name: string; // short name for ids and `platform` db column, e.g. "xrisk"
label: string; // longer name for displaying on frontend etc., e.g. "X-risk estimates"
color: string; // used on frontend
fetcher?: PlatformFetcher;
}
calculateStars: (question: FetchedQuestion) => number;
} & (
| {
version: "v1";
fetcher?: PlatformFetcherV1;
}
| {
version: "v2";
fetcherArgs?: ArgNames[];
fetcher?: PlatformFetcherV2<ArgNames>;
}
);
// draft for the future callback-based streaming/chunking API:
// interface FetchOptions {
// since?: string; // some kind of cursor, Date object or opaque string?
// save: (questions: Question[]) => Promise<void>;
// }
// export type PlatformFetcher = (options: FetchOptions) => Promise<void>;
export const platforms: Platform[] = [
export const platforms: Platform<string>[] = [
betfair,
fantasyscotus,
foretold,
@ -86,26 +106,59 @@ export const platforms: Platform[] = [
xrisk,
];
export const processPlatform = async (platform: Platform) => {
// Typing notes:
// There's a difference between prisma's Question type (type returned from `find` and `findMany`) and its input types due to JsonValue vs InputJsonValue mismatch.
// On the other hand, we can't use Prisma.QuestionUpdateInput or Prisma.QuestionCreateManyInput either, because we use this question in guesstimate's code for preparing questions from guesstimate models...
// So here we build a new type which should be ok to use both in place of prisma's Question type and as an input to its update or create methods.
type PreparedQuestion = Omit<
Question,
"extra" | "qualityindicators" | "options"
> & {
extra: NonNullable<Question["extra"]>;
qualityindicators: NonNullable<Question["qualityindicators"]>;
options: NonNullable<Question["options"]>;
};
export const prepareQuestion = (
q: FetchedQuestion,
platform: Platform<any>
): PreparedQuestion => {
return {
extra: {},
timestamp: new Date(),
...q,
platform: platform.name,
qualityindicators: {
...q.qualityindicators,
stars: platform.calculateStars(q),
},
};
};
export const processPlatform = async <T extends string = "">(
platform: Platform<T>,
args?: { [k in T]: string }
) => {
if (!platform.fetcher) {
console.log(`Platform ${platform.name} doesn't have a fetcher, skipping`);
return;
}
const fetchedQuestions = await platform.fetcher();
if (!fetchedQuestions || !fetchedQuestions.length) {
const result =
platform.version === "v1"
? { questions: await platform.fetcher(), partial: false } // this is not exactly PlatformFetcherV2Result, since `questions` can be null
: await platform.fetcher({ args });
if (!result) {
console.log(`Platform ${platform.name} didn't return any results`);
return;
}
const prepareQuestion = (q: FetchedQuestion): Question => {
return {
extra: {},
timestamp: new Date(),
...q,
platform: platform.name,
qualityindicators: q.qualityindicators as object, // fighting typescript
};
};
const { questions: fetchedQuestions, partial } = result;
if (!fetchedQuestions || !fetchedQuestions.length) {
console.log(`Platform ${platform.name} didn't return any results`);
return;
}
const oldQuestions = await prisma.question.findMany({
where: {
@ -119,11 +172,11 @@ export const processPlatform = async (platform: Platform) => {
const fetchedIdsSet = new Set(fetchedIds);
const oldIdsSet = new Set(oldIds);
const createdQuestions: Question[] = [];
const updatedQuestions: Question[] = [];
const createdQuestions: PreparedQuestion[] = [];
const updatedQuestions: PreparedQuestion[] = [];
const deletedIds = oldIds.filter((id) => !fetchedIdsSet.has(id));
for (const q of fetchedQuestions.map((q) => prepareQuestion(q))) {
for (const q of fetchedQuestions.map((q) => prepareQuestion(q, platform))) {
if (oldIdsSet.has(q.id)) {
updatedQuestions.push(q);
} else {
@ -132,27 +185,45 @@ export const processPlatform = async (platform: Platform) => {
}
}
const stats: { created?: number; updated?: number; deleted?: number } = {};
await prisma.question.createMany({
data: createdQuestions,
});
stats.created = createdQuestions.length;
for (const q of updatedQuestions) {
await prisma.question.update({
where: { id: q.id },
data: q,
});
stats.updated ??= 0;
stats.updated++;
}
await prisma.question.deleteMany({
where: {
id: {
in: deletedIds,
if (!partial) {
await prisma.question.deleteMany({
where: {
id: {
in: deletedIds,
},
},
},
});
stats.deleted = deletedIds.length;
}
await prisma.history.createMany({
data: [...createdQuestions, ...updatedQuestions].map((q) => ({
...q,
idref: q.id,
})),
});
console.log(
`Done, ${deletedIds.length} deleted, ${updatedQuestions.length} updated, ${createdQuestions.length} created`
"Done, " +
Object.entries(stats)
.map(([k, v]) => `${v} ${k}`)
.join(", ")
);
};

69
src/backend/platforms/infer.ts
View File

@ -1,38 +1,37 @@
/* Imports */
import axios from "axios";
import { FullQuestionOption } from "../../common/types";
import { average } from "../../utils";
import { applyIfSecretExists } from "../utils/getSecrets";
import { measureTime } from "../utils/measureTime";
import { calculateStars } from "../utils/stars";
import { sleep } from "../utils/sleep";
import toMarkdown from "../utils/toMarkdown";
import { FetchedQuestion, Platform } from "./";
/* Definitions */
const platformName = "infer";
let htmlEndPoint = "https://www.infer-pub.com/questions";
String.prototype.replaceAll = function replaceAll(search, replace) {
return this.split(search).join(replace);
};
const htmlEndPoint = "https://www.infer-pub.com/questions";
const DEBUG_MODE: "on" | "off" = "off"; // "off"
const SLEEP_TIME_RANDOM = 7000; // miliseconds
const SLEEP_TIME_EXTRA = 2000;
/* Support functions */
function cleanDescription(text) {
function cleanDescription(text: string) {
let md = toMarkdown(text);
let result = md.replaceAll("---", "-").replaceAll(" ", " ");
return result;
}
async function fetchPage(page, cookie) {
async function fetchPage(page: number, cookie: string) {
console.log(`Page #${page}`);
if (page == 1) {
cookie = cookie.split(";")[0]; // Interesting that it otherwise doesn't work :(
}
let urlEndpoint = `${htmlEndPoint}/?page=${page}`;
console.log(urlEndpoint);
let response = await axios({
const response: string = await axios({
url: urlEndpoint,
method: "GET",
headers: {
@ -44,8 +43,8 @@ async function fetchPage(page, cookie) {
return response;
}
async function fetchStats(questionUrl, cookie) {
let response = await axios({
async function fetchStats(questionUrl: string, cookie: string) {
let response: string = await axios({
url: questionUrl + "/stats",
method: "GET",
headers: {
@ -59,7 +58,7 @@ async function fetchStats(questionUrl, cookie) {
throw Error("Not logged in");
}
// Init
let options = [];
let options: FullQuestionOption[] = [];
// Parse the embedded json
let htmlElements = response.split("\n");
@ -84,7 +83,7 @@ async function fetchStats(questionUrl, cookie) {
questionType.includes("Forecast::Question") ||
!questionType.includes("Forecast::MultiTimePeriodQuestion")
) {
options = firstEmbeddedJson.question.answers.map((answer) => ({
options = firstEmbeddedJson.question.answers.map((answer: any) => ({
name: answer.name,
probability: answer.normalized_probability,
type: "PROBABILITY",
@ -94,12 +93,11 @@ async function fetchStats(questionUrl, cookie) {
options[0].probability > 1
? 1 - options[0].probability / 100
: 1 - options[0].probability;
let optionNo = {
options.push({
name: "No",
probability: probabilityNo,
type: "PROBABILITY",
};
options.push(optionNo);
});
}
}
let result = {
@ -109,14 +107,13 @@ async function fetchStats(questionUrl, cookie) {
numforecasts: Number(numforecasts),
numforecasters: Number(numforecasters),
comments_count: Number(comments_count),
stars: calculateStars(platformName, { numforecasts }),
},
};
// console.log(JSON.stringify(result, null, 4));
return result;
}
function isSignedIn(html) {
function isSignedIn(html: string) {
let isSignedInBool = !(
html.includes("You need to sign in or sign up before continuing") ||
html.includes("Sign up")
@ -128,7 +125,7 @@ function isSignedIn(html) {
return isSignedInBool;
}
function reachedEnd(html) {
function reachedEnd(html: string) {
let reachedEndBool = html.includes("No questions match your filter");
if (reachedEndBool) {
//console.log(html)
@ -137,10 +134,6 @@ function reachedEnd(html) {
return reachedEndBool;
}
function sleep(ms) {
return new Promise((resolve) => setTimeout(resolve, ms));
}
/* Body */
async function infer_inner(cookie: string) {
@ -173,17 +166,18 @@ async function infer_inner(cookie: string) {
await sleep(Math.random() * SLEEP_TIME_RANDOM + SLEEP_TIME_EXTRA); // don't be as noticeable
try {
let moreinfo = await fetchStats(url, cookie);
let questionNumRegex = new RegExp("questions/([0-9]+)");
let questionNum = url.match(questionNumRegex)[1]; //.split("questions/")[1].split("-")[0];
let id = `${platformName}-${questionNum}`;
const moreinfo = await fetchStats(url, cookie);
const questionNumRegex = new RegExp("questions/([0-9]+)");
const questionNumMatch = url.match(questionNumRegex);
if (!questionNumMatch) {
throw new Error(`Couldn't find question num in ${url}`);
}
let questionNum = questionNumMatch[1];
const id = `${platformName}-${questionNum}`;
let question: FetchedQuestion = {
id: id,
title: title,
description: moreinfo.description,
url: url,
platform: platformName,
options: moreinfo.options,
id,
title,
url,
...moreinfo,
};
console.log(JSON.stringify(question, null, 4));
@ -236,8 +230,17 @@ export const infer: Platform = {
name: platformName,
label: "Infer",
color: "#223900",
version: "v1",
async fetcher() {
let cookie = process.env.INFER_COOKIE;
return await applyIfSecretExists(cookie, infer_inner);
return (await applyIfSecretExists(cookie, infer_inner)) || null;
},
calculateStars(data) {
let nuno = () => 2;
let eli = () => null;
let misha = () => null;
let starsDecimal = average([nuno()]); //, eli(), misha()])
let starsInteger = Math.round(starsDecimal);
return starsInteger;
},
};

53
src/backend/platforms/kalshi.ts
View File

@ -1,29 +1,28 @@
/* Imports */
import axios from "axios";
import { calculateStars } from "../utils/stars";
import { average } from "../../utils";
import { FetchedQuestion, Platform } from "./";
/* Definitions */
const platformName = "kalshi";
let jsonEndpoint = "https://trading-api.kalshi.com/v1/cached/markets/"; //"https://subgraph-matic.poly.market/subgraphs/name/TokenUnion/polymarket"//"https://subgraph-backup.poly.market/subgraphs/name/TokenUnion/polymarket"//'https://subgraph-matic.poly.market/subgraphs/name/TokenUnion/polymarket3'
let jsonEndpoint = "https://trading-api.kalshi.com/v1/cached/markets/";
async function fetchAllMarkets() {
// for info which the polymarket graphql API
let response = await axios
.get(jsonEndpoint)
.then((response) => response.data.markets);
// console.log(response)
return response;
}
async function processMarkets(markets) {
async function processMarkets(markets: any[]) {
let dateNow = new Date().toISOString();
// console.log(markets)
markets = markets.filter((market) => market.close_date > dateNow);
let results = await markets.map((market) => {
const probability = market.last_price / 100;
const options = [
const options: FetchedQuestion["options"] = [
{
name: "Yes",
probability: probability,
@ -40,41 +39,63 @@ async function processMarkets(markets) {
id,
title: market.title.replaceAll("*", ""),
url: `https://kalshi.com/markets/${market.ticker_name}`,
platform: platformName,
description: `${market.settle_details}. The resolution source is: ${market.ranged_group_name} (${market.settle_source_url})`,
options,
qualityindicators: {
stars: calculateStars(platformName, {
shares_volume: market.volume,
interest: market.open_interest,
}),
yes_bid: market.yes_bid,
yes_ask: market.yes_ask,
spread: Math.abs(market.yes_bid - market.yes_ask),
shares_volume: market.volume, // Assuming that half of all buys are for yes and half for no, which is a big if.
// "open_interest": market.open_interest, also in shares
},
extra: {
open_interest: market.open_interest,
},
};
return result;
});
//console.log(results.length)
// console.log(results.map(result => result.title))
// console.log(results.map(result => result.title).length)
console.log([...new Set(results.map((result) => result.title))]);
console.log(
"Number of unique questions: ",
[...new Set(results.map((result) => result.title))].length
);
// console.log([...new Set(results.map(result => result.title))].length)
return results; //resultsProcessed
return results;
}
export const kalshi: Platform = {
name: platformName,
label: "Kalshi",
color: "#615691",
version: "v1",
fetcher: async function () {
let markets = await fetchAllMarkets();
return await processMarkets(markets);
},
calculateStars(data) {
let nuno = () =>
((data.extra as any)?.open_interest || 0) > 500 &&
data.qualityindicators.shares_volume > 10000
? 4
: data.qualityindicators.shares_volume > 2000
? 3
: 2;
// let eli = (data) => data.interest > 10000 ? 5 : 4
// let misha = (data) => 4
let starsDecimal = average([nuno()]); //, eli(data), misha(data)])
// Substract 1 star if probability is above 90% or below 10%
if (
data.options instanceof Array &&
data.options[0] &&
((data.options[0].probability || 0) < 0.1 ||
(data.options[0].probability || 0) > 0.9)
) {
starsDecimal = starsDecimal - 1;
}
let starsInteger = Math.round(starsDecimal);
return starsInteger;
},
};

40
src/backend/platforms/manifold.ts
View File

@ -1,12 +1,12 @@
/* Imports */
import axios from "axios";
import { calculateStars } from "../utils/stars";
import { average } from "../../utils";
import { FetchedQuestion, Platform } from "./";
/* Definitions */
const platformName = "manifold";
let endpoint = "https://manifold.markets/api/v0/markets";
const endpoint = "https://manifold.markets/api/v0/markets";
// See https://manifoldmarkets.notion.site/Manifold-Markets-API-5e7d0aef4dcf452bb04b319e178fabc5
/* Support functions */
@ -25,16 +25,16 @@ async function fetchData() {
function showStatistics(results: FetchedQuestion[]) {
console.log(`Num unresolved markets: ${results.length}`);
let sum = (arr) => arr.reduce((tally, a) => tally + a, 0);
let sum = (arr: number[]) => arr.reduce((tally, a) => tally + a, 0);
let num2StarsOrMore = results.filter(
(result) => result.qualityindicators.stars >= 2
(result) => manifold.calculateStars(result) >= 2
);
console.log(
`Manifold has ${num2StarsOrMore.length} markets with 2 stars or more`
);
console.log(
`Mean volume: ${
sum(results.map((result) => result.qualityindicators.volume7Days)) /
sum(results.map((result) => result.qualityindicators.volume7Days || 0)) /
results.length
}; mean pool: ${
sum(results.map((result) => result.qualityindicators.pool)) /
@ -43,11 +43,11 @@ function showStatistics(results: FetchedQuestion[]) {
);
}
async function processPredictions(predictions) {
let results: FetchedQuestion[] = await predictions.map((prediction) => {
function processPredictions(predictions: any[]): FetchedQuestion[] {
let results: FetchedQuestion[] = predictions.map((prediction) => {
let id = `${platformName}-${prediction.id}`; // oops, doesn't match platform name
let probability = prediction.probability;
let options = [
let options: FetchedQuestion["options"] = [
{
name: "Yes",
probability: probability,
@ -63,15 +63,9 @@ async function processPredictions(predictions) {
id: id,
title: prediction.question,
url: prediction.url,
platform: platformName,
description: prediction.description,
options: options,
options,
qualityindicators: {
stars: calculateStars(platformName, {
volume7Days: prediction.volume7Days,
volume24Hours: prediction.volume24Hours,
pool: prediction.pool,
}),
createdTime: prediction.createdTime,
volume7Days: prediction.volume7Days,
volume24Hours: prediction.volume24Hours,
@ -94,10 +88,24 @@ export const manifold: Platform = {
name: platformName,
label: "Manifold Markets",
color: "#793466",
version: "v1",
async fetcher() {
let data = await fetchData();
let results = await processPredictions(data); // somehow needed
let results = processPredictions(data); // somehow needed
showStatistics(results);
return results;
},
calculateStars(data) {
let nuno = () =>
(data.qualityindicators.volume7Days || 0) > 250 ||
((data.qualityindicators.pool || 0) > 500 &&
(data.qualityindicators.volume7Days || 0) > 100)
? 2
: 1;
let eli = () => null;
let misha = () => null;
let starsDecimal = average([nuno()]); //, eli(data), misha(data)])
let starsInteger = Math.round(starsDecimal);
return starsInteger;
},
};

52
src/backend/platforms/metaculus.ts
View File

@ -1,18 +1,19 @@
/* Imports */
import axios from "axios";
import { calculateStars } from "../utils/stars";
import { average } from "../../utils";
import { sleep } from "../utils/sleep";
import toMarkdown from "../utils/toMarkdown";
import { FetchedQuestion, Platform } from "./";
/* Definitions */
const platformName = "metaculus";
let jsonEndPoint = "https://www.metaculus.com/api2/questions/?page=";
let now = new Date().toISOString();
let DEBUG_MODE = "off";
let SLEEP_TIME = 5000;
/* Support functions */
async function fetchMetaculusQuestions(next) {
async function fetchMetaculusQuestions(next: string) {
// Numbers about a given address: how many, how much, at what price, etc.
let response;
let data;
@ -24,15 +25,17 @@ async function fetchMetaculusQuestions(next) {
});
data = response.data;
} catch (error) {
console.log(`Error in async function fetchMetaculusQuestions(next)`);
if (!!error.response.headers["retry-after"]) {
let timeout = error.response.headers["retry-after"];
console.log(`Timeout: ${timeout}`);
await sleep(Number(timeout) * 1000 + SLEEP_TIME);
} else {
await sleep(SLEEP_TIME);
}
console.log(`Error in async function fetchMetaculusQuestions(next)`);
console.log(error);
if (axios.isAxiosError(error)) {
if (error.response?.headers["retry-after"]) {
const timeout = error.response.headers["retry-after"];
console.log(`Timeout: ${timeout}`);
await sleep(Number(timeout) * 1000 + SLEEP_TIME);
} else {
await sleep(SLEEP_TIME);
}
}
} finally {
try {
response = await axios({
@ -50,11 +53,7 @@ async function fetchMetaculusQuestions(next) {
return data;
}
function sleep(ms: number) {
return new Promise((resolve) => setTimeout(resolve, ms));
}
async function fetchMetaculusQuestionDescription(slug) {
async function fetchMetaculusQuestionDescription(slug: string) {
try {
let response = await axios({
method: "get",
@ -67,11 +66,12 @@ async function fetchMetaculusQuestionDescription(slug) {
`We encountered some error when attempting to fetch a metaculus page. Trying again`
);
if (
axios.isAxiosError(error) &&
typeof error.response != "undefined" &&
typeof error.response.headers != "undefined" &&
typeof error.response.headers["retry-after"] != "undefined"
) {
let timeout = error.response.headers["retry-after"];
const timeout = error.response.headers["retry-after"];
console.log(`Timeout: ${timeout}`);
await sleep(Number(timeout) * 1000 + SLEEP_TIME);
} else {
@ -98,6 +98,7 @@ export const metaculus: Platform = {
name: platformName,
label: "Metaculus",
color: "#006669",
version: "v1",
async fetcher() {
// let metaculusQuestionsInit = await fetchMetaculusQuestions(1)
// let numQueries = Math.round(Number(metaculusQuestionsInit.count) / 20)
@ -131,7 +132,7 @@ export const metaculus: Platform = {
let description = descriptionprocessed2;
let isbinary = result.possibilities.type == "binary";
let options = [];
let options: FetchedQuestion["options"] = [];
if (isbinary) {
let probability = Number(result.community_prediction.full.q2);
options = [
@ -152,14 +153,10 @@ export const metaculus: Platform = {
id,
title: result.title,
url: "https://www.metaculus.com" + result.page_url,
platform: platformName,
description,
options,
qualityindicators: {
numforecasts: Number(result.number_of_predictions),
stars: calculateStars(platformName, {
numforecasts: result.number_of_predictions,
}),
},
extra: {
resolution_data: {
@ -194,4 +191,15 @@ export const metaculus: Platform = {
return all_questions;
},
calculateStars(data) {
const { numforecasts } = data.qualityindicators;
let nuno = () =>
(numforecasts || 0) > 300 ? 4 : (numforecasts || 0) > 100 ? 3 : 2;
let eli = () => 3;
let misha = () => 3;
let starsDecimal = average([nuno(), eli(), misha()]);
let starsInteger = Math.round(starsDecimal);
return starsInteger;
},
};

56
src/backend/platforms/polymarket.ts
View File

@ -1,13 +1,13 @@
/* Imports */
import axios from "axios";
import { calculateStars } from "../utils/stars";
import { average } from "../../utils";
import { FetchedQuestion, Platform } from "./";
/* Definitions */
const platformName = "polymarket";
let graphQLendpoint =
"https://api.thegraph.com/subgraphs/name/polymarket/matic-markets-5"; // "https://api.thegraph.com/subgraphs/name/polymarket/matic-markets-4"// "https://api.thegraph.com/subgraphs/name/tokenunion/polymarket-matic"//"https://subgraph-matic.poly.market/subgraphs/name/TokenUnion/polymarket"//"https://subgraph-backup.poly.market/subgraphs/name/TokenUnion/polymarket"//'https://subgraph-matic.poly.market/subgraphs/name/TokenUnion/polymarket3'
const graphQLendpoint =
"https://api.thegraph.com/subgraphs/name/polymarket/matic-markets-5";
let units = 10 ** 6;
async function fetchAllContractInfo() {
@ -18,11 +18,11 @@ async function fetchAllContractInfo() {
// "https://strapi-matic.poly.market/markets?active=true&_sort=volume:desc&_limit=-1" to get all markets, including closed ones
)
.then((query) => query.data);
response = response.filter((res) => res.closed != true);
response = response.filter((res: any) => res.closed != true);
return response;
}
async function fetchIndividualContractData(marketMakerAddress) {
async function fetchIndividualContractData(marketMakerAddress: string) {
let daysSinceEra = Math.round(Date.now() / (1000 * 24 * 60 * 60)) - 7; // last week
let response = await axios({
url: graphQLendpoint,
@ -59,7 +59,7 @@ async function fetchIndividualContractData(marketMakerAddress) {
})
.then((res) => res.data)
.then((res) => res.data.fixedProductMarketMakers);
// console.log(response)
return response;
}
@ -67,6 +67,7 @@ export const polymarket: Platform = {
name: platformName,
label: "PolyMarket",
color: "#00314e",
version: "v1",
async fetcher() {
let results: FetchedQuestion[] = [];
let webpageEndpointData = await fetchAllContractInfo();
@ -93,11 +94,11 @@ export const polymarket: Platform = {
// let isbinary = Number(moreMarketInfo.conditions[0].outcomeSlotCount) == 2
// let percentage = Number(moreMarketInfo.outcomeTokenPrices[0]) * 100
// let percentageFormatted = isbinary ? (percentage.toFixed(0) + "%") : "none"
let options = [];
let options: FetchedQuestion["options"] = [];
for (let outcome in moreMarketInfo.outcomeTokenPrices) {
options.push({
name: marketInfo.outcomes[outcome],
probability: moreMarketInfo.outcomeTokenPrices[outcome],
name: String(marketInfo.outcomes[outcome]),
probability: Number(moreMarketInfo.outcomeTokenPrices[outcome]),
type: "PROBABILITY",
});
}
@ -106,18 +107,12 @@ export const polymarket: Platform = {
id: id,
title: marketInfo.question,
url: "https://polymarket.com/market/" + marketInfo.slug,
platform: platformName,
description: marketInfo.description,
options: options,
options,
qualityindicators: {
numforecasts: numforecasts.toFixed(0),
liquidity: liquidity.toFixed(2),
tradevolume: tradevolume.toFixed(2),
stars: calculateStars(platformName, {
liquidity,
option: options[0],
volume: tradevolume,
}),
},
extra: {
address: marketInfo.address,
@ -133,4 +128,33 @@ export const polymarket: Platform = {
}
return results;
},
calculateStars(data) {
// let nuno = (data) => (data.volume > 10000 ? 4 : data.volume > 1000 ? 3 : 2);
// let eli = (data) => data.liquidity > 10000 ? 5 : 4
// let misha = (data) => 4
const liquidity = data.qualityindicators.liquidity || 0;
const volume = data.qualityindicators.tradevolume || 0;
let nuno = () =>
liquidity > 1000 && volume > 10000
? 4
: liquidity > 500 && volume > 1000
? 3
: 2;
let starsDecimal = average([nuno()]); //, eli(data), misha(data)])
// Substract 1 star if probability is above 90% or below 10%
if (
data.options instanceof Array &&
data.options[0] &&
((data.options[0].probability || 0) < 0.1 ||
(data.options[0].probability || 0) > 0.9)
) {
starsDecimal = starsDecimal - 1;
}
let starsInteger = Math.round(starsDecimal);
return starsInteger;
},
};

46
src/backend/platforms/predictit.ts
View File

@ -1,24 +1,25 @@
import axios from "axios";
import { calculateStars } from "../utils/stars";
import { average } from "../../utils";
import { sleep } from "../utils/sleep";
import toMarkdown from "../utils/toMarkdown";
import { FetchedQuestion, Platform } from "./";
const platformName = "predictit";
/* Support functions */
async function fetchmarkets() {
let response = await axios({
async function fetchmarkets(): Promise<any[]> {
const response = await axios({
method: "get",
url: "https://www.predictit.org/api/marketdata/all/",
});
let openMarkets = response.data.markets.filter(
(market) => market.status == "Open"
const openMarkets = response.data.markets.filter(
(market: any) => market.status == "Open"
);
return openMarkets;
}
async function fetchmarketrules(market_id) {
async function fetchmarketrules(market_id: string | number) {
let response = await axios({
method: "get",
url: "https://www.predictit.org/api/Market/" + market_id,
@ -34,15 +35,12 @@ async function fetchmarketvolumes() {
return response.data;
}
function sleep(ms: number) {
return new Promise((resolve) => setTimeout(resolve, ms));
}
/* Body */
export const predictit: Platform = {
name: platformName,
label: "PredictIt",
color: "#460c00",
version: "v1",
async fetcher() {
let markets = await fetchmarkets();
let marketVolumes = await fetchmarketvolumes();
@ -65,13 +63,15 @@ export const predictit: Platform = {
let shares_volume = market["TotalSharesTraded"];
// let percentageFormatted = isbinary ? Number(Number(market.contracts[0].lastTradePrice) * 100).toFixed(0) + "%" : "none"
let options = market.contracts.map((contract) => ({
name: contract.name,
probability: contract.lastTradePrice,
type: "PROBABILITY",
}));
let options: FetchedQuestion["options"] = (market.contracts as any[]).map(
(contract) => ({
name: String(contract.name),
probability: Number(contract.lastTradePrice),
type: "PROBABILITY",
})
);
let totalValue = options
.map((element) => Number(element.probability))
.map((element: any) => Number(element.probability))
.reduce((a, b) => a + b, 0);
if (options.length != 1 && totalValue > 1) {
@ -81,7 +81,7 @@ export const predictit: Platform = {
}));
} else if (options.length == 1) {
let option = options[0];
let probability = option["probability"];
let probability = option.probability;
options = [
{
name: "Yes",
@ -90,7 +90,7 @@ export const predictit: Platform = {
},
{
name: "No",
probability: 1 - probability,
probability: 1 - (probability || 0),
type: "PROBABILITY",
},
];
@ -100,11 +100,9 @@ export const predictit: Platform = {
id,
title: market["name"],
url: market.url,
platform: platformName,
description,
options,
qualityindicators: {
stars: calculateStars(platformName, {}),
shares_volume,
},
};
@ -114,4 +112,12 @@ export const predictit: Platform = {
return results;
},
calculateStars(data) {
let nuno = () => 3;
let eli = () => 3.5;
let misha = () => 2.5;
let starsDecimal = average([nuno(), eli(), misha()]);
let starsInteger = Math.round(starsDecimal);
return starsInteger;
},
};

17
src/backend/platforms/rootclaim.ts
View File

@ -1,7 +1,7 @@
import axios from "axios";
import { JSDOM } from "jsdom";
import { calculateStars } from "../utils/stars";
import { average } from "../../utils";
import toMarkdown from "../utils/toMarkdown";
import { FetchedQuestion, Platform } from "./";
@ -48,6 +48,7 @@ export const rootclaim: Platform = {
name: platformName,
label: "Rootclaim",
color: "#0d1624",
version: "v1",
async fetcher() {
const claims = await fetchAllRootclaims();
const results: FetchedQuestion[] = [];
@ -55,7 +56,7 @@ export const rootclaim: Platform = {
for (const claim of claims) {
const id = `${platformName}-${claim.slug.toLowerCase()}`;
let options = [];
let options: FetchedQuestion["options"] = [];
for (let scenario of claim.scenarios) {
options.push({
name: toMarkdown(scenario.name || scenario.text)
@ -75,16 +76,22 @@ export const rootclaim: Platform = {
id,
title: toMarkdown(claim.question).replace("\n", ""),
url,
platform: platformName,
description: toMarkdown(description).replace("&#39;", "'"),
options: options,
options,
qualityindicators: {
numforecasts: 1,
stars: calculateStars(platformName, {}),
},
};
results.push(obj);
}
return results;
},
calculateStars(data) {
let nuno = () => 4;
let eli = () => null;
let misha = () => null;
let starsDecimal = average([nuno() /*, eli(data), misha(data)*/]);
let starsInteger = Math.round(starsDecimal);
return starsInteger;
},
};

308
src/backend/platforms/smarkets.ts
View File

@ -1,180 +1,212 @@
import axios from "axios";
import { calculateStars } from "../utils/stars";
import { QuestionOption } from "../../common/types";
import { average } from "../../utils";
import { FetchedQuestion, Platform } from "./";
/* Definitions */
const platformName = "smarkets";
let htmlEndPointEntrance = "https://api.smarkets.com/v3/events/";
let VERBOSE = false;
let empty = () => 0;
const apiEndpoint = "https://api.smarkets.com/v3"; // documented at https://docs.smarkets.com/
type Context = {
verbose: boolean;
};
/* Support functions */
async function fetchEvents(url) {
let response = await axios({
url: htmlEndPointEntrance + url,
method: "GET",
headers: {
"Content-Type": "text/html",
},
}).then((res) => res.data);
VERBOSE ? console.log(response) : empty();
return response;
async function fetchEvents(ctx: Context) {
let queryString =
"?state=new&state=upcoming&state=live&type_domain=politics&type_scope=single_event&with_new_type=true&sort=id&limit=50";
let events = [];
while (queryString) {
const data = await axios({
url: `${apiEndpoint}/events/${queryString}`,
method: "GET",
}).then((res) => res.data);
events.push(...data.events);
queryString = data.pagination.next_page;
}
ctx.verbose && console.log(events);
return events;
}
async function fetchMarkets(eventid) {
let response = await axios({
url: `https://api.smarkets.com/v3/events/${eventid}/markets/`,
async function fetchSingleEvent(id: string, ctx: Context) {
const events = await fetchEvents(ctx);
const event = events.find((event) => event.id === id);
if (!event) {
throw new Error(`Event ${id} not found`);
}
return event;
}
async function fetchMarkets(eventId: string) {
const response = await axios({
url: `${apiEndpoint}/events/${eventId}/markets/`,
method: "GET",
headers: {
"Content-Type": "text/json",
},
})
.then((res) => res.data)
.then((res) => res.markets);
return response;
}
async function fetchContracts(marketid) {
let response = await axios({
url: `https://api.smarkets.com/v3/markets/${marketid}/contracts/`,
async function fetchContracts(marketId: string, ctx: Context) {
const response = await axios({
url: `${apiEndpoint}/markets/${marketId}/contracts/?include_hidden=true`,
method: "GET",
headers: {
"Content-Type": "text/html",
},
}).then((res) => res.data);
VERBOSE ? console.log(response) : empty();
return response;
ctx.verbose && console.log(response);
if (!(response.contracts instanceof Array)) {
throw new Error("Invalid response while fetching contracts");
}
return response.contracts as any[];
}
async function fetchPrices(marketid) {
let response = await axios({
url: `https://api.smarkets.com/v3/markets/${marketid}/last_executed_prices/`,
async function fetchPrices(marketId: string, ctx: Context) {
const response = await axios({
url: `https://api.smarkets.com/v3/markets/${marketId}/last_executed_prices/`,
method: "GET",
headers: {
"Content-Type": "text/html",
},
}).then((res) => res.data);
VERBOSE ? console.log(response) : empty();
return response;
ctx.verbose && console.log(response);
if (!response.last_executed_prices) {
throw new Error("Invalid response while fetching prices");
}
return response.last_executed_prices;
}
export const smarkets: Platform = {
name: platformName,
label: "Smarkets",
color: "#6f5b41",
async fetcher() {
let htmlPath =
"?state=new&state=upcoming&state=live&type_domain=politics&type_scope=single_event&with_new_type=true&sort=id&limit=50";
async function processEventMarkets(event: any, ctx: Context) {
ctx.verbose && console.log(Date.now());
ctx.verbose && console.log(event.name);
let events = [];
while (htmlPath) {
let data = await fetchEvents(htmlPath);
events.push(...data.events);
htmlPath = data.pagination.next_page;
}
VERBOSE ? console.log(events) : empty();
let markets = [];
for (let event of events) {
VERBOSE ? console.log(Date.now()) : empty();
VERBOSE ? console.log(event.name) : empty();
let eventMarkets = await fetchMarkets(event.id);
eventMarkets = eventMarkets.map((market) => ({
...market,
slug: event.full_slug,
}));
VERBOSE ? console.log("Markets fetched") : empty();
VERBOSE ? console.log(event.id) : empty();
VERBOSE ? console.log(eventMarkets) : empty();
markets.push(...eventMarkets);
//let lastPrices = await fetchPrices(market.id)
}
VERBOSE ? console.log(markets) : empty();
let markets = await fetchMarkets(event.id);
markets = markets.map((market: any) => ({
...market,
// smarkets doesn't have separate urls for different markets in a single event
// we could use anchors (e.g. https://smarkets.com/event/886716/politics/uk/uk-party-leaders/next-conservative-leader#contract-collapse-9815728-control), but it's unclear if they aren't going to change
slug: event.full_slug,
}));
ctx.verbose && console.log(`Markets for ${event.id} fetched`);
ctx.verbose && console.log(markets);
let results = [];
for (let market of markets) {
VERBOSE ? console.log("================") : empty();
VERBOSE ? console.log("Market: ", market) : empty();
let id = `${platformName}-${market.id}`;
let name = market.name;
let results: FetchedQuestion[] = [];
for (const market of markets) {
ctx.verbose && console.log("================");
ctx.verbose && console.log("Market:", market);
let contracts = await fetchContracts(market.id);
VERBOSE ? console.log("Contracts: ", contracts) : empty();
let prices = await fetchPrices(market.id);
VERBOSE
? console.log("Prices: ", prices["last_executed_prices"][market.id])
: empty();
const contracts = await fetchContracts(market.id, ctx);
ctx.verbose && console.log("Contracts:", contracts);
const prices = await fetchPrices(market.id, ctx);
ctx.verbose && console.log("Prices:", prices[market.id]);
let optionsObj = {};
for (let contract of contracts["contracts"]) {
optionsObj[contract.id] = { name: contract.name };
let optionsObj: {
[k: string]: QuestionOption;
} = {};
const contractsById = Object.fromEntries(
contracts.map((c) => [c.id as string, c])
);
for (const price of prices[market.id]) {
const contract = contractsById[price.contract_id];
if (!contract) {
console.warn(
`Couldn't find contract ${price.contract_id} in contracts data for ${market.id}, event ${market.event_id}, skipping`
);
continue;
}
for (let price of prices["last_executed_prices"][market.id]) {
optionsObj[price.contract_id] = {
...optionsObj[price.contract_id],
probability: price.last_executed_price
? Number(price.last_executed_price)
: null,
type: "PROBABILITY",
};
}
let options: any[] = Object.values(optionsObj);
// monkey patch the case where there are only two options and only one has traded.
if (
options.length == 2 &&
options.map((option) => option.probability).includes(null)
) {
let nonNullPrice =
options[0].probability == null
? options[1].probability
: options[0].probability;
optionsObj[price.contract_id] = {
name: contract.name,
probability: contract.hidden ? 0 : Number(price.last_executed_price),
type: "PROBABILITY",
};
}
let options: QuestionOption[] = Object.values(optionsObj);
ctx.verbose && console.log("Options before patching:", options);
// monkey patch the case where there are only two options and only one has traded.
if (
options.length === 2 &&
options.map((option) => option.probability).includes(0)
) {
const nonNullPrice = options[0].probability || options[1].probability;
if (nonNullPrice) {
options = options.map((option) => {
let probability = option.probability;
return {
...option,
probability: probability == null ? 100 - nonNullPrice : probability,
probability: option.probability || 100 - nonNullPrice,
// yes, 100, because prices are not yet normalized.
};
});
}
// Normalize normally
let totalValue = options
.map((element) => Number(element.probability))
.reduce((a, b) => a + b, 0);
options = options.map((element) => ({
...element,
probability: Number(element.probability) / totalValue,
}));
VERBOSE ? console.log(options) : empty();
/*
if(contracts["contracts"].length == 2){
isBinary = true
percentage = ( Number(prices["last_executed_prices"][market.id][0].last_executed_price) + (100 - Number(prices["last_executed_prices"][market.id][1].last_executed_price)) ) / 2
percentage = Math.round(percentage)+"%"
let contractName = contracts["contracts"][0].name
name = name+ (contractName=="Yes"?'':` (${contracts["contracts"][0].name})`)
}
*/
let result: FetchedQuestion = {
id: id,
title: name,
url: "https://smarkets.com/event/" + market.event_id + market.slug,
platform: platformName,
description: market.description,
options: options,
timestamp: new Date(),
qualityindicators: {
stars: calculateStars(platformName, {}),
},
};
VERBOSE ? console.log(result) : empty();
results.push(result);
ctx.verbose && console.log("Options after patching:", options);
// Normalize normally
const totalValue = options
.map((element) => Number(element.probability))
.reduce((a, b) => a + b, 0);
options = options.map((element) => ({
...element,
probability: Number(element.probability) / totalValue,
}));
ctx.verbose && console.log("Normalized options:", options);
const result: FetchedQuestion = {
id: `${platformName}-${market.id}`,
title: market.name,
url: "https://smarkets.com/event/" + market.event_id + market.slug,
description: market.description,
options,
timestamp: new Date(),
qualityindicators: {},
};
ctx.verbose && console.log(result);
results.push(result);
}
return results;
}
export const smarkets: Platform<"eventId" | "verbose"> = {
name: platformName,
label: "Smarkets",
color: "#6f5b41",
version: "v2",
fetcherArgs: ["eventId", "verbose"],
async fetcher(opts) {
const ctx = {
verbose: Boolean(opts.args?.verbose) || false,
};
let events: any[] = [];
let partial = true;
if (opts.args?.eventId) {
events = [await fetchSingleEvent(opts.args.eventId, ctx)];
} else {
events = await fetchEvents(ctx);
partial = false;
}
VERBOSE ? console.log(results) : empty();
return results;
let results: FetchedQuestion[] = [];
for (const event of events) {
const eventResults = await processEventMarkets(event, ctx);
results.push(...eventResults);
}
return {
questions: results,
partial,
};
},
calculateStars(data) {
const nuno = () => 2;
const eli = () => null;
const misha = () => null;
const starsDecimal = average([nuno()]); //, eli(), misha()])
const starsInteger = Math.round(starsDecimal);
return starsInteger;
},
};

44
src/backend/platforms/wildeford.ts
View File

@ -1,9 +1,9 @@
/* Imports */
import { GoogleSpreadsheet } from "google-spreadsheet";
import { average } from "../../utils";
import { applyIfSecretExists } from "../utils/getSecrets";
import { hash } from "../utils/hash";
import { calculateStars } from "../utils/stars";
import { FetchedQuestion, Platform } from "./";
/* Definitions */
@ -13,7 +13,7 @@ const endpoint = `https://docs.google.com/spreadsheets/d/${SHEET_ID}/edit#gid=0`
// https://docs.google.com/spreadsheets/d/1xcgYF7Q0D95TPHLLSgwhWBHFrWZUGJn7yTyAhDR4vi0/edit#gid=0
/* Support functions */
const formatRow = (row) => {
const formatRow = (row: string[]) => {
let colNames = [
"Prediction Date",
"Prediction",
@ -23,15 +23,15 @@ const formatRow = (row) => {
"Prediction Right?",
"Brier Score",
"Notes",
];
let result = {};
row.forEach((col, i) => {
] as const;
let result: Partial<{ [k in typeof colNames[number]]: string }> = {};
row.forEach((col: string, i) => {
result[colNames[i]] = col;
});
return result;
return result as Required<typeof result>;
};
async function fetchGoogleDoc(google_api_key) {
async function fetchGoogleDoc(google_api_key: string) {
// https://gist.github.com/micalevisk/9bc831bd4b3e5a3f62b9810330129c59
let results = [];
const doc = new GoogleSpreadsheet(SHEET_ID);
@ -41,7 +41,7 @@ async function fetchGoogleDoc(google_api_key) {
console.log(">>", doc.title);
const sheet = doc.sheetsByIndex[0];
const rows = await sheet.getRows({ offset: 0 });
const rows = await sheet.getRows();
console.log("# " + rows[0]._sheet.headerValues.join(","));
let isEnd = false;
@ -68,7 +68,9 @@ async function fetchGoogleDoc(google_api_key) {
return results;
}
async function processPredictions(predictions) {
async function processPredictions(
predictions: Awaited<ReturnType<typeof fetchGoogleDoc>>
) {
let currentPredictions = predictions.filter(
(prediction) => prediction["Actual"] == "Unknown"
);
@ -76,7 +78,7 @@ async function processPredictions(predictions) {
let title = prediction["Prediction"].replace(" [update]", "");
let id = `${platformName}-${hash(title)}`;
let probability = Number(prediction["Odds"].replace("%", "")) / 100;
let options = [
let options: FetchedQuestion["options"] = [
{
name: "Yes",
probability: probability,
@ -92,20 +94,17 @@ async function processPredictions(predictions) {
id,
title,
url: prediction["url"],
platform: platformName,
description: prediction["Notes"] || "",
options,
timestamp: new Date(Date.parse(prediction["Prediction Date"] + "Z")),
qualityindicators: {
stars: calculateStars(platformName, null),
},
qualityindicators: {},
};
return result;
});
results = results.reverse();
let uniqueTitles = [];
let uniqueResults = [];
let uniqueTitles: string[] = [];
let uniqueResults: FetchedQuestion[] = [];
results.forEach((result) => {
if (!uniqueTitles.includes(result.title)) uniqueResults.push(result);
uniqueTitles.push(result.title);
@ -113,7 +112,7 @@ async function processPredictions(predictions) {
return uniqueResults;
}
export async function wildeford_inner(google_api_key) {
export async function wildeford_inner(google_api_key: string) {
let predictions = await fetchGoogleDoc(google_api_key);
return await processPredictions(predictions);
}
@ -122,8 +121,17 @@ export const wildeford: Platform = {
name: platformName,
label: "Peter Wildeford",
color: "#984158",
version: "v1",
async fetcher() {
const GOOGLE_API_KEY = process.env.GOOGLE_API_KEY; // See: https://developers.google.com/sheets/api/guides/authorizing#APIKey
return await applyIfSecretExists(GOOGLE_API_KEY, wildeford_inner);
return (await applyIfSecretExists(GOOGLE_API_KEY, wildeford_inner)) || null;
},
calculateStars(data) {
let nuno = () => 3;
let eli = () => null;
let misha = () => null;
let starsDecimal = average([nuno()]); //, eli(), misha()])
let starsInteger = Math.round(starsDecimal);
return starsInteger;
},
};

7
src/backend/platforms/xrisk.ts
View File

@ -9,21 +9,22 @@ export const xrisk: Platform = {
name: "xrisk",
label: "X-risk estimates",
color: "#272600",
version: "v1",
async fetcher() {
// return; // not necessary to refill the DB every time
let fileRaw = fs.readFileSync("./input/xrisk-questions.json", {
encoding: "utf-8",
});
let results = JSON.parse(fileRaw);
results = results.map((item) => {
let parsedData = JSON.parse(fileRaw);
const results = parsedData.map((item: any) => {
item.extra = item.moreoriginsdata;
delete item.moreoriginsdata;
return {
...item,
id: `${platformName}-${hash(item.title + " | " + item.url)}`, // some titles are non-unique, but title+url pair is always unique
platform: platformName,
};
});
return results;
},
calculateStars: () => 2,
};

7
src/backend/utils/algolia.ts
View File

@ -5,13 +5,14 @@ import { Question } from "@prisma/client";
import { prisma } from "../database/prisma";
import { platforms } from "../platforms";
let cookie = process.env.ALGOLIA_MASTER_API_KEY;
const algoliaAppId = process.env.NEXT_PUBLIC_ALGOLIA_APP_ID;
let cookie = process.env.ALGOLIA_MASTER_API_KEY || "";
const algoliaAppId = process.env.NEXT_PUBLIC_ALGOLIA_APP_ID || "";
const client = algoliasearch(algoliaAppId, cookie);
const index = client.initIndex("metaforecast");
export type AlgoliaQuestion = Omit<Question, "timestamp"> & {
timestamp: string;
optionsstringforsearch?: string;
};
const getoptionsstringforsearch = (record: Question): string => {
@ -43,7 +44,7 @@ export async function rebuildAlgoliaDatabase() {
})
);
if (index.exists()) {
if (await index.exists()) {
console.log("Index exists");
await index.replaceAllObjects(records, { safe: true });
console.log(

51
src/backend/utils/evaluations/pullForecastsToCSVForRating.ts
View File

@ -1,51 +0,0 @@
/* Imports */
import fs from "fs";
import { prisma } from "../../database/prisma";
/* Definitions */
/* Utilities */
/* Support functions */
const getQualityIndicators = (question) =>
Object.entries(question.qualityindicators)
.map((entry) => `${entry[0]}: ${entry[1]}`)
.join("; ");
/* Body */
const main = async () => {
let highQualityPlatforms = [
"CSET-foretell",
"Foretold",
"Good Judgment Open",
"Metaculus",
"PredictIt",
"Rootclaim",
];
const json = await prisma.question.findMany({});
console.log(json.length);
//let uniquePlatforms = [...new Set(json.map(forecast => forecast.platform))]
//console.log(uniquePlatforms)
const questionsFromGoodPlatforms = json.filter((question) =>
highQualityPlatforms.includes(question.platform)
);
const tsv =
"index\ttitle\turl\tqualityindicators\n" +
questionsFromGoodPlatforms
.map((question, index) => {
let row = `${index}\t${question.title}\t${
question.url
}\t${getQualityIndicators(question)}`;
console.log(row);
return row;
})
.join("\n");
//console.log(tsv)
// let string = JSON.stringify(json, null, 2)
fs.writeFileSync("metaforecasts.tsv", tsv);
};
main();

48
src/backend/utils/evaluations/pullMetaculusForecastsToCSVForRating.ts
View File

@ -1,48 +0,0 @@
/* Imports */
import fs from "fs";
import { shuffleArray } from "../../../utils";
import { prisma } from "../../database/prisma";
/* Definitions */
/* Utilities */
/* Support functions */
let getQualityIndicators = (question) =>
Object.entries(question.qualityindicators)
.map((entry) => `${entry[0]}: ${entry[1]}`)
.join("; ");
/* Body */
let main = async () => {
let highQualityPlatforms = ["Metaculus"]; // ['CSET-foretell', 'Foretold', 'Good Judgment Open', 'Metaculus', 'PredictIt', 'Rootclaim']
let json = await prisma.question.findMany({});
console.log(json.length);
//let uniquePlatforms = [...new Set(json.map(question => question.platform))]
//console.log(uniquePlatforms)
let questionsFromGoodPlatforms = json.filter((question) =>
highQualityPlatforms.includes(question.platform)
);
let questionsFromGoodPlatformsShuffled = shuffleArray(
questionsFromGoodPlatforms
);
let tsv =
"index\ttitle\turl\tqualityindicators\n" +
questionsFromGoodPlatforms
.map((question, index) => {
let row = `${index}\t${question.title}\t${
question.url
}\t${getQualityIndicators(question)}`;
console.log(row);
return row;
})
.join("\n");
//console.log(tsv)
// let string = JSON.stringify(json, null, 2)
fs.writeFileSync("metaforecasts_metaculus_v2.tsv", tsv);
};
main();

2
src/backend/utils/getSecrets.ts
View File

@ -1,5 +1,5 @@
export async function applyIfSecretExists<T>(
cookie: string,
cookie: string | undefined,
fun: (cookie: string) => T
) {
if (cookie) {

2
src/backend/utils/misc/process-forecasts-into-elicit.ts
View File

@ -11,7 +11,7 @@ let locationData = "./data/";
// let rawdata = fs.readFileSync("./data/merged-questions.json") // run from topmost folder, not from src
async function main() {
const data = await prisma.question.findMany({});
const processDescription = (description) => {
const processDescription = (description: string | null | undefined) => {
if (description == null || description == undefined || description == "") {
return "";
} else {

2
src/backend/utils/misc/process-forecasts-template.ts
View File

@ -10,7 +10,7 @@ let rawdata = fs.readFileSync("../data/merged-questions.json", {
});
let data = JSON.parse(rawdata);
let results = [];
let results: any[] = [];
for (let datum of data) {
// do something
}

25
src/backend/utils/roughSize.ts
View File

@ -1,25 +0,0 @@
export function roughSizeOfObject(object) {
var objectList = [];
var stack = [object];
var bytes = 0;
while (stack.length) {
var value = stack.pop();
if (typeof value === "boolean") {
bytes += 4;
} else if (typeof value === "string") {
bytes += value.length * 2;
} else if (typeof value === "number") {
bytes += 8;
} else if (typeof value === "object" && objectList.indexOf(value) === -1) {
objectList.push(value);
for (var i in value) {
stack.push(value[i]);
}
}
}
let megaBytes = bytes / 1024 ** 2;
let megaBytesRounded = Math.round(megaBytes * 10) / 10;
return megaBytesRounded;
}

3
src/backend/utils/sleep.ts Normal file
View File

@ -0,0 +1,3 @@
export function sleep(ms: number) {
return new Promise((resolve) => setTimeout(resolve, ms));
}

356
src/backend/utils/stars.ts
View File

@ -1,356 +0,0 @@
export function getStarSymbols(numstars) {
let stars = "★★☆☆☆";
switch (numstars) {
case 0:
stars = "☆☆☆☆☆";
break;
case 1:
stars = "★☆☆☆☆";
break;
case 2:
stars = "★★☆☆☆";
break;
case 3:
stars = "★★★☆☆";
break;
case 4:
stars = "★★★★☆";
break;
case 5:
stars = "★★★★★";
break;
default:
stars = "★★☆☆☆";
}
return stars;
}
let average = (array) => array.reduce((a, b) => a + b, 0) / array.length;
function calculateStarsAstralCodexTen(data) {
let nuno = (data) => 3;
let eli = (data) => null;
let misha = (data) => null;
let starsDecimal = average([nuno(data)]); //, eli(data), misha(data)])
let starsInteger = Math.round(starsDecimal);
return starsInteger;
}
function calculateStarsBetfair(data) {
let nuno = (data) => (data.volume > 10000 ? 4 : data.volume > 1000 ? 3 : 2);
let eli = (data) => (data.volume > 10000 ? null : null);
let misha = (data) => null;
let starsDecimal = average([nuno(data)]); //, eli(data), misha(data)])
// Substract 1 star if probability is above 90% or below 10%
if (
data.option &&
(data.option.probability < 0.1 || data.option.probability > 0.9)
) {
starsDecimal = starsDecimal - 1;
}
let starsInteger = Math.round(starsDecimal);
return starsInteger;
}
function calculateStarsCoupCast(data) {
let nuno = (data) => 3;
let starsDecimal = average([nuno(data)]); //, eli(data), misha(data)])
let starsInteger = Math.round(starsDecimal);
return starsInteger;
}
function calculateStarsCSETForetell(data) {
let nuno = (data) => (data.numforecasts > 100 ? 3 : 2);
let eli = (data) => 3;
let misha = (data) => 2;
let starsDecimal = average([nuno(data), eli(data), misha(data)]);
let starsInteger = Math.round(starsDecimal);
return starsInteger;
}
function calculateStarsElicit(data) {
let nuno = (data) => 1;
let eli = (data) => null;
let misha = (data) => null;
let starsDecimal = average([nuno(data)]); //, eli(data), misha(data)])
let starsInteger = Math.round(starsDecimal);
return starsInteger;
}
function calculateStarsEstimize(data) {
let nuno = (data) => 2;
let eli = (data) => null;
let misha = (data) => null;
let starsDecimal = average([nuno(data)]); //, eli(data), misha(data)])
let starsInteger = Math.round(starsDecimal);
return starsInteger;
}
function calculateStarsForetold(data) {
let nuno = (data) => 2;
let eli = (data) => null;
let misha = (data) => null;
let starsDecimal = average([nuno(data)]); //, eli(data), misha(data)])
let starsInteger = Math.round(starsDecimal);
return starsInteger;
}
function calculateStarsGiveWellOpenPhil(data) {
let nuno = (data) => 2;
let eli = (data) => null;
let misha = (data) => null;
let starsDecimal = average([nuno(data)]); //, eli(data), misha(data)])
let starsInteger = Math.round(starsDecimal);
return starsInteger;
}
function calculateStarsGoodJudgment(data) {
let nuno = (data) => 4;
let eli = (data) => 4;
let misha = (data) => 3.5;
let starsDecimal = average([nuno(data)]); //, eli(data), misha(data)])
let starsInteger = Math.round(starsDecimal);
return starsInteger;
}
function calculateStarsGoodJudgmentOpen(data) {
let nuno = (data) => (data.numforecasts > 100 ? 3 : 2);
let eli = (data) => 3;
let misha = (data) =>
data.minProbability > 0.1 || data.maxProbability < 0.9 ? 3.1 : 2.5;
let starsDecimal = average([nuno(data), eli(data), misha(data)]);
let starsInteger = Math.round(starsDecimal);
return starsInteger;
}
function calculateStarsHypermind(data) {
let nuno = (data) => 3;
let eli = (data) => null;
let misha = (data) => null;
let starsDecimal = average([nuno(data)]); //, eli(data), misha(data)])
let starsInteger = Math.round(starsDecimal);
return starsInteger;
}
function calculateStarsInfer(data) {
let nuno = (data) => 2;
let eli = (data) => null;
let misha = (data) => null;
let starsDecimal = average([nuno(data)]); //, eli(data), misha(data)])
let starsInteger = Math.round(starsDecimal);
return starsInteger;
}
function calculateStarsKalshi(data) {
let nuno = (data) =>
data.interest > 500 && data.shares_volume > 10000
? 4
: data.shares_volume > 2000
? 3
: 2;
// let eli = (data) => data.interest > 10000 ? 5 : 4
// let misha = (data) => 4
let starsDecimal = average([nuno(data)]); //, eli(data), misha(data)])
// Substract 1 star if probability is above 90% or below 10%
if (
data.option &&
(data.option.probability < 0.1 || data.option.probability > 0.9)
) {
starsDecimal = starsDecimal - 1;
}
let starsInteger = Math.round(starsDecimal);
return starsInteger;
}
function calculateStarsLadbrokes(data) {
let nuno = (data) => 2;
let eli = (data) => null;
let misha = (data) => null;
let starsDecimal = average([nuno(data)]); //, eli(data), misha(data)])
let starsInteger = Math.round(starsDecimal);
return starsInteger;
}
function calculateStarsManifold(data) {
let nuno = (data) =>
data.volume7Days > 250 || (data.pool > 500 && data.volume7Days > 100)
? 2
: 1;
let eli = (data) => null;
let misha = (data) => null;
let starsDecimal = average([nuno(data)]); //, eli(data), misha(data)])
let starsInteger = Math.round(starsDecimal);
// console.log(data);
// console.log(starsInteger);
return starsInteger;
}
function calculateStarsMetaculus(data) {
let nuno = (data) =>
data.numforecasts > 300 ? 4 : data.numforecasts > 100 ? 3 : 2;
let eli = (data) => 3;
let misha = (data) => 3;
let starsDecimal = average([nuno(data), eli(data), misha(data)]);
let starsInteger = Math.round(starsDecimal);
return starsInteger;
}
function calculateStarsOmen(data) {
let nuno = (data) => 1;
let eli = (data) => null;
let misha = (data) => null;
let starsDecimal = average([nuno(data)]); //, eli(data), misha(data)])
let starsInteger = Math.round(starsDecimal);
return starsInteger;
}
function calculateStarsPolymarket(data) {
// let nuno = (data) => (data.volume > 10000 ? 4 : data.volume > 1000 ? 3 : 2);
// let eli = (data) => data.liquidity > 10000 ? 5 : 4
// let misha = (data) => 4
let nuno = (data) =>
data.liquidity > 1000 && data.volume > 10000
? 4
: data.liquidity > 500 && data.volume > 1000
? 3
: 2;
let starsDecimal = average([nuno(data)]); //, eli(data), misha(data)])
// Substract 1 star if probability is above 90% or below 10%
if (
data.option &&
(data.option.probability < 0.1 || data.option.probability > 0.9)
) {
starsDecimal = starsDecimal - 1;
}
let starsInteger = Math.round(starsDecimal);
return starsInteger;
}
function calculateStarsPredictIt(data) {
let nuno = (data) => 3;
let eli = (data) => 3.5;
let misha = (data) => 2.5;
let starsDecimal = average([nuno(data), eli(data), misha(data)]);
let starsInteger = Math.round(starsDecimal);
return starsInteger;
}
function calculateStarsRootclaim(data) {
let nuno = (data) => 4;
let eli = (data) => null;
let misha = (data) => null;
let starsDecimal = average([nuno(data) /*, eli(data), misha(data)*/]);
let starsInteger = Math.round(starsDecimal);
return starsInteger;
}
function calculateStarsSmarkets(data) {
let nuno = (data) => 2;
let eli = (data) => null;
let misha = (data) => null;
let starsDecimal = average([nuno(data)]); //, eli(data), misha(data)])
let starsInteger = Math.round(starsDecimal);
return starsInteger;
}
function calculateStarsWildeford(data) {
let nuno = (data) => 3;
let eli = (data) => null;
let misha = (data) => null;
let starsDecimal = average([nuno(data)]); //, eli(data), misha(data)])
let starsInteger = Math.round(starsDecimal);
return starsInteger;
}
function calculateStarsWilliamHill(data) {
let nuno = (data) => 2;
let eli = (data) => null;
let misha = (data) => null;
let starsDecimal = average([nuno(data)]); //, eli(data), misha(data)])
let starsInteger = Math.round(starsDecimal);
return starsInteger;
}
export function calculateStars(platform: string, data) {
let stars = 2;
switch (platform) {
case "betfair":
stars = calculateStarsBetfair(data);
break;
case "infer":
stars = calculateStarsInfer(data);
break;
case "foretold":
stars = calculateStarsForetold(data);
break;
case "givewellopenphil":
stars = calculateStarsGiveWellOpenPhil(data);
break;
case "goodjudgment":
stars = calculateStarsGoodJudgment(data);
break;
case "goodjudgmentopen":
stars = calculateStarsGoodJudgmentOpen(data);
break;
case "kalshi":
stars = calculateStarsKalshi(data);
break;
case "manifold":
stars = calculateStarsManifold(data);
break;
case "metaculus":
stars = calculateStarsMetaculus(data);
break;
case "polymarket":
stars = calculateStarsPolymarket(data);
break;
case "predictit":
stars = calculateStarsPredictIt(data);
break;
case "rootclaim":
stars = calculateStarsRootclaim(data);
break;
case "smarkets":
stars = calculateStarsSmarkets(data);
break;
case "wildeford":
stars = calculateStarsWildeford(data);
break;
// deprecated
case "AstralCodexTen":
stars = calculateStarsAstralCodexTen(data);
break;
case "CoupCast":
stars = calculateStarsCoupCast(data);
break;
case "CSET-foretell":
stars = calculateStarsCSETForetell(data);
break;
case "Elicit":
stars = calculateStarsElicit(data);
break;
case "Estimize":
stars = calculateStarsEstimize(data);
break;
case "Hypermind":
stars = calculateStarsHypermind(data);
break;
case "Ladbrokes":
stars = calculateStarsLadbrokes(data);
break;
case "Omen":
stars = calculateStarsOmen(data);
break;
case "WilliamHill":
stars = calculateStarsWilliamHill(data);
break;
default:
stars = 2;
}
return stars;
}

30
src/backend/utils/toMarkdown.ts
View File

@ -1,26 +1,16 @@
/* Imports */
import textVersion from "textversionjs";
/* Definitions */
String.prototype.replaceAll = function replaceAll(search, replace) {
return this.split(search).join(replace);
};
var styleConfig = {
linkProcess: function (href, linkText) {
let newHref = href ? href.replace(/\(/g, "%28").replace(/\)/g, "%29") : "";
// Deal corretly in markdown with links that contain parenthesis
return `[${linkText}](${newHref})`;
},
};
/* Support functions */
/* Body */
export default function toMarkdown(htmlText) {
export default function toMarkdown(htmlText: string) {
let html2 = htmlText.replaceAll(`='`, `="`).replaceAll(`'>`, `">`);
return textVersion(html2, styleConfig);
return textVersion(html2, {
linkProcess: (href, linkText) => {
let newHref = href
? href.replace(/\(/g, "%28").replace(/\)/g, "%29")
: "";
// Deal correctly in markdown with links that contain parenthesis
return `[${linkText}](${newHref})`;
},
});
}
// toMarkdown()

22
src/common/types.ts Normal file
View File

@ -0,0 +1,22 @@
import { QuestionFragment } from "../web/fragments.generated";
// this type is good both for backend (e.g. FetchedQuestion["options"]) and for graphql shapes
export type QuestionOption = {
name?: string;
probability?: number;
type: "PROBABILITY";
};
export type FullQuestionOption = Exclude<
QuestionOption,
"name" | "probability"
> & {
name: NonNullable<QuestionOption["name"]>;
probability: NonNullable<QuestionOption["probability"]>;
};
export const isFullQuestionOption = (
option: QuestionOption | QuestionFragment["options"][0]
): option is FullQuestionOption => {
return option.name != null && option.probability != null;
};

1
src/graphql/schema/dashboards.ts
View File

@ -36,6 +36,7 @@ const DashboardObj = builder.objectRef<Dashboard>("Dashboard").implement({
builder.queryField("dashboard", (t) =>
t.field({
type: DashboardObj,
nullable: true,
description: "Look up a single dashboard by its id",
args: {
id: t.arg({ type: "ID", required: true }),

2
src/graphql/schema/questions.ts
View File

@ -140,6 +140,7 @@ builder.queryField("questions", (t) =>
builder.queryField("question", (t) =>
t.field({
type: QuestionObj,
nullable: true,
description: "Look up a single question by its id",
args: {
id: t.arg({ type: "ID", required: true }),
@ -149,7 +150,6 @@ builder.queryField("question", (t) =>
const [platform, id] = [parts[0], parts.slice(1).join("-")];
if (platform === "guesstimate") {
const q = await guesstimate.fetchQuestion(Number(id));
console.log(q);
return q;
}
return await prisma.question.findUnique({

14
src/graphql/schema/search.ts
View File

@ -32,19 +32,19 @@ builder.queryField("searchQuestions", (t) =>
// defs
const query = input.query === undefined ? "" : input.query;
if (query === "") return [];
const forecastsThreshold = input.forecastsThreshold;
const starsThreshold = input.starsThreshold;
const { forecastsThreshold, starsThreshold } = input;
const platformsIncludeGuesstimate =
input.forecastingPlatforms?.includes("guesstimate") &&
starsThreshold <= 1;
(!starsThreshold || starsThreshold <= 1);
// preparation
const unawaitedAlgoliaResponse = searchWithAlgolia({
queryString: query,
hitsPerPage: input.limit + 50,
starsThreshold,
filterByPlatforms: input.forecastingPlatforms,
forecastsThreshold,
hitsPerPage: input.limit ?? 50,
starsThreshold: starsThreshold ?? undefined,
filterByPlatforms: input.forecastingPlatforms ?? undefined,
forecastsThreshold: forecastsThreshold ?? undefined,
});
let results: AlgoliaQuestion[] = [];

5
src/pages/api/squiggle.ts
View File

@ -1,5 +1,6 @@
import { NextApiRequest, NextApiResponse } from "next/types";
import { runMePlease } from "squiggle-experimental/dist/index.js";
import { run } from "@quri/squiggle-lang";
export default async function handler(
req: NextApiRequest,
@ -24,6 +25,6 @@ $ curl -X POST -H "Content-Type: application/json" -d '{"model": "1 to 4"}'
});
} else {
console.log(body.model);
res.status(200).send(runMePlease(body.model));
res.status(200).send(run(body.model));
}
}

16
src/pages/dashboards/embed/[id].tsx
View File

@ -1,5 +1,5 @@
import { GetServerSideProps, NextPage } from "next";
import Error from "next/error";
import NextError from "next/error";
import {
DashboardByIdDocument, DashboardFragment
@ -19,9 +19,13 @@ export const getServerSideProps: GetServerSideProps<Props> = async (
const dashboardId = context.query.id as string;
const numCols = Number(context.query.numCols);
const dashboard = (
await client.query(DashboardByIdDocument, { id: dashboardId }).toPromise()
).data?.result;
const response = await client
.query(DashboardByIdDocument, { id: dashboardId })
.toPromise();
if (!response.data) {
throw new Error(`GraphQL query failed: ${response.error}`);
}
const dashboard = response.data.result;
if (!dashboard) {
context.res.statusCode = 404;
@ -32,14 +36,14 @@ export const getServerSideProps: GetServerSideProps<Props> = async (
// reduntant: page component doesn't do graphql requests, but it's still nice/more consistent to have data in cache
urqlState: ssrCache.extractData(),
dashboard,
numCols: !numCols ? null : numCols < 5 ? numCols : 4,
numCols: !numCols ? undefined : numCols < 5 ? numCols : 4,
},
};
};
const EmbedDashboardPage: NextPage<Props> = ({ dashboard, numCols }) => {
if (!dashboard) {
return <Error statusCode={404} />;
return <NextError statusCode={404} />;
}
return (

9
src/pages/index.tsx
View File

@ -45,8 +45,11 @@ export const getServerSideProps: GetServerSideProps<Props> = async (
const defaultNumDisplay = 21;
const initialNumDisplay = Number(urlQuery.numDisplay) || defaultNumDisplay;
const defaultResults = (await client.query(FrontpageDocument).toPromise())
.data.result;
const response = await client.query(FrontpageDocument).toPromise();
if (!response.data) {
throw new Error(`GraphQL query failed: ${response.error}`);
}
const defaultResults = response.data.result;
if (
!!initialQueryParameters &&
@ -58,7 +61,7 @@ export const getServerSideProps: GetServerSideProps<Props> = async (
.query(SearchDocument, {
input: {
...initialQueryParameters,
limit: initialNumDisplay,
limit: initialNumDisplay + 50,
},
})
.toPromise();

23
src/pages/secretEmbed.tsx
View File

@ -29,16 +29,19 @@ export const getServerSideProps: GetServerSideProps<Props> = async (
let results: QuestionFragment[] = [];
if (initialQueryParameters.query !== "") {
results = (
await client
.query(SearchDocument, {
input: {
...initialQueryParameters,
limit: 1,
},
})
.toPromise()
).data.result;
const response = await client
.query(SearchDocument, {
input: {
...initialQueryParameters,
limit: 1,
},
})
.toPromise();
if (response.data?.result) {
results = response.data.result;
} else {
throw new Error("GraphQL request failed");
}
}
return {

3
src/utils.ts
View File

@ -6,3 +6,6 @@ export const shuffleArray = <T>(array: T[]): T[] => {
}
return array;
};
export const average = (array: number[]) =>
array.reduce((a, b) => a + b, 0) / array.length;

2
src/web/common/Layout.tsx
View File

@ -2,7 +2,7 @@ import Head from "next/head";
import Link from "next/link";
import React, { ErrorInfo } from "react";
import { Logo2 } from "../icons/index";
import { Logo2 } from "../icons";
interface MenuItem {
page: string;

2
src/web/common/MultiSelectPlatform.tsx
View File

@ -87,7 +87,7 @@ export const MultiSelectPlatform: React.FC<Props> = ({
const selectValue = value.map((v) => id2option[v]).filter((v) => v);
const onSelectChange = (newValue: Option[]) => {
const onSelectChange = (newValue: readonly Option[]) => {
onChange(newValue.map((o) => o.value));
};

8
src/web/display/DashboardCreator.tsx
View File

@ -1,4 +1,4 @@
import React, { EventHandler, SyntheticEvent, useState } from "react";
import React, { ChangeEvent, EventHandler, SyntheticEvent, useState } from "react";
import { Button } from "../common/Button";
import { InfoBox } from "../common/InfoBox";
@ -18,7 +18,7 @@ export const DashboardCreator: React.FC<Props> = ({ handleSubmit }) => {
const [value, setValue] = useState(exampleInput);
const [acting, setActing] = useState(false);
const handleChange = (event) => {
const handleChange = (event: ChangeEvent<HTMLTextAreaElement>) => {
setValue(event.target.value);
};
@ -37,7 +37,9 @@ export const DashboardCreator: React.FC<Props> = ({ handleSubmit }) => {
}
} catch (error) {
setActing(false);
const substituteText = `Error: ${error.message}
const substituteText = `Error: ${
error instanceof Error ? error.message : "Unknown"
}
Try something like:
${exampleInput}

36
src/web/display/SliderElement.tsx
View File

@ -1,6 +1,7 @@
/* Imports */
import React from "react";
import { Handles, Rail, Slider, Tracks } from "react-compound-slider";
import {
GetHandleProps, GetTrackProps, Handles, Rail, Slider, SliderItem, Tracks
} from "react-compound-slider";
// https://sghall.github.io/react-compound-slider/#/getting-started/tutorial
@ -24,12 +25,11 @@ const railStyle = {
};
/* Support functions */
function Handle({
handle: { id, value, percent },
getHandleProps,
displayFunction,
handleWidth,
}) {
const Handle: React.FC<{
handle: SliderItem;
getHandleProps: GetHandleProps;
displayFunction: (value: number) => string;
}> = ({ handle: { id, value, percent }, getHandleProps, displayFunction }) => {
return (
<>
<div className="justify-center text-center text-gray-600 text-xs">
@ -53,9 +53,13 @@ function Handle({
></div>
</>
);
}
};
function Track({ source, target, getTrackProps }) {
const Track: React.FC<{
source: SliderItem;
target: SliderItem;
getTrackProps: GetTrackProps;
}> = ({ source, target, getTrackProps }) => {
return (
<div
style={{
@ -74,16 +78,15 @@ function Track({ source, target, getTrackProps }) {
}
/>
);
}
};
interface Props {
value: number;
onChange: (event: any) => void;
onChange: (value: number) => void;
displayFunction: (value: number) => string;
}
/* Body */
// Two functions, essentially identical.
export const SliderElement: React.FC<Props> = ({
onChange,
value,
@ -96,21 +99,20 @@ export const SliderElement: React.FC<Props> = ({
}
domain={[0, 200]}
values={[value]}
onChange={onChange}
onChange={(values) => onChange(values[0])}
>
<Rail>
{({ getRailProps }) => <div style={railStyle} {...getRailProps()} />}
</Rail>
<Handles>
{({ handles, getHandleProps }) => (
<div className="slider-handles">
<div>
{handles.map((handle) => (
<Handle
key={handle.id}
handle={handle}
getHandleProps={getHandleProps}
displayFunction={displayFunction}
handleWidth={"15em"}
/>
))}
</div>
@ -118,7 +120,7 @@ export const SliderElement: React.FC<Props> = ({
</Handles>
<Tracks right={false}>
{({ tracks, getTrackProps }) => (
<div className="slider-tracks">
<div>
{tracks.map(({ id, source, target }) => (
<Track
key={id}

8
src/web/icons/Favicon.tsx
View File

@ -1,6 +1,4 @@
import * as React from "react";
function SvgFavicon(props) {
export const Favicon: React.FC<React.SVGAttributes<SVGElement>> = (props) => {
return (
<svg
xmlns="http://www.w3.org/2000/svg"
@ -11,6 +9,4 @@ function SvgFavicon(props) {
<path d="M512 64C264.6 64 64 264.6 64 512s200.6 448 448 448 448-200.6 448-448S759.4 64 512 64zm0 820c-205.4 0-372-166.6-372-372s166.6-372 372-372 372 166.6 372 372-166.6 372-372 372zm198.4-588.1a32 32 0 00-24.5.5L414.9 415 296.4 686c-3.6 8.2-3.6 17.5 0 25.7 3.4 7.8 9.7 13.9 17.7 17 3.8 1.5 7.7 2.2 11.7 2.2 4.4 0 8.7-.9 12.8-2.7l271-118.6 118.5-271a32.06 32.06 0 00-17.7-42.7zM576.8 534.4l26.2 26.2-42.4 42.4-26.2-26.2L380 644.4 447.5 490 422 464.4l42.4-42.4 25.5 25.5L644.4 380l-67.6 154.4zM464.4 422L422 464.4l25.5 25.6 86.9 86.8 26.2 26.2 42.4-42.4-26.2-26.2-86.8-86.9z" />
</svg>
);
}
export default SvgFavicon;
};

8
src/web/icons/Logo.tsx
View File

@ -1,6 +1,4 @@
import * as React from "react";
function SvgLogo(props) {
export const Logo: React.FC<React.SVGAttributes<SVGElement>> = (props) => {
return (
<svg
width={1333.333}
@ -76,6 +74,4 @@ function SvgLogo(props) {
/>
</svg>
);
}
export default SvgLogo;
};

8
src/web/icons/Logo2.tsx
View File

@ -1,6 +1,4 @@
import * as React from "react";
function SvgLogo2(props) {
export const Logo2: React.FC<React.SVGAttributes<SVGElement>> = (props) => {
return (
<svg
xmlns="http://www.w3.org/2000/svg"
@ -69,6 +67,4 @@ function SvgLogo2(props) {
/>
</svg>
);
}
export default SvgLogo2;
};

6
src/web/icons/index.ts
View File

@ -1,3 +1,3 @@
export { default as Favicon } from "./Favicon";
export { default as Logo } from "./Logo";
export { default as Logo2 } from "./Logo2";
export { Favicon } from "./Favicon";
export { Logo } from "./Logo";
export { Logo2 } from "./Logo2";

8
src/web/questions/components/HistoryChart/InnerChart.tsx
View File

@ -34,10 +34,12 @@ const getVictoryGroup = ({
);
};
export const InnerChart: React.FC<{
export type Props = {
data: ChartData;
highlight: number | undefined;
}> = ({
};
export const InnerChart: React.FC<Props> = ({
data: { maxProbability, seriesList, minDate, maxDate },
highlight,
}) => {
@ -120,7 +122,7 @@ export const InnerChart: React.FC<{
<VictoryAxis
tickCount={Math.min(7, differenceInDays(maxDate, minDate) + 1)}
style={{
grid: { stroke: null, strokeWidth: 0.5 },
grid: { strokeWidth: 0.5 },
}}
tickLabelComponent={
<VictoryLabel

8
src/web/questions/components/HistoryChart/Legend.tsx
View File

@ -12,15 +12,17 @@ const LegendItem: React.FC<{ item: Item; onHighlight: () => void }> = ({
onHighlight,
}) => {
const { x, y, reference, floating, strategy } = useFloating({
// placement: "right",
middleware: [shift()],
});
const [showTooltip, setShowTooltip] = useState(false);
const textRef = useRef<HTMLDivElement>();
const textRef = useRef<HTMLDivElement>(null);
const onHover = () => {
if (textRef.current.scrollWidth > textRef.current.clientWidth) {
if (
textRef.current &&
textRef.current.scrollWidth > textRef.current.clientWidth
) {
setShowTooltip(true);
}
onHighlight();

3
src/web/questions/components/HistoryChart/index.tsx
View File

@ -2,11 +2,12 @@ import dynamic from "next/dynamic";
import React, { useMemo, useState } from "react";
import { QuestionWithHistoryFragment } from "../../../fragments.generated";
import { Props as InnerChartProps } from "./InnerChart"; // hopefully doesn't import code, just types - need to check
import { InnerChartPlaceholder } from "./InnerChartPlaceholder";
import { Legend } from "./Legend";
import { buildChartData, chartColors } from "./utils";
const InnerChart = dynamic(
const InnerChart = dynamic<InnerChartProps>(
() => import("./InnerChart").then((mod) => mod.InnerChart),
{ ssr: false, loading: () => <InnerChartPlaceholder /> }
);

10
src/web/questions/components/HistoryChart/utils.ts
View File

@ -1,6 +1,8 @@
import { addDays, startOfDay, startOfToday, startOfTomorrow } from "date-fns";
import { isFullQuestionOption } from "../../../../common/types";
import { QuestionWithHistoryFragment } from "../../../fragments.generated";
import { isQuestionBinary } from "../../../utils";
export type ChartSeries = { x: Date; y: number; name: string }[];
@ -33,6 +35,7 @@ export const buildChartData = (
question: QuestionWithHistoryFragment
): ChartData => {
let seriesNames = question.options
.filter(isFullQuestionOption)
.sort((a, b) => {
if (a.probability > b.probability) {
return -1;
@ -44,9 +47,7 @@ export const buildChartData = (
.map((o) => o.name)
.slice(0, MAX_LINES);
const isBinary =
(seriesNames[0] === "Yes" && seriesNames[1] === "No") ||
(seriesNames[0] === "No" && seriesNames[1] === "Yes");
const isBinary = isQuestionBinary(question);
if (isBinary) {
seriesNames = ["Yes"];
}
@ -69,6 +70,9 @@ export const buildChartData = (
const date = new Date(item.timestamp * 1000);
for (const option of item.options) {
if (option.name == null || option.probability == null) {
continue;
}
const idx = nameToIndex[option.name];
if (idx === undefined) {
continue;

10
src/web/questions/components/IndicatorsTable.tsx
View File

@ -45,18 +45,18 @@ export const IndicatorsTable: React.FC<Props> = ({ question }) => (
) : null}
{Object.keys(question.qualityIndicators)
.filter(
(indicator) =>
question.qualityIndicators[indicator] != null &&
!!qualityIndicatorLabels[indicator]
(indicator): indicator is UsedIndicatorName =>
(question.qualityIndicators as any)[indicator] != null &&
indicator in qualityIndicatorLabels
)
.map((indicator: UsedIndicatorName) => {
.map((indicator) => {
return (
<TableRow
title={qualityIndicatorLabels[indicator]}
key={indicator}
>
{formatIndicatorValue(
question.qualityIndicators[indicator],
Number(question.qualityIndicators[indicator]), // must be non-null due to former check
indicator,
question.platform.id
)}

49
src/web/questions/components/QuestionCard/QuestionFooter.tsx
View File

@ -30,13 +30,17 @@ export const qualityIndicatorLabels: { [k in UsedIndicatorName]: string } = {
openInterest: "Interest",
};
const formatNumber = (num) => {
if (Number(num) < 1000) {
return Number(num).toFixed(0);
const isUsedIndicatorName = (name: string): name is UsedIndicatorName => {
return name in qualityIndicatorLabels;
};
const formatNumber = (num: number) => {
if (num < 1000) {
return num.toFixed(0);
} else if (num < 10000) {
return (Number(num) / 1000).toFixed(1) + "k";
return (num / 1000).toFixed(1) + "k";
} else {
return (Number(num) / 1000).toFixed(0) + "k";
return (num / 1000).toFixed(0) + "k";
}
};
@ -100,7 +104,7 @@ const FirstQualityIndicator: React.FC<{
};
export const formatIndicatorValue = (
value: any,
value: number,
indicator: UsedIndicatorName,
platform: string
): string => {
@ -119,21 +123,26 @@ const QualityIndicatorsList: React.FC<{
return (
<div className="text-sm">
<FirstQualityIndicator question={question} />
{Object.entries(question.qualityIndicators).map((entry, i) => {
const indicatorLabel = qualityIndicatorLabels[entry[0]];
if (!indicatorLabel || entry[1] === null) return;
const indicator = entry[0] as UsedIndicatorName; // guaranteed by the previous line
const value = entry[1];
{Object.entries(question.qualityIndicators).map(
([indicator, value], i) => {
if (!isUsedIndicatorName(indicator)) return;
const indicatorLabel = qualityIndicatorLabels[indicator];
if (!indicatorLabel || value === null) return;
return (
<div key={indicator}>
<span>{indicatorLabel}:</span>&nbsp;
<span className="font-bold">
{formatIndicatorValue(value, indicator, question.platform.id)}
</span>
</div>
);
})}
return (
<div key={indicator}>
<span>{indicatorLabel}:</span>&nbsp;
<span className="font-bold">
{formatIndicatorValue(
Number(value),
indicator,
question.platform.id
)}
</span>
</div>
);
}
)}
</div>
);
};

55
src/web/questions/components/QuestionCard/index.tsx
View File

@ -13,62 +13,25 @@ const truncateText = (length: number, text: string): string => {
if (!text) {
return "";
}
if (!!text && text.length <= length) {
if (text.length <= length) {
return text;
}
const breakpoints = " .!?";
let lastLetter = null;
let lastIndex = null;
let lastLetter: string | undefined = undefined;
let lastIndex: number | undefined = undefined;
for (let index = length; index > 0; index--) {
let letter = text[index];
const letter = text[index];
if (breakpoints.includes(letter)) {
lastLetter = letter;
lastIndex = index;
break;
}
}
let truncatedText = !!text.slice
? text.slice(0, lastIndex) + (lastLetter != "." ? "..." : "..")
: "";
let truncatedText =
text.slice(0, lastIndex) + (lastLetter != "." ? "..." : "..");
return truncatedText;
};
// replaceAll polyfill
function escapeRegExp(string) {
return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); // $& means the whole matched string
}
function replaceAll(
originalString: string,
pattern: string | RegExp,
substitute
) {
return originalString.replace(
new RegExp(escapeRegExp(pattern), "g"),
substitute
);
}
if (!String.prototype.replaceAll) {
String.prototype.replaceAll = function (
pattern: string | RegExp,
substitute
) {
let originalString = this;
// If a regex pattern
if (
Object.prototype.toString.call(pattern).toLowerCase() ===
"[object regexp]"
) {
return originalString.replace(pattern, substitute);
}
// If a string
return replaceAll(originalString, pattern, substitute);
};
}
// Auxiliary components
const DisplayMarkdown: React.FC<{ description: string }> = ({
@ -153,14 +116,14 @@ export const QuestionCard: React.FC<Props> = ({
</div>
{isBinary ? (
<div className="flex justify-between">
<QuestionOptions options={options} />
<QuestionOptions question={question} />
<div className={`hidden ${showTimeStamp ? "sm:block" : ""}`}>
<LastUpdated timestamp={lastUpdated} />
</div>
</div>
) : (
<div className="space-y-2">
<QuestionOptions options={options} />
<QuestionOptions question={question} />
<div className={`hidden ${showTimeStamp ? "sm:block" : ""} ml-6`}>
<LastUpdated timestamp={lastUpdated} />
</div>
@ -173,7 +136,7 @@ export const QuestionCard: React.FC<Props> = ({
</div>
)}
{question.platform.id === "guesstimate" && (
{question.platform.id === "guesstimate" && question.visualization && (
<img
className="rounded-sm"
src={question.visualization}

227
src/web/questions/components/QuestionIndicators.tsx
View File

@ -1,227 +0,0 @@
import { QuestionFragment } from "../../fragments.generated";
type QualityIndicator = QuestionFragment["qualityIndicators"];
type IndicatorName = keyof QualityIndicator;
// this duplication can probably be simplified with typescript magic, but this is good enough for now
type UsedIndicatorName =
| "volume"
| "numForecasters"
| "spread"
| "sharesVolume"
| "liquidity"
| "tradeVolume"
| "openInterest";
const qualityIndicatorLabels: { [k in UsedIndicatorName]: string } = {
// numForecasts: null,
// stars: null,
// yesBid: "Yes bid",
// yesAsk: "Yes ask",
volume: "Volume",
numForecasters: "Forecasters",
spread: "Spread",
sharesVolume: "Shares vol.",
liquidity: "Liquidity",
tradeVolume: "Volume",
openInterest: "Interest",
};
const formatNumber = (num) => {
if (Number(num) < 1000) {
return Number(num).toFixed(0);
} else if (num < 10000) {
return (Number(num) / 1000).toFixed(1) + "k";
} else {
return (Number(num) / 1000).toFixed(0) + "k";
}
};
/* Display functions*/
const getPercentageSymbolIfNeeded = ({
indicator,
platform,
}: {
indicator: UsedIndicatorName;
platform: string;
}) => {
let indicatorsWhichNeedPercentageSymbol: IndicatorName[] = ["spread"];
if (indicatorsWhichNeedPercentageSymbol.includes(indicator)) {
return "%";
} else {
return "";
}
};
const getCurrencySymbolIfNeeded = ({
indicator,
platform,
}: {
indicator: UsedIndicatorName;
platform: string;
}) => {
const indicatorsWhichNeedCurrencySymbol: IndicatorName[] = [
"volume",
"tradeVolume",
"openInterest",
"liquidity",
];
let dollarPlatforms = ["predictit", "kalshi", "polymarket"];
if (indicatorsWhichNeedCurrencySymbol.includes(indicator)) {
if (dollarPlatforms.includes(platform)) {
return "$";
} else {
return "£";
}
} else {
return "";
}
};
const FirstQualityIndicator: React.FC<{
question: QuestionFragment;
}> = ({ question }) => {
if (question.qualityIndicators.numForecasts) {
return (
<div className="flex">
<span>Forecasts:</span>&nbsp;
<span className="font-bold">
{Number(question.qualityIndicators.numForecasts).toFixed(0)}
</span>
</div>
);
} else {
return null;
}
};
const QualityIndicatorsList: React.FC<{
question: QuestionFragment;
}> = ({ question }) => {
return (
<div className="text-sm">
<FirstQualityIndicator question={question} />
{Object.entries(question.qualityIndicators).map((entry, i) => {
const indicatorLabel = qualityIndicatorLabels[entry[0]];
if (!indicatorLabel || entry[1] === null) return;
const indicator = entry[0] as UsedIndicatorName; // guaranteed by the previous line
const value = entry[1];
return (
<div key={indicator}>
<span>{indicatorLabel}:</span>&nbsp;
<span className="font-bold">
{`${getCurrencySymbolIfNeeded({
indicator,
platform: question.platform.id,
})}${formatNumber(value)}${getPercentageSymbolIfNeeded({
indicator,
platform: question.platform.id,
})}`}
</span>
</div>
);
})}
</div>
);
};
// Database-like functions
export function getstars(numstars: number) {
let stars = "★★☆☆☆";
switch (numstars) {
case 0:
stars = "☆☆☆☆☆";
break;
case 1:
stars = "★☆☆☆☆";
break;
case 2:
stars = "★★☆☆☆";
break;
case 3:
stars = "★★★☆☆";
break;
case 4:
stars = "★★★★☆";
break;
case 5:
stars = "★★★★★";
break;
default:
stars = "★★☆☆☆";
}
return stars;
}
function getStarsColor(numstars: number) {
let color = "text-yellow-400";
switch (numstars) {
case 0:
color = "text-red-400";
break;
case 1:
color = "text-red-400";
break;
case 2:
color = "text-orange-400";
break;
case 3:
color = "text-yellow-400";
break;
case 4:
color = "text-green-400";
break;
case 5:
color = "text-blue-400";
break;
default:
color = "text-yellow-400";
}
return color;
}
interface Props {
question: QuestionFragment;
expandFooterToFullWidth: boolean;
}
export const QuestionFooter: React.FC<Props> = ({
question,
expandFooterToFullWidth,
}) => {
return (
<div
className={`grid grid-cols-3 ${
expandFooterToFullWidth ? "justify-between" : ""
} text-gray-500 mb-2 mt-1`}
>
<div
className={`self-center col-span-1 ${getStarsColor(
question.qualityIndicators.stars
)}`}
>
{getstars(question.qualityIndicators.stars)}
</div>
<div
className={`${
expandFooterToFullWidth ? "place-self-center" : "self-center"
} col-span-1 font-bold`}
>
{question.platform.label
.replace("Good Judgment Open", "GJOpen")
.replace(/ /g, "\u00a0")}
</div>
<div
className={`${
expandFooterToFullWidth
? "justify-self-end mr-4"
: "justify-self-center"
} col-span-1`}
>
<QualityIndicatorsList question={question} />
</div>
</div>
);
};

29
src/web/questions/components/QuestionOptions.tsx
View File

@ -1,8 +1,8 @@
import { FullQuestionOption, isFullQuestionOption } from "../../../common/types";
import { QuestionFragment } from "../../fragments.generated";
import { isQuestionBinary } from "../../utils";
import { formatProbability } from "../utils";
type Option = QuestionFragment["options"][0];
const textColor = (probability: number) => {
if (probability < 0.03) {
return "text-red-600";
@ -89,7 +89,7 @@ const chooseColor = (probability: number) => {
}
};
const OptionRow: React.FC<{ option: Option }> = ({ option }) => {
const OptionRow: React.FC<{ option: FullQuestionOption }> = ({ option }) => {
return (
<div className="flex items-center">
<div
@ -106,15 +106,19 @@ const OptionRow: React.FC<{ option: Option }> = ({ option }) => {
);
};
export const QuestionOptions: React.FC<{ options: Option[] }> = ({
options,
export const QuestionOptions: React.FC<{ question: QuestionFragment }> = ({
question,
}) => {
const isBinary =
options.length === 2 &&
(options[0].name === "Yes" || options[0].name === "No");
const isBinary = isQuestionBinary(question);
if (isBinary) {
const yesOption = options.find((o) => o.name === "Yes");
const yesOption = question.options.find((o) => o.name === "Yes");
if (!yesOption) {
return null; // shouldn't happen
}
if (!isFullQuestionOption(yesOption)) {
return null; // missing data
}
return (
<div className="space-x-2">
<span
@ -134,8 +138,11 @@ export const QuestionOptions: React.FC<{ options: Option[] }> = ({
</div>
);
} else {
const optionsSorted = options.sort((a, b) => b.probability - a.probability);
const optionsMax5 = !!optionsSorted.slice ? optionsSorted.slice(0, 5) : []; // display max 5 options.
const optionsSorted = question.options
.filter(isFullQuestionOption)
.sort((a, b) => b.probability - a.probability);
const optionsMax5 = optionsSorted.slice(0, 5); // display max 5 options.
return (
<div className="space-y-2">

2
src/web/questions/pages/QuestionPage.tsx
View File

@ -74,7 +74,7 @@ const LargeQuestionCard: React.FC<{
</div>
<div className="mb-8">
{question.platform.id === "guesstimate" ? (
{question.platform.id === "guesstimate" && question.visualization ? (
<a className="no-underline" href={question.url} target="_blank">
<img
className="rounded-sm"

4
src/web/search/components/QueryForm.tsx
View File

@ -1,3 +1,5 @@
import { ChangeEvent } from "react";
interface Props {
value: string;
onChange: (v: string) => void;
@ -9,7 +11,7 @@ export const QueryForm: React.FC<Props> = ({
onChange,
placeholder,
}) => {
const handleInputChange = (event) => {
const handleInputChange = (event: ChangeEvent<HTMLInputElement>) => {
event.preventDefault();
onChange(event.target.value); // In this case, the query, e.g. "COVID.19"
};

28
src/web/search/components/SearchScreen.tsx
View File

@ -1,5 +1,5 @@
import { useRouter } from "next/router";
import React, { Fragment, useMemo, useState } from "react";
import React, { useMemo, useState } from "react";
import { useQuery } from "urql";
import { PlatformConfig } from "../../../backend/platforms";
@ -61,7 +61,7 @@ export const SearchScreen: React.FC<Props> = ({
variables: {
input: {
...queryParameters,
limit: numDisplay,
limit: numDisplay + 50,
},
},
pause: !isFirstRender,
@ -126,7 +126,8 @@ export const SearchScreen: React.FC<Props> = ({
};
const updateRoute = () => {
const stringify = (key: string, value: any) => {
const stringify = (key: string, obj: { [k: string]: any }) => {
const value = obj[key];
if (key === "forecastingPlatforms") {
return value.join("|");
} else {
@ -134,15 +135,16 @@ export const SearchScreen: React.FC<Props> = ({
}
};
const query = {};
const query: { [k: string]: string } = {};
for (const key of Object.keys(defaultQueryParameters)) {
const value = stringify(key, queryParameters[key]);
const defaultValue = stringify(key, defaultQueryParameters[key]);
const value = stringify(key, queryParameters);
const defaultValue = stringify(key, defaultQueryParameters);
if (value === defaultValue) continue;
query[key] = value;
}
if (numDisplay !== defaultNumDisplay) query["numDisplay"] = numDisplay;
if (numDisplay !== defaultNumDisplay)
query["numDisplay"] = String(numDisplay);
router.replace(
{
@ -191,8 +193,8 @@ export const SearchScreen: React.FC<Props> = ({
(Math.round(value) === 1 ? "" : "s")
);
};
const onChangeSliderForNumDisplay = (event) => {
setNumDisplay(Math.round(event[0]));
const onChangeSliderForNumDisplay = (value: number) => {
setNumDisplay(Math.round(value));
setForceSearch(forceSearch + 1); // FIXME - force new search iff numDisplay is greater than last search limit
};
@ -200,10 +202,10 @@ export const SearchScreen: React.FC<Props> = ({
const displayFunctionNumForecasts = (value: number) => {
return "# Forecasts > " + Math.round(value);
};
const onChangeSliderForNumForecasts = (event) => {
const onChangeSliderForNumForecasts = (value: number) => {
setQueryParameters({
...queryParameters,
forecastsThreshold: Math.round(event[0]),
forecastsThreshold: Math.round(value),
});
};
@ -230,7 +232,7 @@ export const SearchScreen: React.FC<Props> = ({
/* Final return */
return (
<Fragment>
<>
<label className="mb-4 mt-4 flex flex-row justify-center items-center">
<div className="w-10/12 mb-2">
<QueryForm
@ -317,6 +319,6 @@ export const SearchScreen: React.FC<Props> = ({
</p>
</div>
) : null}
</Fragment>
</>
);
};

3
src/web/urql.ts
View File

@ -36,5 +36,8 @@ export const getUrqlClientOptions = (ssr: SSRExchange) => ({
export const ssrUrql = () => {
const ssrCache = ssrExchange({ isClient: false });
const client = initUrqlClient(getUrqlClientOptions(ssrCache), false);
if (!client) {
throw new Error("Expected non-null client instance from initUrqlClient");
}
return [ssrCache, client] as const;
};

11
src/web/utils.ts
View File

@ -1,3 +1,5 @@
import { QuestionFragment } from "./fragments.generated";
export const getBasePath = () => {
if (process.env.NEXT_PUBLIC_VERCEL_URL) {
return `https://${process.env.NEXT_PUBLIC_VERCEL_URL}`;
@ -29,3 +31,12 @@ export const cleanText = (text: string): string => {
//console.log(textString)
return textString;
};
export const isQuestionBinary = (question: QuestionFragment): boolean => {
const { options } = question;
return (
options.length === 2 &&
((options[0].name === "Yes" && options[1].name === "No") ||
(options[0].name === "No" && options[1].name === "Yes"))
);
};

58
src/web/worker/searchWithAlgolia.ts
View File

@ -1,18 +1,31 @@
import algoliasearch from "algoliasearch";
import { Hit } from "@algolia/client-search";
import { AlgoliaQuestion } from "../../backend/utils/algolia";
const client = algoliasearch(
process.env.NEXT_PUBLIC_ALGOLIA_APP_ID,
process.env.NEXT_PUBLIC_ALGOLIA_SEARCH_KEY
process.env.NEXT_PUBLIC_ALGOLIA_APP_ID || "",
process.env.NEXT_PUBLIC_ALGOLIA_SEARCH_KEY || ""
);
const index = client.initIndex("metaforecast");
let buildFilter = ({
interface SearchOpts {
queryString: string;
hitsPerPage?: number;
starsThreshold?: number;
filterByPlatforms?: string[];
forecastsThreshold?: number;
}
const buildFilter = ({
starsThreshold,
filterByPlatforms,
forecastsThreshold,
}) => {
}: Pick<
SearchOpts,
"starsThreshold" | "filterByPlatforms" | "forecastsThreshold"
>) => {
const starsFilter = starsThreshold
? `qualityindicators.stars >= ${starsThreshold}`
: null;
@ -20,7 +33,7 @@ let buildFilter = ({
? filterByPlatforms.map((platform) => `platform:"${platform}"`).join(" OR ")
: null;
const numForecastsFilter =
forecastsThreshold > 0
forecastsThreshold && forecastsThreshold > 0
? `qualityindicators.numforecasts >= ${forecastsThreshold}`
: null;
const finalFilter = [starsFilter, platformsFilter, numForecastsFilter]
@ -35,26 +48,15 @@ let buildFilter = ({
return finalFilter;
};
let buildFacetFilter = ({ filterByPlatforms }) => {
let platformsFilter = [];
if (filterByPlatforms.length > 0) {
platformsFilter = [
[filterByPlatforms.map((platform) => `platform:${platform}`)],
];
}
console.log(platformsFilter);
console.log(
"searchWithAlgolia.js/searchWithAlgolia/buildFacetFilter",
platformsFilter
);
return platformsFilter;
};
let noExactMatch = (queryString, result) => {
const noExactMatch = (queryString: string, result: Hit<AlgoliaQuestion>) => {
queryString = queryString.toLowerCase();
let title = result.title.toLowerCase();
let description = result.description.toLowerCase();
let optionsstringforsearch = result.optionsstringforsearch.toLowerCase();
const title = result.title.toLowerCase();
const description = result.description.toLowerCase();
const optionsstringforsearch = (
result.optionsstringforsearch || ""
).toLowerCase();
return !(
title.includes(queryString) ||
description.includes(queryString) ||
@ -62,14 +64,6 @@ let noExactMatch = (queryString, result) => {
);
};
interface SearchOpts {
queryString: string;
hitsPerPage?: number;
starsThreshold: number;
filterByPlatforms: string[];
forecastsThreshold: number;
}
// only query string
export default async function searchWithAlgolia({
queryString,

2
tsconfig.json
View File

@ -12,7 +12,7 @@
"dom.iterable",
"esnext"
],
"strict": false,
"strict": true,
"noEmit": true,
"incremental": true,
"moduleResolution": "node",