add manag script + checksums

calo_hits.sha256

@@ -0,0 +1,100 @@
+c1bf988c8a11897bb571143de2a19621738d24b5034c1121b81e33dc25e650f5  hard_scatter.ggf.v1.reco.calo_hits.events0-999.parquet
+3f8510cfd34751403a8bc8ed2d18659a1fa6edc53cbe2bbbb33525826c5f3d41  hard_scatter.ggf.v1.reco.calo_hits.events1000-1999.parquet
+5b7a8c042f811dd90c3792fc5f636f089a0667b937b2172e8b70cde2c21fe102  hard_scatter.ggf.v1.reco.calo_hits.events10000-10999.parquet
+5b91f0be4bfc3e59d1177f475b2dbf3cdb11cd83eb09d5d00927d37edb851588  hard_scatter.ggf.v1.reco.calo_hits.events11000-11999.parquet
+dea9741603fa74a112f2ef8d7db1b693491c1f71af77c6ab3347de582adedca6  hard_scatter.ggf.v1.reco.calo_hits.events12000-12999.parquet
+3f3e40e35f93ac49bb386f2dd0219598c911d9ea866337b2e4a04f9ed7cf903a  hard_scatter.ggf.v1.reco.calo_hits.events13000-13999.parquet
+5f7dc938260e67c956ccde0eb9aa402d3dbaadf2becb811ac9550ad451ebad37  hard_scatter.ggf.v1.reco.calo_hits.events14000-14999.parquet
+f7813318e3444dd13c0ff30c7999a34bd08b14c10aa0f04f87e4465386e6249b  hard_scatter.ggf.v1.reco.calo_hits.events15000-15999.parquet
+e73e314b9533b3f3f8b8059be5e61b1e29ac8a0beddd0cdc149a599d2824116d  hard_scatter.ggf.v1.reco.calo_hits.events16000-16999.parquet
+d29301c5e55a47f4c68d6e63173324b696b53da71057c57e9147c6852678931e  hard_scatter.ggf.v1.reco.calo_hits.events17000-17999.parquet
+aeb94e4eb71f4930068c56f6a82464a2b53d132a38560fbe319aefb18191bca7  hard_scatter.ggf.v1.reco.calo_hits.events18000-18999.parquet
+d048967091cc9b32abb0ca12c61eed8ff9bef578127dabffc011f5352c9d8016  hard_scatter.ggf.v1.reco.calo_hits.events19000-19999.parquet
+9e2eac8bd89237a9a0d5a2b83a85ff668cf3e219c21339030e0e316b7adce012  hard_scatter.ggf.v1.reco.calo_hits.events2000-2999.parquet
+99552822c3175ebe69055a53f4afe9c38bf9072cc466bd69064e4481158d6122  hard_scatter.ggf.v1.reco.calo_hits.events20000-20999.parquet
+14ea6e13f0958bcdfad20ac6accb24938c15a8d122632bb5a3d886ae1b79ad3d  hard_scatter.ggf.v1.reco.calo_hits.events21000-21999.parquet
+ed95ac4be1d9021d3081fc9bd64dc5e4ad043a0872561f443927c455ba8cf4ac  hard_scatter.ggf.v1.reco.calo_hits.events22000-22999.parquet
+3d0869744b033253ee892446554c98f2847a02c70f0b551dc586a5c3a3b45f2d  hard_scatter.ggf.v1.reco.calo_hits.events23000-23999.parquet
+5b17e0317230758ed7d610b7238ecfbfb0e2f797e0dbfc6fea42756273b415ec  hard_scatter.ggf.v1.reco.calo_hits.events24000-24999.parquet
+2c364077d687fd2e6c8c0451ed76bcc96980897693e01e8c337067751cff579e  hard_scatter.ggf.v1.reco.calo_hits.events25000-25999.parquet
+7f60fec13de169dd8d3700368e13657c4de8c6bb3fb0c907b9fdf97dec4fee4f  hard_scatter.ggf.v1.reco.calo_hits.events26000-26999.parquet
+30e9725ce9308fb27b93b81c4dddc349b8c1cf656aec5169ebbb4bd26e3edca8  hard_scatter.ggf.v1.reco.calo_hits.events27000-27999.parquet
+fbcd25a945e82b0e6aff5eb0ea3f6a8ddf39edb4d071149536a4665c33b74483  hard_scatter.ggf.v1.reco.calo_hits.events28000-28999.parquet
+3fd8d410e8d58e70c0ac6611d51e22a664bbe43299f8557e39430b522c61c090  hard_scatter.ggf.v1.reco.calo_hits.events29000-29999.parquet
+87f538b5f72236fe7a902d2baa49348989123e584cb1831c3c007430d2fb0611  hard_scatter.ggf.v1.reco.calo_hits.events3000-3999.parquet
+cdce022e38db20275f1dc1d4a724fbfbfd58dffec27a99d48379b39e66491d52  hard_scatter.ggf.v1.reco.calo_hits.events30000-30999.parquet
+d55235f2bd4c55b81d2330fde857a9f2ea8544f183f5cff9d6cf945f9959aa97  hard_scatter.ggf.v1.reco.calo_hits.events31000-31999.parquet
+8ea8ed34b6ee6eb0bbac7ca6308640f63fb5b4743d4d8a2cf19c34b4d65e48ec  hard_scatter.ggf.v1.reco.calo_hits.events32000-32999.parquet
+26ce4f4551b5d532cb7042ebf626785755ae869a557985556c72194dcd22e0a4  hard_scatter.ggf.v1.reco.calo_hits.events33000-33999.parquet
+c3b31bc805f768bc1ad573bae4c597310b5cbfc5c5bebd9d1fc4b1c73b55b5f2  hard_scatter.ggf.v1.reco.calo_hits.events34000-34999.parquet
+dc46a7faaa43017f8cce92ae8c8c3293334cafd4aca95cd7dd5e406e46af4bcc  hard_scatter.ggf.v1.reco.calo_hits.events35000-35999.parquet
+23351d1d2fbdabbf060910cb52af2fad8de9cbe1eae364ee0dd888b7ca756278  hard_scatter.ggf.v1.reco.calo_hits.events36000-36999.parquet
+81ca97d56b3283a21f8ff549acd35db0d90e2cde2a8b927c17c72e330bff65c0  hard_scatter.ggf.v1.reco.calo_hits.events37000-37999.parquet
+d2a60c48addd7b35e70ffa2811a61c947ac686567781431b7028163f8775ec4e  hard_scatter.ggf.v1.reco.calo_hits.events38000-38999.parquet
+29ec6f9b85d1b0c64d6487e0054124739853c18d7a9c84ce876a4746154a313c  hard_scatter.ggf.v1.reco.calo_hits.events39000-39999.parquet
+c002abe5ebcd62ee2dbadc225eb2b4bed2d96ca1e7c2ffc97a3cebebc6eb5931  hard_scatter.ggf.v1.reco.calo_hits.events4000-4999.parquet
+4beb73fc0c9fb9da34611c5d4644c71602cd43a63522e266997bd9b145c6ba73  hard_scatter.ggf.v1.reco.calo_hits.events40000-40999.parquet
+85918d729107b3f2e19075ab1116cc7715ad05523b143b55525b79f9a3736446  hard_scatter.ggf.v1.reco.calo_hits.events41000-41999.parquet
+47aa805b224e9d3aee434c85d782ff529968cfdc0500ed484d2b3180f243192a  hard_scatter.ggf.v1.reco.calo_hits.events42000-42999.parquet
+5d2b91d325554b9a9104e255eed1762c8486a3b52f54b53524abe2ac1c6ea47d  hard_scatter.ggf.v1.reco.calo_hits.events43000-43999.parquet
+14f241c63e6d85e0be735c7edf53eff3f8806519d07adc38d89b688a92a0ebea  hard_scatter.ggf.v1.reco.calo_hits.events44000-44999.parquet
+1b39e3f533fc05882bebed705a46fd841350a4136d58175942fa2b4637c675e9  hard_scatter.ggf.v1.reco.calo_hits.events45000-45999.parquet
+eaa525304416dbe92a3105399339c714478b3b13dcd51eacd1357013c67dfa7a  hard_scatter.ggf.v1.reco.calo_hits.events46000-46999.parquet
+01a875368912b7482944c42d4820b1175cddd753c5c6d6086e0a149cef7c392f  hard_scatter.ggf.v1.reco.calo_hits.events47000-47999.parquet
+056093fbad50ef2d60229985d2eb88be59b6d9958f2466510aa7dc25f8b103ac  hard_scatter.ggf.v1.reco.calo_hits.events48000-48999.parquet
+ae46280667917e9bec9fc042b4e60d7cc2b1da96d2cbeb960f6ec5b8632e0d2e  hard_scatter.ggf.v1.reco.calo_hits.events49000-49999.parquet
+953e089fd27f1e94d8f083da1cfac51995265ef246c7af44bb8fa352bb852c9f  hard_scatter.ggf.v1.reco.calo_hits.events5000-5999.parquet
+67a001cd7ec9423292b18cff0413a2274fe2677690821502d2b96e002cf4d206  hard_scatter.ggf.v1.reco.calo_hits.events50000-50999.parquet
+6eef869dcb8c42f2759f1fdcf8e549465b3339fc4cc3edebdc0f56970bedd796  hard_scatter.ggf.v1.reco.calo_hits.events51000-51999.parquet
+ecba6d40a8437219694498b854d73b9473df7e396892e124e22d8a10152585e0  hard_scatter.ggf.v1.reco.calo_hits.events52000-52999.parquet
+d7e652ff0189acd1f48f0fbcb59dcb1d18e47e507f5a3215a39013e37ea931ea  hard_scatter.ggf.v1.reco.calo_hits.events53000-53999.parquet
+cad3be715d2f82896cd12e29a9e9991e9d4e45526fafa378a53ed5b7db762605  hard_scatter.ggf.v1.reco.calo_hits.events54000-54999.parquet
+5186967d9e4e2ad0eb4ab6c32bc5e96cfeea7e696325bd09d91ae9b0910089a8  hard_scatter.ggf.v1.reco.calo_hits.events55000-55999.parquet
+7cb6c3e4fa1c854b8cb95cc7b80337e4fe0c3e015e7f939db0bb60a8c9126406  hard_scatter.ggf.v1.reco.calo_hits.events56000-56999.parquet
+b006a28f2cb148b29108b074e53d9fbe48c27efaefc9574ec418263b1431f29b  hard_scatter.ggf.v1.reco.calo_hits.events57000-57999.parquet
+043e08901d1bd44ec71d27e83639b639a74d25c867b43e55987699e50b6759e1  hard_scatter.ggf.v1.reco.calo_hits.events58000-58999.parquet
+50b54f44570c364bac8bd4f20a95bf6552698f547ce84c9d1c8415a4a03c2546  hard_scatter.ggf.v1.reco.calo_hits.events59000-59999.parquet
+09cda34843f462d26c557a8cfffdadd6da66b632e4e8a29bbf686c210a2994ca  hard_scatter.ggf.v1.reco.calo_hits.events6000-6999.parquet
+7260559885f211d838554fefaf9fbaba27aac3d2beadcf97e2de86f71dfeeaef  hard_scatter.ggf.v1.reco.calo_hits.events60000-60999.parquet
+954fc4898520573d3d487455f7175083fc7764ad93219361f340843073d3354f  hard_scatter.ggf.v1.reco.calo_hits.events61000-61999.parquet
+d37bc0bbb64cf6b9e9c081a40509c426b55842ee138117f66fb33a1a0b4448d2  hard_scatter.ggf.v1.reco.calo_hits.events62000-62999.parquet
+e16d880082cfac91fbf43f715c1699bad90b1c4d16ebf0224a8a08d51a330d5f  hard_scatter.ggf.v1.reco.calo_hits.events63000-63999.parquet
+b9c3f68eff01eccf15f4a6b905d0613c208320ca8e8828b5cea1943d2be1ccf6  hard_scatter.ggf.v1.reco.calo_hits.events64000-64999.parquet
+b33a39de973af6a31f0ba6c95f70c4f0a2f7766e0c838feab7fd111e8922398f  hard_scatter.ggf.v1.reco.calo_hits.events65000-65999.parquet
+15acc6fb861c582b6b3f21307ad33b47d71496da69ff086cfdb0d1b0842229a6  hard_scatter.ggf.v1.reco.calo_hits.events66000-66999.parquet
+5f29b16e7ade3fca872f293cd557b8fbf06c6753e0a5bc83dd74fea9d9c8273e  hard_scatter.ggf.v1.reco.calo_hits.events67000-67999.parquet
+940abd57436c132b8a0ee09fdd089d9f338c42a4c97cbc23f7ee91d426c6ab6f  hard_scatter.ggf.v1.reco.calo_hits.events68000-68999.parquet
+df700e347f801cd7ffd4db58a093a90f1309356c4bb4c9da6b17dca7185b9cdd  hard_scatter.ggf.v1.reco.calo_hits.events69000-69999.parquet
+c046b385ae43473da0d21bc9df84a5ab7a0504fb55acc98f5735c69f6e95aab5  hard_scatter.ggf.v1.reco.calo_hits.events7000-7999.parquet
+eba23882a9075678c6c100010022d10bbf943ec09606eafd6e15ed3a4fa074da  hard_scatter.ggf.v1.reco.calo_hits.events70000-70999.parquet
+6d4e105e7168067caff1f1a237afd789664268c6646d450c15b121cb8197d515  hard_scatter.ggf.v1.reco.calo_hits.events71000-71999.parquet
+72073fccfb747d8690bbf13f5d967170c187905f028edc6a582180219d4729c0  hard_scatter.ggf.v1.reco.calo_hits.events72000-72999.parquet
+56df72d547f209768e34d2bd6fd8be51d0c0dc421707bf43372e91de703de586  hard_scatter.ggf.v1.reco.calo_hits.events73000-73999.parquet
+37a72f6b1cabb9c4cd6389e95fc383754e61c11b73909c58549adf11e2518c97  hard_scatter.ggf.v1.reco.calo_hits.events74000-74999.parquet
+8bc36d02844a3d9f939bb4daff637d8eacdf17070528552604205924331aaa27  hard_scatter.ggf.v1.reco.calo_hits.events75000-75999.parquet
+5df50c989e11e5b9db40b70aa5c1a17832c25159dc4ee1dee154b2cf854f7f63  hard_scatter.ggf.v1.reco.calo_hits.events76000-76999.parquet
+4333ec817b2a344a33309aeca734672ebc8633f8415d8a778e6c2d1e165f9288  hard_scatter.ggf.v1.reco.calo_hits.events77000-77999.parquet
+b5c03a9b54b02df9b46c23f94ab7bfd6258a290661ffc55f98fbfe9edd9f6922  hard_scatter.ggf.v1.reco.calo_hits.events78000-78999.parquet
+67b6e2061b6a4321654a0c2d994e0016574e45c41a96114c2a1c0f655d18034a  hard_scatter.ggf.v1.reco.calo_hits.events79000-79999.parquet
+28851f8745785814bfb12bbea30566e687b02cd5f8c634dded949007cef282ef  hard_scatter.ggf.v1.reco.calo_hits.events8000-8999.parquet
+45075881b98648c4d5b58f5f6836456597e6e7c21c0fa2ad45e263951aa7d1be  hard_scatter.ggf.v1.reco.calo_hits.events80000-80999.parquet
+096bc30ea9dac93c78e7ab3cfbc453f76b9fe30a01fd897984c1d573b36b6457  hard_scatter.ggf.v1.reco.calo_hits.events81000-81999.parquet
+526f78ee7ddc878900ae78c2d957b3b2c52794abec48f69e0f5d6f0a3041aead  hard_scatter.ggf.v1.reco.calo_hits.events82000-82999.parquet
+9c052964e80d0c22c0e155fb276cd97b8ea2f0e3b01c3284eb927b808007cb84  hard_scatter.ggf.v1.reco.calo_hits.events83000-83999.parquet
+e00896efe4b4e5cb3e0f955f7aa4a10035550d281397c215ffd6b4af6e930d2a  hard_scatter.ggf.v1.reco.calo_hits.events84000-84999.parquet
+bdfd7ff1e799bec04a1608c6e5d5ff4d3e3fadd3236b921df63d1f2dd42e635f  hard_scatter.ggf.v1.reco.calo_hits.events85000-85999.parquet
+6ecf35dfa8962a1711a2095c9faef8fc9630f3542e7260f83979b122e8c45b73  hard_scatter.ggf.v1.reco.calo_hits.events86000-86999.parquet
+97c39ddd0fe70ba1bbf8f36343d416e8d7f8e8375a9d944aa0dd138ebe39182f  hard_scatter.ggf.v1.reco.calo_hits.events87000-87999.parquet
+44735b262a373d51f8f71048b37e4770db637da50a8091beb95c2361a16a1e3b  hard_scatter.ggf.v1.reco.calo_hits.events88000-88999.parquet
+9c32eaa5bc53107d2abd99de975803efa75d7a29f79fe42610ddf37bd22c9a65  hard_scatter.ggf.v1.reco.calo_hits.events89000-89999.parquet
+bb503a8d4d987783d933ffd51390d1e762704fa6e01b25c2a7ecdd710ffba441  hard_scatter.ggf.v1.reco.calo_hits.events9000-9999.parquet
+e00b8c04594d54dc5d79d5ca99ebbac908a773ae12786e97263b60bbc15d1818  hard_scatter.ggf.v1.reco.calo_hits.events90000-90999.parquet
+3db61c6ce79085dd6a0c01e8ed2021300d8fd132632fd1323272937aad6ee990  hard_scatter.ggf.v1.reco.calo_hits.events91000-91999.parquet
+a4427717e07846a882adcc41953252c7ec6654ab847016a1889faa6ff9a2aed1  hard_scatter.ggf.v1.reco.calo_hits.events92000-92999.parquet
+49075a131c03d14c35e5be52effcb507dc5ca4a67c064d8702c070441c275e4d  hard_scatter.ggf.v1.reco.calo_hits.events93000-93999.parquet
+1fe0d71b031508876091abb1714d8e565d8369ab5530493f0d4f8117137b4f87  hard_scatter.ggf.v1.reco.calo_hits.events94000-94999.parquet
+de69c27541d3928ec3743461187c3ec81aec3faa8ac8b24ab6d48d953916b05b  hard_scatter.ggf.v1.reco.calo_hits.events95000-95999.parquet
+acc6dc717a108c7e0f2820464853e8b79418e570a8d4e2f60951d4b044727c21  hard_scatter.ggf.v1.reco.calo_hits.events96000-96999.parquet
+4c4e03522473f9214762040fb94df85c73d11e8f88c02c0ad253b3cd4098dac5  hard_scatter.ggf.v1.reco.calo_hits.events97000-97999.parquet
+3b89b8168ce43dc81ca57e24df80572cf953bab2f2a87258f2b47d73b31862e2  hard_scatter.ggf.v1.reco.calo_hits.events98000-98999.parquet
+ca7674e963513f1de24b23ea1f1690d783e623c531ddfdc044fb2909d21a33ce  hard_scatter.ggf.v1.reco.calo_hits.events99000-99999.parquet

