Datasets:
File size: 21,935 Bytes
7f9a652 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 | """Generators for the smaller remote ledgers (one module, several datasets)."""
import glob, os
import pandas as pd
from remote_util import latest, day_of, uniq
from common import cname, cname2
# ---------------------------------------------------------------- machine-economy-daily
class machine_economy:
DS = 'Lilambd/machine-economy-daily'
LICENSE = 'CC BY 4.0'
STR = {}
KEYS = {}
@staticmethod
def build(B):
root = B.store.root
SH = 'Machine Economy Daily'
f = latest(root, 'x402/hosts/*.csv')
if f:
machine_economy.KEYS[f] = ['host']
h = B.store[f]
on = f'In {SH} x402 hosts for {day_of(f)}'
for r in uniq(h, 'host').pipe(lambda d: d.loc[B.sample(d.index, 30)]).itertuples():
col = B.rng.choice(['resources', 'median_usdc', 'max_usdc', 'payees'])
B.add('lookup', f'{on}, what is the {col} value of the host {r.host}?', {'op': 'lookup', 'file': f, 'where': [['host', '==', r.host]], 'col': col}, tol={'rel': 0.0001}, skills=['table_lookup', 'agent_economy'])
B.add('rank', f'{on}, which host lists the most paid resources?', {'op': 'argmax', 'file': f, 'col': 'resources', 'return': 'host'}, difficulty=2, skills=['ranking', 'agent_economy'])
B.add('count', f'{on}, how many hosts are listed?', {'op': 'count', 'file': f}, skills=['count', 'agent_economy'])
for p in [0.001, 0.01, 0.1]:
B.add('count', f'{on}, how many hosts have a median price of at most {p} USDC?', {'op': 'count', 'file': f, 'where': [['median_usdc', '<=', p]]}, difficulty=2, skills=['filter', 'count', 'agent_economy'])
B.add('aggregate', f'{on}, how many paid resources are listed in total across all hosts?', {'op': 'sum', 'file': f, 'col': 'resources'}, tol={'abs': 0}, difficulty=2, skills=['aggregation', 'agent_economy'])
B.add('aggregate', f'{on}, what is the median of the hosts\' median prices in USDC?', {'op': 'median', 'file': f, 'col': 'median_usdc'}, tol={'rel': 0.001}, difficulty=3, skills=['aggregation', 'agent_economy'])
f = latest(root, 'npm_top/*.csv')
if f:
machine_economy.KEYS[f] = ['keyword', 'rank', 'package']
n = B.store[f]
on = f'In {SH} npm top packages for {day_of(f)}'
for r in n[~n.duplicated(['keyword', 'package'], keep=False)].pipe(lambda d: d.loc[B.sample(d.index, 30)]).itertuples():
col = B.rng.choice(['weekly_downloads', 'rank', 'dependents', 'version'])
B.add('lookup', f'{on}, under the keyword "{r.keyword}", what is the {col.replace("_", " ")} of {r.package}?', {'op': 'lookup', 'file': f, 'where': [['keyword', '==', r.keyword], ['package', '==', r.package]], 'col': col}, tol={'abs': 0}, skills=['table_lookup', 'agent_economy'])
for k in sorted(n.keyword.dropna().unique()):
B.add('lookup', f'{on}, which package is ranked #1 under the keyword "{k}"?', {'op': 'lookup', 'file': f, 'where': [['keyword', '==', k], ['rank', '==', 1]], 'col': 'package'}, skills=['table_lookup', 'agent_economy'])
B.add('rank', f'{on}, under the keyword "{k}", which package has the most dependents?', {'op': 'argmax', 'file': f, 'where': [['keyword', '==', k]], 'col': 'dependents', 'return': 'package'}, difficulty=2, skills=['ranking', 'agent_economy'])
f = latest(root, 'hf_trending/*.csv')
if f:
machine_economy.KEYS[f] = ['kind', 'rank', 'id']
h = B.store[f]
on = f'In {SH} Hugging Face trending for {day_of(f)}'
for r in h[~h.duplicated(['kind', 'id'], keep=False)].pipe(lambda d: d.loc[B.sample(d.index, 25)]).itertuples():
col = B.rng.choice(['likes', 'downloads', 'rank'])
B.add('lookup', f'{on}, what is the {col} value of the {r.kind[:-1]} {r.id}?', {'op': 'lookup', 'file': f, 'where': [['kind', '==', r.kind], ['id', '==', r.id]], 'col': col}, tol={'abs': 0}, skills=['table_lookup'])
for k in sorted(h.kind.dropna().unique()):
B.add('rank', f'{on}, among trending {k}, which has the most likes?', {'op': 'argmax', 'file': f, 'where': [['kind', '==', k]], 'col': 'likes', 'return': 'id'}, difficulty=2, skills=['ranking'])
f = latest(root, 'mcp/new/*.csv')
if f:
machine_economy.KEYS[f] = ['name']
m = B.store[f]
on = f'In {SH} new MCP registry entries for {day_of(f)}'
for r in uniq(m, 'name').pipe(lambda d: d.loc[B.sample(d.index, 25)]).itertuples():
col = B.rng.choice(['version', 'title'])
if getattr(r, col) != getattr(r, col):
continue
B.add('lookup', f'{on}, what is the {col} of the MCP server {r.name}?', {'op': 'lookup', 'file': f, 'where': [['name', '==', r.name]], 'col': col}, skills=['table_lookup', 'agent_economy'])
B.add('count', f'{on}, how many new or updated MCP servers are listed?', {'op': 'count', 'file': f}, skills=['count', 'agent_economy'])
B.add('count', f'{on}, how many listed servers offer a streamable-http remote?', {'op': 'count', 'file': f, 'where': [['remotes', 'contains', 'streamable-http']]}, difficulty=2, skills=['filter', 'count', 'text_match', 'agent_economy'])
B.add('count', f'{on}, how many listed servers have no remote endpoint (remotes empty)?', {'op': 'count', 'file': f, 'where': [['remotes', 'isna', None]]}, difficulty=2, skills=['filter', 'count', 'agent_economy'])
for nm in ['com.lilambd/hibe-oracle', 'io.example/nonexistent-mcp']:
B.add('unanswerable', f'{on}, what version is the MCP server {nm}? If it is not listed, answer null.', {'op': 'absent', 'file': f, 'where': [['name', '==', nm]]}, skills=['abstention'])
# ---------------------------------------------------------------- world-seeds
class seeds:
DS = 'Lilambd/world-seeds'
LICENSE = 'CC BY-SA 4.0'
STR = {'index.csv': ['revid']}
KEYS = {'index.csv': ['file']}
@staticmethod
def build(B):
root = B.store.root
SH = 'World Seeds (Wikipedia "by country" tables)'
idx = B.store['index.csv']
for r in idx.loc[B.sample(idx.index, 30)].itertuples():
B.add('lookup', f'In {SH}, how many countries does the table "{r.title}" cover?', {'op': 'lookup', 'file': 'index.csv', 'where': [['file', '==', r.file]], 'col': 'countries'}, tol={'abs': 0}, skills=['table_lookup', 'provenance'])
for r in idx.loc[B.sample(idx.index, 15)].itertuples():
B.add('lookup', f'In {SH}, which Wikipedia revision id was the table "{r.title}" taken from?', {'op': 'lookup', 'file': 'index.csv', 'where': [['file', '==', r.file]], 'col': 'revid'}, skills=['provenance'])
files = list(idx.file)
made = 0
for fp in B.sample(files, len(files)):
if made >= 70 or not os.path.exists(os.path.join(root, fp)):
continue
t = B.store[fp]
if 'iso2' not in t.columns:
continue
seeds.STR[fp] = ['iso2']
seeds.KEYS[fp] = ['iso2', 'country']
title = idx[idx.file == fp].title.iloc[0]
numc = [c for c in t.columns if c.endswith('_num') and pd.to_numeric(t[c], errors='coerce').notna().sum() >= 10]
if not numc:
continue
tu = t[t.iso2.notna() & ~t.duplicated(['iso2'], keep=False)]
col = B.rng.choice(numc)
label = col[:-4]
for r in tu[pd.to_numeric(tu[col], errors='coerce').notna()].pipe(lambda d: d.loc[B.sample(d.index, 2)]).to_dict('records'):
if B.add('lookup', f'In {SH}, table "{title}": what is the value of "{label}" for {cname2(r["iso2"])}? (numeric column {col})', {'op': 'lookup', 'file': fp, 'where': [['iso2', '==', r['iso2']]], 'col': col}, tol={'rel': 0.001}, skills=['table_lookup', 'code_resolution']):
made += 1
B.add('rank', f'In {SH}, table "{title}": which country (ISO2) has the highest "{label}" ({col})?', {'op': 'argmax', 'file': fp, 'col': col, 'return': 'iso2'}, difficulty=2, skills=['ranking'])
B.add('count', f'In {SH}, table "{title}": for how many countries is "{label}" ({col}) filled in?', {'op': 'count', 'file': fp, 'where': [[col, 'notna', None]]}, difficulty=2, skills=['count'])
# ---------------------------------------------------------------- japan-dpc-hospitals
class dpc:
DS = 'Lilambd/japan-dpc-hospitals'
LICENSE = 'CC BY 4.0'
STR = {'hospitals.csv': ['id', 'city_code'], 'top100_mdc.csv': ['id']}
KEYS = {'hospitals.csv': ['id', 'name'], 'top100_mdc.csv': ['id', 'name']}
MDC = {'m01': 'nervous system', 'm02': 'eye', 'm03': 'ear, nose, mouth and throat', 'm04': 'respiratory', 'm05': 'circulatory', 'm06': 'digestive', 'm07': 'musculoskeletal',
'm08': 'skin', 'm09': 'breast', 'm10': 'endocrine and metabolic', 'm11': 'kidney and urinary', 'm12': 'female reproductive', 'm13': 'blood', 'm14': 'newborn',
'm15': 'paediatric', 'm16': 'trauma and poisoning', 'm17': 'mental', 'm18': 'other'}
@staticmethod
def build(B):
SH = 'Japan DPC Hospitals'
h = B.store['hospitals.csv']
hu = uniq(h, 'name')
for r in hu.loc[B.sample(hu.index, 50)].itertuples():
col = B.rng.choice(['beds', 'discharges', 'pref_en'])
t = {'beds': f'In {SH}, how many beds does 「{r.name}」 have?', 'discharges': f'In {SH}, how many discharges are recorded for 「{r.name}」?', 'pref_en': f'In {SH}, in which prefecture is 「{r.name}」? Answer in English.'}[col]
B.add('lookup', t, {'op': 'lookup', 'file': 'hospitals.csv', 'where': [['id', '==', r.id]], 'col': col}, tol={'abs': 0}, skills=['table_lookup', 'multilingual_entity'])
for p in sorted(h.pref_en.dropna().unique()):
B.add('count', f'In {SH}, how many DPC hospitals are listed in {p} prefecture?', {'op': 'count', 'file': 'hospitals.csv', 'where': [['pref_en', '==', p]]}, skills=['filter', 'count'])
B.add('rank', f'In {SH}, which hospital in {p} has the most discharges? Give its name as written.', {'op': 'argmax', 'file': 'hospitals.csv', 'where': [['pref_en', '==', p]], 'col': 'discharges', 'return': 'name'}, difficulty=2, skills=['ranking', 'multilingual_entity'])
for p in B.sample(sorted(h.pref_en.dropna().unique()), 20):
B.add('aggregate', f'In {SH}, how many beds in total do the listed DPC hospitals of {p} have?', {'op': 'sum', 'file': 'hospitals.csv', 'where': [['pref_en', '==', p]], 'col': 'beds'}, tol={'abs': 0}, difficulty=2, skills=['aggregation'])
B.add('rank', f'In {SH}, list the 5 hospitals with the most beds, most first.', {'op': 'topk', 'k': 5, 'file': 'hospitals.csv', 'col': 'beds', 'return': 'name'}, difficulty=2, skills=['ranking'], answer_format='JSON list')
for _ in range(15):
a, b = hu.sample(2, random_state=B.rng.randint(0, 1 << 30)).to_dict('records')
B.add('compare', f"In {SH}, which hospital has more beds: 「{a['name']}」 or 「{b['name']}」?", {'op': 'compare', 'labels': [a['name'], b['name']], 'parts': [
{'op': 'lookup', 'file': 'hospitals.csv', 'where': [['id', '==', a['id']]], 'col': 'beds'}, {'op': 'lookup', 'file': 'hospitals.csv', 'where': [['id', '==', b['id']]], 'col': 'beds'}]}, difficulty=2, skills=['comparison'])
t = B.store['top100_mdc.csv']
for r in uniq(t, 'name').pipe(lambda d: d.loc[B.sample(d.index, 30)]).to_dict('records'):
m = B.rng.choice(list(dpc.MDC))
kind = B.rng.choice(['all', 'ope'])
B.add('lookup', f"In {SH} top-100 table, how many {'surgical ' if kind == 'ope' else ''}cases in MDC {m[1:]} ({dpc.MDC[m]}) does 「{r['name']}」 have?", {'op': 'lookup', 'file': 'top100_mdc.csv', 'where': [['id', '==', r['id']]], 'col': f'{m}_{kind}'}, tol={'abs': 0}, skills=['table_lookup', 'multilingual_entity'])
for m in dpc.MDC:
B.add('rank', f'In {SH} top-100 table, which hospital has the most cases in MDC {m[1:]} ({dpc.MDC[m]})?', {'op': 'argmax', 'file': 'top100_mdc.csv', 'col': f'{m}_all', 'return': 'name'}, difficulty=2, skills=['ranking'])
for nm in ['湧水総合医療センター', 'リランブ記念病院']:
B.add('unanswerable', f'In {SH}, how many beds does 「{nm}」 have? If it is not listed, answer null.', {'op': 'absent', 'file': 'hospitals.csv', 'where': [['name', '==', nm]]}, skills=['abstention'])
# ---------------------------------------------------------------- japan-prefecture-facts
class prefecture:
DS = 'Lilambd/japan-prefecture-facts'
LICENSE = 'CC BY 4.0 (facts from Japanese government open data, 政府標準利用規約2.0)'
STR = {'facts.csv': ['pref_code', 'period']}
KEYS = {'facts.csv': ['topic', 'pref_en']}
@staticmethod
def build(B):
SH = 'Japan by Prefecture'
f = B.store['facts.csv']
tu = f[~f.duplicated(['topic', 'pref_en'], keep=False)]
ind = tu.groupby('topic').indicator_ja.first().to_dict()
unit = tu.groupby('topic').unit.first().to_dict()
for r in tu.loc[B.sample(tu.index, 120)].itertuples():
B.add('lookup', f'In {SH}, what is 「{r.indicator_ja}」 (topic {r.topic}, unit {r.unit}, period {r.period}) for {r.pref_en}?', {'op': 'lookup', 'file': 'facts.csv', 'where': [['topic', '==', r.topic], ['pref_en', '==', r.pref_en]], 'col': 'value'},
unit=r.unit, tol={'rel': 0.001}, skills=['table_lookup', 'multilingual_entity'])
for tp in sorted(ind):
B.add('rank', f'In {SH}, which prefecture has the highest 「{ind[tp]}」 (topic {tp})?', {'op': 'argmax', 'file': 'facts.csv', 'where': [['topic', '==', tp]], 'col': 'value', 'return': 'pref_en'}, difficulty=2, skills=['ranking'])
B.add('rank', f'In {SH}, which prefecture has the lowest 「{ind[tp]}」 (topic {tp})?', {'op': 'argmin', 'file': 'facts.csv', 'where': [['topic', '==', tp]], 'col': 'value', 'return': 'pref_en'}, difficulty=2, skills=['ranking'])
vals = pd.to_numeric(tu[tu.topic == tp].value, errors='coerce').dropna()
if len(vals) > 20:
thr = float(f'{vals.median():.4g}')
B.add('count', f'In {SH}, for how many prefectures is 「{ind[tp]}」 (topic {tp}) above {thr:g} {unit[tp]}?', {'op': 'count', 'file': 'facts.csv', 'where': [['topic', '==', tp], ['value', '>', thr]]}, difficulty=2, skills=['filter', 'count'])
for _ in range(30):
tp = B.rng.choice(sorted(ind))
a, b = B.sample(sorted(tu[tu.topic == tp].pref_en), 2)
B.add('compare', f'In {SH}, which prefecture has the higher 「{ind[tp]}」 (topic {tp}): {a} or {b}?', {'op': 'compare', 'labels': [a, b], 'parts': [
{'op': 'lookup', 'file': 'facts.csv', 'where': [['topic', '==', tp], ['pref_en', '==', a]], 'col': 'value'}, {'op': 'lookup', 'file': 'facts.csv', 'where': [['topic', '==', tp], ['pref_en', '==', b]], 'col': 'value'}]}, difficulty=2, skills=['comparison'])
for r in tu.loc[B.sample(tu.index, 20)].itertuples():
B.add('multi_hop', f'In {SH}, what is the topic "{r.topic}" value for the prefecture written 「{r.pref_ja}」?', {'op': 'lookup', 'file': 'facts.csv', 'where': [['topic', '==', r.topic], ['pref_ja', '==', r.pref_ja]], 'col': 'value'}, tol={'rel': 0.001}, skills=['multilingual_entity'])
# ---------------------------------------------------------------- world-biodiversity-cells
class biodiversity:
DS = 'Lilambd/world-biodiversity-cells'
LICENSE = 'CC BY-NC 4.0 (questions on *_open columns only may be used under CC BY 4.0)'
STR = {'cells.parquet': ['country', 'admin1']}
KEYS = {'cells.parquet': ['cell_id', 'country'], 'world_totals.csv': ['kingdom', 'class', 'basis', 'decade']}
@staticmethod
def build(B):
SH = 'World Biodiversity Cells (GBIF, 0.5° grid)'
c = B.store['cells.parquet']
cr = c[c.records > 0]
for r in cr.loc[B.sample(cr.index, 50)].itertuples():
col = B.rng.choice(['records', 'species', 'species_birds', 'records_2020s', 'first_year', 'species_only_in_this_cell'])
B.add('lookup', f'In {SH}, what is {col} for cell_id {r.cell_id} (centre {r.lat_center}, {r.lon_center})?', {'op': 'lookup', 'file': 'cells.parquet', 'where': [['cell_id', '==', int(r.cell_id)]], 'col': col}, tol={'abs': 0}, skills=['id_lookup', 'geo'])
cc = c[c.country.notna()].groupby('country').size()
for k in B.sample(list(cc[cc >= 30].index), 40):
col = B.rng.choice(['species', 'records'])
B.add('rank', f'In {SH}, which cell_id in {cname(k)} has the most recorded {col}?', {'op': 'argmax', 'file': 'cells.parquet', 'where': [['country', '==', k]], 'col': col, 'return': 'cell_id'}, difficulty=2, skills=['ranking', 'geo'])
B.add('count', f'In {SH}, how many land-mesh cells in {cname(k)} have no record at all?', {'op': 'count', 'file': 'cells.parquet', 'where': [['country', '==', k], ['records', '==', 0]]}, difficulty=2, skills=['filter', 'count', 'geo'])
B.add('aggregate', f'In {SH}, how many GBIF records in total fall in cells assigned to {cname(k)}?', {'op': 'sum', 'file': 'cells.parquet', 'where': [['country', '==', k]], 'col': 'records'}, tol={'abs': 0}, difficulty=2, skills=['aggregation', 'geo'])
B.add('rank', f'In {SH}, which cell_id has the most recorded species in the whole grid?', {'op': 'argmax', 'file': 'cells.parquet', 'col': 'species', 'return': 'cell_id'}, difficulty=2, skills=['ranking', 'full_scan'])
w = B.store['world_totals.csv']
wu = w[~w.duplicated(['kingdom', 'class', 'basis', 'decade'], keep=False)]
for r in wu.loc[B.sample(wu.index, 40)].to_dict('records'):
dec = 'with no year' if r['decade'] == -1 else f"from the {r['decade']}s"
B.add('lookup', f"In {SH} world totals, how many {r['basis']} records of {r['kingdom']} / {r['class']} are {dec}?", {'op': 'lookup', 'file': 'world_totals.csv', 'where': [['kingdom', '==', r['kingdom']], ['class', '==', r['class']], ['basis', '==', r['basis']], ['decade', '==', int(r['decade'])]], 'col': 'records'}, tol={'abs': 0}, skills=['table_lookup'])
for k in sorted(w.kingdom.dropna().unique()):
B.add('aggregate', f'In {SH} world totals, how many records of kingdom {k} are there in total?', {'op': 'sum', 'file': 'world_totals.csv', 'where': [['kingdom', '==', k]], 'col': 'records'}, tol={'abs': 0}, difficulty=2, skills=['aggregation'])
B.add('rank', f'In {SH} world totals, which class of kingdom {k} has the most records summed over all decades and bases?', {'op': 'group_top', 'file': 'world_totals.csv', 'where': [['kingdom', '==', k]], 'by': 'class', 'agg': 'sum', 'col': 'records'}, difficulty=3, skills=['group_by', 'aggregation'])
for d in [1970, 1980, 1990, 2000, 2010, 2020]:
B.add('aggregate', f'In {SH} world totals, how many records (all kingdoms) are from the {d}s?', {'op': 'sum', 'file': 'world_totals.csv', 'where': [['decade', '==', d]], 'col': 'records'}, tol={'abs': 0}, difficulty=2, skills=['aggregation', 'temporal'])
# ---------------------------------------------------------------- world-markets
class markets:
DS = 'Lilambd/world-markets'
LICENSE = 'CDLA-Permissive-2.0'
STR = {'markets.parquet': ['id', 'country_iso2', 'region']}
KEYS = {'markets.parquet': ['id', 'name']}
@staticmethod
def build(B):
SH = 'World Markets'
m = B.store['markets.parquet']
mn = m[m.name.notna()]
for r in mn.loc[B.sample(mn.index, 60)].itertuples():
col = B.rng.choice(['town', 'kind', 'country_iso2'])
if getattr(r, col) != getattr(r, col) or getattr(r, col) is None:
continue
B.add('lookup', f'In {SH}, what is the {col.replace("_iso2", " (ISO2)")} of market {r.id} ("{r.name}")?', {'op': 'lookup', 'file': 'markets.parquet', 'where': [['id', '==', r.id]], 'col': col}, skills=['id_lookup'])
oc = m.groupby(['country_iso2', 'kind']).size()
for (c, k) in B.sample(list(oc[oc >= 20].index), 60):
B.add('count', f'In {SH}, how many markets of kind "{k}" are listed in {cname2(c)}?', {'op': 'count', 'file': 'markets.parquet', 'where': [['country_iso2', '==', c], ['kind', '==', k]]}, difficulty=2, skills=['filter', 'count', 'full_scan'])
cc = m.groupby('country_iso2').size()
for c in B.sample(list(cc[cc >= 200].index), 35):
B.add('rank', f'In {SH}, which town in {cname2(c)} has the most markets listed?', {'op': 'group_top', 'file': 'markets.parquet', 'where': [['country_iso2', '==', c]], 'by': 'town'}, difficulty=3, skills=['group_by', 'ranking'])
B.add('rank', f'In {SH}, which kind of market is most common in {cname2(c)}?', {'op': 'group_top', 'file': 'markets.parquet', 'where': [['country_iso2', '==', c]], 'by': 'kind'}, difficulty=2, skills=['group_by'])
for k in sorted(m.kind.dropna().unique()):
B.add('rank', f'In {SH}, which country (ISO2) has the most markets of kind "{k}"?', {'op': 'group_top', 'file': 'markets.parquet', 'where': [['kind', '==', k]], 'by': 'country_iso2'}, difficulty=2, skills=['group_by', 'full_scan'])
B.add('count', f'In {SH}, how many markets of kind "{k}" are listed worldwide?', {'op': 'count', 'file': 'markets.parquet', 'where': [['kind', '==', k]]}, skills=['count', 'full_scan'])
|