10854685536

Committed 13 Sep 2024 07:03PM UTC coverage: 31.866% (-0.006%) from 31.872%

Build # 10854685536

Build Type

push

github

Committed by

ben-pace

Commit Message

mostly done i think

Run Details

5079 of 41326 branches covered (12.29%)

Branch coverage included in aggregate %.

16 of 30 new or added lines in 10 files covered. (53.33%)

177 existing lines in 8 files now uncovered.

29400 of 66873 relevant lines covered (43.96%)

185.15 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

12.82

/packages/lesswrong/lib/collections/posts/annualReviewMarkets.ts

import { manifoldAPIKeySetting, highlightReviewWinnerThresholdSetting } from "../../instanceSettings";
import { loadByIds } from "../../loaders";
import { filterNonnull } from "../../utils/typeGuardUtils";

// Information about a market, but without bets or comments
type LiteMarket = {
  // Unique identifer for this market
  id: string

  // Attributes about the creator
  creatorId: string
  creatorUsername: string
  creatorName: string
  creatorAvatarUrl?: string

  // Market atributes
  createdTime: number // When the market was created
  closeTime?: number // Min of creator's chosen date, and resolutionTime
  question: string

  // Note: This url always points to https://manifold.markets, regardless of what instance the api is running on.
  // This url includes the creator's username, but this doesn't need to be correct when constructing valid URLs.
  //   i.e. https://manifold.markets/Austin/test-market is the same as https://manifold.markets/foo/test-market
  url: string

  outcomeType: string // BINARY, FREE_RESPONSE, MULTIPLE_CHOICE, NUMERIC, PSEUDO_NUMERIC, BOUNTIED_QUESTION, POLL, or ...
  mechanism: string // dpm-2, cpmm-1, or cpmm-multi-1

  probability: number
  pool: { outcome: number } // For CPMM markets, the number of shares in the liquidity pool. For DPM markets, the amount of mana invested in each answer.
  p?: number // CPMM markets only, probability constant in y^p * n^(1-p) = k
  totalLiquidity?: number // CPMM markets only, the amount of mana deposited into the liquidity pool

  value?: number // PSEUDO_NUMERIC markets only, the current market value, which is mapped from probability using min, max, and isLogScale.
  min?: number // PSEUDO_NUMERIC markets only, the minimum resolvable value
  max?: number // PSEUDO_NUMERIC markets only, the maximum resolvable value
  isLogScale?: boolean // PSEUDO_NUMERIC markets only, if true `number = (max - min + 1)^probability + minstart - 1`, otherwise `number = min + (max - min) * probability`

  volume: number
  volume24Hours: number

  isResolved: boolean
  resolutionTime?: number
  resolution?: string
  resolutionProbability?: number // Used for BINARY markets resolved to MKT
  uniqueBettorCount: number

  lastUpdatedTime?: number
  lastBetTime?: number
}

export type AnnualReviewMarketInfo = {
  probability: number;
  isResolved: boolean;
  year: number;
  url: string;
}

export const getMarketInfo = (post: PostsBase): AnnualReviewMarketInfo | undefined => {
  if (typeof post.annualReviewMarketProbability !== 'number') return undefined
  if (typeof post.annualReviewMarketIsResolved !== 'boolean') return undefined
  if (typeof post.annualReviewMarketYear !== 'number') return undefined
  if (typeof post.annualReviewMarketUrl !== 'string') return undefined
  return {
    probability: post.annualReviewMarketProbability,
    isResolved: post.annualReviewMarketIsResolved,
    year: post.annualReviewMarketYear,
    url: post.annualReviewMarketUrl,
  }
}

export const highlightMarket = (info: AnnualReviewMarketInfo | undefined): boolean =>
  !!info && !info.isResolved && info.probability > highlightReviewWinnerThresholdSetting.get()


const manifoldAPIKey = manifoldAPIKeySetting.get()