particles.sha256

@@ -0,0 +1,100 @@
+5c5a2fe4d780b18f383a35400fb5ebc8bae73ebadb2f9e53d96b5463225906ad  hard_scatter.ggf.v1.truth.particles.events0-999.parquet
+a1fe71a3eb44cea226b04b1b9f4bf28b55f71fa6fa7f5ba3f021e151820e7a46  hard_scatter.ggf.v1.truth.particles.events1000-1999.parquet
+de4b577ca8c49580a943299fb5b2e3ca334927135c7a1a0a41c4f7e3ffb61f17  hard_scatter.ggf.v1.truth.particles.events10000-10999.parquet
+218fc0c5e11e072eecc752851712073740f38356a636838ec2764bc8d602eb01  hard_scatter.ggf.v1.truth.particles.events11000-11999.parquet
+5f47d1624f25cb9191415133e49a2c3c131f24b901ed2b5381c8d98825e32328  hard_scatter.ggf.v1.truth.particles.events12000-12999.parquet
+38d9b16738925196f768b2080062be9f69dafe9b1662de859bc5621f05159a52  hard_scatter.ggf.v1.truth.particles.events13000-13999.parquet
+c8f4254feb8ce12870b852f18747c205fad9e508478078fd4d016acc8c0c88ce  hard_scatter.ggf.v1.truth.particles.events14000-14999.parquet
+05915dfb527fc6462af7b671ea1e0e4a2fccf01b22dbf1ee5f165a3eb91fb0d8  hard_scatter.ggf.v1.truth.particles.events15000-15999.parquet
+f355f35848c3ac2c2f56b65c1dc664035efb31e54df96d3dddf958d1ecf47817  hard_scatter.ggf.v1.truth.particles.events16000-16999.parquet
+cb53ccbb1340ecaf126cb545ab88c5bd7147d4dba86e86167527f637ed4996f3  hard_scatter.ggf.v1.truth.particles.events17000-17999.parquet
+e832398fe830a8bf8008527a868164f591bfd55751f86d1bdde18112d4643cde  hard_scatter.ggf.v1.truth.particles.events18000-18999.parquet
+5ddf0fcd3041bbfff6fecb3fe56e5df03370d6ee4f6c9dd2b974bd523205e812  hard_scatter.ggf.v1.truth.particles.events19000-19999.parquet
+9da249ab88a84185c238f3a0a20f0e7c61c36ec592d6c20b003a2dfb5fa82d14  hard_scatter.ggf.v1.truth.particles.events2000-2999.parquet
+5f60278e4fc2e973536c32923226d77192e87ff072d9c8c39744ed88c3210b11  hard_scatter.ggf.v1.truth.particles.events20000-20999.parquet
+4cd9f1bea14a4e23fcc31b5efadd18f0bdf44323af6130777074a1397cd27938  hard_scatter.ggf.v1.truth.particles.events21000-21999.parquet
+0930c1aba661caf4145e3794cb369a8f57f3824f2fb1ff22dd91bc5d3f9f49e4  hard_scatter.ggf.v1.truth.particles.events22000-22999.parquet
+d778716f65e03da50a54e02eb59166383a25fe20c19397db0faa43d8a5c0ad17  hard_scatter.ggf.v1.truth.particles.events23000-23999.parquet
+8d43b574815886eaadfd15c2febd49ebb7fc92c5cdca9040f14d94f6edd43351  hard_scatter.ggf.v1.truth.particles.events24000-24999.parquet
+1751dd574ac00da79eeb0c81dd8c759fad37f7cddc0817dae0a25307f2ed0737  hard_scatter.ggf.v1.truth.particles.events25000-25999.parquet
+739a6e28bdf3b7e44b2e48a6c9e1682034dffa4202a7eb47243894e534ba3123  hard_scatter.ggf.v1.truth.particles.events26000-26999.parquet
+daee9ac14ef9b7aa3b26602fcbef9ffa5f0eb6b9f11954ae9c267d5f6f568bf4  hard_scatter.ggf.v1.truth.particles.events27000-27999.parquet
+21b95303959b647136723cbcf76090e50fba9e2da1719041f357d4d6188b384b  hard_scatter.ggf.v1.truth.particles.events28000-28999.parquet
+e2377374dce4279039981f53c21aa3776c5aac51384794e015accf0fde5a0972  hard_scatter.ggf.v1.truth.particles.events29000-29999.parquet
+19efa31b130be09675e85b533458597d18a069f3ed5f93144b37356d23dc6c8a  hard_scatter.ggf.v1.truth.particles.events3000-3999.parquet
+2ba8830e5256168fadcc50297d184c7c92bdb425569013812a8174d3364504c5  hard_scatter.ggf.v1.truth.particles.events30000-30999.parquet
+2bafd682009ac15756c67fe04543ab829565befdd8d8c0309461ad80d406b42c  hard_scatter.ggf.v1.truth.particles.events31000-31999.parquet
+ccbbe358a310a3f0bf4854d8a28af18ccc0de2279ccbf65481cc31a0af04cd4b  hard_scatter.ggf.v1.truth.particles.events32000-32999.parquet
+cb4e1bcc8aedf51b2d9e9d450a98b43ad53a6d173fb0df49b818afe46dcb4a1b  hard_scatter.ggf.v1.truth.particles.events33000-33999.parquet
+b4b711bc5e735812e4d747d38ff94fc96bdafe422c980afaa91ddcf631555b03  hard_scatter.ggf.v1.truth.particles.events34000-34999.parquet
+539615faa59179e2cf6050237a3739976b7124e451460d4285ac925df294b33e  hard_scatter.ggf.v1.truth.particles.events35000-35999.parquet
+7847350550b92f163baa6bcfaec3f13fc06c73380086d4713de2c1f79a506159  hard_scatter.ggf.v1.truth.particles.events36000-36999.parquet
+04693a54c9f9a98fa768f423a0e5e0906c1bbe5dce5c4035a84ed1c842ecbf99  hard_scatter.ggf.v1.truth.particles.events37000-37999.parquet
+5d805d76b597b8cd1aeeb2510bd8eceeb1e2bf661b9c717cbc1865e65dc344b6  hard_scatter.ggf.v1.truth.particles.events38000-38999.parquet
+80c56842aa7f95389796fc00019db318fda7b05adcad853263bd5edab0dedee9  hard_scatter.ggf.v1.truth.particles.events39000-39999.parquet
+952cca48b2cd34a8dafc652765654a6746db8750627a6b341313176082e5db1e  hard_scatter.ggf.v1.truth.particles.events4000-4999.parquet
+5a5b589b71980ae188fdc7c6fb084c03c9bdec2c5e6c3d0fe8792307e6d96d5b  hard_scatter.ggf.v1.truth.particles.events40000-40999.parquet
+0b2fd81952263e80ff3a26831db9275c0ae525471a228ddb14ee0b3e6886d1d4  hard_scatter.ggf.v1.truth.particles.events41000-41999.parquet
+9cbe6674c08eff458d8db8a0d5fcdb2805d78cf8567730d4ec9dc128620124a0  hard_scatter.ggf.v1.truth.particles.events42000-42999.parquet
+e55a7a8f7c95e4a8f3432f78cd41036511b86c21912e3370907a75d5ca2536e2  hard_scatter.ggf.v1.truth.particles.events43000-43999.parquet
+8b4b4ad7a6a8d1e87368a37a83717f186da2f85b0c833aa7f17a157a84c4042f  hard_scatter.ggf.v1.truth.particles.events44000-44999.parquet
+fb88642e2c9f38471382dc4d880d648c461bd0e642cba9e0d191ab17502d2907  hard_scatter.ggf.v1.truth.particles.events45000-45999.parquet
+46873a206224f8d8cc9313493a14ced827f59b4dd9d01504fce037d2766b613e  hard_scatter.ggf.v1.truth.particles.events46000-46999.parquet
+41f202a3d7a2ec448553ba1d84efd178b9c6f49a2b4dba447870d4e53efe1fd3  hard_scatter.ggf.v1.truth.particles.events47000-47999.parquet
+21b3fa4911e17bda4f519ba34844a6de9197a4b268878dbdd8dc23c9cac2bea9  hard_scatter.ggf.v1.truth.particles.events48000-48999.parquet
+6644c5c04591b22fa844a4be54af55b991d8628c6868655ad9cd837f58b414d3  hard_scatter.ggf.v1.truth.particles.events49000-49999.parquet
+b33c39692353960eb25264ccdc519986a1ed3134afa5449de1463de675ecd21f  hard_scatter.ggf.v1.truth.particles.events5000-5999.parquet
+2837497a84e2395c9a71924379beb71e3d31304fc5a3ebcf3f6ea4acbdc18d4b  hard_scatter.ggf.v1.truth.particles.events50000-50999.parquet
+af2c2869a11fc090b71c9e0cb6ebaabfa8113525c0448484edf12ecb94dec5da  hard_scatter.ggf.v1.truth.particles.events51000-51999.parquet
+5a9e5d68653bd2ebe43b9d683d897340a5f2542aa9e5e01aa6a58e0d20fb6108  hard_scatter.ggf.v1.truth.particles.events52000-52999.parquet
+54429cff1b132d5d53eea1ec9ff5d8ddff1bfcd31b3c2ab8f0ebccac15f01d13  hard_scatter.ggf.v1.truth.particles.events53000-53999.parquet
+e33d37e8683ddbcf24fc4291d4a138572e5d9c809dffa92f3fbe6ce5172c0a38  hard_scatter.ggf.v1.truth.particles.events54000-54999.parquet
+8744b5c76bd184d57dd69de74f15893f70fbe89ec238f01c5816cf7ce5b14a61  hard_scatter.ggf.v1.truth.particles.events55000-55999.parquet
+7df7a128119b7e6cdf217cf6222f8f977832830a5ccc8c0ccf3adc261a0a4c01  hard_scatter.ggf.v1.truth.particles.events56000-56999.parquet
+99fd3c801931b80d96f39127c9190611e8ca66bc2c15798b65701c1b92ad11e6  hard_scatter.ggf.v1.truth.particles.events57000-57999.parquet
+1d7eeb5380f5755c5631ed847101cc54aa1b98f4a6993be7d42700ba295ddea6  hard_scatter.ggf.v1.truth.particles.events58000-58999.parquet
+691ccdff5ed57b1d0742b9fdb18ecb0cafaa285aa140fdff2182215b97a4a514  hard_scatter.ggf.v1.truth.particles.events59000-59999.parquet
+bdabb9981d344d5fb1dc5c3940d49a5855c8f39a9db5d82980c45d9dfad194b0  hard_scatter.ggf.v1.truth.particles.events6000-6999.parquet
+9afdc5b039fcf8ac97f29b307e5df32e07971638f0bf23fc2d35e920fcb76599  hard_scatter.ggf.v1.truth.particles.events60000-60999.parquet
+0b90cd01f8e048abf2bb1f001baf859c6a4aa68b9de0babaca618141839a920c  hard_scatter.ggf.v1.truth.particles.events61000-61999.parquet
+124d8be6d97ed3a87b9f09a0128f6f966e2a4a645d2e1451a27cb59c8f2822ab  hard_scatter.ggf.v1.truth.particles.events62000-62999.parquet
+607a0f48bf02ad170b7e8f8bd4eaba62d9cef051084fa29a000a3609da5871e4  hard_scatter.ggf.v1.truth.particles.events63000-63999.parquet
+41b339c641b13755e023bef1274b0062ee8ac446975cadd958ae875b9d592a3a  hard_scatter.ggf.v1.truth.particles.events64000-64999.parquet
+7da7504d546305bb14c8612cd9829512b9f2a455ddc6aa5cc173d2eb979c975c  hard_scatter.ggf.v1.truth.particles.events65000-65999.parquet
+df39f572b3268d0fe09d36b2660901ce3af59a22314afd47fe6f458f832f287a  hard_scatter.ggf.v1.truth.particles.events66000-66999.parquet
+1fc4dd913c216503e096d232896aa3682c54cb7c114d50e0d7f6fa475f2feb1e  hard_scatter.ggf.v1.truth.particles.events67000-67999.parquet
+b542bb000945d2aceb2e580f7178625ba4b7e82edf9b47a19fd302f3e202cb36  hard_scatter.ggf.v1.truth.particles.events68000-68999.parquet
+9770e8864f88647b76c5e2b43759b3b2dda8e52a07219a7174685c16c9aae402  hard_scatter.ggf.v1.truth.particles.events69000-69999.parquet
+35a5a9f967a12f8de295c30edc08f30cad4e2f2cf8c5e1d10a8a5c204429c9dc  hard_scatter.ggf.v1.truth.particles.events7000-7999.parquet
+355b7d25672b6b5905eac37ab9464c27ae1c2b8b06d9087793395c56463c25e5  hard_scatter.ggf.v1.truth.particles.events70000-70999.parquet
+30ab5b83636433592a6639bff63a79a2df11f8a193858ae18fa9c818b989e6c5  hard_scatter.ggf.v1.truth.particles.events71000-71999.parquet
+14c64fa33f1554d8629752ed7ecc235844ef81211fbc0a0210b983dcddec44b9  hard_scatter.ggf.v1.truth.particles.events72000-72999.parquet
+d9f4dbca565f3f22c86b0f1b1d20e2e21ef637b49980dd803e92e38cc8682874  hard_scatter.ggf.v1.truth.particles.events73000-73999.parquet
+ab0b41dcbdd95857fbe130391c3f2791e0f2f6ec611da0dd03c8635b622fbe8f  hard_scatter.ggf.v1.truth.particles.events74000-74999.parquet
+26090bc11dfefcf955554755c71d125388cfc5b5e488a2021a711e30a26284fa  hard_scatter.ggf.v1.truth.particles.events75000-75999.parquet
+4eb57a2f139d3475db630b7bcec0e0d8a5f623c78b79474e194e394e6f8aa2ae  hard_scatter.ggf.v1.truth.particles.events76000-76999.parquet
+6188e39b2559b3be7073f9d38d30166be8fd370004bd361ec0a95898dd4f77ed  hard_scatter.ggf.v1.truth.particles.events77000-77999.parquet
+cedd9c2c48f7dbc7e7bcb5c19b3f629696512a2722a69438045b88f33a71f879  hard_scatter.ggf.v1.truth.particles.events78000-78999.parquet
+1e503ee1e9eebb4e2cc55d9fb05274df10a3b2bec661c806e070a5abb81d6085  hard_scatter.ggf.v1.truth.particles.events79000-79999.parquet
+99aa9ba7d2e95f12ae6b4cd14a88492ac7659c9f538ad168e53985bba3e3f83f  hard_scatter.ggf.v1.truth.particles.events8000-8999.parquet
+e37276313f65eff5a7fe386e0718166eba320bcd8629a0c93555bb6e961bf84b  hard_scatter.ggf.v1.truth.particles.events80000-80999.parquet
+30038919caeb6f2b23117d810cf4203ca390fcbefa75962e7e57eb3c0ab52076  hard_scatter.ggf.v1.truth.particles.events81000-81999.parquet
+24916c0e1482f78c65c224f5b54c967f79e4cf701c1aef03929ec23ecee459ac  hard_scatter.ggf.v1.truth.particles.events82000-82999.parquet
+eb7b7661db89532299f28053fc9c5acd63ffa7e50bfabcc515274390a3d7c6d5  hard_scatter.ggf.v1.truth.particles.events83000-83999.parquet
+dd9929eff081fcfa8cf0591a1098f503c67ffb175c458607ca8a7018c3d02ba5  hard_scatter.ggf.v1.truth.particles.events84000-84999.parquet
+8a655557ef8885dbfefda7c398907c21d8a94d1e1b71757b25f1f282ebafd657  hard_scatter.ggf.v1.truth.particles.events85000-85999.parquet
+ee296f29c753def91a52385b9c4e0d8ef418a265c5f5a1615edc42e52a38f1ee  hard_scatter.ggf.v1.truth.particles.events86000-86999.parquet
+29e8aeeba8f97955d97422f6b0f337753ee4978877e51af7bc5179a4a430134d  hard_scatter.ggf.v1.truth.particles.events87000-87999.parquet
+313637ce9c4270081eb9ba9de09f23e545b83839d07473b9d033fd9443bfe9f5  hard_scatter.ggf.v1.truth.particles.events88000-88999.parquet
+d80b36b82287a1e70159a40f0b09ff994173eaeeb12bc77874d2523bd4b1ba2f  hard_scatter.ggf.v1.truth.particles.events89000-89999.parquet
+736fe3986334922cbe4124e1bcebd90527f85bfcc087b98168370ba35b731d34  hard_scatter.ggf.v1.truth.particles.events9000-9999.parquet
+f7638ed1ff3f30c71b116998406dea2ef5f485ebaf6cefe61aeea762694fa761  hard_scatter.ggf.v1.truth.particles.events90000-90999.parquet
+c42d489b707484aeef13c233baaae67081af1f8bfff6694d2ad13245d1bb3d73  hard_scatter.ggf.v1.truth.particles.events91000-91999.parquet
+d67fe353c33668758a7ab14cda3bd393889631300302faaffd21e45bef35ff18  hard_scatter.ggf.v1.truth.particles.events92000-92999.parquet
+b7f50c9c48bff24e08005d1f904f8d92ed25191984199c4a38083c3d99544c59  hard_scatter.ggf.v1.truth.particles.events93000-93999.parquet
+58aaba455bc16ef97997b37b35e0a0fa13ed1e20f8058b32313f37809a511c02  hard_scatter.ggf.v1.truth.particles.events94000-94999.parquet
+f2fe5d5f66eb091a11037d69f5f6ba728a600f949badb15c36baffbf7367f824  hard_scatter.ggf.v1.truth.particles.events95000-95999.parquet
+cf90aa6d9e74fd58fa933fff6025d5fd8b007438f5674b8748604fa46b91cf2c  hard_scatter.ggf.v1.truth.particles.events96000-96999.parquet
+5fb390ffd2d41ea0f21d4f6234fdb5613e602a277212539296679cfcd094eceb  hard_scatter.ggf.v1.truth.particles.events97000-97999.parquet
+7698ca8a4d77baf537aa66dc4d3ee31aec95fb06f63253d8daebe605df4fbb97  hard_scatter.ggf.v1.truth.particles.events98000-98999.parquet
+769b6a9e869de32f20845985ee9df03de229bf647f19a52c5213845f5d12b01c  hard_scatter.ggf.v1.truth.particles.events99000-99999.parquet

