{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "26b5b0d7-e935-4de9-aba7-eb8183f71fa4",
   "metadata": {},
   "source": [
    "# Getting Partial Results with `split_fileset`\n",
    "\n",
    "When processing large filesets, individual files or datasets can fail — a broken XRootD link, a network timeout, a corrupt file. By default, one failure aborts the whole run and you lose all partial progress.\n",
    "\n",
    "This notebook shows two utilities from `coffea.dataset_tools` that let you work around this:\n",
    "\n",
    "- **`split_fileset`** — divides a fileset into independently-processable chunks so a single failure only loses one chunk\n",
    "- **`hash_fileset`** — produces a stable content-based hash for a chunk, enabling on-disk caching so successfully processed chunks are never re-run\n",
    "\n",
    "These work alongside the `use_result_type=True` flag on `processor.Runner`, which changes the runner's return value from a plain accumulator to an `Ok(Accumulatable)`/`Err(Exception)` result object — letting you decide what to do with each failed chunk instead of catching exceptions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "cda0d64d-6b39-47ed-9ad2-0741ad6663ba",
   "metadata": {},
   "outputs": [],
   "source": [
    "import hist\n",
    "import coffea.processor as processor\n",
    "from coffea.nanoevents import schemas\n",
    "from coffea.dataset_tools import split_fileset, hash_fileset\n",
    "from coffea.util import load, save"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b1308e0-8735-467e-8666-e509136eff1a",
   "metadata": {},
   "source": [
    "## 1. Processor\n",
    "\n",
    "No changes are needed to the processor itself, `split_fileset` works with any existing `ProcessorABC` subclass."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "26495a49-c13a-472c-9d3f-d20a2aba36d2",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Processor(processor.ProcessorABC):\n",
    "    def __init__(self):\n",
    "        dataset_axis = hist.axis.StrCategory(name=\"dataset\", label=\"\", categories=[], growth=True)\n",
    "        MET_axis = hist.axis.Regular(name=\"MET\", label=\"MET [GeV]\", bins=50, start=0, stop=100)\n",
    "        self.output = processor.dict_accumulator({\n",
    "            'MET': hist.Hist(dataset_axis, MET_axis),\n",
    "            'cutflow': processor.defaultdict_accumulator(int)\n",
    "        })\n",
    "\n",
    "    def process(self, events):\n",
    "        dataset = events.metadata[\"dataset\"]\n",
    "        MET = events.MET.pt\n",
    "        self.output['cutflow']['all events'] += len(MET)\n",
    "        self.output['cutflow']['number of chunks'] += 1\n",
    "        self.output['MET'].fill(dataset=dataset, MET=MET)\n",
    "        return self.output\n",
    "\n",
    "    def postprocess(self, accumulator):\n",
    "        pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3de49799-5e69-46cf-9be0-3f946369bf4f",
   "metadata": {},
   "source": [
    "## 2. Setting up the Runner with `use_result_type=True`\n",
    "\n",
    "By default, `processor.Runner.__call__` returns the accumulator directly or raises on error.\n",
    "Setting `use_result_type=True` changes this: the runner returns an `Ok(output)` on success or `Err(exception)` on failure, without raising.\n",
    "\n",
    "`use_result_type` works as an extension of `skipbadfiles`: the `skipbadfiles` value picks which exception types are considered \"expected\" (broken file, missing tree, etc.), and `use_result_type=True` flips the handling of those exceptions from a silent skip + warning to an explicit `Err` return. Exceptions outside that set still propagate as real bugs.\n",
    "\n",
    "`skipbadfiles` is therefore **required** when `use_result_type=True`. The most common values are:\n",
    "\n",
    "- `skipbadfiles=True` — match `OSError` (the default file/network family). Good for most IO-failure cases.\n",
    "- `skipbadfiles=(FileNotFoundError, uproot.exceptions.KeyInFileError)` — restrict to a specific set.\n",
    "\n",
    "With `split_fileset` you process each chunk independently and decide per-chunk what to do based on result type:\n",
    "\n",
    "```python\n",
    "run_result = run(chunk, processor_instance=Processor())\n",
    "if run_result.is_ok():\n",
    "    output, metrics = run_result.unwrap()\n",
    "else:\n",
    "    print(f\"Chunk failed: {run_result.exception}\")\n",
    "```\n",
    "\n",
    "The `Result` API:\n",
    "- `result.is_ok()` — `True` if the chunk processed successfully\n",
    "- `result.unwrap()` — returns the value (`output` or `(output, metrics)` when `savemetrics=True`), or raises if `Err`\n",
    "- `result.exception` — the exception, if `Err`\n",
    "- `result.value` — when an executor with `recoverable=True` produced a partial accumulator before the failure, this holds the salvaged output (otherwise `None`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "96becdbb-1cd6-426f-8b1f-188664422ecd",
   "metadata": {},
   "outputs": [],
   "source": [
    "executor = processor.FuturesExecutor()\n",
    "\n",
    "run = processor.Runner(\n",
    "    executor=executor,\n",
    "    schema=schemas.NanoAODSchema,\n",
    "    savemetrics=True,\n",
    "    skipbadfiles=True,        # which exception types count as \"expected\"\n",
    "    use_result_type=True,     # ... and turn those into Err instead of silent skip\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f28a6f96-c05f-4725-8f76-d137152e1959",
   "metadata": {},
   "source": [
    "## 3. Splitting a fileset into chunks\n",
    "\n",
    "`split_fileset` divides a fileset into a list of smaller filesets (chunks). Each chunk can be processed independently, so a failure in one chunk does not affect the others.\n",
    "\n",
    "> **Note:** These chunks are *fileset-level* splits — a grouping of files — not the row-level chunks that coffea's executor creates internally when processing a single file.\n",
    "\n",
    "**Parameters:**\n",
    "\n",
    "- `fileset` — accepts any of the schemas understood by `processor.Runner`:\n",
    "  - `{dataset: {\"files\": {path: treename, ...}}}` (per-file treename — used in this notebook)\n",
    "  - `{dataset: {\"files\": [path, ...], \"treename\": ...}}` (dataset-level treename)\n",
    "  - `{dataset: [path, ...]}` (bare list — requires `treename=` below)\n",
    "- `strategy` — `\"by_dataset\"`: one dataset per chunk; `None` (default): all datasets together in each chunk\n",
    "- `percentage` — integer that divides 100 evenly (e.g. 20, 25, 50); each chunk gets this percentage of each dataset's files\n",
    "- `datasets` — list, callable, or tuple to restrict which datasets are included\n",
    "- `treename` — required when any dataset uses list-format files without its own `treename` field; the value is folded into each chunk so the chunks remain self-contained for caching\n",
    "\n",
    "**Splitting modes:**\n",
    "\n",
    "- `strategy=\"by_dataset\"` → one chunk per dataset\n",
    "- `percentage=20` → 5 mixed chunks, each containing 20% of *every* dataset\n",
    "- `strategy=\"by_dataset\", percentage=20` → `N_datasets × 5` chunks, each dataset split separately\n",
    "- `datasets=[\"X\"]` + any of the above → strategy applied only to the listed datasets\n",
    "\n",
    "File paths are sorted before slicing into bins, so chunk composition is deterministic regardless of input dict insertion order — important for stable cache keys via `hash_fileset`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "4621c2ff-47f7-4d1c-98d8-0e02784a7b0c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "strategy='by_dataset': 2 chunks\n",
      "[{'SingleMu_0': {'files': {'root://eeeeeeospublic.cern.ch//eos/opendata/cms/mc/RunIISummer20UL16NanoAODv9/GluGluHToWWTo2L2Nu_M125_TuneCP5_13TeV_powheg2_JHUGenV714_pythia8/NANOAODSIM/106X_mcRun2_asymptotic_v17-v2/260000/A41320F6-C9F9-574C-8DD2-BD98C200E4EE.root': 'Events',\n",
      "                           'root://eospublic.cern.ch//eos/opendata/cms/mc/RunIISummer20UL16NanoAODv9/GluGluHToWWTo2L2Nu_M125_TuneCP5_13TeV_powheg2_JHUGenV714_pythia8/NANOAODSIM/106X_mcRun2_asymptotic_v17-v2/260000/A7FEFB1C-387F-2B4D-A111-C53CC9371EC7.root': 'Events',\n",
      "                           'root://eospublic.cern.ch//eos/opendata/cms/mc/RunIISummer20UL16NanoAODv9/GluGluHToWWTo2L2Nu_M125_TuneCP5_13TeV_powheg2_JHUGenV714_pythia8/NANOAODSIM/106X_mcRun2_asymptotic_v17-v2/260000/AB10FBAB-92C0-C043-933D-117FCC5704BA.root': 'Events',\n",
      "                           'root://eospublic.cern.ch//eos/opendata/cms/mc/RunIISummer20UL16NanoAODv9/GluGluHToWWTo2L2Nu_M125_TuneCP5_13TeV_powheg2_JHUGenV714_pythia8/NANOAODSIM/106X_mcRun2_asymptotic_v17-v2/260000/C6E8BB7F-7F54-0C4C-9EDF-479C7DBB12E4.root': 'Events',\n",
      "                           'root://eospublic.cern.ch//eos/opendata/cms/mc/RunIISummer20UL16NanoAODv9/GluGluHToWWTo2L2Nu_M125_TuneCP5_13TeV_powheg2_JHUGenV714_pythia8/NANOAODSIM/106X_mcRun2_asymptotic_v17-v2/260000/CB90AA65-868A-F548-A291-3837A3113162.root': 'Events'}}},\n",
      " {'SingleMu_1': {'files': {'root://eospublic.cern.ch//eos/opendata/cms/mc/RunIISummer20UL16NanoAODv9/GluGluHToWWTo2L2Nu_M125_TuneCP5_13TeV_powheg2_JHUGenV714_pythia8/NANOAODSIM/106X_mcRun2_asymptotic_v17-v2/260000/18B53494-657F-5744-8131-58ABA4EE00ED.root': 'Events',\n",
      "                           'root://eospublic.cern.ch//eos/opendata/cms/mc/RunIISummer20UL16NanoAODv9/GluGluHToWWTo2L2Nu_M125_TuneCP5_13TeV_powheg2_JHUGenV714_pythia8/NANOAODSIM/106X_mcRun2_asymptotic_v17-v2/260000/2CCE1139-F301-C341-AE1E-4D27AF294018.root': 'Events',\n",
      "                           'root://eospublic.cern.ch//eos/opendata/cms/mc/RunIISummer20UL16NanoAODv9/GluGluHToWWTo2L2Nu_M125_TuneCP5_13TeV_powheg2_JHUGenV714_pythia8/NANOAODSIM/106X_mcRun2_asymptotic_v17-v2/260000/300C603C-F1DD-4A40-B4DD-F4E0B239A460.root': 'Events',\n",
      "                           'root://eospublic.cern.ch//eos/opendata/cms/mc/RunIISummer20UL16NanoAODv9/GluGluHToWWTo2L2Nu_M125_TuneCP5_13TeV_powheg2_JHUGenV714_pythia8/NANOAODSIM/106X_mcRun2_asymptotic_v17-v2/260000/39251543-EE21-9C4C-80D5-5D9178F55C71.root': 'Events',\n",
      "                           'root://eospublic.cern.ch//eos/opendata/cms/mc/RunIISummer20UL16NanoAODv9/GluGluHToWWTo2L2Nu_M125_TuneCP5_13TeV_powheg2_JHUGenV714_pythia8/NANOAODSIM/106X_mcRun2_asymptotic_v17-v2/260000/3BD29D89-9C4A-E743-8616-C6806281BF12.root': 'Events'}}}]\n",
      "\n",
      "strategy='by_dataset', percentage=20: 10 chunks\n",
      "\n",
      "percentage=20 (mixed): 5 chunks\n"
     ]
    }
   ],
   "source": [
    "import pprint\n",
    "\n",
    "fileset = {\n",
    "    'SingleMu_0': {\n",
    "        \"files\": {\n",
    "            # broken link (intentional — demonstrates error handling)\n",
    "            \"root://eeeeeeospublic.cern.ch//eos/opendata/cms/mc/RunIISummer20UL16NanoAODv9/GluGluHToWWTo2L2Nu_M125_TuneCP5_13TeV_powheg2_JHUGenV714_pythia8/NANOAODSIM/106X_mcRun2_asymptotic_v17-v2/260000/A41320F6-C9F9-574C-8DD2-BD98C200E4EE.root\": \"Events\",\n",
    "            \"root://eospublic.cern.ch//eos/opendata/cms/mc/RunIISummer20UL16NanoAODv9/GluGluHToWWTo2L2Nu_M125_TuneCP5_13TeV_powheg2_JHUGenV714_pythia8/NANOAODSIM/106X_mcRun2_asymptotic_v17-v2/260000/A7FEFB1C-387F-2B4D-A111-C53CC9371EC7.root\": \"Events\",\n",
    "            \"root://eospublic.cern.ch//eos/opendata/cms/mc/RunIISummer20UL16NanoAODv9/GluGluHToWWTo2L2Nu_M125_TuneCP5_13TeV_powheg2_JHUGenV714_pythia8/NANOAODSIM/106X_mcRun2_asymptotic_v17-v2/260000/AB10FBAB-92C0-C043-933D-117FCC5704BA.root\": \"Events\",\n",
    "            \"root://eospublic.cern.ch//eos/opendata/cms/mc/RunIISummer20UL16NanoAODv9/GluGluHToWWTo2L2Nu_M125_TuneCP5_13TeV_powheg2_JHUGenV714_pythia8/NANOAODSIM/106X_mcRun2_asymptotic_v17-v2/260000/C6E8BB7F-7F54-0C4C-9EDF-479C7DBB12E4.root\": \"Events\",\n",
    "            \"root://eospublic.cern.ch//eos/opendata/cms/mc/RunIISummer20UL16NanoAODv9/GluGluHToWWTo2L2Nu_M125_TuneCP5_13TeV_powheg2_JHUGenV714_pythia8/NANOAODSIM/106X_mcRun2_asymptotic_v17-v2/260000/CB90AA65-868A-F548-A291-3837A3113162.root\": \"Events\",\n",
    "        }\n",
    "    },\n",
    "    'SingleMu_1': {\n",
    "        \"files\": {\n",
    "            \"root://eospublic.cern.ch//eos/opendata/cms/mc/RunIISummer20UL16NanoAODv9/GluGluHToWWTo2L2Nu_M125_TuneCP5_13TeV_powheg2_JHUGenV714_pythia8/NANOAODSIM/106X_mcRun2_asymptotic_v17-v2/260000/18B53494-657F-5744-8131-58ABA4EE00ED.root\": \"Events\",\n",
    "            \"root://eospublic.cern.ch//eos/opendata/cms/mc/RunIISummer20UL16NanoAODv9/GluGluHToWWTo2L2Nu_M125_TuneCP5_13TeV_powheg2_JHUGenV714_pythia8/NANOAODSIM/106X_mcRun2_asymptotic_v17-v2/260000/2CCE1139-F301-C341-AE1E-4D27AF294018.root\": \"Events\",\n",
    "            \"root://eospublic.cern.ch//eos/opendata/cms/mc/RunIISummer20UL16NanoAODv9/GluGluHToWWTo2L2Nu_M125_TuneCP5_13TeV_powheg2_JHUGenV714_pythia8/NANOAODSIM/106X_mcRun2_asymptotic_v17-v2/260000/300C603C-F1DD-4A40-B4DD-F4E0B239A460.root\": \"Events\",\n",
    "            \"root://eospublic.cern.ch//eos/opendata/cms/mc/RunIISummer20UL16NanoAODv9/GluGluHToWWTo2L2Nu_M125_TuneCP5_13TeV_powheg2_JHUGenV714_pythia8/NANOAODSIM/106X_mcRun2_asymptotic_v17-v2/260000/39251543-EE21-9C4C-80D5-5D9178F55C71.root\": \"Events\",\n",
    "            \"root://eospublic.cern.ch//eos/opendata/cms/mc/RunIISummer20UL16NanoAODv9/GluGluHToWWTo2L2Nu_M125_TuneCP5_13TeV_powheg2_JHUGenV714_pythia8/NANOAODSIM/106X_mcRun2_asymptotic_v17-v2/260000/3BD29D89-9C4A-E743-8616-C6806281BF12.root\": \"Events\",\n",
    "        }\n",
    "    }\n",
    "}\n",
    "\n",
    "# strategy=\"by_dataset\": one chunk per dataset -> 2 chunks\n",
    "chunks_1 = split_fileset(fileset, strategy=\"by_dataset\")\n",
    "print(f\"strategy='by_dataset': {len(chunks_1)} chunks\")\n",
    "pprint.pprint(chunks_1)\n",
    "\n",
    "print()\n",
    "# strategy=\"by_dataset\", percentage=20: 5 chunks per dataset -> 10 chunks total\n",
    "chunks_2 = split_fileset(fileset, strategy=\"by_dataset\", percentage=20)\n",
    "print(f\"strategy='by_dataset', percentage=20: {len(chunks_2)} chunks\")\n",
    "\n",
    "print()\n",
    "# percentage=20: 5 mixed chunks — each chunk contains 20% of SingleMu_0 + 20% of SingleMu_1\n",
    "chunks_3 = split_fileset(fileset, percentage=20)\n",
    "print(f\"percentage=20 (mixed): {len(chunks_3)} chunks\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b8993c6-41f8-4f51-985a-06348e576cbd",
   "metadata": {},
   "source": [
    "## 4. Example 1: `strategy=\"by_dataset\"`\n",
    "\n",
    "The fileset has two datasets: `SingleMu_0` (which contains a broken link) and `SingleMu_1` (all valid files).\n",
    "With `strategy=\"by_dataset\"`, each dataset is its own chunk — so the failure in `SingleMu_0` leaves `SingleMu_1` unaffected.\n",
    "\n",
    "Expected result: the run for `SingleMu_0` returns `Err`, the run for `SingleMu_1` returns `Ok` and its output is accumulated."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "ba247645-de2a-4606-9b46-4ba3db86f40d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "632a394952254ac6bf29c0258742ade1",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/iason/Dropbox/work/pyhep_dev/coffea/src/coffea/processor/executor.py:1277: UserWarning: Performed attempt 1 out of 4\n",
      "  warnings.warn(\n",
      "/home/iason/Dropbox/work/pyhep_dev/coffea/src/coffea/processor/executor.py:1277: UserWarning: Performed attempt 2 out of 4\n",
      "  warnings.warn(\n",
      "/home/iason/Dropbox/work/pyhep_dev/coffea/src/coffea/processor/executor.py:1277: UserWarning: Performed attempt 3 out of 4\n",
      "  warnings.warn(\n",
      "/home/iason/Dropbox/work/pyhep_dev/coffea/src/coffea/processor/executor.py:1277: UserWarning: Performed attempt 4 out of 4\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"></pre>\n"
      ],
      "text/plain": []
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "loky.process_executor._RemoteTraceback: \n",
      "\"\"\"\n",
      "Traceback (most recent call last):\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/loky/process_executor.py\", line 490, in _process_worker\n",
      "    r = call_item()\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/loky/process_executor.py\", line 291, in __call__\n",
      "    return self.fn(*self.args, **self.kwargs)\n",
      "           ~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
      "  File \"/home/iason/Dropbox/work/pyhep_dev/coffea/src/coffea/processor/executor.py\", line 1289, in automatic_retries\n",
      "    raise e\n",
      "  File \"/home/iason/Dropbox/work/pyhep_dev/coffea/src/coffea/processor/executor.py\", line 1275, in automatic_retries\n",
      "    return func(*args, **kwargs)\n",
      "  File \"/home/iason/Dropbox/work/pyhep_dev/coffea/src/coffea/processor/executor.py\", line 1359, in metadata_fetcher_root\n",
      "    with uproot.open(\n",
      "         ~~~~~~~~~~~^\n",
      "        {item.filename: None}, timeout=xrootdtimeout, **uproot_options\n",
      "        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
      "    ) as file:\n",
      "    ^\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/uproot/reading.py\", line 144, in open\n",
      "    file = ReadOnlyFile(\n",
      "        file_path,\n",
      "    ...<5 lines>...\n",
      "        **options,\n",
      "    )\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/uproot/reading.py\", line 563, in __init__\n",
      "    self._source = source_cls(file_path, **self._options)\n",
      "                   ~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/uproot/source/fsspec.py\", line 63, in __init__\n",
      "    self._open()\n",
      "    ~~~~~~~~~~^^\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/uproot/source/fsspec.py\", line 70, in _open\n",
      "    self._fo = self._open_file.__enter__()\n",
      "               ~~~~~~~~~~~~~~~~~~~~~~~~~^^\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/fsspec/core.py\", line 105, in __enter__\n",
      "    f = self.fs.open(self.path, mode=mode)\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/fsspec_xrootd/xrootd.py\", line 802, in open\n",
      "    f = self._open(\n",
      "        path,\n",
      "    ...<4 lines>...\n",
      "        **kwargs,\n",
      "    )\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/fsspec_xrootd/xrootd.py\", line 759, in _open\n",
      "    return XRootDFile(\n",
      "        self,\n",
      "    ...<5 lines>...\n",
      "        **kwargs,\n",
      "    )\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/fsspec_xrootd/xrootd.py\", line 867, in __init__\n",
      "    self._hosts = self._locate_sources(path)\n",
      "                  ~~~~~~~~~~~~~~~~~~~~^^^^^^\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/fsspec_xrootd/xrootd.py\", line 967, in _locate_sources\n",
      "    raise OSError(\"XRootD error: \" + status.message)\n",
      "OSError: XRootD error: [FATAL] Invalid address\n",
      "\"\"\"\n",
      "\n",
      "The above exception was the direct cause of the following exception:\n",
      "\n",
      "Traceback (most recent call last):\n",
      "  File \"/home/iason/Dropbox/work/pyhep_dev/coffea/src/coffea/processor/executor.py\", line 717, in _processwith\n",
      "    merged = _watcher(FH, self, reducer, pool)\n",
      "  File \"/home/iason/Dropbox/work/pyhep_dev/coffea/src/coffea/processor/executor.py\", line 498, in _watcher\n",
      "    batch = FH.fetch(len(FH.completed))\n",
      "  File \"/home/iason/Dropbox/work/pyhep_dev/coffea/src/coffea/processor/executor.py\", line 382, in fetch\n",
      "    raise bad_futures[0].exception()\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/loky/process_executor.py\", line 490, in _process_worker\n",
      "    r = call_item()\n",
      "    ^^^^^^^^^^^\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/loky/process_executor.py\", line 291, in __call__\n",
      "    return self.fn(*self.args, **self.kwargs)\n",
      "    ^^^^^^^^^^^^^^^\n",
      "  File \"/home/iason/Dropbox/work/pyhep_dev/coffea/src/coffea/processor/executor.py\", line 1289, in automatic_retries\n",
      "    raise e\n",
      "    \n",
      "  File \"/home/iason/Dropbox/work/pyhep_dev/coffea/src/coffea/processor/executor.py\", line 1275, in automatic_retries\n",
      "    return func(*args, **kwargs)\n",
      "    ^^^^^^^\n",
      "  File \"/home/iason/Dropbox/work/pyhep_dev/coffea/src/coffea/processor/executor.py\", line 1359, in metadata_fetcher_root\n",
      "    with uproot.open(\n",
      "    ^^^^^^^^^^^^^^^\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/uproot/reading.py\", line 144, in open\n",
      "    file = ReadOnlyFile(\n",
      "      ^^^^^^^^^^^^^^^^^\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/uproot/reading.py\", line 563, in __init__\n",
      "    self._source = source_cls(file_path, **self._options)\n",
      "    ^^^^^^^^^^^^^^^\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/uproot/source/fsspec.py\", line 63, in __init__\n",
      "    self._open()\n",
      "    ~~~~~~~~~~^^\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/uproot/source/fsspec.py\", line 70, in _open\n",
      "    self._fo = self._open_file.__enter__()\n",
      "    ^^^^^^^^^^^^^^^\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/fsspec/core.py\", line 105, in __enter__\n",
      "    f = self.fs.open(self.path, mode=mode)\n",
      "    ^^^^^^^^^^^\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/fsspec_xrootd/xrootd.py\", line 802, in open\n",
      "    f = self._open(\n",
      "    ^^^^^^^^^^^\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/fsspec_xrootd/xrootd.py\", line 759, in _open\n",
      "    return XRootDFile(\n",
      "    ^^^^^^^^^^^^^^^\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/fsspec_xrootd/xrootd.py\", line 867, in __init__\n",
      "    self._hosts = self._locate_sources(path)\n",
      "    ^^^^^^^^^^^\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/fsspec_xrootd/xrootd.py\", line 967, in _locate_sources\n",
      "    raise OSError(\"XRootD error: \" + status.message)\n",
      "    ^^^^^^^^^^^\n",
      "OSError: XRootD error: [FATAL] Invalid address\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error processing chunk: XRootD error: [FATAL] Invalid address\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0115067f6e9048ed915b82a3b4902d37",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"></pre>\n"
      ],
      "text/plain": []
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3f717169494a4ac2b598bd07aa86a68a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"></pre>\n"
      ],
      "text/plain": []
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "result = None\n",
    "\n",
    "for chunk in chunks_1:\n",
    "    run_result = run(chunk, processor_instance=Processor())\n",
    "    if run_result.is_ok():\n",
    "        output, metrics = run_result.unwrap()\n",
    "    else:\n",
    "        # user can implement their own logic on how to treat failed chunks\n",
    "        print(f\"Error processing chunk: {run_result.exception}\")\n",
    "        continue\n",
    "    if result is None:\n",
    "        result = output\n",
    "    else:\n",
    "        result += output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "5b4a5e6b-2a85-46c4-b77b-625535fb8549",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[StairsArtists(stairs=<matplotlib.patches.StepPatch object at 0x7f54b9ceb0e0>, errorbar=None, legend_artist=None)]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "result['MET'].plot1d()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "c891ecdd-410f-48ef-b3ad-4b655ae93ac4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "all events 482000\n",
      "number of chunks 6\n"
     ]
    }
   ],
   "source": [
    "for key, value in result['cutflow'].items():\n",
    "    print(key, value)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08989afd-0b2d-4126-9a74-4a5ad8da4f69",
   "metadata": {},
   "source": [
    "## 5. Example 2: `strategy=\"by_dataset\", percentage=20`\n",
    "\n",
    "Each dataset is split into 5 chunks of 20% each -> 10 chunks total (5 per dataset).\n",
    "Only the one chunk from `SingleMu_0` that contains the broken file will fail; the other 4 chunks from `SingleMu_0` and all 5 from `SingleMu_1` succeed.\n",
    "\n",
    "Expected result: 9 of 10 chunks succeed and are accumulated."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "e8f6dcfd-c71d-43df-90af-e50515ead53c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "37169072984745d98452bfa532a43225",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"></pre>\n"
      ],
      "text/plain": []
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "loky.process_executor._RemoteTraceback: \n",
      "\"\"\"\n",
      "Traceback (most recent call last):\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/loky/process_executor.py\", line 490, in _process_worker\n",
      "    r = call_item()\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/loky/process_executor.py\", line 291, in __call__\n",
      "    return self.fn(*self.args, **self.kwargs)\n",
      "           ~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
      "  File \"/home/iason/Dropbox/work/pyhep_dev/coffea/src/coffea/processor/executor.py\", line 1289, in automatic_retries\n",
      "    raise e\n",
      "  File \"/home/iason/Dropbox/work/pyhep_dev/coffea/src/coffea/processor/executor.py\", line 1275, in automatic_retries\n",
      "    return func(*args, **kwargs)\n",
      "  File \"/home/iason/Dropbox/work/pyhep_dev/coffea/src/coffea/processor/executor.py\", line 1359, in metadata_fetcher_root\n",
      "    with uproot.open(\n",
      "         ~~~~~~~~~~~^\n",
      "        {item.filename: None}, timeout=xrootdtimeout, **uproot_options\n",
      "        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
      "    ) as file:\n",
      "    ^\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/uproot/reading.py\", line 144, in open\n",
      "    file = ReadOnlyFile(\n",
      "        file_path,\n",
      "    ...<5 lines>...\n",
      "        **options,\n",
      "    )\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/uproot/reading.py\", line 563, in __init__\n",
      "    self._source = source_cls(file_path, **self._options)\n",
      "                   ~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/uproot/source/fsspec.py\", line 63, in __init__\n",
      "    self._open()\n",
      "    ~~~~~~~~~~^^\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/uproot/source/fsspec.py\", line 70, in _open\n",
      "    self._fo = self._open_file.__enter__()\n",
      "               ~~~~~~~~~~~~~~~~~~~~~~~~~^^\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/fsspec/core.py\", line 105, in __enter__\n",
      "    f = self.fs.open(self.path, mode=mode)\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/fsspec_xrootd/xrootd.py\", line 802, in open\n",
      "    f = self._open(\n",
      "        path,\n",
      "    ...<4 lines>...\n",
      "        **kwargs,\n",
      "    )\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/fsspec_xrootd/xrootd.py\", line 759, in _open\n",
      "    return XRootDFile(\n",
      "        self,\n",
      "    ...<5 lines>...\n",
      "        **kwargs,\n",
      "    )\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/fsspec_xrootd/xrootd.py\", line 867, in __init__\n",
      "    self._hosts = self._locate_sources(path)\n",
      "                  ~~~~~~~~~~~~~~~~~~~~^^^^^^\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/fsspec_xrootd/xrootd.py\", line 967, in _locate_sources\n",
      "    raise OSError(\"XRootD error: \" + status.message)\n",
      "OSError: XRootD error: [FATAL] Invalid address\n",
      "\"\"\"\n",
      "\n",
      "The above exception was the direct cause of the following exception:\n",
      "\n",
      "Traceback (most recent call last):\n",
      "  File \"/home/iason/Dropbox/work/pyhep_dev/coffea/src/coffea/processor/executor.py\", line 717, in _processwith\n",
      "    merged = _watcher(FH, self, reducer, pool)\n",
      "  File \"/home/iason/Dropbox/work/pyhep_dev/coffea/src/coffea/processor/executor.py\", line 498, in _watcher\n",
      "    batch = FH.fetch(len(FH.completed))\n",
      "  File \"/home/iason/Dropbox/work/pyhep_dev/coffea/src/coffea/processor/executor.py\", line 382, in fetch\n",
      "    raise bad_futures[0].exception()\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/loky/process_executor.py\", line 490, in _process_worker\n",
      "    r = call_item()\n",
      "    ^^^^^^^^^^^\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/loky/process_executor.py\", line 291, in __call__\n",
      "    return self.fn(*self.args, **self.kwargs)\n",
      "    ^^^^^^^^^^^^^^^\n",
      "  File \"/home/iason/Dropbox/work/pyhep_dev/coffea/src/coffea/processor/executor.py\", line 1289, in automatic_retries\n",
      "    raise e\n",
      "    \n",
      "  File \"/home/iason/Dropbox/work/pyhep_dev/coffea/src/coffea/processor/executor.py\", line 1275, in automatic_retries\n",
      "    return func(*args, **kwargs)\n",
      "    ^^^^^^^\n",
      "  File \"/home/iason/Dropbox/work/pyhep_dev/coffea/src/coffea/processor/executor.py\", line 1359, in metadata_fetcher_root\n",
      "    with uproot.open(\n",
      "    ^^^^^^^^^^^^^^^\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/uproot/reading.py\", line 144, in open\n",
      "    file = ReadOnlyFile(\n",
      "      ^^^^^^^^^^^^^^^^^\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/uproot/reading.py\", line 563, in __init__\n",
      "    self._source = source_cls(file_path, **self._options)\n",
      "    ^^^^^^^^^^^^^^^\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/uproot/source/fsspec.py\", line 63, in __init__\n",
      "    self._open()\n",
      "    ~~~~~~~~~~^^\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/uproot/source/fsspec.py\", line 70, in _open\n",
      "    self._fo = self._open_file.__enter__()\n",
      "    ^^^^^^^^^^^^^^^\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/fsspec/core.py\", line 105, in __enter__\n",
      "    f = self.fs.open(self.path, mode=mode)\n",
      "    ^^^^^^^^^^^\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/fsspec_xrootd/xrootd.py\", line 802, in open\n",
      "    f = self._open(\n",
      "    ^^^^^^^^^^^\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/fsspec_xrootd/xrootd.py\", line 759, in _open\n",
      "    return XRootDFile(\n",
      "    ^^^^^^^^^^^^^^^\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/fsspec_xrootd/xrootd.py\", line 867, in __init__\n",
      "    self._hosts = self._locate_sources(path)\n",
      "    ^^^^^^^^^^^\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/fsspec_xrootd/xrootd.py\", line 967, in _locate_sources\n",
      "    raise OSError(\"XRootD error: \" + status.message)\n",
      "    ^^^^^^^^^^^\n",
      "OSError: XRootD error: [FATAL] Invalid address\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error processing chunk: XRootD error: [FATAL] Invalid address\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "63a927713afc48cc8533e3bea192fb2c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"></pre>\n"
      ],
      "text/plain": []
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f45738d4edf640a6a7327cdb08778781",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"></pre>\n"
      ],
      "text/plain": []
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "89b85a5179404d3aa1fd9faa13b4f8b2",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"></pre>\n"
      ],
      "text/plain": []
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f795f8f2c8a24944a350d7790ef65572",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"></pre>\n"
      ],
      "text/plain": []
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9837932298144db4b13021e650f89a78",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"></pre>\n"
      ],
      "text/plain": []
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "907ef58b9f194004981567476e71c3bb",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"></pre>\n"
      ],
      "text/plain": []
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d3a730407e8149709bdca8a672a02e00",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"></pre>\n"
      ],
      "text/plain": []
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "585d62fe1edf4aa3aa5b25173bfd5b01",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"></pre>\n"
      ],
      "text/plain": []
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8c9075be03ca4a9c858fca1da18dc384",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"></pre>\n"
      ],
      "text/plain": []
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b3d4bf317878478aaac70fbec866e61f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"></pre>\n"
      ],
      "text/plain": []
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "abe47b784f404240b5b2586c9733ac56",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"></pre>\n"
      ],
      "text/plain": []
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b601d1a42815427e9f014f119ef6f2a9",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"></pre>\n"
      ],
      "text/plain": []
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f82056327b614931b55db9d2886e2d7f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"></pre>\n"
      ],
      "text/plain": []
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "result_2 = None\n",
    "\n",
    "for chunk in chunks_2:\n",
    "    run_result = run(chunk, processor_instance=Processor())\n",
    "    if run_result.is_ok():\n",
    "        output, metrics = run_result.unwrap()\n",
    "    else:\n",
    "        # user can implement their own logic on how to treat failed chunks\n",
    "        print(f\"Error processing chunk: {run_result.exception}\")\n",
    "        continue\n",
    "    if result_2 is None:\n",
    "        result_2 = output\n",
    "    else:\n",
    "        result_2 += output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "8acd1a56-24ea-4ffe-82e1-02f0eb8fa603",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[StairsArtists(stairs=<matplotlib.patches.StepPatch object at 0x7f54b9adc550>, errorbar=None, legend_artist=None),\n",
       " StairsArtists(stairs=<matplotlib.patches.StepPatch object at 0x7f54b9adc690>, errorbar=None, legend_artist=None)]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjkAAAGwCAYAAABLvHTgAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQAATG1JREFUeJzt3XtYVNX+P/D3MDDcL4JyO4KSd7yLiZRaHtFBqY6Xr6lpoaB+9aCl5CVveCtNvJuWpzyKz/dopqV2jqZGeFAzvECamklpGJ10wKPCKCCDsH5/+GPnJA4zODAze96v59mPzN6f2bNmC8yHtdf6LIUQQoCIiIhIZhws3QAiIiKiusAkh4iIiGSJSQ4RERHJEpMcIiIikiUmOURERCRLTHKIiIhIlpjkEBERkSw5WroBllRZWYlr167B09MTCoXC0s0hIiIiIwghcOfOHQQHB8PB4fH9NXad5Fy7dg0hISGWbgYRERHVwq+//orGjRs/9rhdJzmenp4AHlwkLy8vC7eGiIiIjKHVahESEiJ9jj+OXSc5VbeovLy8mOQQERHZmJqGmnDgMREREckSkxwiIiKSJSY5REREJEt2PSaHiIisW0VFBcrLyy3dDKpnTk5OUCqVT3weJjlERGR1hBDQaDQoLCy0dFPIQnx8fBAYGPhEdeyY5BARkdWpSnD8/f3h5ubGgq12RAiBkpISFBQUAACCgoJqfS4mOUREZFUqKiqkBMfPz8/SzSELcHV1BQAUFBTA39+/1reuOPCYiIisStUYHDc3Nwu3hCyp6v//ScZkMckhIiKrxFtU9s0c//9McoiIiEiWmOQQERGRLDHJISIiMoPnn38eU6ZMsXQz6CFMcoiIiOpZRkYGFApFvdcBWrBgATp16lSvr2lJnEJOJENCCJSWV1jktV2dlBwwSkRWgUkOkQyVllcgPPmQRV774iI13FT81ULyVlxcjIkTJ2L37t3w9PTEtGnT9I7/3//9H9auXYucnBy4u7vjz3/+M9asWQN/f39cvXoVvXv3BgA0aNAAABAXF4fU1FQcPHgQb7/9Ni5cuAClUomoqCisXbsWzZo1AwDodDokJSXhs88+w+3btxEQEIAJEyZg1qxZAIDCwkJMmzYNn3/+OcrKytC1a1esXr0aHTt2RGpqKhYuXAjg95lLW7ZswejRo+vjklkEb1cRERGZaPr06Thy5Ag+//xzfPnll8jIyMC3334rHS8vL8fixYvx3XffYe/evbh69aqUTISEhOCzzz4DAOTk5OD69etYu3YtgAfJU1JSErKyspCeng4HBwcMGjQIlZWVAIB169bhn//8J3bu3ImcnBxs27YNTZs2lV536NChKCgowIEDB5CdnY0uXbqgT58+uHXrFoYNG4Y333wTbdu2xfXr13H9+nUMGzasfi6YhfDPLSKZy5obDTfVky90Z0iJrgJd3/6qTl+DyFrcvXsXf//73/GPf/wDffr0AQBs3boVjRs3lmLi4+Olr5966imsW7cOTz/9NO7evQsPDw/4+voCAPz9/eHj4yPFDhkyRO+1Nm/ejEaNGuHixYto164d8vLy0KJFC/To0QMKhQJNmjSRYr/++mucOnUKBQUFcHZ2BgCsWLECe/fuxaefforx48fDw8MDjo6OCAwMNPt1sUZMcohkzk2l5O0jIjO6cuUKdDodIiMjpX2+vr5o1aqV9Dg7OxsLFizAd999h9u3b0s9MXl5eQgPD3/suX/66SckJyfj5MmT+O9//6v3vHbt2mH06NHo27cvWrVqhZiYGLzwwgvo168fAOC7777D3bt3H1kKo7S0FFeuXDHb+7cl/M1HRGZVoqt5wDMHJ5OcFRcXQ61WQ61WY9u2bWjUqBHy8vKgVquh0+kMPvfFF19EkyZN8NFHHyE4OBiVlZVo166d9LwuXbogNzcXBw4cwFdffYWXX34Z0dHR+PTTT3H37l0EBQUhIyPjkfM+3FtkT5jkEJFZGXPbioOTyZY1a9YMTk5OOHnyJEJDQwEAt2/fxo8//ojnnnsOly5dws2bN/Huu+8iJCQEAJCVlaV3DpVKBeDBYqRVbt68iZycHHz00Ufo2bMngAe3oP7Iy8sLw4YNw7Bhw/A///M/iImJwa1bt9ClSxdoNBo4OjrqjdP54+s+/Jpyx98yRFTv2NtDtszDwwMJCQmYPn06/Pz84O/vjzlz5sDB4cFcntDQUKhUKrz33nuYMGECLly4gMWLF+udo0mTJlAoFNi3bx8GDBgAV1dXNGjQAH5+fvjwww8RFBSEvLw8vPXWW3rPW7VqFYKCgtC5c2c4ODhg165dCAwMhI+PD6KjoxEVFYWBAwciJSUFLVu2xLVr17B//34MGjQIXbt2RdOmTZGbm4uzZ8+icePG8PT0lMbvyJIwwfvvvy/at28vPD09haenp+jevbv44osvpOOlpaXir3/9q/D19RXu7u5i8ODBQqPR6J3jl19+EQMGDBCurq6iUaNGYtq0aaK8vFwv5t///rfo3LmzUKlUolmzZmLLli2PtGX9+vWiSZMmwtnZWXTr1k2cPHnSlLcihBCiqKhIABBFRUUmP5fImhWXlYsmM/eJJjP3ieKy8pqf8IQqKytFcVm5we3GnXtSm4zZ6qPdZJ1KS0vFxYsXRWlpqaWb8lh37twRo0aNEm5ubiIgIECkpKSI5557TrzxxhtCCCG2b98umjZtKpydnUVUVJT45z//KQCIM2fOSOdYtGiRCAwMFAqFQsTFxQkhhEhLSxNt2rQRzs7OokOHDiIjI0MAEHv27BFCCPHhhx+KTp06CXd3d+Hl5SX69Okjvv32W+mcWq1WTJ48WQQHBwsnJycREhIiRo4cKfLy8oQQQty7d08MGTJE+Pj4CADVfr5aC0PfB8Z+fiuEEMLYhOhf//oXlEolWrRoASEEtm7diuXLl+PMmTNo27YtJk6ciP379yM1NRXe3t6YNGkSHBwccPz4cQAPuuU6deqEwMBALF++HNevX8drr72GcePGYcmSJQCA3NxctGvXDhMmTMDYsWORnp6OKVOmYP/+/VCr1QCATz75BK+99ho2btyIyMhIrFmzBrt27UJOTg78/f2NTvC0Wi28vb1RVFQELy8vo59HZO1KdPelOjnWcmvo4TYZw1raTfXv3r17yM3NRVhYGFxcXCzdHLIQQ98HRn9+P2mm1aBBA7Fp0yZRWFgonJycxK5du6RjP/zwgwAgMjMzhRBCfPHFF8LBwUGvd+eDDz4QXl5eoqysTAghxIwZM0Tbtm31XmPYsGFCrVZLj7t16yYSExOlxxUVFSI4OFgsXbrUpLazJ4dskam9JtbSI2Kr7ab6Zws9OVT3zNGTU+s/kyoqKrBr1y4UFxcjKioK2dnZKC8vR3R0tBTTunVrhIaGIjMzE927d0dmZibat2+PgIAAKUatVmPixIn4/vvv0blzZ2RmZuqdoyqmatEznU6H7OxsqbojADg4OCA6OhqZmZkG21xWVoaysjLpsVarre3bJ6oTwojlGGy1Jo1CoWDPDBHVK5N/45w/fx5RUVG4d+8ePDw8sGfPHoSHh+Ps2bNQqVSPTFMLCAiARqMBAGg0Gr0Ep+p41TFDMVqtFqWlpbh9+zYqKiqqjbl06ZLBti9dulQqaU1kjSy5HAMRkdyYnOS0atUKZ8+eRVFRET799FPExcXhyJEjddE2s5s1axaSkpKkx1qtVpreR2SLjKlm7OpUt9WOiYislclJjkqlQvPmzQEAEREROH36NNauXYthw4ZBp9OhsLBQrzcnPz9fKh8dGBiIU6dO6Z0vPz9fOlb1b9W+h2O8vLzg6uoKpVIJpVJZbUxNZaqdnZ3lPVWOZMXYBIbTrImIqvfEC3RWVlairKwMERERcHJyQnp6unQsJycHeXl5iIqKAgBERUXh/PnzKCgokGLS0tLg5eUllbmOiorSO0dVTNU5VCoVIiIi9GIqKyuRnp4uxRDJQdVyDIY2OSc4JboKlOjuG9yE8ZNDicgOmdSTM2vWLPTv3x+hoaG4c+cOtm/fjoyMDBw6dAje3t5ISEhAUlISfH194eXlhcmTJyMqKgrdu3cHAPTr1w/h4eF49dVXkZKSAo1Gg7lz5yIxMVHqYZkwYQLWr1+PGTNmID4+HocPH8bOnTuxf/9+qR1JSUmIi4tD165d0a1bN6xZswbFxcUYM2aMGS8NEVkSKycT0ZMy6bdDQUEBXnvtNVy/fh3e3t7o0KEDDh06hL59+wIAVq9eDQcHBwwZMgRlZWVQq9V4//33pecrlUrs27cPEydORFRUFNzd3REXF4dFixZJMWFhYdi/fz+mTp2KtWvXonHjxti0aZNUIwcAhg0bhhs3biA5ORkajQadOnXCwYMHHxmMTERERPbLpGKAcsNigGRtrLGIX30ydQq9PV4je8BigASYpxjgE4/JISIyl6paOoY3zhYj26ZQKLB3716znnPBggXo1KmTWc8pB0xyiOqJEKLGgbTGLFxJRNbtxo0bmDhxIkJDQ+Hs7IzAwECo1WppiaPr16+jf//+Fm7lg2RLoVDgxIkTevvLysrg5+cHhUKBjIwMs73euXPn0LNnT7i4uCAkJAQpKSlmO/fjsJ+XqJ6w0B+RfRgyZAh0Oh22bt2Kp556Cvn5+UhPT8fNmzcBoMZyJ/UpJCQEW7ZskSYIAcCePXvg4eGBW7dume11tFot+vXrh+joaGzcuBHnz59HfHw8fHx8MH78eLO9zh+xJ4eIiKyecT2hdbOZMnS1sLAQx44dw7Jly9C7d280adIE3bp1w6xZs/DSSy8B0L9ddfXqVSgUCuzevRu9e/eGm5sbOnbs+MgyRR999BFCQkLg5uaGQYMGYdWqVY+sMPBHmzZtQps2beDi4oLWrVvrTQSqEhcXhx07dqC0tFTat3nzZsTFxenFZWRkQKFQoLCwUNp39uxZKBQKXL16tcbrsm3bNuh0OmzevBlt27bF8OHD8frrr2PVqlU1PvdJsCeHyAJYqZjINJbsCTVlgLuHhwc8PDywd+9edO/e3egCtHPmzMGKFSvQokULzJkzByNGjMDly5fh6OiI48ePY8KECVi2bBleeuklfPXVV5g3b57B823btg3JyclYv349OnfujDNnzmDcuHHSrOYqERERaNq0KT777DOMGjUKeXl5OHr0KDZs2IDFixcb1XZjZGZmolevXlCpVNI+tVqNZcuW4fbt22jQoIHZXuth7MkhsgB7L/RnLiwYSNbG0dERqamp2Lp1K3x8fPDss89i9uzZOHfunMHnTZs2DbGxsWjZsiUWLlyIX375BZcvXwYAvPfee+jfvz+mTZuGli1b4q9//WuNY3rmz5+PlStXYvDgwQgLC8PgwYMxdepU/O1vf3skNj4+Hps3bwYApKamYsCAAWjUqFEtr0D1jFm7si6wJ4eIbBYLBtoPVyclLi5S1xxYR69tiiFDhiA2NhbHjh3DiRMncODAAaSkpGDTpk0YPXp0tc/p0KGD9HVQUBCAB7XpWrdujZycHAwaNEgvvlu3bti3b1+15youLsaVK1eQkJCAcePGSfvv378Pb2/vR+JHjRqFt956Cz///DNSU1Oxbt06k96vNeNPPhERWb2q8gK2wsXFBX379kXfvn0xb948jB07FvPnz39skuPk5CR9XdWLW1lZWavXvnv3LoAH43giIyP1jimVjyZsfn5+eOGFF5CQkIB79+6hf//+uHPnjl6Mg8ODGz8P94yWl5cb3abHrUtZdayu2M53DJEVM7aIHT05Y/6if7hgIJE1CA8Pr3VtnFatWuH06dN6+/74+GEBAQEIDg7Gzz//jJEjRxr1GvHx8RgwYABmzpxZbSJUdfvq+vXr0viZs2fPGvkOHqxLOWfOHJSXl0sJXVpaGlq1alVn43EAJjlEZsHp4fXH1v6iJ/ty8+ZNDB06FPHx8ejQoQM8PT2RlZWFlJQU/OUvf6nVOSdPnoxevXph1apVePHFF3H48GEcOHDA4Li9hQsX4vXXX4e3tzdiYmJQVlaGrKws3L59G0lJSY/Ex8TE4MaNG4+tHty8eXOEhIRgwYIFeOedd/Djjz9i5cqVRr+HV155BQsXLkRCQgJmzpyJCxcuYO3atVi9erXR56gNDjwmIiIyEw8PD0RGRmL16tXo1asX2rVrh3nz5mHcuHFYv359rc757LPPYuPGjVi1ahU6duyIgwcPYurUqQaXvBg7diw2bdqELVu2oH379njuueeQmpqKsLCwauMVCgUaNmyoN/vpYU5OTvj4449x6dIldOjQAcuWLcPbb79t9Hvw9vbGl19+idzcXERERODNN99EcnJyndbIAbh2FdeuIrN4eM0pY6eHc/ZU3bH3NcBsHdeuqtm4ceNw6dIlHDt2zNJNqTPmWLuKP/lEZlY1PZyIyFxWrFiBvn37wt3dHQcOHMDWrVurLe5H+ni7ioiIyMqdOnUKffv2Rfv27bFx40asW7cOY8eOtXSzJP3795cKIf5xW7JkicXaxT83iUjWjJnVxtuHZO127txp6SYYtGnTJr2lIR7m6+tbz635HZMcIpI1Fgwkqnt/+tOfLN2EavF2FREREckS/3QhItlhwUAiApjkEJEMsWAgEQG8XUVEREQyxSSHiIiIZIlJDhERUT1SKBS1XqzzcRYsWIBOnTqZ9ZxywCSHqAZCCJTo7tewcYVxInrgxo0bmDhxIkJDQ+Hs7IzAwECo1WocP34cwIOVvPv372/hVj5IthQKBU6cOKG3v6ysDH5+flAoFMjIyDDLa927dw+jR49G+/bt4ejoiIEDB5rlvDXhyDyiGnCFcSIyxZAhQ6DT6bB161Y89dRTyM/PR3p6Om7evAkACAwMtHALfxcSEoItW7age/fu0r49e/bAw8MDt27dMtvrVFRUwNXVFa+//jo+++wzs523JuzJISIi6ycEoCu2zGbCOtaFhYU4duwYli1bht69e6NJkybo1q0bZs2ahZdeegmA/u2qq1evQqFQYPfu3ejduzfc3NzQsWNHZGZm6p33o48+QkhICNzc3DBo0CCsWrUKPj4+BtuyadMmtGnTBi4uLmjdunW1a13FxcVhx44detWKN2/ejLi4OL24jIwMKBQKFBYWSvvOnj0LhUKBq1ev1nhd3N3d8cEHH2DcuHH1muSxJ4fIBMauME62hUs/2IDyEmBJsGVee/Y1QOVuVGjVek179+5F9+7d4ezsbNTz5syZgxUrVqBFixaYM2cORowYgcuXL8PR0RHHjx/HhAkTsGzZMrz00kv46quvMG/ePIPn27ZtG5KTk7F+/Xp07twZZ86cwbhx4+Du7q6XwERERKBp06b47LPPMGrUKOTl5eHo0aPYsGEDFi9ebFTbrRmTHCITcIVxeeLSD2Qujo6OSE1Nxbhx47Bx40Z06dIFzz33HIYPH44OHTo89nnTpk1DbGwsAGDhwoVo27YtLl++jNatW+O9995D//79MW3aNABAy5Yt8c0332Dfvn2PPd/8+fOxcuVKDB48GAAQFhaGixcv4m9/+9sjvTTx8fHYvHkzRo0ahdTUVAwYMACNGjV60kthFfgTS0RE1s/J7UGPiqVe2wRDhgxBbGwsjh07hhMnTuDAgQNISUnBpk2bMHr06Gqf83ACFBQUBAAoKChA69atkZOTg0GDBunFd+vW7bFJTnFxMa5cuYKEhASMGzdO2n///n14e3s/Ej9q1Ci89dZb+Pnnn5Gamop169aZ9H6tGZMcIrJLXPrBxigURt8ysgYuLi7o27cv+vbti3nz5mHs2LGYP3/+Y5McJycn6euq26KVlZW1eu27d+8CeDCOJzIyUu+YUvno7XQ/Pz+88MILSEhIwL1799C/f3/cuXNHL8bB4cEQXvHQ+KTy8vJata8+MckhIrvEpR+oPoWHh9e6Nk6rVq1w+vRpvX1/fPywgIAABAcH4+eff8bIkSONeo34+HgMGDAAM2fOrDYRqrp9df36dTRo0ADAg4HH1o4/4URERGZy8+ZNDB06FPHx8ejQoQM8PT2RlZWFlJQU/OUvf6nVOSdPnoxevXph1apVePHFF3H48GEcOHDA4ED4hQsX4vXXX4e3tzdiYmJQVlaGrKws3L59G0lJSY/Ex8TE4MaNG/Dy8qr2fM2bN0dISAgWLFiAd955Bz/++CNWrlxp0vu4ePEidDodbt26hTt37khJUl0WMWSSQ0REZCYeHh6IjIzE6tWrceXKFZSXlyMkJATjxo3D7Nmza3XOZ599Fhs3bsTChQsxd+5cqNVqTJ06FevXr3/sc8aOHQs3NzcsX74c06dPh7u7O9q3b48pU6ZUG69QKNCwYcPHns/JyQkff/wxJk6ciA4dOuDpp5/G22+/jaFDhxr9PgYMGIBffvlFety5c2cA+rfAzE0h6vLsVk6r1cLb2xtFRUWPzV6JSnT3pWKAnGFjX/h/bxn37t1Dbm4uwsLC4OLiYunmWKVx48bh0qVLOHbsmKWbUmcMfR8Y+/nNn1giIiIrt2LFCvTt2xfu7u44cOAAtm7dWm1xP9LHisdERERW7tSpU+jbty/at2+PjRs3Yt26dRg7dqylmyXp37+/VAjxj9uSJUss1i725JBdE0KgtNxwtVsuvklElrZz505LN8GgTZs26S0N8TBfX996bs3vmOSQXePim0RET+5Pf/qTpZtQLd6uIiIiq1TbYngkD+b4/2dPDtH/x8U3iayDSqWCg4MDrl27hkaNGkGlUnFxVDsihIBOp8ONGzfg4OAAlUpV63MxySH6/7j4JpF1cHBwQFhYGK5fv45r1yy0XhVZnJubG0JDQ6UlJWqDv9GJiIxgzAB0VyclexzMRKVSITQ0FPfv30dFBQf/2xulUglHR8cn/nlikkNEZARjFupkwUDzUigUcHJy0lu8ksgUHHhMREREssQ/OYiIHsPVSYmLi9QGY0p0FUb18hBR/WOSQ0T0GAqFgrefiGwYb1cRERGRLJmU5CxduhRPP/00PD094e/vj4EDByInJ0cv5vnnn4dCodDbJkyYoBeTl5eH2NhYuLm5wd/fH9OnT8f9+/f1YjIyMtClSxc4OzujefPmSE1NfaQ9GzZsQNOmTeHi4oLIyEicOnXKlLdDREREMmZSknPkyBEkJibixIkTSEtLQ3l5Ofr164fi4mK9uHHjxuH69evSlpKSIh2rqKhAbGwsdDodvvnmG2zduhWpqalITk6WYnJzcxEbG4vevXvj7NmzmDJlCsaOHYtDh34vv//JJ58gKSkJ8+fPx7fffouOHTtCrVajoKCgtteCiIiIZEQhhBC1ffKNGzfg7++PI0eOoFevXgAe9OR06tQJa9asqfY5Bw4cwAsvvIBr164hICAAALBx40bMnDkTN27cgEqlwsyZM7F//35cuHBBet7w4cNRWFiIgwcPAgAiIyPx9NNPY/369QAelH8OCQnB5MmT8dZbbxnVfq1WC29vbxQVFcHLy6u2l4FsWInuvrR2Faf/Um3we4io/hn7+f1EY3KKiooAPLrC6LZt29CwYUO0a9cOs2bNQklJiXQsMzMT7du3lxIcAFCr1dBqtfj++++lmOjoaL1zqtVqZGZmAgB0Oh2ys7P1YhwcHBAdHS3FVKesrAxarVZvIyIiInmq9Z8clZWVmDJlCp599lm0a9dO2v/KK6+gSZMmCA4Oxrlz5zBz5kzk5ORg9+7dAACNRqOX4ACQHms0GoMxWq0WpaWluH37NioqKqqNuXTp0mPbvHTpUixcuLC2b5mIiIhsSK2TnMTERFy4cAFff/213v7x48dLX7dv3x5BQUHo06cPrly5gmbNmtW+pWYwa9YsJCUlSY+1Wi1CQkIs2CIikhMu/UBkXWqV5EyaNAn79u3D0aNH0bhxY4OxkZGRAIDLly+jWbNmCAwMfGQWVH5+PgAgMDBQ+rdq38MxXl5ecHV1hVKphFKprDam6hzVcXZ2hrOzs3FvkojIRFz6gci6mDQmRwiBSZMmYc+ePTh8+DDCwsJqfM7Zs2cBAEFBQQCAqKgonD9/Xm8WVFpaGry8vBAeHi7FpKen650nLS0NUVFRAB4s3BYREaEXU1lZifT0dCmGiIiI7JtJf04kJiZi+/bt+Pzzz+Hp6SmNofH29oarqyuuXLmC7du3Y8CAAfDz88O5c+cwdepU9OrVCx06dAAA9OvXD+Hh4Xj11VeRkpICjUaDuXPnIjExUeplmTBhAtavX48ZM2YgPj4ehw8fxs6dO7F//36pLUlJSYiLi0PXrl3RrVs3rFmzBsXFxRgzZoy5rg0RUY249AOR9TIpyfnggw8APJgm/rAtW7Zg9OjRUKlU+Oqrr6SEIyQkBEOGDMHcuXOlWKVSiX379mHixImIioqCu7s74uLisGjRIikmLCwM+/fvx9SpU7F27Vo0btwYmzZtglr9+y+SYcOG4caNG0hOToZGo0GnTp1w8ODBRwYjk/0SQqC03PAYCWPGUBAZwqUfiKzXE9XJsXWskyNvD9cvMQbHSlBdYS0dIvOqlzo5RERERNaKf06QXciaGw03ldJgjKuT4eNERGRbmOSQXXBTKXmLgIjIzvB2FREREckSkxwiIiKSJSY5REREJEtMcoiIiEiWmOQQERGRLDHJISIiIllikkNERESyxMIhRET1yJj10lydlFAoFPXQGiJ5Y5JDRFSPjFmNnOtbEZkHb1cRERGRLPFPBSKiOubqpMTFRWqDMSW6CqN6eYjIeExyyCYJIVBabnhsgzFjH4jqg0Kh4O0nIgvgTx3ZpNLyCoQnH7J0M4iIyIpxTA4RERHJEntyyOZlzY2Gm0ppMMbVyfBxIiKSHyY5ZPPcVEqOdyAiokfwdhURERHJEpMcIiIikiUmOURERCRLTHKIiIhIlpjkEBERkSxxSgoRkZXhSuVE5sEkh4jIynClciLz4O0qIiIikiX+GUBEZAW4UjmR+THJISKyAlypnMj8eLuKiIiIZIl/NpDVEUKgtNzw7BJjZp8QEZF9Y5JDVqe0vALhyYcs3QwiIrJxvF1FREREssSeHLJqWXOj4aZSGoxxdTJ8nIiI7BOTHLJqbiolZ5wQEVGt8HYVERERyRKTHCIiIpIlJjlEREQkS0xyiIiISJaY5BAREZEsMckhIiIiWWKSQ0RERLLEAiRERDbImPXbXJ2UUCgU9dAaIuvEJIeIyAZ1ffurGmMuLlKzmCbZNd6uIiIiIlliik9EZCNcnZS4uEhtMKZEV2FULw+RPTCpJ2fp0qV4+umn4enpCX9/fwwcOBA5OTl6Mffu3UNiYiL8/Pzg4eGBIUOGID8/Xy8mLy8PsbGxcHNzg7+/P6ZPn4779+/rxWRkZKBLly5wdnZG8+bNkZqa+kh7NmzYgKZNm8LFxQWRkZE4deqUKW+HiMimKBQKuKkca9i4YC1RFZOSnCNHjiAxMREnTpxAWloaysvL0a9fPxQXF0sxU6dOxb/+9S/s2rULR44cwbVr1zB48GDpeEVFBWJjY6HT6fDNN99g69atSE1NRXJyshSTm5uL2NhY9O7dG2fPnsWUKVMwduxYHDp0SIr55JNPkJSUhPnz5+Pbb79Fx44doVarUVBQ8CTXg4iIiORCPIGCggIBQBw5ckQIIURhYaFwcnISu3btkmJ++OEHAUBkZmYKIYT44osvhIODg9BoNFLMBx98ILy8vERZWZkQQogZM2aItm3b6r3WsGHDhFqtlh5369ZNJCYmSo8rKipEcHCwWLp0qdHtLyoqEgBEUVGRCe+a6lpxWbloMnOfaDJznyguK7d0c4hsCn9+yB4Y+/n9RAOPi4qKAAC+vr4AgOzsbJSXlyM6OlqKad26NUJDQ5GZmQkAyMzMRPv27REQECDFqNVqaLVafP/991LMw+eoiqk6h06nQ3Z2tl6Mg4MDoqOjpZjqlJWVQavV6m1EREQkT7VOciorKzFlyhQ8++yzaNeuHQBAo9FApVLBx8dHLzYgIAAajUaKeTjBqTpedcxQjFarRWlpKf773/+ioqKi2piqc1Rn6dKl8Pb2lraQkBDT3zgRERHZhFonOYmJibhw4QJ27NhhzvbUqVmzZqGoqEjafv31V0s3iYiIiOpIraaQT5o0Cfv27cPRo0fRuHFjaX9gYCB0Oh0KCwv1enPy8/MRGBgoxfxxFlTV7KuHY/44Iys/Px9eXl5wdXWFUqmEUqmsNqbqHNVxdnaGs7Oz6W+YiIiIbI5JPTlCCEyaNAl79uzB4cOHERYWpnc8IiICTk5OSE9Pl/bl5OQgLy8PUVFRAICoqCicP39ebxZUWloavLy8EB4eLsU8fI6qmKpzqFQqRERE6MVUVlYiPT1diiHrJIRAie5+DVvN5eqJiIhqYlJPTmJiIrZv347PP/8cnp6e0vgXb29vuLq6wtvbGwkJCUhKSoKvry+8vLwwefJkREVFoXv37gCAfv36ITw8HK+++ipSUlKg0Wgwd+5cJCYmSr0sEyZMwPr16zFjxgzEx8fj8OHD2LlzJ/bv3y+1JSkpCXFxcejatSu6deuGNWvWoLi4GGPGjDHXtaE6UFpegfDkQzUHEhERPSGTkpwPPvgAAPD888/r7d+yZQtGjx4NAFi9ejUcHBwwZMgQlJWVQa1W4/3335dilUol9u3bh4kTJyIqKgru7u6Ii4vDokWLpJiwsDDs378fU6dOxdq1a9G4cWNs2rQJavXvlT6HDRuGGzduIDk5GRqNBp06dcLBgwcfGYxMRERE9kkhhBCWboSlaLVaeHt7o6ioCF5eXpZujl0o0d2XenKy5kbXWJ2VqygTmYY/Y2QPjP385tpVZDFuKiVXSCaqQ1ypnOwdVyEnIiIiWWL6TkQkI1ypnOh3THKIiGSkaqVyIuLtKiIiIpIpJjlEREQkS0xyiIiISJaY5BAREZEsMckhIiIiWWKSQ0RERLLEJIeIiIhkiUkOERERyRIrRhER2bESXUWNMVzEk2wVkxwiIjvGRTxJzni7ioiIiGSJqTkRkZ3hIp5kL5jkEBHZGS7iSfaCt6uIiIhIlpjkEBERkSyxv5LMRgiB0nLD01GNma5KRERkDkxyyGxKyysQnnzI0s0gIiICwNtVREREJFPsyaE6kTU3Gm4qpcEYVyfDx4mIiJ4EkxyqE24qJaeoEhGRRfF2FREREckSkxwiIiKSJSY5REREJEtMcoiIiEiWmOQQERGRLDHJISIiIllikkNERESyxEImRERkkDFrzrk6KaFQKOqhNUTGY5JDREQGdX37qxpjLi5SswAoWR3eriIiIiJZYtpNRESPcHVS4uIitcGYEl2FUb08RJbCJIeIiB6hUCh4+4lsHm9XERERkSwxySEiIiJZYpJDREREssQkh4iIiGSJSQ4RERHJEofOE9krIYDyEtOe4+QGVFfV1tRzPe48RERmxCSHjCKEQGm54dLuxpR+p3piTNKhKwFWNDftvNMuAyq3Jz/X7GuAyt201yYiMhGTHDJKaXkFwpMPWboZZKzyEmBJsPnPa2pSRERkQUxyiOjxPTSA6b005urtIZvCRTzJGjHJIZNlzY2Gm0ppMMbVyfBxqkeGEpgqhsbIOLk9uL1kLI63sUtcxJOskcmzq44ePYoXX3wRwcHBUCgU2Lt3r97x0aNHQ6FQ6G0xMTF6Mbdu3cLIkSPh5eUFHx8fJCQk4O7du3ox586dQ8+ePeHi4oKQkBCkpKQ80pZdu3ahdevWcHFxQfv27fHFF1+Y+naoFtxUSripHA1u/GutloQAdMVm2B4aj6NyezD+xdBm6P9Loaj5+caei4ioHpmcUhcXF6Njx46Ij4/H4MGDq42JiYnBli1bpMfOzs56x0eOHInr168jLS0N5eXlGDNmDMaPH4/t27cDALRaLfr164fo6Ghs3LgR58+fR3x8PHx8fDB+/HgAwDfffIMRI0Zg6dKleOGFF7B9+3YMHDgQ3377Ldq1a2fq2yKyDnU1loaoDnART7J2Jic5/fv3R//+/Q3GODs7IzAwsNpjP/zwAw4ePIjTp0+ja9euAID33nsPAwYMwIoVKxAcHIxt27ZBp9Nh8+bNUKlUaNu2Lc6ePYtVq1ZJSc7atWsRExOD6dOnAwAWL16MtLQ0rF+/Hhs3bjT1bRFRfdIZMd2ct72sHhfxJGtXJ9+dGRkZ8Pf3R4MGDfDnP/8Zb7/9Nvz8/AAAmZmZ8PHxkRIcAIiOjoaDgwNOnjyJQYMGITMzE7169YJKpZJi1Go1li1bhtu3b6NBgwbIzMxEUlKS3uuq1epHbp89rKysDGVlZdJjrVZrpndMVAeMGUtjDCcznMPcjBmA/KRjiYjI7pk9yYmJicHgwYMRFhaGK1euYPbs2ejfvz8yMzOhVCqh0Wjg7++v3whHR/j6+kKj0QAANBoNwsLC9GICAgKkYw0aNIBGo5H2PRxTdY7qLF26FAsXLjTH2ySqe1VjaeyVMYkQ6+0QkQFmT3KGDx8ufd2+fXt06NABzZo1Q0ZGBvr06WPulzPJrFmz9Hp/tFotQkJCLNgisivGFuiTK2NmaXGaORGZUZ3fTH3qqafQsGFDXL58GX369EFgYCAKCgr0Yu7fv49bt25J43gCAwORn5+vF1P1uKaYx40FAh6MFfrjIGiiemPvg4qrZmkZwkSIiMyozhfo/M9//oObN28iKCgIABAVFYXCwkJkZ2dLMYcPH0ZlZSUiIyOlmKNHj6K8vFyKSUtLQ6tWrdCgQQMpJj09Xe+10tLSEBUVVddviehRRk39lnEvjbkYNV3dCscYEZFVMrkn5+7du7h8+bL0ODc3F2fPnoWvry98fX2xcOFCDBkyBIGBgbhy5QpmzJiB5s2bQ61+MM2wTZs2iImJwbhx47Bx40aUl5dj0qRJGD58OIKDH/yV+8orr2DhwoVISEjAzJkzceHCBaxduxarV6+WXveNN97Ac889h5UrVyI2NhY7duxAVlYWPvzwwye9JkSmM7WXxthBtUREVGsm9+RkZWWhc+fO6Ny5MwAgKSkJnTt3RnJyMpRKJc6dO4eXXnoJLVu2REJCAiIiInDs2DG920Tbtm1D69at0adPHwwYMAA9evTQS068vb3x5ZdfIjc3FxEREXjzzTeRnJwsTR8HgGeeeQbbt2/Hhx9+iI4dO+LTTz/F3r17WSOHbMOTFugjIqIamdyT8/zzz0MI8djjhw7VvIijr6+vVPjvcTp06IBjx44ZjBk6dCiGDh1a4+sR1Sv20tQf1tshIgNYxYnI3Ox96nd94jRzIjKgzgceExEREVkCe3KIyLZwmrnNKtFV1Bjj6qTkAr9kNkxyiMi2GFNvh6ySMQt1Xlyk5npYZDb8TiIieePgZCK7xSSHqCb2vhyDrePgZItydVLi4iK1wZgSXYVRvTxEpmKSQ1QTe1+OgegJKBQK3n4ii+F3HkEIgdJywwMCjRkwSGQ1ODiZiMAkhwCUllcgPLnmIo4EFvqzFRycTERgkkP2ztTxNiz0J08cnEwkS0xySE/W3Gi4qZQGY1ydDB+3KRxvQwAHJxPJFJMc0uOmUnKQIBERyQI/zYiqcLyNfTF1cDJvadULVkUmc2KSQ1SF423si6mDk3lLq16wKjKZExfoJCIiIlliKkxE9Dist1MvWBWZ6gqTHCKix2G9nXrBqshUV3i7ioiIiGSJSQ4RERHJEpMcIiIikiXeBCUiMhfW0iGyKkxySL5MXZeK6Emxlg6RVWGSQ/LFdamIiOwakxwioifBWjpEVotJDtkHrktFdYW1dIisFpMcsg9cl4qIyO5wCjkRERHJEntyiIjIppToKmqMcXVSQsGp+naPSQ4REdkUYxbqvLhIzfWwiEkO2SjWwCFbxYKBRPWGSQ7ZJtbAIVvFgoG14uqkxMVFaoMxJboKo3p5yH4wySEiIqunUCh4+4lMxu8Ysn2sgUPWjgUDiSyCSQ7ZPtbAIWvHgoFEFsE6OURERCRL7MmROSEESssN15QwpuYEERGRrWGSI3Ol5RUITz5k6WYQERHVOyY5RETWhrV0nhirIhPAJMeuZM2NhptKaTDG1cnwcSKqB6yl88RYFZkAJjl2xU2ltI0faFYzJiIiM7CBTzyyO6xmTPaItXSeGKsi0x8xySEisgaspfPEWBWZ/ojfDWTdWM2YiIhqiUkOWTdWMyYiolpixWMiIiKSJfbkEBHZItbSIaqRyT05R48exYsvvojg4GAoFArs3btX77gQAsnJyQgKCoKrqyuio6Px008/6cXcunULI0eOhJeXF3x8fJCQkIC7d+/qxZw7dw49e/aEi4sLQkJCkJKS8khbdu3ahdatW8PFxQXt27fHF198YerbISKyTSuaP5iFaGirqRQDkcyZnOQUFxejY8eO2LBhQ7XHU1JSsG7dOmzcuBEnT56Eu7s71Go17t27J8WMHDkS33//PdLS0rBv3z4cPXoU48ePl45rtVr069cPTZo0QXZ2NpYvX44FCxbgww8/lGK++eYbjBgxAgkJCThz5gwGDhyIgQMH4sKFC6a+JSIiIpIj8QQAiD179kiPKysrRWBgoFi+fLm0r7CwUDg7O4uPP/5YCCHExYsXBQBx+vRpKebAgQNCoVCI3377TQghxPvvvy8aNGggysrKpJiZM2eKVq1aSY9ffvllERsbq9eeyMhI8b//+79Gt7+oqEgAEEVFRUY/x9YUl5WLJjP3iSYz94nisnJLN8c4ZXeFmO/1YCu7a+nWEFmPysoHPxOGtjsF/PkxwCZ/J9IjjP38NuvA49zcXGg0GkRHR0v7vL29ERkZiczMTABAZmYmfHx80LVrVykmOjoaDg4OOHnypBTTq1cvqFQqKUatViMnJwe3b9+WYh5+naqYqtepTllZGbRard5G9UwIQFdcw8YudqJqVdXSMbixpAJRFbMOPNZoNACAgIAAvf0BAQHSMY1GA39/f/1GODrC19dXLyYsLOyRc1Qda9CgATQajcHXqc7SpUuxcOHCWrwzMhtWMyYionpiV1PIZ82ahaKiImn79ddfLd0kIiKykBJdBUp09w1uQghLN5OegFl7cgIDAwEA+fn5CAoKkvbn5+ejU6dOUkxBQYHe8+7fv49bt25Jzw8MDER+fr5eTNXjmmKqjlfH2dkZzs7OtXhnVCdYzZiobnGauUFcqVz+zPo/FxYWhsDAQKSnp0tJjVarxcmTJzFx4kQAQFRUFAoLC5GdnY2IiAgAwOHDh1FZWYnIyEgpZs6cOSgvL4eTkxMAIC0tDa1atUKDBg2kmPT0dEyZMkV6/bS0NERFRZnzLVFdYjVjorplzGKes6/x55Bky+Qk5+7du7h8+bL0ODc3F2fPnoWvry9CQ0MxZcoUvP3222jRogXCwsIwb948BAcHY+DAgQCANm3aICYmBuPGjcPGjRtRXl6OSZMmYfjw4QgOfjBW45VXXsHChQuRkJCAmTNn4sKFC1i7di1Wr14tve4bb7yB5557DitXrkRsbCx27NiBrKwsvWnmRERED+NK5fbF5CQnKysLvXv3lh4nJSUBAOLi4pCamooZM2aguLgY48ePR2FhIXr06IGDBw/CxcVFes62bdswadIk9OnTBw4ODhgyZAjWrVsnHff29saXX36JxMREREREoGHDhkhOTtarpfPMM89g+/btmDt3LmbPno0WLVpg7969aNeuXa0uBBGRLDi5PeidMURXYlwvjwxxpXL7ohB2PKpKq9XC29sbRUVF8PLysnRz6kSJ7j7Ckw8BsJJ7y7ri32dXsZucyDL4c2iQ1f3epEcY+/ltV7OriIiIyH4wPSUiInqMEl1FjTGuTkoo7HSGmrVjkkNEZM84zdwgTjO3bfxfIfMRouZVj7lkA5F14TRzkjEmOWQ+XLKBiGSA08zlg0mODRNCoLTc8P1iY+4nE5Gd4TRzgzjNXD74v2jDSssrpGmOVodLNhBZr6rVzIlkjkkO1Q0u2UBERBbGJEcmsuZGw02lNBjj6mT4OBERkZwwyZEJN5WS95CJiIgeworHREREJEv805+IiAxjwUCDWBXZejHJISIiw1gw0CBWRbZevF1FREREssS0koiIHsWCgQaxKrJtYJJDRESPYsFAg1gV2Tbwf4iIiJ4cByeTFWKSQ8bhCuNEZAgHJ5MVYpJDxuEK40REZGOY5BARUe1wcDJZOSY5ZDquME5EAAcnm4AFAy2DSQ6ZjiuMExGZhAUDLYPFAImIiEiWmDISERHVARYMtDwmOURERHWABQMtj1efiIjqBwsGUj1jkkNERPWDBQOpnnHgMREREckSe3KISzYQUd1hwUCyICY5xCUbiKjusGCg0Vgw0PyY5BAREVkBFgw0P14p0sclG4jIkjgDi8yISQ7p45INRGRJdjYDiwUD6xaTHCslhEBpueH7s8bcvyUiIuvFgoF1i1fWSpWWVyA8+ZClm0FEVPc4A4vqCJMcIiKyLM7AMhpnYJmGSY4NyJobDTeV0mCMq5Ph40REsmHHg5M5A8s0vAo2wE2l5DcsEVEVOxucTLXHT04iIiIrxhlYtcckh4iIrJ8dD07mDKza41UjIiLrZ+rgZDset0O/Y5JDRETyw3E7BCY58scVxomI7Aqnmf+OSY7ccYVxIrIXdjxu52GcZv47+b9DIiKyDywqSH/AJMeecIVxIiJZ4jTz6jmY+4QLFiyAQqHQ21q3bi0dv3fvHhITE+Hn5wcPDw8MGTIE+fn5eufIy8tDbGws3Nzc4O/vj+nTp+P+/ft6MRkZGejSpQucnZ3RvHlzpKammvutyE/VCuOGNju4R0tEJDdV08wNb/ZXGb9OenLatm2Lr776PVt0dPz9ZaZOnYr9+/dj165d8Pb2xqRJkzB48GAcP34cAFBRUYHY2FgEBgbim2++wfXr1/Haa6/ByckJS5YsAQDk5uYiNjYWEyZMwLZt25Ceno6xY8ciKCgIarXhTJaIiAgAp5nbgTpJchwdHREYGPjI/qKiIvz973/H9u3b8ec//xkAsGXLFrRp0wYnTpxA9+7d8eWXX+LixYv46quvEBAQgE6dOmHx4sWYOXMmFixYAJVKhY0bNyIsLAwrV64EALRp0wZff/01Vq9ezSSHiIiMY8fTzO1lBladJDk//fQTgoOD4eLigqioKCxduhShoaHIzs5GeXk5oqOjpdjWrVsjNDQUmZmZ6N69OzIzM9G+fXsEBARIMWq1GhMnTsT333+Pzp07IzMzU+8cVTFTpkwx2K6ysjKUlZVJj7VarXneMBERkQ2xlxlYZm99ZGQkUlNT0apVK1y/fh0LFy5Ez549ceHCBWg0GqhUKvj4+Og9JyAgABqNBgCg0Wj0Epyq41XHDMVotVqUlpbC1dW12rYtXboUCxcuNMfbJCIiW8Rp5nbF7ElO//79pa87dOiAyMhINGnSBDt37nxs8lFfZs2ahaSkJOmxVqtFSEiIBVtERET1yo6nmdvjDKw674fy8fFBy5YtcfnyZfTt2xc6nQ6FhYV6vTn5+fnSGJ7AwECcOnVK7xxVs68ejvnjjKz8/Hx4eXkZTKScnZ3h7OxsjrdFRERkU+xxoU+zTyH/o7t37+LKlSsICgpCREQEnJyckJ6eLh3PyclBXl4eoqKiAABRUVE4f/48CgoKpJi0tDR4eXkhPDxcinn4HFUxVecgIiIyC10JoCs2vAlh6VbWiRJdBUp09w1uwsrfu9lTumnTpuHFF19EkyZNcO3aNcyfPx9KpRIjRoyAt7c3EhISkJSUBF9fX3h5eWHy5MmIiopC9+7dAQD9+vVDeHg4Xn31VaSkpECj0WDu3LlITEyUemEmTJiA9evXY8aMGYiPj8fhw4exc+dO7N+/39xvx7pxXSoiorplxzOw5DA42ewt+89//oMRI0bg5s2baNSoEXr06IETJ06gUaNGAIDVq1fDwcEBQ4YMQVlZGdRqNd5//33p+UqlEvv27cPEiRMRFRUFd3d3xMXFYdGiRVJMWFgY9u/fj6lTp2Lt2rVo3LgxNm3aZH/Tx7kuFRER0WMphLX3NdUhrVYLb29vFBUVwcvLy9LN0VOiu4/w5EMADGTKumLTkhyZ/rVBRGRWxvaSV/XyyOh3qxACpeWGa+g8PDjZUj05xn5+W28fE5mG61IREZmHqTOwZFQ52dTBydZeVJBJjlxUrUtFRET1i+N2DLLkuJ06n11FREREZAnsySEiIjKVHVdOtqWigkxyiIiITGXHlZNtqaigbbRSZowdvU5ERDIho8HJtoRJjgWUlldI08OJiMgO2PHgZEviwGMiIiKSJfbkWFjW3Gi4qZQGY1ydDB8nIiIrZMeDk60FkxwLc1MpbWYAFxERmcCOiwpaC366EhERWQOO2zE7jskhIiIiWWJPDhERkaWYOm6Ht7RMwiTHWhm7Ci4REdkuU8ft8JaWSZjkWKvyEmBJsKVbQUREZLOY5BAREVkzTkWvNSY5tmDaZUDlZjjGqYbjRERkmzgVvdaY5NgClRvvrxIRkXE4bkfCKeREREQkS+zJISIisnWcil4tJjlERES2jlPRq8XbVURERCRL7MkhIiKyB3Z4S4tJDhERkT2ww1taTHKIiIiodh7X26O7D1fce/C1EPXXnj9gkkNEREQPmHpL6zG9PW4AfnB58HVJeR7g7G2+NpqASY4lCPF7hqsrRrX/DVx8k4iI6pupt7SsHJMcSygvwQ8u8Q++XmHZphAREZnEiN6ekmIt3Na2rqcGPR6THCIiIjKeMb09uvv105YaMMmxsJI3LsHN3ctwEBffJCIiMhmTHEtz4uKbREREdYEVj4mIiEiWmOQQERGRLPF2lZkJIVBaXmEwpkRXAY6yISIiqltMcsystLwC4cmHDMa44p5UJImIiIjqBm9XERERkSyxJ6cOZc2NhptK+egBXbFUBNDVqZrjRERE9MSY5NQhN5USbqrqLvHv+xRWvEQ9ERGRLePtKiIiIpIlJjlEREQkS7xdZW5cYZyIiMgqMMkxN64wTkREZBV4u4qIiIhkiT05dYgrjBMREVkOk5y6xBXGiYiILIa3q4iIiMjshBDY/UM5bt26bbE22HySs2HDBjRt2hQuLi6IjIzEqVOnLN0kIiIiu3ehoBJDdpYivF0HzJs3D7du3ar3Nth0kvPJJ58gKSkJ8+fPx7fffouOHTtCrVajoKDA0k0jIiKya+WVD/7t168fVq1ahaZNm9Z7smPTSc6qVaswbtw4jBkzBuHh4di4cSPc3NywefNmSzeNiIiIAMyePRu5ubmYMGFCvSc7NjvwWKfTITs7G7NmzZL2OTg4IDo6GpmZmdU+p6ysDGVlZdLjoqIiAIBWqzVbu0ruanG/TDz4WqvF/UquTUVERPal5K4Wd3VCeuzv74+UlBRMmzYNK1aswKpVq7B27VpMmDABkydPhre3t0nnr/rcFkIYDhQ26rfffhMAxDfffKO3f/r06aJbt27VPmf+/PkCADdu3Lhx48atnrbs7OxHPo/Pnz8vGjVq9MTn/vXXXw3mCjbbk1Mbs2bNQlJSkvS4srISt27dgp+fn1lXA9dqtQgJCcGvv/4KL68a6uRQrfE61x9e6/rB61w/eJ3rx/HjxzFgwAC9fQUFBVi+fDnef/99KJVKTJ8+vVY9OUII3LlzB8HBwQbjbDbJadiwIZRKJfLz8/X25+fnIzAwsNrnODs7w9nZWW+fj49PXTURXl5e/AGqB7zO9YfXun7wOtcPXue65e7+e524PyY3SUlJmDp1Knx9fWt9fmMSI5sdeKxSqRAREYH09HRpX2VlJdLT0xEVFWXBlhEREVGVJUuWICwsDH/729+QlJSEq1evYvHixU+U4BjLZntyACApKQlxcXHo2rUrunXrhjVr1qC4uBhjxoyxdNOIiIjsmpOTEwDgyy+/NEvPTW3YdJIzbNgw3LhxA8nJydBoNOjUqRMOHjyIgIAAi7bL2dkZ8+fPf+TWGJkXr3P94bWuH7zO9YPXuX507twZL7/8MtasWYOgoCCLtEEhRE3zr4iIiIhsj82OySEiIiIyhEkOERERyRKTHCIiIpIlJjlEREQkS0xy6sCGDRvQtGlTuLi4IDIyEqdOnbJ0k2za0qVL8fTTT8PT0xP+/v4YOHAgcnJy9GLu3buHxMRE+Pn5wcPDA0OGDHmkUCQZ791334VCocCUKVOkfbzG5vPbb79h1KhR8PPzg6urK9q3b4+srCzpuBACycnJCAoKgqurK6Kjo/HTTz9ZsMW2p6KiAvPmzUNYWBhcXV3RrFkzLF68WG+tI15n0x09ehQvvvgigoODoVAosHfvXr3jxlzTW7duYeTIkfDy8oKPjw8SEhJw9+7dumlwLZaNIgN27NghVCqV2Lx5s/j+++/FuHHjhI+Pj8jPz7d002yWWq0WW7ZsERcuXBBnz54VAwYMEKGhoeLu3btSzIQJE0RISIhIT08XWVlZonv37uKZZ56xYKtt16lTp0TTpk1Fhw4dxBtvvCHt5zU2j1u3bokmTZqI0aNHi5MnT4qff/5ZHDp0SFy+fFmKeffdd4W3t7fYu3ev+O6778RLL70kwsLCRGlpqQVbblveeecd4efnJ/bt2ydyc3PFrl27hIeHh1i7dq0Uw+tsui+++ELMmTNH7N69WwAQe/bs0TtuzDWNiYkRHTt2FCdOnBDHjh0TzZs3FyNGjKiT9jLJMbNu3bqJxMRE6XFFRYUIDg4WS5cutWCr5KWgoEAAEEeOHBFCCFFYWCicnJzErl27pJgffvhBABCZmZmWaqZNunPnjmjRooVIS0sTzz33nJTk8Bqbz8yZM0WPHj0ee7yyslIEBgaK5cuXS/sKCwuFs7Oz+Pjjj+ujibIQGxsr4uPj9fYNHjxYjBw5UgjB62wOf0xyjLmmFy9eFADE6dOnpZgDBw4IhUIhfvvtN7O3kberzEin0yE7OxvR0dHSPgcHB0RHRyMzM9OCLZOXoqIiAJAqZ2ZnZ6O8vFzvurdu3RqhoaG87iZKTExEbGys3rUEeI3N6Z///Ce6du2KoUOHwt/fH507d8ZHH30kHc/NzYVGo9G71t7e3oiMjOS1NsEzzzyD9PR0/PjjjwCA7777Dl9//TX69+8PgNe5LhhzTTMzM+Hj44OuXbtKMdHR0XBwcMDJkyfN3iabrnhsbf773/+ioqLikYrLAQEBuHTpkoVaJS+VlZWYMmUKnn32WbRr1w4AoNFooFKpHllsNSAgABqNxgKttE07duzAt99+i9OnTz9yjNfYfH7++Wd88MEHSEpKwuzZs3H69Gm8/vrrUKlUiIuLk65ndb9HeK2N99Zbb0Gr1aJ169ZQKpWoqKjAO++8g5EjRwIAr3MdMOaaajQa+Pv76x13dHSEr69vnVx3JjlkUxITE3HhwgV8/fXXlm6KrPz666944403kJaWBhcXF0s3R9YqKyvRtWtXLFmyBMCD0vcXLlzAxo0bERcXZ+HWycfOnTuxbds2bN++HW3btsXZs2cxZcoUBAcH8zrbEd6uMqOGDRtCqVQ+MuMkPz8fgYGBFmqVfEyaNAn79u3Dv//9bzRu3FjaHxgYCJ1Oh8LCQr14XnfjZWdno6CgAF26dIGjoyMcHR1x5MgRrFu3Do6OjggICOA1NpOgoCCEh4fr7WvTpg3y8vIAQLqe/D3yZKZPn4633noLw4cPR/v27fHqq69i6tSpWLp0KQBe57pgzDUNDAxEQUGB3vH79+/j1q1bdXLdmeSYkUqlQkREBNLT06V9lZWVSE9PR1RUlAVbZtuEEJg0aRL27NmDw4cPIywsTO94REQEnJyc9K57Tk4O8vLyeN2N1KdPH5w/fx5nz56Vtq5du2LkyJHS17zG5vHss88+UgLhxx9/RJMmTQAAYWFhCAwM1LvWWq0WJ0+e5LU2QUlJCRwc9D/ilEolKisrAfA61wVjrmlUVBQKCwuRnZ0txRw+fBiVlZWIjIw0f6PMPpTZzu3YsUM4OzuL1NRUcfHiRTF+/Hjh4+MjNBqNpZtmsyZOnCi8vb1FRkaGuH79urSVlJRIMRMmTBChoaHi8OHDIisrS0RFRYmoqCgLttr2PTy7SgheY3M5deqUcHR0FO+884746aefxLZt24Sbm5v4xz/+IcW8++67wsfHR3z++efi3Llz4i9/+QunNpsoLi5O/OlPf5KmkO/evVs0bNhQzJgxQ4rhdTbdnTt3xJkzZ8SZM2cEALFq1Spx5swZ8csvvwghjLumMTExonPnzuLkyZPi66+/Fi1atOAUclvy3nvvidDQUKFSqUS3bt3EiRMnLN0kmwag2m3Lli1STGlpqfjrX/8qGjRoINzc3MSgQYPE9evXLddoGfhjksNrbD7/+te/RLt27YSzs7No3bq1+PDDD/WOV1ZWinnz5omAgADh7Ows+vTpI3JycizUWtuk1WrFG2+8IUJDQ4WLi4t46qmnxJw5c0RZWZkUw+tsun//+9/V/j6Oi4sTQhh3TW/evClGjBghPDw8hJeXlxgzZoy4c+dOnbRXIcRD5R+JiIiIZIJjcoiIiEiWmOQQERGRLDHJISIiIllikkNERESyxCSHiIiIZIlJDhEREckSkxwiIiKSJSY5REREJEtMcohIVq5evQqFQgGFQoFOnTpZtC3PP/+81JazZ89atC1E9ohJDhGZzejRo6FQKDBhwoRHjiUmJkKhUGD06NGPxP9xi4mJQUZGRrXHHt4yMjIe25avvvpKb6FA4MFigfPmzUPbtm3h6uoKPz8/PP3000hJScHt27eNeo+fffYZlEolfvvtt2qPt2jRAklJSQCA3bt349SpU0adl4jMz9HSDSAieQkJCcGOHTuwevVquLq6AgDu3buH7du3IzQ09JH4mJgYbNmyRW+fs7Mz3N3dcf36dWnfG2+8Aa1Wqxfr6+v72Hb4+fnBz89Penzr1i306NEDWq0WixcvRkREBLy9vZGTk4MtW7Zg+/btSExMrPH9vfTSS/Dz88PWrVsxe/ZsvWNHjx7F5cuXkZCQILVPq9XWeE4iqhtMcojIrLp06YIrV65g9+7dGDlyJIAHPRqhoaEICwt7JN7Z2RmBgYHVnuvh/a6urigrK3tsbE1mz56NvLw8/PjjjwgODpb2N2nSBP369cPDy/iVlZVhzpw5+Pjjj1FYWIh27dph2bJleP755+Hk5IRXX30VqampjyQ5mzdvRmRkJNq2bVurNhKRefF2FRGZXXx8vF6Py+bNmzFmzBiLtaeyshKffPIJRo0apZfgPEyhUEhfT5o0CZmZmdixYwfOnTuHoUOHIiYmBj/99BMAICEhAT/99BOOHj0qPefu3bv49NNPpV4cIrI8JjlEZHajRo3C119/jV9++QW//PILjh8/jlGjRlUbu2/fPnh4eOhtS5YsMWt7bty4gcLCQrRq1Upvf0REhPSaI0aMAADk5eVhy5Yt2LVrF3r27IlmzZph2rRp6NGjh5S4hYeHo3v37ti8ebN0rp07d0IIgeHDh5u17URUe7xdRURm16hRI8TGxiI1NRVCCMTGxqJhw4bVxvbu3RsffPCB3j5DY23Mac+ePdDpdJg5cyZKS0sBAOfPn0dFRQVatmypF1tWVqY3xic+Ph5Tp07Fe++9B09PT2zevBlDhw6Fp6dnvbSdiGrGJIeI6kR8fDwmTZoEANiwYcNj49zd3dG8efM6bUujRo3g4+ODnJwcvf1VA6E9PT1RWFgI4MFtJ6VSiezsbCiVSr14Dw8P6evhw4dj6tSp2LlzJ3r16oXjx49j6dKldfo+iMg0THKIqE7ExMRAp9NBoVBArVZbtC0ODg54+eWX8Y9//APJycmPHZcDAJ07d0ZFRQUKCgrQs2fPx8Z5enpi6NCh2Lx5M65cuYKWLVsajCei+sckh4jqhFKpxA8//CB9/ThlZWXQaDR6+xwdHR97e6u2lixZgoyMDHTr1g2LFi1C165d4e7ujnPnziEzMxPt2rUDALRs2RIjR47Ea6+9hpUrV6Jz5864ceMG0tPT0aFDB8TGxkrnTEhIQM+ePfHDDz9g5syZZm0vET05JjlEVGe8vLxqjDl48CCCgoL09rVq1QqXLl0ya1v8/Pxw6tQpLFu2DMuXL0dubi4cHBzQokULDBs2DFOmTJFit2zZgrfffhtvvvkmfvvtNzRs2BDdu3fHCy+8oHfOHj16oFWrVrh8+TJee+01s7aXiJ6cQjxcHIKIyMZdvXoVYWFhOHPmjMWXdbDG9hDZE04hJyJZeuaZZ/DMM89YtA39+/dnYUAiC2JPDhHJyv3793H16lUAD6oph4SEWKwtv/32mzQ1PTQ0FCqVymJtIbJHTHKIiIhIlni7ioiIiGSJSQ4RERHJEpMcIiIikiUmOURERCRLTHKIiIhIlpjkEBERkSwxySEiIiJZYpJDREREsvT/ACB4u82tSNY/AAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "result_2['MET'].plot1d()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "b62af5e5-2aed-4335-9754-7b55eebd8c47",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "all events 1439000\n",
      "number of chunks 17\n"
     ]
    }
   ],
   "source": [
    "for key, value in result_2['cutflow'].items():\n",
    "    print(key, value)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8fd3df57-53c6-4eb8-a424-82885fa4abc7",
   "metadata": {},
   "source": [
    "## 6. Stable chunk identity for caching\n",
    "\n",
    "`hash_fileset` returns a stable SHA-256 hex string for a chunk. The hash covers dataset names, sorted file paths, and all output-affecting dataset-level fields (`treename`, `preload`, `metadata`) in canonical form, so chunks that differ in any of those will hash differently. The hash is consistent across sessions, making it suitable as a cache key.\n",
    "\n",
    "```python\n",
    "chunk_hash = hash_fileset(chunk)\n",
    "# gives 'a3f2c1...'\n",
    "```\n",
    "\n",
    "> **Note:** `hash_fileset` requires self-contained chunks. A bare `{dataset: [path, ...]}` (or `{dataset: {\"files\": [path, ...]}}` without a `treename` field) is rejected — pass `treename=` to `split_fileset` first so the chunks carry their own tree name.\n",
    "\n",
    "The typical pattern: before running a chunk, check if a cached result already exists on disk. If it does, load it. If not, run the processor, save the result, and use it. On a subsequent run (or after a partial failure), already-processed chunks are loaded from cache and only missing chunks are recomputed."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b343ad7b-6b6a-439f-a52c-cefc123c6c2d",
   "metadata": {},
   "source": [
    "## 7. Example 3: on-disk caching + (`percentage=20`, mixed chunks)\n",
    "\n",
    "With `percentage=20` and no strategy, each chunk is a *mix* of 20% of every dataset — so `SingleMu_0` and `SingleMu_1` appear together in each chunk.\n",
    "The chunk that contains the broken `SingleMu_0` file will fail, but the remaining 4 mixed chunks succeed.\n",
    "\n",
    "Successfully processed chunks are saved to `./chunk_cache/`. Re-running this cell will load them from disk and skip reprocessing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "0bfcc0e2-7214-438a-a425-3a2b7367070e",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "result_3 = None\n",
    "cache_dir = \"./chunk_cache\"\n",
    "os.makedirs(cache_dir, exist_ok=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "fd6227f5-4719-49a5-93e9-b29c53187964",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0f03a87d2e8545eca335d18f9a4fd4da",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"></pre>\n"
      ],
      "text/plain": []
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "loky.process_executor._RemoteTraceback: \n",
      "\"\"\"\n",
      "Traceback (most recent call last):\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/loky/process_executor.py\", line 490, in _process_worker\n",
      "    r = call_item()\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/loky/process_executor.py\", line 291, in __call__\n",
      "    return self.fn(*self.args, **self.kwargs)\n",
      "           ~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
      "  File \"/home/iason/Dropbox/work/pyhep_dev/coffea/src/coffea/processor/executor.py\", line 1289, in automatic_retries\n",
      "    raise e\n",
      "  File \"/home/iason/Dropbox/work/pyhep_dev/coffea/src/coffea/processor/executor.py\", line 1275, in automatic_retries\n",
      "    return func(*args, **kwargs)\n",
      "  File \"/home/iason/Dropbox/work/pyhep_dev/coffea/src/coffea/processor/executor.py\", line 1359, in metadata_fetcher_root\n",
      "    with uproot.open(\n",
      "         ~~~~~~~~~~~^\n",
      "        {item.filename: None}, timeout=xrootdtimeout, **uproot_options\n",
      "        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
      "    ) as file:\n",
      "    ^\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/uproot/reading.py\", line 144, in open\n",
      "    file = ReadOnlyFile(\n",
      "        file_path,\n",
      "    ...<5 lines>...\n",
      "        **options,\n",
      "    )\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/uproot/reading.py\", line 563, in __init__\n",
      "    self._source = source_cls(file_path, **self._options)\n",
      "                   ~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/uproot/source/fsspec.py\", line 63, in __init__\n",
      "    self._open()\n",
      "    ~~~~~~~~~~^^\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/uproot/source/fsspec.py\", line 70, in _open\n",
      "    self._fo = self._open_file.__enter__()\n",
      "               ~~~~~~~~~~~~~~~~~~~~~~~~~^^\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/fsspec/core.py\", line 105, in __enter__\n",
      "    f = self.fs.open(self.path, mode=mode)\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/fsspec_xrootd/xrootd.py\", line 802, in open\n",
      "    f = self._open(\n",
      "        path,\n",
      "    ...<4 lines>...\n",
      "        **kwargs,\n",
      "    )\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/fsspec_xrootd/xrootd.py\", line 759, in _open\n",
      "    return XRootDFile(\n",
      "        self,\n",
      "    ...<5 lines>...\n",
      "        **kwargs,\n",
      "    )\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/fsspec_xrootd/xrootd.py\", line 867, in __init__\n",
      "    self._hosts = self._locate_sources(path)\n",
      "                  ~~~~~~~~~~~~~~~~~~~~^^^^^^\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/fsspec_xrootd/xrootd.py\", line 967, in _locate_sources\n",
      "    raise OSError(\"XRootD error: \" + status.message)\n",
      "OSError: XRootD error: [FATAL] Invalid address\n",
      "\"\"\"\n",
      "\n",
      "The above exception was the direct cause of the following exception:\n",
      "\n",
      "Traceback (most recent call last):\n",
      "  File \"/home/iason/Dropbox/work/pyhep_dev/coffea/src/coffea/processor/executor.py\", line 717, in _processwith\n",
      "    merged = _watcher(FH, self, reducer, pool)\n",
      "  File \"/home/iason/Dropbox/work/pyhep_dev/coffea/src/coffea/processor/executor.py\", line 498, in _watcher\n",
      "    batch = FH.fetch(len(FH.completed))\n",
      "  File \"/home/iason/Dropbox/work/pyhep_dev/coffea/src/coffea/processor/executor.py\", line 382, in fetch\n",
      "    raise bad_futures[0].exception()\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/loky/process_executor.py\", line 490, in _process_worker\n",
      "    r = call_item()\n",
      "    ^^^^^^^^^^^\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/loky/process_executor.py\", line 291, in __call__\n",
      "    return self.fn(*self.args, **self.kwargs)\n",
      "    ^^^^^^^^^^^^^^^\n",
      "  File \"/home/iason/Dropbox/work/pyhep_dev/coffea/src/coffea/processor/executor.py\", line 1289, in automatic_retries\n",
      "    raise e\n",
      "    \n",
      "  File \"/home/iason/Dropbox/work/pyhep_dev/coffea/src/coffea/processor/executor.py\", line 1275, in automatic_retries\n",
      "    return func(*args, **kwargs)\n",
      "    ^^^^^^^\n",
      "  File \"/home/iason/Dropbox/work/pyhep_dev/coffea/src/coffea/processor/executor.py\", line 1359, in metadata_fetcher_root\n",
      "    with uproot.open(\n",
      "    ^^^^^^^^^^^^^^^\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/uproot/reading.py\", line 144, in open\n",
      "    file = ReadOnlyFile(\n",
      "      ^^^^^^^^^^^^^^^^^\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/uproot/reading.py\", line 563, in __init__\n",
      "    self._source = source_cls(file_path, **self._options)\n",
      "    ^^^^^^^^^^^^^^^\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/uproot/source/fsspec.py\", line 63, in __init__\n",
      "    self._open()\n",
      "    ~~~~~~~~~~^^\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/uproot/source/fsspec.py\", line 70, in _open\n",
      "    self._fo = self._open_file.__enter__()\n",
      "    ^^^^^^^^^^^^^^^\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/fsspec/core.py\", line 105, in __enter__\n",
      "    f = self.fs.open(self.path, mode=mode)\n",
      "    ^^^^^^^^^^^\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/fsspec_xrootd/xrootd.py\", line 802, in open\n",
      "    f = self._open(\n",
      "    ^^^^^^^^^^^\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/fsspec_xrootd/xrootd.py\", line 759, in _open\n",
      "    return XRootDFile(\n",
      "    ^^^^^^^^^^^^^^^\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/fsspec_xrootd/xrootd.py\", line 867, in __init__\n",
      "    self._hosts = self._locate_sources(path)\n",
      "    ^^^^^^^^^^^\n",
      "  File \"/home/iason/micromamba/envs/py3.14/lib/python3.14/site-packages/fsspec_xrootd/xrootd.py\", line 967, in _locate_sources\n",
      "    raise OSError(\"XRootD error: \" + status.message)\n",
      "    ^^^^^^^^^^^\n",
      "OSError: XRootD error: [FATAL] Invalid address\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error processing chunk 5febc050...: XRootD error: [FATAL] Invalid address\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8d355c7ee389401a85e63ad867dff1be",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"></pre>\n"
      ],
      "text/plain": []
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved result for chunk 326dec70...\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "306751e1515d491181ebcbf6a45d9054",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"></pre>\n"
      ],
      "text/plain": []
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved result for chunk 28afadc5...\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4b7f885498b54004a29446f74b47c995",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"></pre>\n"
      ],
      "text/plain": []
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved result for chunk 7aab00fd...\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "aaf708f915904c53979e22f05a0cafd5",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"></pre>\n"
      ],
      "text/plain": []
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved result for chunk bc4cbe30...\n"
     ]
    }
   ],
   "source": [
    "for chunk in chunks_3:\n",
    "    chunk_hash = hash_fileset(chunk)\n",
    "    cache_path = os.path.join(cache_dir, f\"{chunk_hash}.coffea\")\n",
    "\n",
    "    if os.path.exists(cache_path):\n",
    "        print(f\"Loading cached result for chunk {chunk_hash[:8]}...\")\n",
    "        output = load(cache_path)\n",
    "    else:\n",
    "        run_result = run(chunk, processor_instance=Processor())\n",
    "        if run_result.is_ok():\n",
    "            output, metrics = run_result.unwrap()\n",
    "            save(output, cache_path)\n",
    "            print(f\"Saved result for chunk {chunk_hash[:8]}...\")\n",
    "        else:\n",
    "            print(f\"Error processing chunk {chunk_hash[:8]}...: {run_result.exception}\")\n",
    "            continue\n",
    "    if result_3 is None:\n",
    "        result_3 = output \n",
    "    else:\n",
    "        result_3 += output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "67e14881-9a71-4102-856f-185ece21168d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[StairsArtists(stairs=<matplotlib.patches.StepPatch object at 0x7f54b9b90550>, errorbar=None, legend_artist=None),\n",
       " StairsArtists(stairs=<matplotlib.patches.StepPatch object at 0x7f54b9b90690>, errorbar=None, legend_artist=None)]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "result_3['MET'].plot1d()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "842e8bf3-bff8-408f-8bd9-3f0fbb462121",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "all events 1292000\n",
      "number of chunks 16\n"
     ]
    }
   ],
   "source": [
    "for key, value in result_3['cutflow'].items():\n",
    "    print(key, value)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.14.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}