export const postGetMarketInfoFromManifold = async (post: DbPost): Promise<AnnualReviewMarketInfo | null > => {
  if (!post.manifoldReviewMarketId) return null;

  const result = await fetch(`https://api.manifold.markets./v0/market/${post.manifoldReviewMarketId}`, {
    method: "GET",
    headers: {
      "content-type": "application/json"
    },
  })
  
  if (!result.ok) {
    //eslint-disable-next-line no-console
    console.error(`HTTP error! status: ${result.status}`); 
    return null
  }

  const fullMarket = await result.json()
  
  return { probability: fullMarket.probability, isResolved: fullMarket.isResolved, year: post.postedAt.getFullYear(), url: fullMarket.url }
}

export const createManifoldMarket = async (question: string, descriptionMarkdown: string, closeTime: Date, visibility: string, initialProb: number): Promise<LiteMarket | undefined> => {
  
  //eslint-disable-next-line no-console
  if (!manifoldAPIKey) console.error("Manifold API key not found");

  const manifoldLessWrongAnnualReviewTag = "0a0b0d16-7a4b-4de5-aadf-ddd85fbefe5c"
  try {
    const result = await fetch("https://api.manifold.markets/v0/market", {
      method: "POST",
      headers: {
        authorization: `Key ${manifoldAPIKey}`,
        "content-type": "application/json"
      },
      body: JSON.stringify({
        outcomeType: "BINARY",
        question,
        descriptionMarkdown,
        closeTime: Number(closeTime),
        visibility,
        initialProb,
        groupIds: [manifoldLessWrongAnnualReviewTag]
      })
    })

    if (!result.ok) {
      throw new Error(`HTTP error! status: ${result.status}`);
    }

    return result.json()
  } catch (error) {

    //eslint-disable-next-line no-console
    console.error('There was a problem with the fetch operation for creating a Manifold Market: ', error);
    return undefined;
  }
}



async function refreshMarketInfoInCache(post: DbPost, context: ResolverContext) {
  const marketInfo = await postGetMarketInfoFromManifold(post);
  if (!marketInfo || !post.manifoldReviewMarketId) return null;

  await context.repos.manifoldProbabilitiesCachesRepo.upsertMarketInfoInCache(post.manifoldReviewMarketId, marketInfo);
}

export const getPostMarketInfo = async (post: DbPost, context: ResolverContext): Promise<AnnualReviewMarketInfo | undefined>  => {
  if (!post.manifoldReviewMarketId) {
    return undefined;
  }
  
  const cacheItem = await context.ManifoldProbabilitiesCaches.findOne({
    marketId: post.manifoldReviewMarketId
  });

  if (!cacheItem) {
    void refreshMarketInfoInCache(post, context)
    return undefined;
  }

  const timeDifference = new Date().getTime() - cacheItem.lastUpdated.getTime();

  if (timeDifference >= 10_000) {
    void refreshMarketInfoInCache(post, context);
  }

  return { probability: cacheItem.probability, isResolved: cacheItem.isResolved, year: cacheItem.year, url: cacheItem.url };
}

/**
 * This function requires currying a resolver context into it so that we can use dataloaders, otherwise when we get a list of posts we end up doing another round trip in here
 */
export const marketInfoLoader = (context: ResolverContext) => async (postIds: string[]) => {
  const posts = filterNonnull(await loadByIds(context, 'Posts', postIds));
  const postMarketInfoPairs = await Promise.all(posts.map(async (post) => ([
    post._id,
    await getPostMarketInfo(post, context)
  ] as const)));

  // Custom loaders are sensitive to the order of ids > entries, and postgres doesn't return things in any guaranteed order
  const postMarketInfoMapping = Object.fromEntries(postMarketInfoPairs);
  return postIds.map(postId => postMarketInfoMapping[postId]);
};