scripts/manage_dataset_files.py

@@ -0,0 +1,1689 @@
+#!/usr/bin/env python3
+# /// script
+# requires-python = ">=3.9"
+# dependencies = [
+#     "aiohttp",
+#     "typer>=0.9",
+#     "rich",
+#     "PyYAML",
+#     "pyarrow",
+# ]
+# ///
+"""Download ColliderML dataset assets and manage README URL updates."""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import hashlib
+import logging
+import os
+import re
+import shutil
+import tempfile
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Annotated, Any, Dict, List, Sequence
+from urllib.parse import urlparse
+
+import aiohttp
+import pyarrow.parquet as pq
+import typer
+import yaml
+from rich.console import Console
+from rich.logging import RichHandler
+from rich.progress import (
+    BarColumn,
+    DownloadColumn,
+    Progress,
+    TextColumn,
+    TimeElapsedColumn,
+    TransferSpeedColumn,
+)
+from rich.table import Table
+
+
+console = Console()
+app = typer.Typer()
+
+# Set up logging with rich handler
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(message)s",
+    datefmt="[%X]",
+    handlers=[RichHandler(console=console, show_path=False)],
+)
+logger = logging.getLogger(__name__)
+
+
+@app.callback()
+def main_callback(
+    verbose: Annotated[
+        bool,
+        typer.Option(
+            "--verbose",
+            "-v",
+            help="Enable verbose logging.",
+        ),
+    ] = False,
+) -> None:
+    """Manage dataset file URLs declared in README front matter."""
+    if verbose:
+        logging.getLogger().setLevel(logging.DEBUG)
+        logger.debug("Verbose logging enabled")
+
+
+@dataclass
+class DataFileEntry:
+    config_name: str
+    path: Sequence[str]
+    url: str
+
+    def parsed(self) -> tuple[str, str]:
+        parsed = urlparse(self.url)
+        return parsed.netloc, parsed.path.lstrip("/")
+
+    def relative_path(self) -> Path:
+        netloc, remainder = self.parsed()
+        return Path(netloc) / Path(remainder)
+
+
+@dataclass
+class DownloadResult:
+    entry: DataFileEntry
+    path: Path
+    success: bool
+    skipped: bool
+    error: Exception | None = None
+    order: int = 0
+
+
+@dataclass
+class VerifyResult:
+    entry: DataFileEntry
+    ok: bool
+    status: int | None
+    detail: str = ""
+    order: int = 0
+
+
+@dataclass
+class ChecksumResult:
+    entry: DataFileEntry
+    filename: str
+    computed_hash: str | None
+    expected_hash: str | None
+    matches: bool
+    success: bool
+    error: Exception | None = None
+    order: int = 0
+
+
+@dataclass
+class SchemaInfo:
+    config_name: str
+    filename: str
+    columns: List[tuple[str, str]]  # (column_name, data_type)
+    num_rows: int | None
+    success: bool
+    error: Exception | None = None
+
+
+def read_front_matter(readme_path: Path) -> tuple[str, str]:
+    text = readme_path.read_text(encoding="utf-8")
+    if not text.startswith("---\n"):
+        raise ValueError("README.md does not start with YAML front matter.")
+    try:
+        front_matter, body = text[4:].split("\n---\n", 1)
+    except ValueError as exc:
+        raise ValueError("README.md front matter is not terminated by '---'.") from exc
+    return front_matter, body
+
+
+def load_data_file_entries(front_matter_text: str) -> List[DataFileEntry]:
+    data = yaml.safe_load(front_matter_text)
+    configs = data.get("configs", []) if isinstance(data, dict) else []
+    entries: List[DataFileEntry] = []
+
+    def _walk(value: Any, path: list[str]) -> None:
+        if value is None:
+            return
+        if isinstance(value, str):
+            entries.append(
+                DataFileEntry(config_name=current_config, path=tuple(path), url=value)
+            )
+        elif isinstance(value, list):
+            for idx, item in enumerate(value):
+                _walk(item, [*path, str(idx)])
+        elif isinstance(value, dict):
+            for key, item in value.items():
+                _walk(item, [*path, str(key)])
+
+    for config in configs:
+        if not isinstance(config, dict):
+            continue
+        current_config = str(config.get("config_name", "<unnamed>"))
+        _walk(config.get("data_files"), ["data_files"])
+
+    return entries
+
+
+def replace_once(text: str, old: str, new: str) -> str:
+    index = text.find(old)
+    if index == -1:
+        raise ValueError(f"Value '{old}' was not found in front matter.")
+    return f"{text[:index]}{new}{text[index + len(old):]}"
+
+
+def build_rewritten_url(
+    result: DownloadResult, output_dir: Path, base_url: str
+) -> str:
+    """Build new URL by replacing output_dir with base_url in the file path.
+
+    For example:
+    - File path: /data/output/particles/file.parquet
+    - Output dir: /data/output
+    - Base URL: https://example.com/files
+    - Result: https://example.com/files/particles/file.parquet
+    """
+    relative_path = result.path.relative_to(output_dir)
+    # Ensure base_url doesn't end with slash, relative_path is POSIX-style
+    base_url = base_url.rstrip("/")
+    return f"{base_url}/{relative_path.as_posix()}"
+
+
+def resolve_destination(entry: DataFileEntry, output_dir: Path) -> Path:
+    _, remote_path = entry.parsed()
+    filename = Path(remote_path).name or remote_path
+    base_dir = output_dir / entry.config_name
+    return (base_dir / filename).resolve()
+
+
+def move_with_progress(src: Path, dst: Path, progress: Progress, task_id: int) -> None:
+    """Move file with progress tracking for cross-filesystem moves."""
+    # Try fast rename first (works if same filesystem)
+    try:
+        os.rename(src, dst)
+        return
+    except OSError:
+        # Cross-filesystem move - need to copy with progress
+        pass
+
+    # Get file size for progress tracking
+    file_size = src.stat().st_size
+    progress.update(task_id, total=file_size)
+
+    # Copy with progress tracking - use larger buffers for remote filesystems
+    buffer_size = 8 << 20  # 8 MB chunks for better performance on remote FS
+    with src.open("rb") as fsrc, dst.open("wb") as fdst:
+        copied = 0
+        while True:
+            buf = fsrc.read(buffer_size)
+            if not buf:
+                break
+            fdst.write(buf)
+            copied += len(buf)
+            progress.update(task_id, completed=copied)
+
+        # Ensure data is flushed to disk (critical for remote filesystems)
+        fdst.flush()
+        os.fsync(fdst.fileno())
+
+    # Verify file was written correctly before removing source
+    if dst.stat().st_size != file_size:
+        raise IOError(
+            f"File size mismatch after copy: expected {file_size}, got {dst.stat().st_size}"
+        )
+
+    # Remove source after successful copy
+    src.unlink()
+
+
+async def download_one(
+    entry: DataFileEntry,
+    output_dir: Path,
+    session: aiohttp.ClientSession,
+    semaphore: asyncio.Semaphore,
+    skip_existing: bool,
+    progress: Progress,
+    order: int,
+    staging_dir: Path | None = None,
+) -> DownloadResult:
+    _, remote_path = entry.parsed()
+    filename = Path(remote_path).name or remote_path
+    terse_name = (filename[:32] + "…") if len(filename) > 33 else filename
+    description = f"{entry.config_name}: {terse_name}"
+    async with semaphore:
+        task_id: int | None = None
+        destination = resolve_destination(entry, output_dir)
+
+        # Determine download location (staging or direct)
+        if staging_dir:
+            download_dest = resolve_destination(entry, staging_dir)
+            tmp_path = download_dest.parent / f"{download_dest.name}.part"
+        else:
+            download_dest = destination
+            tmp_path = destination.parent / f"{destination.name}.part"
+
+        try:
+            destination.parent.mkdir(parents=True, exist_ok=True)
+            download_dest.parent.mkdir(parents=True, exist_ok=True)
+            task_id = progress.add_task(description, total=0, start=False)
+            progress.start_task(task_id)
+            async with session.get(entry.url) as response:
+                response.raise_for_status()
+                total_bytes = response.content_length or 0
+
+                # Check if we can skip this file
+                if skip_existing and destination.exists():
+                    local_size = destination.stat().st_size
+                    if total_bytes and local_size == total_bytes:
+                        if task_id is not None:
+                            progress.remove_task(task_id)
+                            task_id = None
+                        logger.info(
+                            f"Skipped {destination.name} ({total_bytes:,} bytes) - already exists with correct size"
+                        )
+                        return DownloadResult(
+                            entry=entry,
+                            path=destination,
+                            success=True,
+                            skipped=True,
+                            order=order,
+                        )
+                    else:
+                        # File exists but needs re-download
+                        if not total_bytes:
+                            reason = f"remote size unknown, local size is {local_size:,} bytes"
+                        else:
+                            reason = f"size mismatch (local: {local_size:,} bytes, remote: {total_bytes:,} bytes)"
+                        logger.info(f"Downloading {destination.name} - {reason}")
+                else:
+                    # File doesn't exist or skip_existing is disabled
+                    if not destination.exists():
+                        size_info = f" ({total_bytes:,} bytes)" if total_bytes else ""
+                        logger.info(
+                            f"Downloading {destination.name}{size_info} - file not found locally"
+                        )
+                    else:
+                        size_info = f" ({total_bytes:,} bytes)" if total_bytes else ""
+                        logger.info(
+                            f"Downloading {destination.name}{size_info} - skip_existing is disabled"
+                        )
+
+                if total_bytes:
+                    progress.update(task_id, total=total_bytes)
+                with tmp_path.open("wb") as handle:
+                    async for chunk in response.content.iter_chunked(1 << 17):
+                        handle.write(chunk)
+                        progress.update(task_id, advance=len(chunk))
+
+                    # Flush and sync to ensure data is written (critical for remote filesystems)
+                    handle.flush()
+                    os.fsync(handle.fileno())
+
+            # Move from .part to final location
+            tmp_path.rename(download_dest)
+
+            # If using staging, move from staging to final destination with progress
+            if staging_dir:
+                logger.info(
+                    f"Moving {download_dest.name} from staging to {destination.parent.name}/"
+                )
+                # Update progress bar description for move operation
+                if task_id is not None:
+                    progress.update(
+                        task_id, description=f"{entry.config_name}: Moving {terse_name}"
+                    )
+                await asyncio.to_thread(
+                    move_with_progress, download_dest, destination, progress, task_id
+                )
+
+            return DownloadResult(
+                entry=entry,
+                path=destination,
+                success=True,
+                skipped=False,
+                order=order,
+            )
+        except Exception as exc:  # noqa: BLE001
+            # Report error immediately
+            logger.error(f"Failed to download {entry.config_name}/{filename}: {exc}")
+            with contextlib.suppress(FileNotFoundError):
+                tmp_path.unlink()
+            return DownloadResult(
+                entry=entry,
+                path=destination,
+                success=False,
+                skipped=False,
+                error=exc,
+                order=order,
+            )
+        finally:
+            if task_id is not None:
+                progress.remove_task(task_id)
+
+
+async def perform_downloads(
+    entries: Sequence[DataFileEntry],
+    output_dir: Path,
+    max_concurrency: int,
+    timeout: float,
+    skip_existing: bool,
+    use_staging: bool = False,
+) -> List[DownloadResult]:
+    if not entries:
+        return []
+
+    with contextlib.ExitStack() as stack:
+        # Create staging directory if needed
+        staging_dir: Path | None = None
+        if use_staging:
+            staging_tmp = stack.enter_context(
+                tempfile.TemporaryDirectory(prefix="dataset_staging_")
+            )
+            staging_dir = Path(staging_tmp)
+            logger.info(f"Using staging directory: {staging_dir}")
+
+        semaphore = asyncio.Semaphore(max_concurrency)
+        results: List[DownloadResult] = []
+        timeout_cfg = aiohttp.ClientTimeout(total=timeout)
+        progress = Progress(
+            TextColumn("{task.description}"),
+            BarColumn(bar_width=None),
+            DownloadColumn(),
+            TransferSpeedColumn(),
+            TimeElapsedColumn(),
+            console=console,
+        )
+
+        async with aiohttp.ClientSession(timeout=timeout_cfg) as session:
+            with progress:
+                tasks: list[asyncio.Task[DownloadResult]] = []
+                for order, entry in enumerate(entries):
+                    task = asyncio.create_task(
+                        download_one(
+                            entry=entry,
+                            output_dir=output_dir,
+                            session=session,
+                            semaphore=semaphore,
+                            skip_existing=skip_existing,
+                            progress=progress,
+                            order=order,
+                            staging_dir=staging_dir,
+                        )
+                    )
+                    tasks.append(task)
+
+                for future in asyncio.as_completed(tasks):
+                    result = await future
+                    results.append(result)
+
+        results.sort(key=lambda item: item.order)
+        return results
+
+
+async def get_remote_file_size(
+    entry: DataFileEntry,
+    session: aiohttp.ClientSession,
+    semaphore: asyncio.Semaphore,
+) -> int | None:
+    """Get remote file size via HEAD request."""
+    async with semaphore:
+        try:
+            async with session.head(entry.url, allow_redirects=True) as response:
+                if response.status < 400:
+                    return response.content_length
+        except Exception:  # noqa: BLE001
+            pass
+    return None
+
+
+async def fetch_remote_sizes(
+    entries: Sequence[DataFileEntry],
+    max_concurrency: int,
+    timeout: float,
+) -> Dict[str, int | None]:
+    """Fetch remote file sizes for all entries."""
+    semaphore = asyncio.Semaphore(max_concurrency)
+    timeout_cfg = aiohttp.ClientTimeout(total=timeout)
+    sizes: Dict[str, int | None] = {}
+
+    progress = Progress(
+        TextColumn("Fetching remote file sizes..."),
+        BarColumn(),
+        TextColumn("{task.completed}/{task.total}"),
+        TimeElapsedColumn(),
+        console=console,
+    )
+
+    async with aiohttp.ClientSession(timeout=timeout_cfg) as session:
+        with progress:
+            task_id = progress.add_task("Fetching sizes", total=len(entries))
+            tasks = {
+                entry.url: asyncio.create_task(
+                    get_remote_file_size(entry, session, semaphore)
+                )
+                for entry in entries
+            }
+            for url, task in tasks.items():
+                size = await task
+                sizes[url] = size
+                progress.advance(task_id)
+
+    return sizes
+
+
+async def verify_one(
+    entry: DataFileEntry,
+    session: aiohttp.ClientSession,
+    semaphore: asyncio.Semaphore,
+    order: int,
+) -> VerifyResult:
+    async with semaphore:
+        last_error: str = ""
+        for method in ("HEAD", "GET"):
+            try:
+                async with session.request(
+                    method, entry.url, allow_redirects=True
+                ) as response:
+                    status = response.status
+                    if status < 400:
+                        return VerifyResult(
+                            entry=entry, ok=True, status=status, order=order
+                        )
+                    if method == "HEAD" and status in {405, 501}:
+                        last_error = f"{method} returned {status}; retrying with GET."
+                        continue
+                    return VerifyResult(
+                        entry=entry,
+                        ok=False,
+                        status=status,
+                        detail=f"{method} -> {status}",
+                        order=order,
+                    )
+            except Exception as exc:  # noqa: BLE001
+                last_error = str(exc)
+        return VerifyResult(
+            entry=entry,
+            ok=False,
+            status=None,
+            detail=last_error or "Unknown error",
+            order=order,
+        )
+
+
+async def perform_verification(
+    entries: Sequence[DataFileEntry],
+    max_concurrency: int,
+    timeout: float,
+) -> List[VerifyResult]:
+    if not entries:
+        return []
+
+    semaphore = asyncio.Semaphore(max_concurrency)
+    timeout_cfg = aiohttp.ClientTimeout(total=timeout)
+    results: List[VerifyResult] = []
+    progress = Progress(
+        TextColumn("{task.description}"),
+        BarColumn(),
+        TextColumn("{task.completed}/{task.total}"),
+        TimeElapsedColumn(),
+        console=console,
+    )
+
+    async with aiohttp.ClientSession(timeout=timeout_cfg) as session:
+        with progress:
+            task_id = progress.add_task("Verifying dataset URLs", total=len(entries))
+            tasks = [
+                asyncio.create_task(verify_one(entry, session, semaphore, order=order))
+                for order, entry in enumerate(entries)
+            ]
+            for future in asyncio.as_completed(tasks):
+                result = await future
+                results.append(result)
+                progress.advance(task_id)
+
+    results.sort(key=lambda item: item.order)
+    return results
+
+
+async def compute_file_hash(
+    entry: DataFileEntry,
+    session: aiohttp.ClientSession,
+    semaphore: asyncio.Semaphore,
+    progress: Progress,
+    order: int,
+) -> ChecksumResult:
+    """Download file to temp location and compute SHA256 hash."""
+    # Extract filename from URL
+    _, remote_path = entry.parsed()
+    filename = Path(remote_path).name or remote_path
+    terse_name = (filename[:32] + "…") if len(filename) > 33 else filename
+    description = f"{entry.config_name}: {terse_name}"
+
+    async with semaphore:
+        task_id: int | None = None
+        try:
+            task_id = progress.add_task(description, total=0, start=False)
+            progress.start_task(task_id)
+
+            async with session.get(entry.url) as response:
+                response.raise_for_status()
+                total_bytes = response.content_length or 0
+
+                if total_bytes:
+                    progress.update(task_id, total=total_bytes)
+
+                hasher = hashlib.sha256()
+                async for chunk in response.content.iter_chunked(1 << 17):
+                    hasher.update(chunk)
+                    progress.update(task_id, advance=len(chunk))
+
+                computed_hash = hasher.hexdigest()
+                return ChecksumResult(
+                    entry=entry,
+                    filename=filename,
+                    computed_hash=computed_hash,
+                    expected_hash=None,  # Will be filled in later
+                    matches=False,  # Will be determined later
+                    success=True,
+                    order=order,
+                )
+        except Exception as exc:  # noqa: BLE001
+            return ChecksumResult(
+                entry=entry,
+                filename=filename,
+                computed_hash=None,
+                expected_hash=None,
+                matches=False,
+                success=False,
+                error=exc,
+                order=order,
+            )
+        finally:
+            if task_id is not None:
+                progress.remove_task(task_id)
+
+
+async def perform_checksum_verification(
+    entries: Sequence[DataFileEntry],
+    expected_hashes_by_config: Dict[str, Dict[str, str]],
+    max_concurrency: int,
+    timeout: float,
+) -> List[ChecksumResult]:
+    """Download files and verify their checksums.
+
+    expected_hashes_by_config: dict mapping config_name -> (filename -> hash)
+    """
+    if not entries:
+        return []
+
+    semaphore = asyncio.Semaphore(max_concurrency)
+    timeout_cfg = aiohttp.ClientTimeout(total=timeout)
+    results: List[ChecksumResult] = []
+    progress = Progress(
+        TextColumn("{task.description}"),
+        BarColumn(),
+        DownloadColumn(),
+        TransferSpeedColumn(),
+        TimeElapsedColumn(),
+        console=console,
+    )
+
+    async with aiohttp.ClientSession(timeout=timeout_cfg) as session:
+        with progress:
+            tasks = [
+                asyncio.create_task(
+                    compute_file_hash(
+                        entry, session, semaphore, order=order, progress=progress
+                    )
+                )
+                for order, entry in enumerate(entries)
+            ]
+            for future in asyncio.as_completed(tasks):
+                result = await future
+                # Fill in expected hash and match status
+                config_hashes = expected_hashes_by_config.get(
+                    result.entry.config_name, {}
+                )
+                result.expected_hash = config_hashes.get(result.filename)
+                if result.success and result.expected_hash:
+                    result.matches = result.computed_hash == result.expected_hash
+                results.append(result)
+
+    results.sort(key=lambda item: item.order)
+    return results
+
+
+def load_checksums_for_config(checksum_dir: Path, config_name: str) -> Dict[str, str]:
+    """Load expected hashes from SHA256SUM-style file for a specific config.
+
+    Returns a dict mapping filename -> hash.
+    """
+    checksum_file = checksum_dir / f"{config_name}.sha256"
+    if not checksum_file.exists():
+        return {}
+
+    hashes: Dict[str, str] = {}
+    try:
+        with checksum_file.open("r", encoding="utf-8") as f:
+            for line in f:
+                line = line.strip()
+                if not line or line.startswith("#"):
+                    continue
+                # Format: <hash>  <filename>
+                parts = line.split(None, 1)
+                if len(parts) == 2:
+                    hash_value, filename = parts
+                    hashes[filename] = hash_value
+    except OSError as exc:
+        logger.warning(f"Failed to load checksum file {checksum_file}: {exc}")
+
+    return hashes
+
+
+def save_checksums_for_config(
+    checksum_dir: Path, config_name: str, file_hashes: Dict[str, str]
+) -> None:
+    """Save hashes to SHA256SUM-style file for a specific config.
+
+    file_hashes: dict mapping filename -> hash
+    """
+    checksum_dir.mkdir(parents=True, exist_ok=True)
+    checksum_file = checksum_dir / f"{config_name}.sha256"
+
+    with checksum_file.open("w", encoding="utf-8") as f:
+        for filename in sorted(file_hashes.keys()):
+            hash_value = file_hashes[filename]
+            f.write(f"{hash_value}  {filename}\n")
+
+    logger.info(f"Saved {len(file_hashes)} checksums to {checksum_file}")
+
+
+
+
+@app.command()
+def download(
+    output_dir: Annotated[
+        Path,
+        typer.Option(
+            "--output-dir",
+            "-o",
+            help="Directory where files will be stored.",
+            resolve_path=True,
+        ),
+    ],
+    readme_path: Annotated[
+        Path,
+        typer.Option(
+            "--readme-path",
+            "-r",
+            help="Path to the README file with YAML front matter.",
+            exists=True,
+            resolve_path=True,
+            dir_okay=False,
+        ),
+    ] = Path("README.md"),
+    max_concurrency: Annotated[
+        int,
+        typer.Option(
+            "--max-concurrency",
+            "-c",
+            min=1,
+            show_default=True,
+            help="Maximum number of concurrent downloads.",
+        ),
+    ] = 4,
+    timeout: Annotated[
+        float,
+        typer.Option(
+            "--timeout",
+            min=1.0,
+            show_default=True,
+            help="Request timeout in seconds.",
+        ),
+    ] = 600.0,
+    dry_run: Annotated[
+        bool,
+        typer.Option(
+            "--dry-run/--no-dry-run",
+            show_default=True,
+            help="Preview downloads and README rewrites without performing any changes.",
+        ),
+    ] = False,
+    skip_existing: Annotated[
+        bool,
+        typer.Option(
+            "--skip-existing/--no-skip-existing",
+            show_default=True,
+            help="Skip downloading files that already exist locally.",
+        ),
+    ] = True,
+    use_staging: Annotated[
+        bool,
+        typer.Option(
+            "--stage/--no-stage",
+            show_default=True,
+            help="Download to a temporary staging directory first, then move to final destination.",
+        ),
+    ] = False,
+    clean_invalid: Annotated[
+        bool,
+        typer.Option(
+            "--clean-invalid",
+            help="Delete files with incorrect sizes but don't download. Useful for cleaning up failed downloads.",
+        ),
+    ] = False,
+) -> None:
+    front_matter_text, body_text = read_front_matter(readme_path)
+    entries = load_data_file_entries(front_matter_text)
+    if not entries:
+        logger.warning("No data_files entries found in README front matter.")
+        raise typer.Exit(code=0)
+
+    logger.info(f"Found {len(entries)} data file URLs across {readme_path}.")
+    output_dir = output_dir.resolve()
+
+    if clean_invalid:
+        # Fetch remote file sizes
+        logger.info("Fetching remote file sizes to check for invalid files...")
+        remote_sizes = asyncio.run(
+            fetch_remote_sizes(
+                entries=entries,
+                max_concurrency=max_concurrency,
+                timeout=timeout,
+            )
+        )
+
+        # Check and delete invalid files
+        deleted = 0
+        skipped = 0
+        missing = 0
+        size_unknown = 0
+
+        table = Table(title="Cleaning invalid files")
+        table.add_column("Config")
+        table.add_column("File")
+        table.add_column("Status")
+        table.add_column("Local size")
+        table.add_column("Remote size")
+
+        for entry in entries:
+            destination = resolve_destination(entry, output_dir)
+            _, remote_path = entry.parsed()
+            filename = Path(remote_path).name or remote_path
+
+            if not destination.exists():
+                missing += 1
+                table.add_row(
+                    entry.config_name,
+                    filename,
+                    "[dim]Not found[/dim]",
+                    "-",
+                    "-",
+                )
+                continue
+
+            local_size = destination.stat().st_size
+            remote_size = remote_sizes.get(entry.url)
+
+            if not remote_size:
+                size_unknown += 1
+                table.add_row(
+                    entry.config_name,
+                    filename,
+                    "[cyan]Skipped (remote size unknown)[/cyan]",
+                    f"{local_size:,}",
+                    "Unknown",
+                )
+                continue
+
+            if local_size == remote_size:
+                skipped += 1
+                table.add_row(
+                    entry.config_name,
+                    filename,
+                    "[green]Valid[/green]",
+                    f"{local_size:,}",
+                    f"{remote_size:,}",
+                )
+            else:
+                # Size mismatch - delete the file
+                destination.unlink()
+                deleted += 1
+                logger.warning(
+                    f"Deleted {destination} (size mismatch: {local_size:,} != {remote_size:,})"
+                )
+                table.add_row(
+                    entry.config_name,
+                    filename,
+                    "[red]Deleted (size mismatch)[/red]",
+                    f"{local_size:,}",
+                    f"{remote_size:,}",
+                )
+
+        console.print(table)
+        logger.info(
+            f"Summary: {deleted} deleted, {skipped} valid, {missing} missing, {size_unknown} unknown size"
+        )
+        return
+
+    if dry_run:
+        # Fetch remote file sizes
+        logger.info("Fetching remote file sizes for dry-run preview...")
+        remote_sizes = asyncio.run(
+            fetch_remote_sizes(
+                entries=entries,
+                max_concurrency=max_concurrency,
+                timeout=timeout,
+            )
+        )
+
+        preview = Table(title="Download plan (dry-run)")
+        preview.add_column("Config")
+        preview.add_column("Local file", overflow="fold")
+        preview.add_column("Status")
+        preview.add_column("Local size")
+        preview.add_column("Remote size")
+        preview.add_column("Source URL", overflow="fold")
+
+        for order, entry in enumerate(entries):
+            destination = resolve_destination(entry, output_dir)
+            try:
+                relative = destination.relative_to(output_dir)
+            except ValueError:
+                relative = Path(destination)
+
+            # Check local file
+            local_exists = destination.exists()
+            local_size = destination.stat().st_size if local_exists else None
+            remote_size = remote_sizes.get(entry.url)
+
+            # Determine status
+            if not local_exists:
+                status = "[yellow]Will download[/yellow]"
+                local_size_str = "-"
+            elif not skip_existing:
+                status = "[red]Will overwrite[/red]"
+                local_size_str = f"{local_size:,}"
+            elif remote_size and local_size == remote_size:
+                status = "[green]Will skip (exists)[/green]"
+                local_size_str = f"{local_size:,}"
+            elif not remote_size:
+                status = "[cyan]Will skip (exists, size unknown)[/cyan]"
+                local_size_str = f"{local_size:,}"
+            else:
+                # skip_existing=True but sizes don't match
+                status = "[red]Will overwrite (size mismatch)[/red]"
+                local_size_str = f"{local_size:,}"
+
+            remote_size_str = f"{remote_size:,}" if remote_size else "Unknown"
+
+            row_data = [
+                entry.config_name,
+                relative.as_posix(),
+                status,
+                local_size_str,
+                remote_size_str,
+                entry.url,
+            ]
+
+            preview.add_row(*row_data)
+
+        console.print(preview)
+
+        # Summary statistics
+        will_download = 0
+        will_skip = 0
+        will_overwrite = 0
+
+        for entry in entries:
+            dest = resolve_destination(entry, output_dir)
+            local_exists = dest.exists()
+            local_size = dest.stat().st_size if local_exists else None
+            remote_size = remote_sizes.get(entry.url)
+
+            if not local_exists:
+                will_download += 1
+            elif not skip_existing:
+                will_overwrite += 1
+            elif remote_size and local_size == remote_size:
+                will_skip += 1
+            elif not remote_size:
+                will_skip += 1
+            else:
+                will_overwrite += 1
+
+        logger.info(
+            f"Summary: {will_download} new, {will_skip} will skip, {will_overwrite} will overwrite"
+        )
+        logger.info("Dry run: no files downloaded and README left unchanged.")
+        return
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    results = asyncio.run(
+        perform_downloads(
+            entries=entries,
+            output_dir=output_dir,
+            max_concurrency=max_concurrency,
+            timeout=timeout,
+            skip_existing=skip_existing,
+            use_staging=use_staging,
+        )
+    )
+
+    successes = sum(1 for item in results if item.success)
+    failures = len(results) - successes
+    skipped = sum(1 for item in results if item.skipped)
+    logger.info(f"{successes} succeeded, {failures} failed, {skipped} skipped.")
+
+    if failures:
+        for item in results:
+            if not item.success:
+                logger.error(f"Error: {item.entry.url} -> {item.error}")
+        raise typer.Exit(code=1)
+
+
+@app.command()
+def rewrite(
+    output_dir: Annotated[
+        Path,
+        typer.Option(
+            "--output-dir",
+            "-o",
+            help="Directory where downloaded files are stored.",
+            resolve_path=True,
+        ),
+    ],
+    base_url: Annotated[
+        str,
+        typer.Option(
+            "--base-url",
+            "-u",
+            help=(
+                "Base URL for rewriting URLs in README. Files under output_dir will be rewritten "
+                "to use this base URL. Example: if output_dir=/data/files and base_url=https://example.com/dataset, "
+                "then /data/files/particles/file.parquet becomes https://example.com/dataset/particles/file.parquet"
+            ),
+        ),
+    ],
+    readme_path: Annotated[
+        Path,
+        typer.Option(
+            "--readme-path",
+            "-r",
+            help="Path to the README file with YAML front matter.",
+            exists=True,
+            resolve_path=True,
+            dir_okay=False,
+        ),
+    ] = Path("README.md"),
+    dry_run: Annotated[
+        bool,
+        typer.Option(
+            "--dry-run/--no-dry-run",
+            show_default=True,
+            help="Preview URL rewrites without modifying the README.",
+        ),
+    ] = False,
+    skip_missing: Annotated[
+        bool,
+        typer.Option(
+            "--skip-missing/--no-skip-missing",
+            show_default=True,
+            help="Skip rewriting URLs for files that don't exist locally.",
+        ),
+    ] = True,
+) -> None:
+    """Rewrite URLs in README to point to local files served at a base URL."""
+    front_matter_text, body_text = read_front_matter(readme_path)
+    entries = load_data_file_entries(front_matter_text)
+    if not entries:
+        logger.warning("No data_files entries found in README front matter.")
+        raise typer.Exit(code=0)
+
+    logger.info(f"Found {len(entries)} data file URLs in {readme_path}.")
+    output_dir = output_dir.resolve()
+
+    # Build list of results for files that exist
+    results: List[DownloadResult] = []
+    missing_files = []
+
+    for order, entry in enumerate(entries):
+        destination = resolve_destination(entry, output_dir)
+        if destination.exists():
+            results.append(
+                DownloadResult(
+                    entry=entry,
+                    path=destination,
+                    success=True,
+                    skipped=False,
+                    order=order,
+                )
+            )
+        else:
+            missing_files.append((entry, destination))
+
+    if missing_files:
+        if not skip_missing:
+            logger.error(f"Found {len(missing_files)} missing files:")
+            for entry, dest in missing_files:
+                logger.error(f"  {entry.config_name}: {dest}")
+            logger.error(
+                "Use --skip-missing to rewrite URLs only for existing files, "
+                "or download the missing files first."
+            )
+            raise typer.Exit(code=1)
+        else:
+            logger.warning(
+                f"Skipping {len(missing_files)} missing files "
+                f"(rewriting {len(results)} existing files)"
+            )
+
+    if not results:
+        logger.error("No files found to rewrite URLs for.")
+        raise typer.Exit(code=1)
+
+    # Preview or perform rewrite
+    table = Table(title="URL rewrite preview" if dry_run else "README URL updates")
+    table.add_column("Config")
+    table.add_column("Local file", overflow="fold")
+    table.add_column("Old URL", overflow="fold")
+    table.add_column("New URL", overflow="fold")
+
+    replacements: list[tuple[DownloadResult, str]] = []
+    for result in results:
+        relative_path = result.path.relative_to(output_dir)
+        new_url = build_rewritten_url(result, output_dir, base_url)
+        replacements.append((result, new_url))
+        table.add_row(
+            result.entry.config_name,
+            relative_path.as_posix(),
+            result.entry.url,
+            new_url,
+        )
+
+    console.print(table)
+
+    if dry_run:
+        logger.info(
+            f"Dry run: would rewrite {len(results)} URLs. "
+            "Remove --dry-run to apply changes."
+        )
+        return
+
+    # Apply rewrites
+    updated_front = front_matter_text
+    for result, new_url in replacements:
+        updated_front = replace_once(updated_front, result.entry.url, new_url)
+
+    readme_path.write_text(f"---\n{updated_front}\n---\n{body_text}", encoding="utf-8")
+    logger.info(f"Successfully rewrote {len(results)} URLs in {readme_path}")
+
+
+@app.command()
+def verify(
+    readme_path: Annotated[
+        Path,
+        typer.Option(
+            "--readme-path",
+            "-r",
+            help="Path to the README file with YAML front matter.",
+            exists=True,
+            resolve_path=True,
+            dir_okay=False,
+        ),
+    ] = Path("README.md"),
+    max_concurrency: Annotated[
+        int,
+        typer.Option(
+            "--max-concurrency",
+            "-c",
+            min=1,
+            show_default=True,
+            help="Maximum concurrent verification requests.",
+        ),
+    ] = 8,
+    timeout: Annotated[
+        float,
+        typer.Option(
+            "--timeout",
+            min=1.0,
+            show_default=True,
+            help="Request timeout in seconds.",
+        ),
+    ] = 60.0,
+) -> None:
+    front_matter_text, _ = read_front_matter(readme_path)
+    entries = load_data_file_entries(front_matter_text)
+    if not entries:
+        logger.warning("No data_files entries found in README front matter.")
+        raise typer.Exit(code=0)
+
+    logger.info(f"Verifying {len(entries)} URLs from {readme_path}.")
+    results = asyncio.run(
+        perform_verification(
+            entries=entries,
+            max_concurrency=max_concurrency,
+            timeout=timeout,
+        )
+    )
+
+    table = Table(title="URL verification results")
+    table.add_column("Config")
+    table.add_column("Status")
+    table.add_column("Detail", overflow="fold")
+    failed = 0
+    for result in sorted(results, key=lambda r: (not r.ok, r.order)):
+        status_text = str(result.status) if result.status is not None else "-"
+        if result.ok:
+            table.add_row(
+                result.entry.config_name,
+                f"[green]{status_text}[/green]",
+                result.entry.url,
+            )
+        else:
+            failed += 1
+            detail = result.detail or result.entry.url
+            table.add_row(
+                result.entry.config_name,
+                f"[red]{status_text}[/red]",
+                f"{result.entry.url}\n{detail}",
+            )
+
+    console.print(table)
+    if failed:
+        logger.error(f"{failed} URLs failed verification.")
+        raise typer.Exit(code=1)
+    logger.info("All URLs verified successfully.")
+
+
+@app.command()
+def checksum(
+    readme_path: Annotated[
+        Path,
+        typer.Option(
+            "--readme-path",
+            "-r",
+            help="Path to the README file with YAML front matter.",
+            exists=True,
+            resolve_path=True,
+            dir_okay=False,
+        ),
+    ] = Path("README.md"),
+    checksum_dir: Annotated[
+        Path,
+        typer.Option(
+            "--checksum-dir",
+            "-d",
+            help="Directory containing SHA256 checksum files (one per config).",
+            resolve_path=True,
+        ),
+    ] = Path("checksums"),
+    max_concurrency: Annotated[
+        int,
+        typer.Option(
+            "--max-concurrency",
+            "-c",
+            min=1,
+            show_default=True,
+            help="Maximum concurrent checksum operations.",
+        ),
+    ] = 8,
+    timeout: Annotated[
+        float,
+        typer.Option(
+            "--timeout",
+            min=1.0,
+            show_default=True,
+            help="Request timeout in seconds.",
+        ),
+    ] = 300.0,
+    generate: Annotated[
+        bool,
+        typer.Option(
+            "--generate",
+            help="Generate/update checksum files with current remote file checksums.",
+        ),
+    ] = False,
+    update_mismatches: Annotated[
+        bool,
+        typer.Option(
+            "--update-mismatches",
+            help="Update checksum files with new hashes for files that don't match.",
+        ),
+    ] = False,
+) -> None:
+    """Verify file integrity using SHA256 checksums."""
+    front_matter_text, _ = read_front_matter(readme_path)
+    entries = load_data_file_entries(front_matter_text)
+    if not entries:
+        logger.warning("No data_files entries found in README front matter.")
+        raise typer.Exit(code=0)
+
+    logger.info(f"Computing checksums for {len(entries)} files from {readme_path}.")
+
+    # Get unique config names
+    config_names = sorted(set(entry.config_name for entry in entries))
+
+    # Load existing hashes per config unless we're regenerating
+    expected_hashes_by_config: Dict[str, Dict[str, str]] = {}
+    if not generate:
+        for config_name in config_names:
+            expected_hashes_by_config[config_name] = load_checksums_for_config(
+                checksum_dir, config_name
+            )
+
+    # Compute checksums
+    results = asyncio.run(
+        perform_checksum_verification(
+            entries=entries,
+            expected_hashes_by_config=expected_hashes_by_config,
+            max_concurrency=max_concurrency,
+            timeout=timeout,
+        )
+    )
+
+    # Display results
+    table = Table(title="Checksum verification results")
+    table.add_column("Config")
+    table.add_column("Filename")
+    table.add_column("Status")
+    table.add_column("SHA256", overflow="fold")
+
+    failed = 0
+    mismatched = 0
+    # new_hashes_by_config: config_name -> (filename -> hash)
+    new_hashes_by_config: Dict[str, Dict[str, str]] = {}
+
+    for result in results:
+        if not result.success:
+            failed += 1
+            error_msg = str(result.error) if result.error else "Unknown error"
+            table.add_row(
+                result.entry.config_name,
+                result.filename,
+                "[red]ERROR[/red]",
+                error_msg,
+            )
+        elif generate:
+            # In generate mode, just collect all hashes
+            if result.entry.config_name not in new_hashes_by_config:
+                new_hashes_by_config[result.entry.config_name] = {}
+            new_hashes_by_config[result.entry.config_name][result.filename] = (
+                result.computed_hash or ""
+            )
+            table.add_row(
+                result.entry.config_name,
+                result.filename,
+                "[cyan]COMPUTED[/cyan]",
+                result.computed_hash or "-",
+            )
+        elif result.expected_hash is None:
+            # No expected hash available
+            table.add_row(
+                result.entry.config_name,
+                result.filename,
+                "[yellow]NEW[/yellow]",
+                result.computed_hash or "-",
+            )
+            if update_mismatches and result.computed_hash:
+                if result.entry.config_name not in new_hashes_by_config:
+                    new_hashes_by_config[result.entry.config_name] = {}
+                new_hashes_by_config[result.entry.config_name][
+                    result.filename
+                ] = result.computed_hash
+        elif result.matches:
+            # Hash matches
+            table.add_row(
+                result.entry.config_name,
+                result.filename,
+                "[green]OK[/green]",
+                result.computed_hash or "-",
+            )
+        else:
+            # Hash mismatch
+            mismatched += 1
+            table.add_row(
+                result.entry.config_name,
+                result.filename,
+                "[red]MISMATCH[/red]",
+                f"Expected: {result.expected_hash}\nComputed: {result.computed_hash}",
+            )
+            if update_mismatches and result.computed_hash:
+                if result.entry.config_name not in new_hashes_by_config:
+                    new_hashes_by_config[result.entry.config_name] = {}
+                new_hashes_by_config[result.entry.config_name][
+                    result.filename
+                ] = result.computed_hash
+
+    console.print(table)
+
+    # Handle checksum file updates
+    if generate:
+        total_saved = 0
+        for config_name, file_hashes in new_hashes_by_config.items():
+            save_checksums_for_config(checksum_dir, config_name, file_hashes)
+            total_saved += len(file_hashes)
+        logger.info(
+            f"Generated {len(new_hashes_by_config)} checksum files with {total_saved} total checksums."
+        )
+    elif update_mismatches and new_hashes_by_config:
+        total_updated = 0
+        for config_name, new_file_hashes in new_hashes_by_config.items():
+            # Merge with existing hashes for this config
+            all_hashes = load_checksums_for_config(checksum_dir, config_name)
+            all_hashes.update(new_file_hashes)
+            save_checksums_for_config(checksum_dir, config_name, all_hashes)
+            total_updated += len(new_file_hashes)
+        logger.warning(
+            f"Updated {total_updated} checksums across {len(new_hashes_by_config)} checksum files."
+        )
+
+    # Exit with appropriate code
+    if failed:
+        logger.error(f"{failed} files failed checksum computation.")
+        raise typer.Exit(code=1)
+    if mismatched and not update_mismatches:
+        logger.error(f"{mismatched} files have checksum mismatches.")
+        logger.warning("Use --update-mismatches to update the checksum files.")
+        raise typer.Exit(code=1)
+    if not generate and not mismatched and not failed:
+        logger.info("All checksums verified successfully.")
+
+
+def clean_arrow_type(type_str: str) -> str:
+    """Clean up Arrow type string for display."""
+    # Remove "element: " from list types
+    # Pattern: list<element: TYPE> -> list<TYPE>
+    cleaned = re.sub(r"list<element:\s*", "list<", type_str)
+    return cleaned
+
+
+def escape_latex(text: str) -> str:
+    """Escape special LaTeX characters."""
+    # Map of characters to escape
+    replacements = {
+        "\\": r"\\",  # Backslash must be first to avoid double-escaping
+        "&": r"\&",
+        "%": r"\%",
+        "$": r"\$",
+        "#": r"\#",
+        "_": r"\_",
+        "{": r"\{",
+        "}": r"\}",
+        "~": r"\textasciitilde{}",
+        "^": r"\^{}",
+    }
+    for char, escaped in replacements.items():
+        text = text.replace(char, escaped)
+    return text
+
+
+async def inspect_file_schema(
+    entry: DataFileEntry,
+    session: aiohttp.ClientSession,
+    semaphore: asyncio.Semaphore,
+    progress: Progress,
+) -> SchemaInfo:
+    """Download file and extract schema information using PyArrow."""
+    _, remote_path = entry.parsed()
+    filename = Path(remote_path).name or remote_path
+    terse_name = (filename[:32] + "…") if len(filename) > 33 else filename
+    description = f"{entry.config_name}: {terse_name}"
+
+    async with semaphore:
+        task_id: int | None = None
+        temp_file = None
+        try:
+            task_id = progress.add_task(description, total=0, start=False)
+            progress.start_task(task_id)
+
+            # Download to temporary file
+            async with session.get(entry.url) as response:
+                response.raise_for_status()
+                total_bytes = response.content_length or 0
+
+                if total_bytes:
+                    progress.update(task_id, total=total_bytes)
+
+                with tempfile.NamedTemporaryFile(delete=False, suffix=".parquet") as f:
+                    temp_file = Path(f.name)
+                    async for chunk in response.content.iter_chunked(1 << 17):
+                        f.write(chunk)
+                        progress.update(task_id, advance=len(chunk))
+
+                    # Read schema with PyArrow
+                    parquet_file = pq.read_table(temp_file)
+                    schema = parquet_file.schema
+
+            columns = [
+                (field.name, clean_arrow_type(str(field.type))) for field in schema
+            ]
+            num_rows = len(parquet_file)
+
+            return SchemaInfo(
+                config_name=entry.config_name,
+                filename=filename,
+                columns=columns,
+                num_rows=num_rows,
+                success=True,
+            )
+
+        except Exception as exc:  # noqa: BLE001
+            return SchemaInfo(
+                config_name=entry.config_name,
+                filename=filename,
+                columns=[],
+                num_rows=None,
+                success=False,
+                error=exc,
+            )
+        finally:
+            if task_id is not None:
+                progress.remove_task(task_id)
+            # Clean up temp file
+            if temp_file and temp_file.exists():
+                temp_file.unlink()
+
+
+async def perform_schema_inspection(
+    entries: Sequence[DataFileEntry],
+    max_concurrency: int,
+    timeout: float,
+) -> List[SchemaInfo]:
+    """Download first file from each config and inspect schema."""
+    if not entries:
+        return []
+
+    semaphore = asyncio.Semaphore(max_concurrency)
+    timeout_cfg = aiohttp.ClientTimeout(total=timeout)
+    results: List[SchemaInfo] = []
+    progress = Progress(
+        TextColumn("{task.description}"),
+        BarColumn(bar_width=None),
+        DownloadColumn(),
+        TransferSpeedColumn(),
+        TimeElapsedColumn(),
+        console=console,
+    )
+
+    async with aiohttp.ClientSession(timeout=timeout_cfg) as session:
+        with progress:
+            tasks = [
+                asyncio.create_task(
+                    inspect_file_schema(entry, session, semaphore, progress)
+                )
+                for entry in entries
+            ]
+            for future in asyncio.as_completed(tasks):
+                result = await future
+                results.append(result)
+
+    # Sort by config name for consistent output
+    results.sort(key=lambda r: r.config_name)
+    return results
+
+
+@app.command()
+def schema(
+    readme_path: Annotated[
+        Path,
+        typer.Option(
+            "--readme-path",
+            "-r",
+            help="Path to the README file with YAML front matter.",
+            exists=True,
+            resolve_path=True,
+            dir_okay=False,
+        ),
+    ] = Path("README.md"),
+    output_file: Annotated[
+        Path | None,
+        typer.Option(
+            "--output-file",
+            "-o",
+            help="Write schema information to plain text file.",
+            resolve_path=True,
+            dir_okay=False,
+        ),
+    ] = None,
+    latex: Annotated[
+        bool,
+        typer.Option(
+            "--latex",
+            help="Output schema in LaTeX format (requires --output-file).",
+        ),
+    ] = False,
+    max_concurrency: Annotated[
+        int,
+        typer.Option(
+            "--max-concurrency",
+            "-c",
+            min=1,
+            show_default=True,
+            help="Maximum concurrent downloads.",
+        ),
+    ] = 4,
+    timeout: Annotated[
+        float,
+        typer.Option(
+            "--timeout",
+            min=1.0,
+            show_default=True,
+            help="Request timeout in seconds.",
+        ),
+    ] = 300.0,
+    types: Annotated[bool, typer.Option(help="Add column type info")] = True,
+) -> None:
+    """Inspect schema of first file from each dataset config."""
+    # Validate options
+    if latex and not output_file:
+        logger.error("--latex requires --output-file to be specified.")
+        raise typer.Exit(code=1)
+
+    front_matter_text, _ = read_front_matter(readme_path)
+    entries = load_data_file_entries(front_matter_text)
+    if not entries:
+        logger.warning("No data_files entries found in README front matter.")
+        raise typer.Exit(code=0)
+
+    # Get first file from each config
+    configs_seen = set()
+    first_files = []
+    for entry in entries:
+        if entry.config_name not in configs_seen:
+            first_files.append(entry)
+            configs_seen.add(entry.config_name)
+
+    logger.info(f"Inspecting schema for {len(first_files)} configs.")
+
+    # Perform schema inspection
+    results = asyncio.run(
+        perform_schema_inspection(
+            entries=first_files,
+            max_concurrency=max_concurrency,
+            timeout=timeout,
+        )
+    )
+
+    # Display results
+    failed = 0
+    text_output_lines = []
+    latex_items = []
+
+    for result in results:
+        if not result.success:
+            failed += 1
+            error_msg = str(result.error) if result.error else "Unknown error"
+            logger.error(
+                f"Failed to inspect {result.config_name}/{result.filename}: {error_msg}"
+            )
+            continue
+
+        # Prepare output file content
+        if output_file:
+            if latex:
+                # LaTeX format: \item \textbf{CONFIG}: \texttt{col1} (\texttt{type1}), ...
+                escaped_config = escape_latex(result.config_name)
+                column_parts = []
+                for col_name, col_type in result.columns:
+                    escaped_col = escape_latex(col_name)
+                    escaped_type = escape_latex(col_type)
+                    part = f"\\texttt{{{escaped_col}}}"
+                    if types:
+                        part += f" (\\texttt{{{escaped_type}}})"
+                    column_parts.append(part)
+                columns_str = ", ".join(column_parts)
+                latex_items.append(
+                    f"\\item \\textbf{{{escaped_config}}}: {columns_str}"
+                )
+            else:
+                # Plain text format
+                text_output_lines.append(f"# {result.config_name} — {result.filename}")
+                if result.num_rows is not None:
+                    text_output_lines.append(
+                        f"# {len(result.columns)} columns, {result.num_rows:,} rows"
+                    )
+                text_output_lines.append("")
+                for col_name, col_type in result.columns:
+                    text_output_lines.append(f"{col_name}: {col_type}")
+                text_output_lines.append("")
+
+        # Create table for console display
+        table = Table(title=f"[bold]{result.config_name}[/bold] — {result.filename}")
+        table.add_column("Column", style="cyan")
+        table.add_column("Type", style="yellow")
+
+        for col_name, col_type in result.columns:
+            table.add_row(col_name, col_type)
+
+        console.print(table)
+        if result.num_rows is not None:
+            logger.info(
+                f"{result.config_name}: {len(result.columns)} columns, {result.num_rows:,} rows"
+            )
+        console.print()  # Empty line between configs
+
+    # Write to output file if specified
+    if output_file:
+        if latex and latex_items:
+            latex_content = (
+                "\\begin{itemize}\n" + "\n".join(latex_items) + "\n\\end{itemize}"
+            )
+            output_file.write_text(latex_content, encoding="utf-8")
+            logger.info(f"Wrote LaTeX schema to {output_file}")
+        elif text_output_lines:
+            output_file.write_text("\n".join(text_output_lines), encoding="utf-8")
+            logger.info(f"Wrote schema information to {output_file}")
+
+    if failed:
+        logger.error(f"{failed} configs failed schema inspection.")
+        raise typer.Exit(code=1)
+    logger.info("Schema inspection completed successfully.")
+
+
+if __name__ == "__main__":
+    app()

tracker_hits.sha256

@@ -0,0 +1,100 @@
+40a3e5f0fb8252309ff963081a8cfce9aff3baaea347e744a43edb21da371e99  hard_scatter.ggf.v1.reco.tracker_hits.events0-999.parquet
+1fef61a8b45b2bf8a7fa43d319526e2a9466f7c83e4afe97b47d4011b5f66e77  hard_scatter.ggf.v1.reco.tracker_hits.events1000-1999.parquet
+bd2887fe2c9f05e6b3bc2c1d49f54259110e06dbec292ef1b544bb328f92f1d9  hard_scatter.ggf.v1.reco.tracker_hits.events10000-10999.parquet
+d57207fcda9cb6c7e4cbe516b2709d2ff96979e49cfbf80be3a397f2fe757f41  hard_scatter.ggf.v1.reco.tracker_hits.events11000-11999.parquet
+85cb716a048fa8100b04d6f1dc81d2d9f753b508e289d6fe0034e620cc6ff53b  hard_scatter.ggf.v1.reco.tracker_hits.events12000-12999.parquet
+830b86318753736883b7760184e03de3d41f7e010b76ea711cc92253df0305fb  hard_scatter.ggf.v1.reco.tracker_hits.events13000-13999.parquet
+616392d873f4cbb49813d970a7743bc6e4bb526441c39c895f81e010c3a0b731  hard_scatter.ggf.v1.reco.tracker_hits.events14000-14999.parquet
+f292f92688b74ece8da2058b4f898b4b55fe2b4dd48226611bd75c39b84f1676  hard_scatter.ggf.v1.reco.tracker_hits.events15000-15999.parquet
+ff43c7cb3c03bae51cbd3de0fdfa4e6c9e04b656b621606eccb338b99dd16014  hard_scatter.ggf.v1.reco.tracker_hits.events16000-16999.parquet
+a884e6688a497cbf658446a893e7011bfde785c9e6f032d5b5c8ddb410e9cec9  hard_scatter.ggf.v1.reco.tracker_hits.events17000-17999.parquet
+b8386f9f538f066adbd004ad7e295837f72f735cecd087143c33bfcf4cbadcf2  hard_scatter.ggf.v1.reco.tracker_hits.events18000-18999.parquet
+417d759efd0abbb1f3757a9bf8921d322a0a839704feb50b6e073664e2e1e654  hard_scatter.ggf.v1.reco.tracker_hits.events19000-19999.parquet
+907d0b191da02be0e1f53270e9b5eb970b7f872054f9431400f19845112c67c4  hard_scatter.ggf.v1.reco.tracker_hits.events2000-2999.parquet
+f0480fc8544da41a702256e5627a701b6dd3785f69c1921056efddb88e11354c  hard_scatter.ggf.v1.reco.tracker_hits.events20000-20999.parquet
+d66c770474a086fbfb01f208f95c36f20ba5fdaf2e0f44072abbe55d70b85461  hard_scatter.ggf.v1.reco.tracker_hits.events21000-21999.parquet
+9f575bd8e09aa9b0c2a19b5b67f603cfc9af29d20dbd16f9fb5c6d5ea780632a  hard_scatter.ggf.v1.reco.tracker_hits.events22000-22999.parquet
+7ff6a507647cb419bc431c6f0bfec42da1f315a473e781998f430353996e6da3  hard_scatter.ggf.v1.reco.tracker_hits.events23000-23999.parquet
+c0c73b4dd9e479b816b9435e8df96dc5fdcd29653c090dbc5919f00866a090d5  hard_scatter.ggf.v1.reco.tracker_hits.events24000-24999.parquet
+72fdc33cae508e575aaf5939059c6cf7ed1e9361e9efd28223039272fe5e9478  hard_scatter.ggf.v1.reco.tracker_hits.events25000-25999.parquet
+12eb77a3b0ac1c8d19a69c861100a325149a003e8ce5b77584edbe79bf25fc9e  hard_scatter.ggf.v1.reco.tracker_hits.events26000-26999.parquet
+deee72ecbe403769403d257b4717a08df7aea95b7578bc2ac8b1d487d9429262  hard_scatter.ggf.v1.reco.tracker_hits.events27000-27999.parquet
+c97d190775ef30a03d20f8a29b05a5dcf51d94c9c930197bdbf5fd37b3e713af  hard_scatter.ggf.v1.reco.tracker_hits.events28000-28999.parquet
+ad0bc6a08f20552bc4eda5ead08b31b965e9c3832ee94b6a15c45717618c10b4  hard_scatter.ggf.v1.reco.tracker_hits.events29000-29999.parquet
+364a465f98a331e860c547ef5bc169cb11678acc023b0f152f7cf9589ab790c8  hard_scatter.ggf.v1.reco.tracker_hits.events3000-3999.parquet
+d38ca9b05de270fc97d4a47f84a298ca12a574ab3c8b984fef321bbd9bae5e55  hard_scatter.ggf.v1.reco.tracker_hits.events30000-30999.parquet
+4980df96cb0f3415cee86fb95f2cf5a12f14879b7d315b3b27cebb4ec88f3991  hard_scatter.ggf.v1.reco.tracker_hits.events31000-31999.parquet
+d7ab78e0178f0536b7e20b2d140589ecea7ce663bf101e04b3a0851a8b8f1f97  hard_scatter.ggf.v1.reco.tracker_hits.events32000-32999.parquet
+d5f9eb101d0002ba1b0925a7b3c1b3c88a682c7e5e102b2350947df3b26e9951  hard_scatter.ggf.v1.reco.tracker_hits.events33000-33999.parquet
+52ad6318e321a3dcec8264e1dc361d5983fb11431f34874791ed95ec7d5dc1ba  hard_scatter.ggf.v1.reco.tracker_hits.events34000-34999.parquet
+3f9bb069fcc58c4ef64fafba85a7bbb4502e22918270771743e247fd16b908d3  hard_scatter.ggf.v1.reco.tracker_hits.events35000-35999.parquet
+a3165c65f6ed9b0c7747f2a1a429b06c5abcb5243a90efc364d5bb289b0874ff  hard_scatter.ggf.v1.reco.tracker_hits.events36000-36999.parquet
+198533ed401cace4b0c1c753d2f88173aa1c4ad178ce06b15210b4ba6deafab2  hard_scatter.ggf.v1.reco.tracker_hits.events37000-37999.parquet
+d72660479f5cfbaaa8cb122e8a6e15853c94eb8a81c55e53baa5d4fdec59ab14  hard_scatter.ggf.v1.reco.tracker_hits.events38000-38999.parquet
+f2b40d2348adf6452a7f0b5d5f00237ce75b996ee7d9ed156f6640964cb4d558  hard_scatter.ggf.v1.reco.tracker_hits.events39000-39999.parquet
+01560bcf7fa5ceed601caac6334feb34f46803620928b5ed24a5c61d478c48fa  hard_scatter.ggf.v1.reco.tracker_hits.events4000-4999.parquet
+1b9385123c94dc305854e52af2a048ba47b1edadd8670e198a2c59a9ca9749ee  hard_scatter.ggf.v1.reco.tracker_hits.events40000-40999.parquet
+f14dc791a7a633e477f2aad630213c259528fa5aa1e1b7be3282e2f035a98605  hard_scatter.ggf.v1.reco.tracker_hits.events41000-41999.parquet
+001b542f75fceb42148669702b8fbc78d2d85a56b6b02f93ced939dc1835e1a0  hard_scatter.ggf.v1.reco.tracker_hits.events42000-42999.parquet
+46ea263ab14025da48c86ba3566e972e9a4b5f99bacfd9dc160dcbd25a3ed810  hard_scatter.ggf.v1.reco.tracker_hits.events43000-43999.parquet
+8a9f6b3c8754fc0fc985b72b947cf415208bd88169cbaa5a2fa625025ff694cc  hard_scatter.ggf.v1.reco.tracker_hits.events44000-44999.parquet
+598ff99a95b471569d1129c537473d5a4521ad40cb07d4e9634b806cb248e071  hard_scatter.ggf.v1.reco.tracker_hits.events45000-45999.parquet
+eaa015b70affa62de4edac9839d94199c04cf15db91f16c9908b610d93f6aa06  hard_scatter.ggf.v1.reco.tracker_hits.events46000-46999.parquet
+65e38780d9649ef99625484a00ee30ab792803afdfa650292db5a20594b0380d  hard_scatter.ggf.v1.reco.tracker_hits.events47000-47999.parquet
+2c7c8ff407d4ecbd92490f48715f504b370a027d5cd8c85c8a39e03f2485b6df  hard_scatter.ggf.v1.reco.tracker_hits.events48000-48999.parquet
+a909eb3e243d2c5e25b091936723e99575a8ee4e510134af6aee03b8eac6e05c  hard_scatter.ggf.v1.reco.tracker_hits.events49000-49999.parquet
+39269d6cd7fe5c9ab4e22719c10dc0f3d38f5822534e2da19596fbe15b1c770d  hard_scatter.ggf.v1.reco.tracker_hits.events5000-5999.parquet
+0f2d8f5b29d3db70135e9af213e10e0a26c47519170b5d49aaa801e4e5985ef9  hard_scatter.ggf.v1.reco.tracker_hits.events50000-50999.parquet
+49c41f8420595bacaa475cc0c32e23c06aad023039e38b51a55a38cb3e4dde36  hard_scatter.ggf.v1.reco.tracker_hits.events51000-51999.parquet
+994cc272e7cdc6b8bc51c5a1d8692c830ee952869ed41d9f04c41fc6f2746678  hard_scatter.ggf.v1.reco.tracker_hits.events52000-52999.parquet
+7f6e9342da1e1e395de5d20085fb47c1160980e97dcabdd455b5d746d92a9976  hard_scatter.ggf.v1.reco.tracker_hits.events53000-53999.parquet
+3c6b222c1679a29ff2b773d9ba236df889683cb8d1829f73feaf266846bb3bf4  hard_scatter.ggf.v1.reco.tracker_hits.events54000-54999.parquet
+baa6273e6cd80896df4c103de4b6ea18f6dae0475aec6b07a9fdb65f7392238e  hard_scatter.ggf.v1.reco.tracker_hits.events55000-55999.parquet
+3c15dac56ebff318540680eabd847c16a157974e435b535906f24900373affb5  hard_scatter.ggf.v1.reco.tracker_hits.events56000-56999.parquet
+6b436d2f70832c3f16ba8f2092053ae1bc18cb49532925c05eca259193e5241c  hard_scatter.ggf.v1.reco.tracker_hits.events57000-57999.parquet
+94233c0470493296d987e21e3ea8f196d71baef4f8dceb9fe59c0449f754869b  hard_scatter.ggf.v1.reco.tracker_hits.events58000-58999.parquet
+bc3d4d05d454f79a96157484a8522dbc51c144061d32fe899494e8a6049207c6  hard_scatter.ggf.v1.reco.tracker_hits.events59000-59999.parquet
+a4be3ccf354f152df35017aa6a61000a0a1e70562174cd3651169b5e89f3d0a8  hard_scatter.ggf.v1.reco.tracker_hits.events6000-6999.parquet
+c8d41a21572a9f4ab7c9b12b8d7e6da65fb39598fef2696aea8273206542ec95  hard_scatter.ggf.v1.reco.tracker_hits.events60000-60999.parquet
+9eed6196c15e3f67e291238485eb92fff536bdff0d10f704267ff740c5812c18  hard_scatter.ggf.v1.reco.tracker_hits.events61000-61999.parquet
+fd2b96cf7644c355842e873ce88257d611b348a307845305b0b9dd2eca507fa1  hard_scatter.ggf.v1.reco.tracker_hits.events62000-62999.parquet
+6ba7b639a85d6921f70e5353497559ef6b35d19d6d62fab895a31c3a1b07111d  hard_scatter.ggf.v1.reco.tracker_hits.events63000-63999.parquet
+dadee4e742af1aef718d816976cff2a5665266af7e5e5eba2eeafd82437f2ed1  hard_scatter.ggf.v1.reco.tracker_hits.events64000-64999.parquet
+8c2c0b59063f5dcf36f0418687553415b9ad803880602fe3d3ec7fe103ca1ba2  hard_scatter.ggf.v1.reco.tracker_hits.events65000-65999.parquet
+164008489d7e3d2a0aa908b214a7ee1f0d0b5b5709fdea88885a4227bc714018  hard_scatter.ggf.v1.reco.tracker_hits.events66000-66999.parquet
+64af8c9cfdd9a0670cc9425cdd1791a8d6d717f357efa2fc2279d6d890f2e500  hard_scatter.ggf.v1.reco.tracker_hits.events67000-67999.parquet
+cc93854ab73d5440528a1187443e80c8b2dda195472e920c8dae0d6eed162f68  hard_scatter.ggf.v1.reco.tracker_hits.events68000-68999.parquet
+6604ae2716f05d58b4c54b2b18e31fdabea8774287957a604b5f05db382fedc3  hard_scatter.ggf.v1.reco.tracker_hits.events69000-69999.parquet
+b1b8adb8c743f4348451f22a73d380c3a97395496701359dbd4f20a9e972ed85  hard_scatter.ggf.v1.reco.tracker_hits.events7000-7999.parquet
+db0f012834d1c1904c7caf12befa388de45c74f19aac708bd9e1d127060dce98  hard_scatter.ggf.v1.reco.tracker_hits.events70000-70999.parquet
+6192a53099ddb1408e3df10b0f70e04a38d2e52f09578512d79dca971079e214  hard_scatter.ggf.v1.reco.tracker_hits.events71000-71999.parquet
+a5d8bcaaa59f2f6971ab867059fd608d0ff9a30b137780b77038afdcf20f0f42  hard_scatter.ggf.v1.reco.tracker_hits.events72000-72999.parquet
+2b47d920dd6e82598388a46ad175d141bd2b68d3c03aa640dad6df02990f8e5e  hard_scatter.ggf.v1.reco.tracker_hits.events73000-73999.parquet
+167a1165aeb064690f0dca16c44bbebc69248452dfa3402a0e5e7f8eb114a98b  hard_scatter.ggf.v1.reco.tracker_hits.events74000-74999.parquet
+42864ddae810351babb115a90b4206b0bce723e7cb6eba42967365125b7dba36  hard_scatter.ggf.v1.reco.tracker_hits.events75000-75999.parquet
+f9fefdc461ce96d2eb5386f973df5e120a4606b0973ee9e928e7bff5113b46bd  hard_scatter.ggf.v1.reco.tracker_hits.events76000-76999.parquet
+ad33fc6c39a958ab0a28b7a06ddced3548e79b814c7418377cc589bcfbe85acc  hard_scatter.ggf.v1.reco.tracker_hits.events77000-77999.parquet
+2da257c047eac3e138a95981883b21825592cdd375bee690450451b2154aa537  hard_scatter.ggf.v1.reco.tracker_hits.events78000-78999.parquet
+cb6fa568c9a168e0aa091c217de4f83e26f87100acbb95bddcd644043540aca6  hard_scatter.ggf.v1.reco.tracker_hits.events79000-79999.parquet
+6aec7c362b3d47422e5cf6af131a649c6ce13de81f9786e3c2c2a4b06532068c  hard_scatter.ggf.v1.reco.tracker_hits.events8000-8999.parquet
+6b2dc41e48dec4df859f2cfd349a6b68dfd06b5945bf6d6e5841486f0a2d0e5a  hard_scatter.ggf.v1.reco.tracker_hits.events80000-80999.parquet
+81b8fefa7554867d7ce47a703275df5197c7793f8c6d6aad292b58e79d9195d4  hard_scatter.ggf.v1.reco.tracker_hits.events81000-81999.parquet
+04fda7efe82d2a4a7ca1d4a46f42c7f35fe408ee71e77f0290212f526a8bd0fb  hard_scatter.ggf.v1.reco.tracker_hits.events82000-82999.parquet
+f91478438a2b97c310c4c885196943617cc039cad5296a9116961f889c984673  hard_scatter.ggf.v1.reco.tracker_hits.events83000-83999.parquet
+8046eff83f407afe693ecaa8b9c3eaa5dc49d85bc30348b99f384c2649101932  hard_scatter.ggf.v1.reco.tracker_hits.events84000-84999.parquet
+a7cc904cdf5d91178e65a69db481f2aacd9692f81447782a659b99c35d9033ff  hard_scatter.ggf.v1.reco.tracker_hits.events85000-85999.parquet
+bac9320b407947465ba9e189043d3902c2e43935e0d9b3a10a7225d655a5012e  hard_scatter.ggf.v1.reco.tracker_hits.events86000-86999.parquet
+dee05cadcb57f3abec4527ac167a3bfd5313208a8bc2cd74162b395db3c33a5b  hard_scatter.ggf.v1.reco.tracker_hits.events87000-87999.parquet
+c6501c5134dec46da79111cb30d527986320a37cc0ccf85c7fc4a6e682433525  hard_scatter.ggf.v1.reco.tracker_hits.events88000-88999.parquet
+c7902f71de90a2f501e01e39167b4deea4f2c2f1e6e02d7a9068ff526fac9b7f  hard_scatter.ggf.v1.reco.tracker_hits.events89000-89999.parquet
+5db6ce01442c65c125adb256d00527cfb10e73360579abed1aaf81cbde7f5317  hard_scatter.ggf.v1.reco.tracker_hits.events9000-9999.parquet
+67885c561a7477b7a00346ecb112c1381d8870c9e144314ed13684f721fd10cf  hard_scatter.ggf.v1.reco.tracker_hits.events90000-90999.parquet
+c56e0a0a826be0192361e8ea32c174bc6531450daf23f25c4097ecdbc3ad20c0  hard_scatter.ggf.v1.reco.tracker_hits.events91000-91999.parquet
+a50fa8d98732d10755483aa9061fc16d8f68c34ae95fe801d2d51486e847ea21  hard_scatter.ggf.v1.reco.tracker_hits.events92000-92999.parquet
+a6a83629423ecb58a53f84f83ca631bf4f5ccf8736cae163294b155d7b123c19  hard_scatter.ggf.v1.reco.tracker_hits.events93000-93999.parquet
+83e6c279b9add5720e7595ebbdd6e14bfa4e58aa0c597f6d08c1c873c5f5008c  hard_scatter.ggf.v1.reco.tracker_hits.events94000-94999.parquet
+7996a990631484ee8d89c1557db3d9f03487223cf9b955bf336cc39ec79b3ff0  hard_scatter.ggf.v1.reco.tracker_hits.events95000-95999.parquet
+546c17167ab5124eb8727c67579357257b05ab3768ec4785412325e2e925cb99  hard_scatter.ggf.v1.reco.tracker_hits.events96000-96999.parquet
+fcc1fb724ee4f149c4bbb9b22589c2f6eaf3181deed808270ecc8e55e54ca316  hard_scatter.ggf.v1.reco.tracker_hits.events97000-97999.parquet
+9bc2593f9083524df35a56c173f1e6a7dfd00f3b36d021402d8b9326feafa0a5  hard_scatter.ggf.v1.reco.tracker_hits.events98000-98999.parquet
+3cc53a7014107bb8baf91da6a9d9d838864b2f7ff414854524660171e90c94c0  hard_scatter.ggf.v1.reco.tracker_hits.events99000-99999.parquet

tracks.sha256

@@ -0,0 +1,100 @@
+d56a9de0d2d1bcaeb35987e239c2456e7bfe0bc31f8ae02852663aa7c191db90  hard_scatter.ggf.v1.reco.tracks.events0-999.parquet
+fec41d0666902ef6839034881e9ad5f7c6e953ec81ed4c68ba43e21c468ee8a0  hard_scatter.ggf.v1.reco.tracks.events1000-1999.parquet
+c08f62c69cf89f670a10c703fcbc3733e9e1c14b826ded93c536953026ccf080  hard_scatter.ggf.v1.reco.tracks.events10000-10999.parquet
+fb788bd732d500c97f29dc17cad589bd58b254eacc08172e046fb226f3143d08  hard_scatter.ggf.v1.reco.tracks.events11000-11999.parquet
+4737a2aea632515ba894c1086d9d83c37ff63a43f5164622299f07a484deffc3  hard_scatter.ggf.v1.reco.tracks.events12000-12999.parquet
+efb6d4af1a43e46195c874fe7efb08ee90fe5b0787e97709bc82431c312e4e50  hard_scatter.ggf.v1.reco.tracks.events13000-13999.parquet
+edbe49ac457a09bf66b3432e356a01787bcc40ec733a878bfce770233b86c1a9  hard_scatter.ggf.v1.reco.tracks.events14000-14999.parquet
+889bde5d2ae25eedcfc3ce423f39eab75c39b4734eada0ddee271c274f20705e  hard_scatter.ggf.v1.reco.tracks.events15000-15999.parquet
+56ac41856a1912727935b0a3bf13c8e8036e147232150f9e6aecab53279396fb  hard_scatter.ggf.v1.reco.tracks.events16000-16999.parquet
+a9f12815de10a9ed9898f21e1d724f870fd05c29be96b3a91e694b9763006535  hard_scatter.ggf.v1.reco.tracks.events17000-17999.parquet
+57944126af3f95cd3cb3dfe4421be26a5a37e743e2581ccd00cc603a776326e4  hard_scatter.ggf.v1.reco.tracks.events18000-18999.parquet
+418249e5b094a80a91fb85a26b3ee8a62069519c9d07461a624b53123cc4cbd3  hard_scatter.ggf.v1.reco.tracks.events19000-19999.parquet
+c5c1344e633d2b502b2ded06da7dd9e3a011644870d773638e66f949e28a4df6  hard_scatter.ggf.v1.reco.tracks.events2000-2999.parquet
+600dae534691e58508f2f7d78cbd1af32dd91ab7f36888a163dd9413016bd1ed  hard_scatter.ggf.v1.reco.tracks.events20000-20999.parquet
+2c767eddcd5692a825bddb4bd63ab0e7937a07e1df66711200f4481502dad971  hard_scatter.ggf.v1.reco.tracks.events21000-21999.parquet
+6f79822d0264deceba5dead81cfeeac07d49a72069f751c88769208514c7c6d5  hard_scatter.ggf.v1.reco.tracks.events22000-22999.parquet
+595142cc992c829338b3d1d652182d7778de70acc8964dde1a5ec6909b5db764  hard_scatter.ggf.v1.reco.tracks.events23000-23999.parquet
+bd277f713153c48e504a5cf2e8d34dae104c174aeab28ea798c7f162830b9d69  hard_scatter.ggf.v1.reco.tracks.events24000-24999.parquet
+1f288a0df744a29c18a2da19f920d517614283423acc39f060421e6d1f9d22f9  hard_scatter.ggf.v1.reco.tracks.events25000-25999.parquet
+c632bf43c0207bb512bfd6fe4ee2352d533e7f9506663a273cf3852eec34b21d  hard_scatter.ggf.v1.reco.tracks.events26000-26999.parquet
+bbac2cd9657f77a7ad3c731790a9dc49cd121068a06aa4bce274bed25a6a66b6  hard_scatter.ggf.v1.reco.tracks.events27000-27999.parquet
+47d2bc81ac1ae39919ae5b0360058cad6d4fa86447fe05a32e7731a2a4cf743d  hard_scatter.ggf.v1.reco.tracks.events28000-28999.parquet
+38d5c12ea7f21c385bfa2dec0180fcee6cd040a3f14da1f0653474cbb39cea5b  hard_scatter.ggf.v1.reco.tracks.events29000-29999.parquet
+e19db7cadaddcd7357b669bb76a777e765948dd1e13c5428662db9a737ebdd21  hard_scatter.ggf.v1.reco.tracks.events3000-3999.parquet
+b97731386fff7b63cb13cf98e91f15bb42aea9de9ee6de4b1e528596e7b0a4af  hard_scatter.ggf.v1.reco.tracks.events30000-30999.parquet
+f9126aac84c2e119de20fc9fd5d34c0c0904310a2bf4d24f888d6cf81556d2fd  hard_scatter.ggf.v1.reco.tracks.events31000-31999.parquet
+4e9bba3a6d23fe6fd111eea76f39641e2cefe168db9b361b01b3c8114799ad6c  hard_scatter.ggf.v1.reco.tracks.events32000-32999.parquet
+d902c91290ab9ee7be30b4d59e2d8746a36b82977621c33f1836bd7b52b64e60  hard_scatter.ggf.v1.reco.tracks.events33000-33999.parquet
+a7a2d6979f21b87cd7db292758bbfc05d767b79489635fa513ecf8e4c0afb6e2  hard_scatter.ggf.v1.reco.tracks.events34000-34999.parquet
+3667c368277809193a23f5367f78a5b25c7a2d5cb6240b602beb4f2acc849916  hard_scatter.ggf.v1.reco.tracks.events35000-35999.parquet
+aba1d44c7fd2a98dcc0e34aed8428e3f9cde80c453e8cfe06d6c0128af359a6e  hard_scatter.ggf.v1.reco.tracks.events36000-36999.parquet
+40195916aae78776bb5956b169be57c28e7f9a8cd6728a4e6bf0a1b267f32e62  hard_scatter.ggf.v1.reco.tracks.events37000-37999.parquet
+0920452cb02a218dd42c9c171bbb4db039cb5dfbdf552e885657bfd438de02d2  hard_scatter.ggf.v1.reco.tracks.events38000-38999.parquet
+b32d86696eca003193952194ec2b1d73342868e275a5bdaa55cabb3ac2150af9  hard_scatter.ggf.v1.reco.tracks.events39000-39999.parquet
+1dd8e1d388c62f4e11634e1d8dcc9130dadbb7f3b2c9a7fe26c115a4b3d4b76f  hard_scatter.ggf.v1.reco.tracks.events4000-4999.parquet
+5fdd9f2ea5c55de57fba2ee6d56b671b7d73a344cb648dc57380b2c68993a9cd  hard_scatter.ggf.v1.reco.tracks.events40000-40999.parquet
+40d308ae4de99accd133bb0fbfebda347947ef945cbc1ca15f11099c520195ee  hard_scatter.ggf.v1.reco.tracks.events41000-41999.parquet
+5a32b138d5133be741f903af5498d3378d34f22fbf596368caff83e065b16dd3  hard_scatter.ggf.v1.reco.tracks.events42000-42999.parquet
+3380c60333e5fcd8ab77198dc144ddcf68a62172d944287e5a91d550e1ced000  hard_scatter.ggf.v1.reco.tracks.events43000-43999.parquet
+91201b33e2b82326430492a363ba4ef87ce25e4488017bcb2e52d587d43c7479  hard_scatter.ggf.v1.reco.tracks.events44000-44999.parquet
+1ba807c77b3757ae7dc7f872e67fd4b92d09330f0e416f157ba84fcd034969c1  hard_scatter.ggf.v1.reco.tracks.events45000-45999.parquet
+8e0b00abf7f080fff0e1fe872951a4fbe6340a0799ea0b4006e0a43c7f270b4f  hard_scatter.ggf.v1.reco.tracks.events46000-46999.parquet
+fd4394ae944dcf33edec6c9b946bf47f5f8b28d738d80a8de3140bdad8c6d63a  hard_scatter.ggf.v1.reco.tracks.events47000-47999.parquet
+5e35f95730260d8fb3e924b654c7c942733b53f9eb2b687a3063a44a78376ce8  hard_scatter.ggf.v1.reco.tracks.events48000-48999.parquet
+2f0faa91003c1b47e530228d6de1eb87fc36b5bc798d4c3b97e3dda389bc6aaf  hard_scatter.ggf.v1.reco.tracks.events49000-49999.parquet
+3f206be19c3be16293272387ce4199f58ae419f8fa8b885a5ff0dc6fd6ec75ce  hard_scatter.ggf.v1.reco.tracks.events5000-5999.parquet
+782e0ab9abe6d9a4f82da2bfdfa37c9d3e71af0f8f06ace0f2ec3b9b87345597  hard_scatter.ggf.v1.reco.tracks.events50000-50999.parquet
+ddacdf92f72f3efe00ecc7d5e07572d92471ac5b2ba57b88aff3656f6b13c9a9  hard_scatter.ggf.v1.reco.tracks.events51000-51999.parquet
+9322317bd3e8e1e17fac8b457541143d1378b38d3e8082b74c3a88f845328720  hard_scatter.ggf.v1.reco.tracks.events52000-52999.parquet
+7ae920f16684d9acf1142b573fa88dbf72405d269c15f131b77c14725f7eee6b  hard_scatter.ggf.v1.reco.tracks.events53000-53999.parquet
+730bec2876d6c59e5a403ead25a79d780a0845e410af14018f2b3aad86c2ee47  hard_scatter.ggf.v1.reco.tracks.events54000-54999.parquet
+c837ef4c8f80fb3a554414114350cc87f312ad56d4ec3b5cfa99f573c6b6c19f  hard_scatter.ggf.v1.reco.tracks.events55000-55999.parquet
+a918d117bc5b71a7711d1207c154a79f91f670bb7a30adbdffbdfca9069b9c2d  hard_scatter.ggf.v1.reco.tracks.events56000-56999.parquet
+1b412b33e2bf8226edf021432a2a75cbce9eb130dce0de63fe29096b3f137427  hard_scatter.ggf.v1.reco.tracks.events57000-57999.parquet
+8988f3838a30fdf90ef2d6ffded15d1d8b0d6daadfc77a96046ea4b60786c338  hard_scatter.ggf.v1.reco.tracks.events58000-58999.parquet
+d77ebd8d68fd3c7ca6d7f593b7fb6b8b179941e13f99facb9c9f711750f683e1  hard_scatter.ggf.v1.reco.tracks.events59000-59999.parquet
+fe963b8aec61d5ad338128c99aa5bace34f044375f125f69eb004a83b9907721  hard_scatter.ggf.v1.reco.tracks.events6000-6999.parquet
+78b0f8c6f6a346d61b5f7002d80c2d9eb5a05b63fc7c8e93229db2b901a97812  hard_scatter.ggf.v1.reco.tracks.events60000-60999.parquet
+09187355a5647703c71f87bec0d109bf0abaa786b8532f4acb3835d3b6f9e857  hard_scatter.ggf.v1.reco.tracks.events61000-61999.parquet
+830d3b69c52c600988487b7a8fcdd1de5e262815819c01bd098cd8c388b71a8e  hard_scatter.ggf.v1.reco.tracks.events62000-62999.parquet
+3355285bb7e3e1698eb06f9171f37b4a9e7e0ee9031cdc7c5614dcddee53d0f9  hard_scatter.ggf.v1.reco.tracks.events63000-63999.parquet
+cd4bd1545a1e3b28eb67c6bcff36e607889b39ba7ac146c40adb63039fbbde6a  hard_scatter.ggf.v1.reco.tracks.events64000-64999.parquet
+66a72601126154309d719c5d76696cfb710ddb85f3196182d6a4da84b3a72cfd  hard_scatter.ggf.v1.reco.tracks.events65000-65999.parquet
+54a9acc3f5bb91e819d0645a1a17f3235babc8503ca66af92deb2853c3b517ef  hard_scatter.ggf.v1.reco.tracks.events66000-66999.parquet
+1dc43f0a299e8fe13b42c485e73a33e854cbb8e7e297be17f625b7cd07758ab9  hard_scatter.ggf.v1.reco.tracks.events67000-67999.parquet
+dc68e8303a2e8d4db5bc0431559dc5629d4f5678b00ee96874f956dc6cd2e1ad  hard_scatter.ggf.v1.reco.tracks.events68000-68999.parquet
+b0a981b6221c469bf49ab02849837cb9ea674f38a05a46c3f9eef9bd4d6f5ab5  hard_scatter.ggf.v1.reco.tracks.events69000-69999.parquet
+f3137f9d1badefe46b41f4d2e55f0b05887423cd8685f71ad84bed995b1905c4  hard_scatter.ggf.v1.reco.tracks.events7000-7999.parquet
+15639a877754c30b748432468e446d34c39dc3468fb58ace8ea8f7840d117afd  hard_scatter.ggf.v1.reco.tracks.events70000-70999.parquet
+2ba69ab43224fc183cdb4f05543bfee0fe8f65817e0416b02d5d060f750c0300  hard_scatter.ggf.v1.reco.tracks.events71000-71999.parquet
+bbdf425f5d1418bcf6f50e0ec56f2423e9d82bdf94d50e42677d2130a33f180c  hard_scatter.ggf.v1.reco.tracks.events72000-72999.parquet
+7cb2872564b5f8b47a819f51a41013d2813e15ef85ba493370c65f516948f988  hard_scatter.ggf.v1.reco.tracks.events73000-73999.parquet
+017cc057f64575b2c1e6fac9b4e479dea416224340be4fa42c7f786b613dc99d  hard_scatter.ggf.v1.reco.tracks.events74000-74999.parquet
+04b2d12655bdcf457c4ed3d74ff8c818a4207e5382e9406b5b843e9934ec18ef  hard_scatter.ggf.v1.reco.tracks.events75000-75999.parquet
+136f1fdf842ae89c2e108e433715bd69940fa92ef8f2e91b23178d5eaaba9956  hard_scatter.ggf.v1.reco.tracks.events76000-76999.parquet
+1bfc75720634510d3e5ac0b4451da0327c9b7fbbb1df822588e5ef6a115578a7  hard_scatter.ggf.v1.reco.tracks.events77000-77999.parquet
+68e1eef7b53765cc0fb769ce643e180fcac69b52d4cd370e1ede45f4063f9857  hard_scatter.ggf.v1.reco.tracks.events78000-78999.parquet
+ac339e89d7356924e30a0f26a0e14a6dbbb2eb508b30c54701594ad780340563  hard_scatter.ggf.v1.reco.tracks.events79000-79999.parquet
+9b07bd4e8966fcb588809057a7afb868cd8ea13ada6c1bcc2bf01a274e625724  hard_scatter.ggf.v1.reco.tracks.events8000-8999.parquet
+7a7123c0fe53f6d072f42a3b765811c4e212115cefa4cb3eac5d7026ef1d02cf  hard_scatter.ggf.v1.reco.tracks.events80000-80999.parquet
+18f28ac99d48ccc69e175f441565bb4cabbb241dd8268f1c42546bb159a18217  hard_scatter.ggf.v1.reco.tracks.events81000-81999.parquet
+9efd76a8004c180bbbc8868583416572b0b888dd51b42422e3bfd0a6f058d6e3  hard_scatter.ggf.v1.reco.tracks.events82000-82999.parquet
+821ebfaec19e9643633dc4a520fbff0d3eb127780825075c196e38d650b4d6a8  hard_scatter.ggf.v1.reco.tracks.events83000-83999.parquet
+f7a62a49653ada5e668d2ba7c85a90fd8a816649cc450d0a65a68b0e7484d010  hard_scatter.ggf.v1.reco.tracks.events84000-84999.parquet
+a6655773bfc48b6e12d958505c6952e8d26fbabbe5e6895fdefbf8c9ebff84d5  hard_scatter.ggf.v1.reco.tracks.events85000-85999.parquet
+1420aea29a11b3ef99d0b9e82eab71e10fc6e220ce1187cccdccea17ca4a4ca5  hard_scatter.ggf.v1.reco.tracks.events86000-86999.parquet
+5ec9c895e8fe9f10644ccccc1c1f026339f819c3528ab0ca84475f4f4aaa9828  hard_scatter.ggf.v1.reco.tracks.events87000-87999.parquet
+bb154b9fb8923891b294ea969359837e12b9d88289753c2da692db23626fc3c9  hard_scatter.ggf.v1.reco.tracks.events88000-88999.parquet
+3767909de6df8dc99a07a83d963b90d75a6848bc6992825ebe840bc90f4ff313  hard_scatter.ggf.v1.reco.tracks.events89000-89999.parquet
+0191182ddfae4095da1005ceea5a41747d9d4771c7baccdf7e223f098c0f86d6  hard_scatter.ggf.v1.reco.tracks.events9000-9999.parquet
+8f514954e3bfb0bce647fb8398bd3933bf02a1408c3e34059638d3e456d0dde9  hard_scatter.ggf.v1.reco.tracks.events90000-90999.parquet
+89ac3e2447cae8a45f5156282a1d562aa01e98b8bdeb09c2c3bbd0111f340842  hard_scatter.ggf.v1.reco.tracks.events91000-91999.parquet
+db71922542bf1f48e07123b125555f9144fa098c47484d5dbca6e415dbe8712b  hard_scatter.ggf.v1.reco.tracks.events92000-92999.parquet
+57c5560567285c4a1a15acba0d4453363e5215565d3e8544e35861ef65b623eb  hard_scatter.ggf.v1.reco.tracks.events93000-93999.parquet
+ab0703a10920c04e3c53b2b404af03053422078191a1810a5dd0f92673b7136f  hard_scatter.ggf.v1.reco.tracks.events94000-94999.parquet
+c2c6d13ed590543a93d0f95f8b3f8b978bc3e2583a6f6a3035bb84ca0bc83515  hard_scatter.ggf.v1.reco.tracks.events95000-95999.parquet
+bc0e448db081cab4f88219d144189df2ac2279473d41911b6c4c7e7b748f19ac  hard_scatter.ggf.v1.reco.tracks.events96000-96999.parquet
+d40910a0b286f110db8da3c666e6e0765f2177f09a72807622c181638d678b89  hard_scatter.ggf.v1.reco.tracks.events97000-97999.parquet
+ccabd788be981ea4cfb1c2a458a8666ed2d06354f61a0740e0226ceac13de58e  hard_scatter.ggf.v1.reco.tracks.events98000-98999.parquet
+68706a5015f127c9319c3d3ff30b30099ad5c7b7ad38c035db853be8509de978  hard_scatter.ggf.v1.reco.tracks.events99000-99999.parquet