1	import { manifoldAPIKeySetting, highlightReviewWinnerThresholdSetting } from "../../instanceSettings";	75✔
2	import { loadByIds } from "../../loaders";	25✔
3	import { filterNonnull } from "../../utils/typeGuardUtils";	25✔
4
5	// Information about a market, but without bets or comments
6	type LiteMarket = {
7	// Unique identifer for this market
8	id: string
9
10	// Attributes about the creator
11	creatorId: string
12	creatorUsername: string
13	creatorName: string
14	creatorAvatarUrl?: string
15
16	// Market atributes
17	createdTime: number // When the market was created
18	closeTime?: number // Min of creator's chosen date, and resolutionTime
19	question: string
20
21	// Note: This url always points to https://manifold.markets, regardless of what instance the api is running on.
22	// This url includes the creator's username, but this doesn't need to be correct when constructing valid URLs.
23	// i.e. https://manifold.markets/Austin/test-market is the same as https://manifold.markets/foo/test-market
24	url: string
25
26	outcomeType: string // BINARY, FREE_RESPONSE, MULTIPLE_CHOICE, NUMERIC, PSEUDO_NUMERIC, BOUNTIED_QUESTION, POLL, or ...
27	mechanism: string // dpm-2, cpmm-1, or cpmm-multi-1
28
29	probability: number
30	pool: { outcome: number } // For CPMM markets, the number of shares in the liquidity pool. For DPM markets, the amount of mana invested in each answer.
31	p?: number // CPMM markets only, probability constant in y^p * n^(1-p) = k
32	totalLiquidity?: number // CPMM markets only, the amount of mana deposited into the liquidity pool
33
34	value?: number // PSEUDO_NUMERIC markets only, the current market value, which is mapped from probability using min, max, and isLogScale.
35	min?: number // PSEUDO_NUMERIC markets only, the minimum resolvable value
36	max?: number // PSEUDO_NUMERIC markets only, the maximum resolvable value
37	isLogScale?: boolean // PSEUDO_NUMERIC markets only, if true `number = (max - min + 1)^probability + minstart - 1`, otherwise `number = min + (max - min) * probability`
38
39	volume: number
40	volume24Hours: number
41
42	isResolved: boolean
43	resolutionTime?: number
44	resolution?: string
45	resolutionProbability?: number // Used for BINARY markets resolved to MKT
46	uniqueBettorCount: number
47
48	lastUpdatedTime?: number
49	lastBetTime?: number
50	}
51
52	export type AnnualReviewMarketInfo = {
53	probability: number;
54	isResolved: boolean;
55	year: number;
56	url: string;
57	}
58
59	export const getMarketInfo = (post: PostsBase): AnnualReviewMarketInfo \| undefined => {	25✔
NEW 60	if (typeof post.annualReviewMarketProbability !== 'number') return undefined	×
NEW 61	if (typeof post.annualReviewMarketIsResolved !== 'boolean') return undefined	×
NEW 62	if (typeof post.annualReviewMarketYear !== 'number') return undefined	×
NEW 63	if (typeof post.annualReviewMarketUrl !== 'string') return undefined	×
NEW 64	return {	×
65	probability: post.annualReviewMarketProbability,
66	isResolved: post.annualReviewMarketIsResolved,
67	year: post.annualReviewMarketYear,
68	url: post.annualReviewMarketUrl,
69	}
70	}
71
72	export const highlightMarket = (info: AnnualReviewMarketInfo \| undefined): boolean =>	25✔
NEW 73	!!info && !info.isResolved && info.probability > highlightReviewWinnerThresholdSetting.get()	×
74
75
76	const manifoldAPIKey = manifoldAPIKeySetting.get()	25✔
77
78	export const postGetMarketInfoFromManifold = async (post: DbPost): Promise<AnnualReviewMarketInfo \| null > => {	25✔
79	if (!post.manifoldReviewMarketId) return null;	×
80
81	const result = await fetch(`https://api.manifold.markets./v0/market/${post.manifoldReviewMarketId}`, {	×
82	method: "GET",
83	headers: {
84	"content-type": "application/json"
85	},
86	})
87
88	if (!result.ok) {	×
89	//eslint-disable-next-line no-console
90	console.error(`HTTP error! status: ${result.status}`);	×
91	return null	×
92	}
93
94	const fullMarket = await result.json()	×
95
NEW 96	return { probability: fullMarket.probability, isResolved: fullMarket.isResolved, year: post.postedAt.getFullYear(), url: fullMarket.url }	×
97	}
98
99	export const createManifoldMarket = async (question: string, descriptionMarkdown: string, closeTime: Date, visibility: string, initialProb: number): Promise<LiteMarket \| undefined> => {	25✔
100
101	//eslint-disable-next-line no-console
102	if (!manifoldAPIKey) console.error("Manifold API key not found");	×
103
104	const manifoldLessWrongAnnualReviewTag = "0a0b0d16-7a4b-4de5-aadf-ddd85fbefe5c"	×
105	try {	×
106	const result = await fetch("https://api.manifold.markets/v0/market", {	×
107	method: "POST",
108	headers: {
109	authorization: `Key ${manifoldAPIKey}`,
110	"content-type": "application/json"
111	},
112	body: JSON.stringify({
113	outcomeType: "BINARY",
114	question,
115	descriptionMarkdown,
116	closeTime: Number(closeTime),
117	visibility,
118	initialProb,
119	groupIds: [manifoldLessWrongAnnualReviewTag]
120	})
121	})
122
123	if (!result.ok) {	×
124	throw new Error(`HTTP error! status: ${result.status}`);	×
125	}
126
127	return result.json()	×
128	} catch (error) {
129
130	//eslint-disable-next-line no-console
131	console.error('There was a problem with the fetch operation for creating a Manifold Market: ', error);	×
132	return undefined;	×
133	}
134	}
135
136
137
138	async function refreshMarketInfoInCache(post: DbPost, context: ResolverContext) {
139	const marketInfo = await postGetMarketInfoFromManifold(post);	×
140	if (!marketInfo \|\| !post.manifoldReviewMarketId) return null;	×
141
142	await context.repos.manifoldProbabilitiesCachesRepo.upsertMarketInfoInCache(post.manifoldReviewMarketId, marketInfo);	×
143	}
144
145	export const getPostMarketInfo = async (post: DbPost, context: ResolverContext): Promise<AnnualReviewMarketInfo \| undefined> => {	25✔
146	if (!post.manifoldReviewMarketId) {	×
147	return undefined;	×
148	}
149
NEW 150	const cacheItem = await context.ManifoldProbabilitiesCaches.findOne({	×
151	marketId: post.manifoldReviewMarketId
152	});
153
154	if (!cacheItem) {	×
NEW 155	void refreshMarketInfoInCache(post, context)	×
156	return undefined;	×
157	}
158
159	const timeDifference = new Date().getTime() - cacheItem.lastUpdated.getTime();	×
160
161	if (timeDifference >= 10_000) {	×
NEW 162	void refreshMarketInfoInCache(post, context);	×
163	}
164
165	return { probability: cacheItem.probability, isResolved: cacheItem.isResolved, year: cacheItem.year, url: cacheItem.url };	×
166	}
167
168	/**
169	* This function requires currying a resolver context into it so that we can use dataloaders, otherwise when we get a list of posts we end up doing another round trip in here
170	*/
171	export const marketInfoLoader = (context: ResolverContext) => async (postIds: string[]) => {	25✔
172	const posts = filterNonnull(await loadByIds(context, 'Posts', postIds));	×
173	const postMarketInfoPairs = await Promise.all(posts.map(async (post) => ([	×
174	post._id,
175	await getPostMarketInfo(post, context)
176	] as const)));
177
178	// Custom loaders are sensitive to the order of ids > entries, and postgres doesn't return things in any guaranteed order
179	const postMarketInfoMapping = Object.fromEntries(postMarketInfoPairs);	×
180	return postIds.map(postId => postMarketInfoMapping[postId]);	×
181	};

ForumMagnum / ForumMagnum / 10854685536

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous