From 28583a984f9f4af26613f73f024eea187238f53c Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" Date: Sat, 3 May 2025 03:19:11 +0000 Subject: [PATCH 01/22] feat: add demo notebook for tracker features --- notebooks/03_orcabridge_tracker.ipynb | 339 ++++++++++++++++++++++++++ 1 file changed, 339 insertions(+) create mode 100644 notebooks/03_orcabridge_tracker.ipynb diff --git a/notebooks/03_orcabridge_tracker.ipynb b/notebooks/03_orcabridge_tracker.ipynb new file mode 100644 index 00000000..a67a0c03 --- /dev/null +++ b/notebooks/03_orcabridge_tracker.ipynb @@ -0,0 +1,339 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "d698bea9", + "metadata": {}, + "source": [ + "## Using Tracker" + ] + }, + { + "cell_type": "markdown", + "id": "5be82e8a", + "metadata": {}, + "source": [ + "In this notebook, I'll demonstrate using `Tracker` and related features of `orcabridge` to keep *track* of all `operations` you are using in a pipeline and to automatically construct computation graph based on it." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "f28a62af", + "metadata": {}, + "outputs": [], + "source": [ + "from orcabridge.tracker import Tracker\n", + "from orcabridge.source import GlobSource\n", + "from orcabridge.pod import FunctionPodWithDirStorage\n", + "import orcabridge.mapper as router\n", + "import networkx as nx\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "id": "110970a8", + "metadata": {}, + "source": [ + "As before let's construct a simple data pipeline that reads files and counts the number of lines, saving that information into another file. We will then chain it with another function that converts JSON to YAML." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "56136d16", + "metadata": {}, + "outputs": [], + "source": [ + "gs = GlobSource(\"data_file\", \"../examples/dataset1\", \"*.txt\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "c32938d6", + "metadata": {}, + "outputs": [], + "source": [ + "import tempfile\n", + "from pathlib import Path\n", + "import json\n", + "import yaml\n", + "\n", + "\n", + "# function to count lines in a file and save it as JSON\n", + "def count_lines(file: str):\n", + " with open(file, \"r\") as f:\n", + " n = len(f.readlines())\n", + " tmp_dir = tempfile.mkdtemp()\n", + " data_file = Path(tmp_dir) / \"data.json\"\n", + " data = dict(lines=n)\n", + " with open(data_file, \"w\") as f:\n", + " json.dump(data, f)\n", + " return data_file\n", + "\n", + "\n", + "def json_to_yaml(json_file: str):\n", + " with open(json_file, \"r\") as f:\n", + " data = json.load(f)\n", + " tmp_dir = tempfile.mkdtemp()\n", + " yaml_path = Path(tmp_dir) / Path(json_file).with_suffix(\".yaml\").name\n", + " with open(yaml_path, \"w\") as f:\n", + " yaml.dump(data, f)\n", + " return yaml_path" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "e763a55e", + "metadata": {}, + "outputs": [], + "source": [ + "# prepare a few MapKey mappers to take care of name differences\n", + "rename_to_file = router.MapKeys({\"data_file\": \"file\"})\n", + "\n", + "count_fp = FunctionPodWithDirStorage(count_lines, [\"stats\"])\n", + "\n", + "rename_to_json = router.MapKeys({\"stats\": \"json_file\"})\n", + "\n", + "convert_fp = FunctionPodWithDirStorage(json_to_yaml, [\"yaml_file\"])" + ] + }, + { + "cell_type": "markdown", + "id": "787b26ca", + "metadata": {}, + "source": [ + "With all steps defined, let's chain them together to form a full pipeline." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "3cdc6e7f", + "metadata": {}, + "outputs": [], + "source": [ + "line_info_json = count_fp(rename_to_file(gs))\n", + "line_info_yaml = convert_fp(rename_to_json(line_info_json))" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "71d18d81", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Tag: {'file_name': 'day1'}, Packet: {'yaml_file': 'pod_data/json_to_yaml/16207fa7-72aa-be99-3d44-e034a5ba8823/data.yaml'}\n", + "Tag: {'file_name': 'day2'}, Packet: {'yaml_file': 'pod_data/json_to_yaml/6c450b34-8835-afa9-2c07-c2d214749c3b/data.yaml'}\n", + "Tag: {'file_name': 'day3'}, Packet: {'yaml_file': 'pod_data/json_to_yaml/21c8f435-47d2-13ee-cdb2-9c31eb54093b/data.yaml'}\n", + "Tag: {'file_name': 'day4'}, Packet: {'yaml_file': 'pod_data/json_to_yaml/9f94dfb0-bded-6e79-dea1-494515af4886/data.yaml'}\n" + ] + } + ], + "source": [ + "line_info_yaml.preview(0)" + ] + }, + { + "cell_type": "markdown", + "id": "d6a0b378", + "metadata": {}, + "source": [ + "It turns out that `orcabrdige` comes with a default tracker that's been tracking all the execution that's been going on all this time!" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "2cdf8d30", + "metadata": {}, + "outputs": [], + "source": [ + "from orcabridge import DEFAULT_TRACKER" + ] + }, + { + "cell_type": "markdown", + "id": "19a999a7", + "metadata": {}, + "source": [ + "We can generate computation graph and appropriate name labels from the `DEFAULT_TRACKER` and plot it out." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "7a91ffaa", + "metadata": {}, + "outputs": [], + "source": [ + "G = DEFAULT_TRACKER.generate_graph()\n", + "labels = DEFAULT_TRACKER.generate_namemap()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "42f5bb99", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_2646006/828196166.py:13: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n", + " plt.tight_layout()\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "pos = nx.drawing.nx_agraph.graphviz_layout(G, prog=\"dot\")\n", + "nx.draw(\n", + " G,\n", + " pos,\n", + " labels=labels,\n", + " node_size=2000,\n", + " node_color=\"lightblue\",\n", + " with_labels=True,\n", + " font_size=10,\n", + " font_weight=\"bold\",\n", + " arrowsize=20,\n", + ")\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "id": "3c02d58c", + "metadata": {}, + "source": [ + "## Explicitly tracking computation pipeline with a tracker" + ] + }, + { + "cell_type": "markdown", + "id": "db480859", + "metadata": {}, + "source": [ + "While the `DEFAULT_TRACKER` offers a nice catch-all tracker, sometimes you'd want to explicitly control what gets tracked. To do so, you would want to create your own tracker, and define the computation using the tracker's context manager. Let's see an example." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "f678050e", + "metadata": {}, + "outputs": [], + "source": [ + "# instantiate a new tracker\n", + "tracker = Tracker()\n", + "\n", + "# start a context manager to track the pipeline\n", + "with tracker:\n", + " # chain the operations into a pipeline inside the context manager\n", + " line_info_json = count_fp(rename_to_file(gs))\n", + "\n", + "# construct the latter half OUTSIDE of the context manager\n", + "line_info_yaml = convert_fp(rename_to_json(line_info_json))" + ] + }, + { + "cell_type": "markdown", + "id": "f7d3484f", + "metadata": {}, + "source": [ + "In the example above, you would notice that only first half of the pipeline is chained together within the `tracker` context manager. Let's now see what the graph looks like." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "b3bf152b", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_2646006/2248456176.py:16: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n", + " plt.tight_layout()\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "G = tracker.generate_graph()\n", + "labels = tracker.generate_namemap()\n", + "\n", + "pos = nx.drawing.nx_agraph.graphviz_layout(G, prog=\"dot\")\n", + "nx.draw(\n", + " G,\n", + " pos,\n", + " labels=labels,\n", + " node_size=2000,\n", + " node_color=\"lightblue\",\n", + " with_labels=True,\n", + " font_size=10,\n", + " font_weight=\"bold\",\n", + " arrowsize=20,\n", + ")\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "id": "73992089", + "metadata": {}, + "source": [ + "As expected, the `tracker` only tracked the first half othe pipeline!" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "venv", + "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.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From b2ffdd363671ba51a27963e2f8ac0d815f03f213 Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" Date: Sat, 3 May 2025 03:38:27 +0000 Subject: [PATCH 02/22] feat: improve hashing to provide unique hash based on content --- src/orcabridge/base.py | 11 ++++++----- src/orcabridge/mapper.py | 29 +++++++++++++++++++++++++++++ src/orcabridge/source.py | 5 +++++ 3 files changed, 40 insertions(+), 5 deletions(-) diff --git a/src/orcabridge/base.py b/src/orcabridge/base.py index 2bc3e3d0..777cf74e 100644 --- a/src/orcabridge/base.py +++ b/src/orcabridge/base.py @@ -30,7 +30,7 @@ def get_invocation(self, *streams: "SyncStream") -> str: hash of the joined streams instead of the individual stream hashes. """ # default implementation where ID is stream order sensitive - invocation_id = ":".join([str(hash(s)) for s in streams]) + invocation_id = hash((self, tuple(streams))) return Invocation(self, invocation_id, streams) def __call__(self, *streams: "SyncStream") -> "SyncStream": @@ -73,7 +73,7 @@ class Invocation: def __init__( self, operation: Operation, - invocation_id: str, + invocation_id: int, streams: Collection["SyncStream"], ) -> None: self.operation = operation @@ -84,9 +84,7 @@ def __repr__(self) -> str: return f"Invocation({self.operation}, ID:{self.invocation_id})" def __hash__(self) -> int: - # TODO: use a better hash function that is based on the operation, - # invocation_id and the streams (ideally invocation objects attached to the streams) - return super().__hash__() + return self.invocation_id def __eq__(self, other: Any) -> bool: if not isinstance(other, Invocation): @@ -138,6 +136,9 @@ class SyncStream(Stream): """ def __hash__(self) -> int: + if self.source is not None: + # use the invocation ID as the hash + return self.source.invocation_id return super().__hash__() def keys(self) -> Tuple[List[str], List[str]]: diff --git a/src/orcabridge/mapper.py b/src/orcabridge/mapper.py index 0e07573b..d644f861 100644 --- a/src/orcabridge/mapper.py +++ b/src/orcabridge/mapper.py @@ -36,6 +36,9 @@ def generator(): def __repr__(self) -> str: return "Join()" + def __hash__(self) -> int: + return hash(self.__class__) + class MapKeys(Mapper): """ @@ -71,6 +74,11 @@ def generator(): def __repr__(self) -> str: return f"MapKeys({self.key_map})" + def __hash__(self) -> int: + return hash( + (self.__class__, tuple(sorted(self.key_map.items())), self.drop_unmapped) + ) + class MapTags(Operation): """ @@ -104,6 +112,11 @@ def generator(): def __repr__(self) -> str: return f"MapTags({self.tag_map})" + def __hash__(self) -> int: + return hash( + (self.__class__, tuple(sorted(self.tag_map.items())), self.drop_unmapped) + ) + class Filter(Mapper): """ @@ -132,6 +145,9 @@ def generator(): def __repr__(self) -> str: return f"Filter({self.predicate})" + def __hash__(self) -> int: + return hash((self.__class__, self.predicate)) + class Transform(Mapper): """ @@ -159,6 +175,9 @@ def generator(): def __repr__(self) -> str: return f"Transform({self.transform})" + def __hash__(self) -> int: + return hash((self.__class__, self.transform)) + class Batch(Mapper): """ @@ -205,6 +224,11 @@ def generator() -> Iterator[Tuple[Tag, Packet]]: def __repr__(self) -> str: return f"Batch(size={self.batch_size}, drop_last={self.drop_last})" + def __hash__(self) -> int: + return hash( + (self.__class__, self.batch_size, self.tag_processor, self.drop_last) + ) + class CacheStream(Mapper): """ @@ -246,3 +270,8 @@ def clear_cache(self) -> None: def __repr__(self) -> str: return f"CacheStream(active:{self.is_cached})" + + def __hash__(self) -> int: + # explicitly shown to signify that no two cachestreams are the same + # unless they are the same instance + return super().__hash__() diff --git a/src/orcabridge/source.py b/src/orcabridge/source.py index 12b88ae2..7b24e130 100644 --- a/src/orcabridge/source.py +++ b/src/orcabridge/source.py @@ -73,3 +73,8 @@ def generator() -> Iterator[Tuple[Tag, Packet]]: yield self.tag_function(file), {self.name: file} return SyncStreamFromGenerator(generator) + + def __hash__(self) -> int: + return hash( + (self.__class__, self.name, self.file_path, self.pattern, self.tag_function) + ) From 12253c48d181b023c7da5f426ff72cc81cb69ace Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" Date: Sat, 3 May 2025 03:41:45 +0000 Subject: [PATCH 03/22] doc: update tutorial about tracker --- notebooks/03_orcabridge_tracker.ipynb | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/notebooks/03_orcabridge_tracker.ipynb b/notebooks/03_orcabridge_tracker.ipynb index a67a0c03..b52653d3 100644 --- a/notebooks/03_orcabridge_tracker.ipynb +++ b/notebooks/03_orcabridge_tracker.ipynb @@ -169,7 +169,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 12, "id": "7a91ffaa", "metadata": {}, "outputs": [], @@ -180,7 +180,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 13, "id": "42f5bb99", "metadata": {}, "outputs": [ @@ -188,7 +188,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_2646006/828196166.py:13: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n", + "/tmp/ipykernel_2650656/828196166.py:13: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n", " plt.tight_layout()\n" ] }, @@ -272,7 +272,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_2646006/2248456176.py:16: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n", + "/tmp/ipykernel_2650656/2248456176.py:16: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n", " plt.tight_layout()\n" ] }, From 632e0da2905431176ce478104cddd24eff4cf6ba Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" Date: Sat, 3 May 2025 04:00:47 +0000 Subject: [PATCH 04/22] fix: improve repr --- src/orcabridge/pod.py | 3 +++ src/orcabridge/source.py | 5 +++++ 2 files changed, 8 insertions(+) diff --git a/src/orcabridge/pod.py b/src/orcabridge/pod.py index d66da170..621d01bb 100644 --- a/src/orcabridge/pod.py +++ b/src/orcabridge/pod.py @@ -70,6 +70,9 @@ def __init__( self.skip_memoization = skip_memoization self.force_computation = force_computation + def __repr__(self) -> str: + return f"pod:{self.function.__name__}() → {self.output_keys}" + def __hash__(self) -> int: return hash((self.function, tuple(self.output_keys))) diff --git a/src/orcabridge/source.py b/src/orcabridge/source.py index 7b24e130..5bfe1e78 100644 --- a/src/orcabridge/source.py +++ b/src/orcabridge/source.py @@ -74,6 +74,11 @@ def generator() -> Iterator[Tuple[Tag, Packet]]: return SyncStreamFromGenerator(generator) + def __repr__(self) -> str: + return ( + f"GlobSource({self.name} from {str(Path(self.file_path) / self.pattern)})" + ) + def __hash__(self) -> int: return hash( (self.__class__, self.name, self.file_path, self.pattern, self.tag_function) From 52850c8a5135ae909f91947619251df72ba3c452 Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" Date: Sat, 3 May 2025 04:03:34 +0000 Subject: [PATCH 05/22] doc: update tutorial on tracker --- notebooks/03_orcabridge_tracker.ipynb | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/notebooks/03_orcabridge_tracker.ipynb b/notebooks/03_orcabridge_tracker.ipynb index b52653d3..6597c27d 100644 --- a/notebooks/03_orcabridge_tracker.ipynb +++ b/notebooks/03_orcabridge_tracker.ipynb @@ -169,7 +169,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 8, "id": "7a91ffaa", "metadata": {}, "outputs": [], @@ -180,7 +180,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 9, "id": "42f5bb99", "metadata": {}, "outputs": [ @@ -188,13 +188,13 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_2650656/828196166.py:13: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n", + "/tmp/ipykernel_2655506/828196166.py:13: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n", " plt.tight_layout()\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -272,13 +272,13 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_2650656/2248456176.py:16: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n", + "/tmp/ipykernel_2655506/2248456176.py:16: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n", " plt.tight_layout()\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] From 541e7b4898fb947b684417758dc31a1c0b14e2cf Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" Date: Sat, 3 May 2025 04:21:10 +0000 Subject: [PATCH 06/22] feat: improved repr for operations --- src/orcabridge/mapper.py | 6 ++++-- src/orcabridge/pod.py | 4 +++- src/orcabridge/source.py | 4 +--- src/orcabridge/utils/name.py | 39 ++++++++++++++++++++++++++++++++++++ 4 files changed, 47 insertions(+), 6 deletions(-) diff --git a/src/orcabridge/mapper.py b/src/orcabridge/mapper.py index d644f861..64ea35fc 100644 --- a/src/orcabridge/mapper.py +++ b/src/orcabridge/mapper.py @@ -72,7 +72,8 @@ def generator(): return SyncStreamFromGenerator(generator) def __repr__(self) -> str: - return f"MapKeys({self.key_map})" + map_repr = ", ".join([f"{k} ⇒ {v}" for k, v in self.key_map.items()]) + return f"MapKeys({map_repr})" def __hash__(self) -> int: return hash( @@ -110,7 +111,8 @@ def generator(): return SyncStreamFromGenerator(generator) def __repr__(self) -> str: - return f"MapTags({self.tag_map})" + map_repr = ", ".join([f"{k} ⇒ {v}" for k, v in self.tag_map.items()]) + return f"MapTags({map_repr})" def __hash__(self) -> int: return hash( diff --git a/src/orcabridge/pod.py b/src/orcabridge/pod.py index 621d01bb..f0f24f11 100644 --- a/src/orcabridge/pod.py +++ b/src/orcabridge/pod.py @@ -5,6 +5,7 @@ from pathlib import Path from typing import List, Optional, Tuple, Iterator, Iterable, Collection from .utils.hash import hash_dict +from .utils.name import get_function_signature from .base import Operation from .mapper import Join from .stream import SyncStream, SyncStreamFromGenerator @@ -71,7 +72,8 @@ def __init__( self.force_computation = force_computation def __repr__(self) -> str: - return f"pod:{self.function.__name__}() → {self.output_keys}" + func_sig = get_function_signature(self.function) + return f"FunctionPod:{func_sig} ⇒ {self.output_keys}" def __hash__(self) -> int: return hash((self.function, tuple(self.output_keys))) diff --git a/src/orcabridge/source.py b/src/orcabridge/source.py index 5bfe1e78..6ecc8333 100644 --- a/src/orcabridge/source.py +++ b/src/orcabridge/source.py @@ -75,9 +75,7 @@ def generator() -> Iterator[Tuple[Tag, Packet]]: return SyncStreamFromGenerator(generator) def __repr__(self) -> str: - return ( - f"GlobSource({self.name} from {str(Path(self.file_path) / self.pattern)})" - ) + return f"GlobSource({str(Path(self.file_path) / self.pattern)}) ⇒ {self.name}" def __hash__(self) -> int: return hash( diff --git a/src/orcabridge/utils/name.py b/src/orcabridge/utils/name.py index 0d8fe76b..8b5fa78b 100644 --- a/src/orcabridge/utils/name.py +++ b/src/orcabridge/utils/name.py @@ -3,6 +3,7 @@ """ import re +import inspect def pascal_to_snake(name: str) -> str: @@ -24,3 +25,41 @@ def snake_to_pascal(name: str) -> str: # Split the string by underscores and capitalize each component components = name.split("_") return "".join(x.title() for x in components) + + +def get_function_signature(func): + """ + Returns a string representation of how the function arguments were defined. + Example output: f(a, b, c, d=0, **kwargs) + """ + sig = inspect.signature(func) + function_name = func.__name__ + + param_strings = [] + + for name, param in sig.parameters.items(): + # Handle different parameter kinds + if param.kind == param.POSITIONAL_ONLY: + formatted_param = f"{name}, /" + elif param.kind == param.POSITIONAL_OR_KEYWORD: + if param.default is param.empty: + formatted_param = name + else: + # Format the default value + default = repr(param.default) + formatted_param = f"{name}={default}" + elif param.kind == param.VAR_POSITIONAL: + formatted_param = f"*{name}" + elif param.kind == param.KEYWORD_ONLY: + if param.default is param.empty: + formatted_param = f"*, {name}" + else: + default = repr(param.default) + formatted_param = f"{name}={default}" + elif param.kind == param.VAR_KEYWORD: + formatted_param = f"**{name}" + + param_strings.append(formatted_param) + + params_str = ", ".join(param_strings) + return f"{function_name}({params_str})" From 0ab2b183001d0f191fb0a0b638c347886a2a05b6 Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" Date: Sat, 3 May 2025 04:21:50 +0000 Subject: [PATCH 07/22] doc: update tracker tutorial --- notebooks/03_orcabridge_tracker.ipynb | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/notebooks/03_orcabridge_tracker.ipynb b/notebooks/03_orcabridge_tracker.ipynb index 6597c27d..d3340d02 100644 --- a/notebooks/03_orcabridge_tracker.ipynb +++ b/notebooks/03_orcabridge_tracker.ipynb @@ -188,13 +188,13 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_2655506/828196166.py:13: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n", + "/tmp/ipykernel_2659995/828196166.py:13: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n", " plt.tight_layout()\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -272,13 +272,13 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_2655506/2248456176.py:16: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n", + "/tmp/ipykernel_2659995/2248456176.py:16: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n", " plt.tight_layout()\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] From f4d261ad1c654f26780f6f71fe7544049cc365ca Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" Date: Sat, 3 May 2025 04:34:44 +0000 Subject: [PATCH 08/22] feat: add robust hashing of function based on code content --- src/orcabridge/pod.py | 5 ++- src/orcabridge/source.py | 4 +- src/orcabridge/utils/name.py | 75 ++++++++++++++++++++++++++++++++++++ 3 files changed, 81 insertions(+), 3 deletions(-) diff --git a/src/orcabridge/pod.py b/src/orcabridge/pod.py index f0f24f11..bb0a4348 100644 --- a/src/orcabridge/pod.py +++ b/src/orcabridge/pod.py @@ -5,7 +5,7 @@ from pathlib import Path from typing import List, Optional, Tuple, Iterator, Iterable, Collection from .utils.hash import hash_dict -from .utils.name import get_function_signature +from .utils.name import get_function_signature, function_content_hash from .base import Operation from .mapper import Join from .stream import SyncStream, SyncStreamFromGenerator @@ -76,7 +76,8 @@ def __repr__(self) -> str: return f"FunctionPod:{func_sig} ⇒ {self.output_keys}" def __hash__(self) -> int: - return hash((self.function, tuple(self.output_keys))) + function_hash = function_content_hash(self.function) + return hash((function_hash, tuple(self.output_keys))) def process(self, packet: Packet) -> Packet: memoized_packet = self.retrieve_memoized(packet) diff --git a/src/orcabridge/source.py b/src/orcabridge/source.py index 6ecc8333..5ab626de 100644 --- a/src/orcabridge/source.py +++ b/src/orcabridge/source.py @@ -51,6 +51,8 @@ class GlobSource(Source): ... lambda f: {'date': Path(f).stem[:8]}) """ + default_tag_function = lambda f: {"file_name": Path(f).stem} + def __init__( self, name: str, @@ -64,7 +66,7 @@ def __init__( self.pattern = pattern if tag_function is None: # extract the file name without extension - tag_function = lambda file: {"file_name": Path(file).stem} + tag_function = self.__class__.default_tag_function self.tag_function = tag_function def forward(self) -> SyncStream: diff --git a/src/orcabridge/utils/name.py b/src/orcabridge/utils/name.py index 8b5fa78b..154ba4d9 100644 --- a/src/orcabridge/utils/name.py +++ b/src/orcabridge/utils/name.py @@ -4,6 +4,10 @@ import re import inspect +import hashlib +import pickle +import types +import ast def pascal_to_snake(name: str) -> str: @@ -27,6 +31,77 @@ def snake_to_pascal(name: str) -> str: return "".join(x.title() for x in components) +def function_content_hash(func): + """ + Compute a hash based on the function's source code, name, module, and closure variables. + """ + components = [] + + # Add function name + components.append(f"name:{func.__name__}") + + # Add module + components.append(f"module:{func.__module__}") + + # Get the function's source code + try: + source = inspect.getsource(func) + # Clean up the source code + source = source.strip() + components.append(f"source:{source}") + except (IOError, TypeError): + # If we can't get the source (e.g., built-in function), use the function's string representation + components.append(f"repr:{repr(func)}") + + # Add closure variables if any + if func.__closure__: + closure_values = [] + for cell in func.__closure__: + # Try to get a stable representation of the cell content + try: + # For simple immutable objects + if isinstance(cell.cell_contents, (int, float, str, bool, type(None))): + closure_values.append(repr(cell.cell_contents)) + # For other objects, we'll use their string representation + else: + closure_values.append(str(cell.cell_contents)) + except: + # If we can't get a stable representation, use the cell's id + closure_values.append(f"cell_id:{id(cell)}") + + components.append(f"closure:{','.join(closure_values)}") + + # Add function attributes that affect behavior + if hasattr(func, "__defaults__") and func.__defaults__: + defaults_str = ",".join(repr(d) for d in func.__defaults__) + components.append(f"defaults:{defaults_str}") + + if hasattr(func, "__kwdefaults__") and func.__kwdefaults__: + kwdefaults_str = ",".join( + f"{k}={repr(v)}" for k, v in func.__kwdefaults__.items() + ) + components.append(f"kwdefaults:{kwdefaults_str}") + + # Function's code object properties (excluding filename and line numbers) + code = func.__code__ + code_props = { + "co_argcount": code.co_argcount, + "co_posonlyargcount": getattr(code, "co_posonlyargcount", 0), # Python 3.8+ + "co_kwonlyargcount": code.co_kwonlyargcount, + "co_nlocals": code.co_nlocals, + "co_stacksize": code.co_stacksize, + "co_flags": code.co_flags, + "co_code": code.co_code, + "co_names": code.co_names, + "co_varnames": code.co_varnames, + } + components.append(f"code_properties:{repr(code_props)}") + + # Join all components and compute hash + combined = "\n".join(components) + return hashlib.sha256(combined.encode("utf-8")).hexdigest() + + def get_function_signature(func): """ Returns a string representation of how the function arguments were defined. From f6e871eda74ebb27e4621e0d209b6d7c5ea22e76 Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" Date: Sat, 3 May 2025 04:35:11 +0000 Subject: [PATCH 09/22] doc: update tutorial based on new hashing --- notebooks/03_orcabridge_tracker.ipynb | 70 +++++++++++++++++++++------ 1 file changed, 56 insertions(+), 14 deletions(-) diff --git a/notebooks/03_orcabridge_tracker.ipynb b/notebooks/03_orcabridge_tracker.ipynb index d3340d02..729ca3aa 100644 --- a/notebooks/03_orcabridge_tracker.ipynb +++ b/notebooks/03_orcabridge_tracker.ipynb @@ -18,7 +18,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 27, "id": "f28a62af", "metadata": {}, "outputs": [], @@ -41,7 +41,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 28, "id": "56136d16", "metadata": {}, "outputs": [], @@ -51,7 +51,49 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 29, + "id": "c7d4def1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "-2515677326234209445" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "hash(gs)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "197b5816", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "-2515677326234209445" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "hash(gs)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, "id": "c32938d6", "metadata": {}, "outputs": [], @@ -86,7 +128,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 32, "id": "e763a55e", "metadata": {}, "outputs": [], @@ -111,7 +153,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 33, "id": "3cdc6e7f", "metadata": {}, "outputs": [], @@ -122,7 +164,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 34, "id": "71d18d81", "metadata": {}, "outputs": [ @@ -151,7 +193,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 35, "id": "2cdf8d30", "metadata": {}, "outputs": [], @@ -169,7 +211,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 36, "id": "7a91ffaa", "metadata": {}, "outputs": [], @@ -180,7 +222,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 37, "id": "42f5bb99", "metadata": {}, "outputs": [ @@ -188,13 +230,13 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_2659995/828196166.py:13: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n", + "/tmp/ipykernel_2662699/828196166.py:13: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n", " plt.tight_layout()\n" ] }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAApQAAAHzCAYAAACe1o1DAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAPYQAAD2EBqD+naQAAZ+lJREFUeJzt3Xl4U2XaP/DvOVnadKObpRu0yGKBCojCIAoiuI06M0hBBRHUcWfTcXnHEVcUl5+MI/COiqMCKspSmBn1dUVxQ0ERFJBVllLaWlpKWZo27cnz+yOch6RJuqVtepLv57pyNTk5y/0kJ6d37uc5J4oQQoCIiIiIqIXUYAdARERERMbGhJKIiIiIAsKEkoiIiIgCwoSSiIiIiALChJKIiIiIAsKEkoiIiIgCwoSSiIiIiALChJKIiIiIAsKEkoiIiIgCwoSSiIiIiALChJKIiIiIAsKEkoiIiIgCwoSSiIiIiALChJKIiIiIAsKEkoiIiIgCwoSSiIiIiALChJKIiIiIAsKEkoiIiIgCYg52AEREHY1D01B0rBo1mhO1mhN1TgGzqsBiUhFhUpEeGwmryRTsMImIOgxFCCGCHQQRUbA4NA17j9hRfLwaxxx1qHU2/ZBoURXEWs1Ii4lEt3gbk0wiCltMKIkoLG09dBS7K05Aa8UjoEkBeiZGo09yXOutlIjIAJhQElHYsDs0rC+uQHl1bZtvKynSgsFpCbBZWbUkotDHhJKIQp7doeHzgjJUa85237bNrGJEl2QmlkQU0phQElFI21xaiV0VVcEOA70SopCb0inYYRARtQkmlEQUkuwODZ8VlKEmCFVJfyJMKkZ2ZbWSiEIPE0oiCjlbSiuxswNUJf1htZKIQg0TSiIKKWsLy1FywhHsMBqVGm3F0MykYIdBRNQqmFASUchYs78Mh9vhDO7WkhhpwYis5GCHQUQUMP70IhGFBKMlkwBwuLoWa/aXBTsMIqKAMaEkIsNbW1huuGRSd7i6FmsLy4MdBhFRQJhQEpGhbSmtNMSYyYaUnHBgS2llsMMgImoxJpREZFh2h9ahz+Zujp0VVbA7tGCHQUTUIkwoiciwPisIrfGHodYeIgofTCiJyJA2l1Z2qIuWt4YazcmubyIyJCaURGQ4dofWIX5OsS2w65uIjIgJJREZzpoDod01HOrtI6LQw4SSiAzF7tBgrwutru767HVOVimJyFCYUBKRoawvrgh2CO3i+5LwaCcRhQYmlERkKOUGvYB5c5XZw6OdRBQamFASkWFsPXQ02CG0q3BrLxEZFxNKIjKM3RUngh1Cuwq39hKRcTGhJCJDcGgaNBHsKNqXJlztJiLq6JhQEpEh7D1iD3YIQbEvTNtNRMbChJKIDKH4eHWwQwiKcG03ERkLE0oKSHZ2NhRFgaIozVpu6tSpcrnly5e3UXQd3+9+9zsoioLY2Nhgh9Jh6fvJ1LFXBmX7M6+7Cnk56cjLScfaD95t9+0fddS1+zaNxG63y33k5ZdfDkoM7sezqVOnBiUGXzRNQ2pqqoxNP97q97OzswHweEytgwkl+VRSUoIzzzwTJpPJ42BksViQm5vbrrE89thjiIiI8IjDZDLJg6FRVVZWYv369QCAhx56qMXr+eSTT6AoCgYNGtRaoXVIzjYaPznr5gnIy0nHR0sXt/q69UT0tpEtf29qW6Hh+udm+PDhHtM/+eQTREVFeXy2oqKi/K4nISEBiqJAcxvX2dQkyj2RaUnS5e/Lq81mQ//+/QEAd999d7PXG2xmsxmKoiAuLq7V1z127Fj89ttv8rGqqoiPj0dERARUVUV6enqrb5PCFxNK8rJ+/Xqkp6djy5YtcDpdv0iiH8Tr6uqwdevWdoslPz8fjz76KBwOh0ccTqcTBQUF7RYHABw+fLhV1zd58mQArjbdf//9LV7Pgw8+CAB44oknWiWucPPLD+sAAJdeMynIkfjXVifm/Pjjj7DbmzZGU9M0HDlyBPHx8bj11lvRv39/j2UfeOABdOvWrU3ibMzcuXMBuKqVX375ZVBi6Ih+/vlneV8IAU3TcPHFF6O6uhqapmHt2rVBjI5CjiCqJyoqSgAQAERycrIoLi6Wz23evFkMGzZMPs7KypLz6qqqqkTv3r3ldADCbDaLGTNmyHmmTJkin5s0aZIwmUzy8ZVXXinnO+ecc+T0zZs3y+nffvutuPrqqz3ifv7550VERITHdtPT00VhYaGcR99ObGxsg23QH3fu3FnExcXJNgghRHl5uejevbvHdkwmk3j33Xfl8iNHjhSqqsrnLRaLePrppz3ijYyMFABERkZG429KA6xWq1BVVT7+8MMPZcz6rVu3buLYsWNCCCEef/xxOX348OFCCCFmz54tp5133nlCCCFGjRrl0Qa9HTNnzpTbcn8fzz33XPn6qqoq3njjDZGXlyeft9ls4pdffvF6jdPS0kRiYqJ8nJCQIEpLS73m633270T+9iKRv71I3PrY08ISEekR2+l9+8nn87cXiWFXXiWUevFbIyPFcys/kvMsWrfNtc3TUuS07Jw+cv4Im0107XVqX77n+ZdF/vYiMTLvWq/XRlVVMfwPeSJ/e5G45/mXPZ5zv+VvLxLX3fM3obrt8wCEoigid8j5Hm3oM+hcAUXxmC86Otrj/W9oX3N/f+rfhBCisLBQrFu3zuN1ttlsPvezmTNnCgBi4sSJ4pZbbpEx620HIDIzM30uO2zYMJ8xmEymJu2PpnqvlX5zPxbpMQwcONDvZ6UhP/zwg9x+Yy6//PJT+5TVKkaNGiUfT5kyRQghxNNPPy3MZrPXPjJy5Ei5Hn/vzbJly8S7774rrFar9z6Smyvq6uoajdHfa+a+3aysLCGE536ybNkyuY6JEyd6rMdkMok77rijqS8phRkmlOThp59+8jh41dTUNDi/r2SsfjLjfps6daoQouF/dADE7NmzhRBCDBw4UE7r2bOnePrpp8WRI0e84vjnP//pd116IihE8xNK99fCarUKIYTXQV6/6f/EzzjjDL+x/POf//TaxujRo5v8/tS3Y8cOAUD06NFDCCHEunXrvOLW78fFxcnl3BPid999V84XEREh50lOTva5HgBi9erVTXof69/S09P9vsbut5SUFK/59ITyztl/95zfLbaUjC4if3uReGLJf/zOoyeF+duLxIVjrhEAxB9vukPkby8S5172hwbj0pft2jPH72tz/b0zxcP/etsrmVVUVSiqKvK3F4nfXfx7v8uff8Vokb+9SFx/70y/76WusX1t1qxZPhNf9/e5/uvsL6HMyMgQAGSyv2fPHo91659tX8aPH+/VTlVVRUJCQpP2x4SEBK9lVVUV48eP99pfo6Ki/MZRXl4uli1b5vOmty8nJ8fv8kK4EsWG9hE9oRwzZozf91iP29d7o6qq+Pjjjz22U3/5s846q8EYG3rNhGhaQnnZZZf5bSOTSvKFCSV50KsQAERSUpKcXr/yp1cG6idjb7zxhnycnJwshHBVNfVpJpNJCOF5ANOTjNWrV3v9U/v88899HtCsVqt4+OGHZXwxMTHyuf/85z9CCCFyc3O9DoAtSSj19VVVVYnp06d7vD56wr1ixQrxww8/iP3798vns7OzhRBCHDt2TP7j0KtLu3fvlvPpyXNLXHHFFQKAmDdvnhBCiOzsbLner7/+WgghPKqEixYtkm2p/88MgKxWCSHE66+/Lvbv3y8fL1q0SM43dOhQr/exU6dOQgghMjMz5bTu3bsLIYSIjo6W/9R8vcY7duwQQnhWx/WKtP5YTyht0Sffa0URL3223pXguVUR533wlbh22n3y8YI1G0T+9iKxbOsBMe7Ov4h/fvqdTChjOsULAOLtn/eJ/O1FHq/J/I/WiiUbf/WoJOoJ5T0vvCLm/OdTuZ7nVn50ar9ITZfT5WchPcOj8vjI68vEY4tWyMevfLVJzhsRFSXytxeJcy68RE77sbDUYx8UQjR5X3N/Dd0revXV/+zVpyiKfE5/3+tXKPUExZdly5Z5JV26puyPvj6n7vr27eu1j9U3a9Ysv0mS+62hpFLflwGIzz//XAjhefzR27Z69Wr5vBBCFBcXy3nc3xtfxyQhXMdN92phTU2NnFc/jjbG32vWlIRSfxwXFyfq6upEXV2d/D/Q1O1TeOEYSvLLffB7YmJik87kfvvtt+X922+/HQCQm5uLhIQEAPAYzK/7y1/+AgAYOXIkIiIiAADV1a5LpYwYMQKff/450tLSPJZxOBx4/PHH8corrwAAjh8/DgCwWq344x//CAD43//9Xzn/559/3mjsvsTHx8v12Ww2fPzxx/K5xYsXw2q1AgDy8vJw9tln49VXX5XP79u3T57BrY9FPXHC9csnO3bskPNlZGS0KDYAWLNmDQDIkxyKiorkc+effz4URUF+fr5HzHpb3njjDY91TZo0CYMHD5aPf/31V3Tv3l2eCKGP+QSA4uJir1guvvhiAECXLl3ktDvuuAMAkJSUBADydXCXkpKCXr16AQAuv/xyOd3f2ab2qpO/HiMEbh85GHk56SjYuU0+/8myNzHq6uvk41tHnI2xvTMwaVAOCvfsROfMrvK545VHEBUTK99HPb6YTvFIy8pGhM2Grj3P8I7haCX+Z9zl8qSbe8dcKp+rOt74zyWqqorZt0+Sy98ybIB8rramBgBwxaSb5bSBmSkwmUweJ1E0dV9rDYsXL4YQAkOHDgXg+rz17dsXR4+62nrHHXfgvvvugxCiRetvyv7YGP2kFl/7mG7mzJkQrkKK35uqqti+fbvfdVRVVQFwHWtGjBgBwHO/1amqiiuvvFJ+ftyPYTUn3+OGREdH47bbbpPLR0REyOOnr+Noa/rmm2/k/aNHj8JsNsNsNsu423r7ZExMKMnDNddcI++7n4RSVFSEF198MRghYcSIESgqKoIQAuvWrcMZZ5z6B68Pxm8q95N6dPo/CF8CPfNSVVWPm5649OjRQ87jKzlriuPHj+PEiRPo3Llzk7atqqrH5Yl++uknj/ndB/D/+uuveOKJJ1BX57pkjaIoUNVThwtf/7T1OMxms5zWtWtXuXxbUFTV62ayWJB4Wgrm/OdTZOf0QYTNddZyddUJfPvhe3jydtfJN0vnzwEADBg+stnb/edD96Lu5IliUBQobq+NaMJZ2Y//+VrU2Kt8Lq/rd+75ePhfbyO9W3dERtrgdDpx5MgRzJ07V56I5c7fvtYannrqKQDA3//+dwDAwoULsWXLFsTExMh5nn32Wezfv7/F22hof2wKPblVfbyWuscee8zjjHZfN6fTKc8aD8TFF18sk/r6n5+mJN5nnXUWKioq5OOG2tXWfB1LWvskRTI+JpTkITc3V142xOl0Iisrq8lngQLA+PHj5f2XXnoJALBlyxZ5YDSZTF7LPP/88wCAL7/8Un4DjoyMBADccMMNGD58OHbu3AkAGDx4MG699Va5bHx8PADIf2wOhwPvvfceAGDKlClyvgsvvBAAYLFYAEC26eDBgzh06JDf9tRPhC655BJ5f/LkyfKb+n//+19s2LABf/7zn+XzKSkpcDgc0DQNmqbhiSeewIwZMwBAVuQA4Pvvv/fYRkZGhrxEk+6qq66S//D+7//+D8Cpyu6ECRPkfO5VkHfeeUdue9u2bRg2bBhWrVoFwJUwPvvssx5t3LRpk6z4LlmyxKPNTqczoDPRG1JaWopff/0VAPDBBx/I6ePGjfM5f6Tt1GVtnl76Plb8UogVvxTiySX/xoDzLsDEv/wNhb/uwlfvrsKz+R9hycbdWLHtIEwnE91dmzYAAFavcFXTb3zgMbk+/Z/28coj+K2wADV2Owp2naomA8CunzfK+6lZ3ZC/7SD+MqfhL1u1evJ5knYyUY+KjUP+toN4eun7Xsts/GoN9u3chnkffIVNhaUeSciqVauavK+50yv5zbVr1y6YzWb069fP6zkhBObPn+8xzdf+6v7Fp34y0tj+CJw6JgC+K2T65XHc56vvnnvuwerVq33esrKyAAD9+vXDpk2b/K5DPz46HA55RrneRnf6l7H4+Hg4nU55ibD69GNibW2tx3Q9QbZYLBBC4ODBg232xay+8847T96PjIxEZWWl3LcWLFiAG264AYmJie0SCxlIELrZqYNbt26d1yDw+o/9jaEUouGTcvTxRY2dzDFr1iwhhOdZ3r7i+PDDD4UQTT8pZ/DgwXK6rzFbOv2xrzFhjZ2U06NHD78xu69PP8u7S5cuHuuPjY31isf9LFl9jFNSUpIA4HHi1Ndff93g6+XrPdqzZ49sk6qq4tixY2Ljxo0NrsfX2Cv9vfUVa1NOfHK/6eNv3efTx1De/vizDcaWv71ITHvqhVPT6j3fs/9A1/hGRRGWiAiPsY1DLrmiwbjuef5lsWzrAc/p9dYfGRUt12dxG3usKIqwRceI/O1Fnifs1D9ZxWQS+duLxKixE/y28cYbb2zWvuY+XVVVeWWB999/v8H2uu9T/fv39/os+ONrH6irq/Nsp6rKdTa2PwohxNixY72Wf+utt+Q2Az3L+6effhKjRo1qdD73M9B93fTPgfvxpf775z4GMSUlxWM+i8UihPAcT+zvvWlMIGMoL7roIr/7Vv3xnkRCcAwl+TB48GAcOHAAZ5xxhqzYiJPVEYvFgkGDBnlVJNyVlJQgJyfHY5rZbMaMGTN8Ljdp0iSPyuXll1+OmTNnAnCNw0xJSZHfzPU4rFYrHn30UVx6qWvs2h133IHnn39ejsHUpaenY9++ffLxxx9/jOTkZACuCmynTp2QkpLS+Ivipri4GN27d/eYZjKZ0LdvXwCuas4FF1zg9dolJCRg2rRpchk99sLCwmZtX1deXo64uDiPrs3zzjsP7777ruyq17dtNpvlBenHjh0rqx/Tp09Ht27dZOXS6XSiT58+GDBgACZOnChfd0VR8PDDD7cozsZkZGTgtNNOk4/j4+OxefNmv/NffPVE3PzQk7CerETJNlos6Ps71xi/rDNyYIs+2R3rVtlLzeqGJ5f8B1++twoQAj37DfRY931zX0HXnqf2XUtEBDJO7+kxj8lkwtg7ZkBRVLn+4X/I8xnr5Psflt3ZQghUnxz/eccTz0HV93kh0OecIacen5Q75DxYI20ebVQUBUOGDMFrr70GoOn72l133eUx3KO8vBxA08ZZ/s///A8A4JFHHml03oaYTCaMHj1aPnY6nSgpKWnS/ggAb731Fjp16uSxfGlpKQBX74Y+DEPv8Wiufv364dNPP210vgceeEB+dgHXZ+v888/3mu/VV1+Vwz+EEBg+fLjPHprFixd7zKdXKt9//32P49kZZ5zRrr+o9cknn2D8+PEyZn3fiomJwc0339zQohSmFCGaMJiDiFpdZWWl7LKfM2eO7MJuiqeeegp/+9vfMHbsWMP+VJqe4GRlZXkk/f6s3NGysaa+3HXlhTiweweeWf4BepzZv9XW21bGnJHW+ExtJDIyEg6Ho8GTXYKtf//++PnnnxEVFdWqJyMRUdOxQkkUJJ06dZJnsTa3+lNVVYWsrCz84x//aIPIOiaL2nrjx5LTM3B6336GSCZbs90tkZ2djeuuu67xGYPEbrfLE3j0k4bChclk8nsjam+sUBJRUDS3QrlmfxkOV9c2Ol+oSYq04IKs5GCHQR1QQyfp8F87tTdz47MQEbW+5v7DS4uJDMuEMi3G/1nLFN6YNFJHwi5vIjKEbvG2YIcQFNlh2m4iMhYmlERkCFaTCabgDidsdybF1W4ioo6OCSURGUaPhOhgh9CueiaGV3uJyLiYUBKRYfQ9LbCfwjSaPsnh1V4iMi4mlERkKEmRlsZnCgHJtvBoJxGFBiaURGQog9MSgh1CuxiUGh7tJKLQwISSiAzFZjXBZg7tQ5fNrMJm5ck4RGQcoX1UJqKQNKJLaF/oO9TbR0ShhwklERmOzWpCz4SoYIfRJnolRLE6SUSGw4SSiAzpzJROiDCF1iEswqQiN6VTsMMgImq20DoaE1FYGdk1tLqGQ609RBQ+mFASkWHZrCb0CpGub3Z1E5GRMaEkIkPLTemE1GhrsMMISGq0lV3dRGRoTCiJyPCGZiYh0aAXPE+MtGBoZlKwwyAiCggTSiIKCSOykg2XVCZGWjAii+Mmicj4FCGECHYQREStZW1hOUpOOIIdRqNSo62sTBJRyGBCSUQhZ0tpJXZWVAU7DL96JURxzCQRhRQmlEQUkuwODZ8VlKFGcwY7FCnCpGJk12SezU1EIYcJJRGFtM2lldjVAaqVrEoSUShjQklEIc/u0LDmQBnsde1frbSZVYzowqokEYU2JpREFDbsDg3riytQXl3b5ttKtlkwKDWBiSQRhQUmlEQUlrYeOordFSegteIR0KQAPROj0Sc5rvVWSkRkAEwoiSisOTQN+47YUXy8Gkcddah1Nv2QaFEVxFnNSIuJRHa8DVYTq5FEFJ6YUBIR1ePQNBQdq0aNJjBr9pOIjIrB3dOnwqyaEGFSkB4byeSRiMgNE0oiogZEREQAAGpqaoIcCRFRx8WfXiQiIiKigDChJCIiIqKAMKEkIiIiooAwoSQiIiKigDChJCIiIqKAMKEkIiIiooAwoSQiIiKigDChJCIiIqKAMKEkIiIiooAwoSQiIiKigDChJCIiIqKAMKEkIiIiooAwoSQiIiKigDChJCIiIqKAMKEkIiIiooAwoSQiIiKigDChJCIiIqKAMKEkIiIiooAwoSQiIiKigDChJCIiIqKAmIMdABFRR/Drr79i2LBhqK6u9pjucDgAAImJiR7TIyMj8dVXX6F79+7tFiMRUUfFhJKICMDu3btRXFzs9/mKigqfyzChJCICFCGECHYQREQdQXR0NKqqqpo87/Hjx9s4IiIiY+AYSiKik/7xj380ed4XXnih7QIhIjIYViiJiNw0pUrJ6iQRkSdWKImI3DSlSsnqJBGRJ1YoiYjqaahKyeokEZE3ViiJiOppqErJ6iQRkTdWKImIfPBVpWR1kojIN1YoiYh88FWlZHWSiMg3ViiJiPxwr1KyOklE5B8rlEREfrhXKVmdJCLyjxVKIqIGmEwmAICmaUGOhIio42JCSURUj0PTUHSsGjWaE7WaE3VOAbOqwGJSEWFSkR4bCevJRJOIiJhQElGYc2ga9h6xo/h4NY456lDrbPoh0aIqiLWakRYTiW7xNiaZRBS2mFASUVjaeugodlecgNaKR0CTAvRMjEaf5LjWWykRkQEwoSSisGF3aFhfXIHy6to231ZSpAWD0xJgs7JqSUShjwklEYU8u0PD5wVlqNac7b5tm1nFiC7JTCyJKKQxoSSikLa5tBK7Knz/Lnd76pUQhdyUTsEOg4ioTTChJKKQZHdo+KygDDVBqEr6E2FSMbIrq5VEFHqYUBJRyNlSWomdHaAq6Q+rlUQUaphQElFIWVtYjpITjmCH0ajUaCuGZiYFOwwiolbBhJKIQsaa/WU43A5ncLeWxEgLRmQlBzsMIqKA8be8iSgkGC2ZBIDD1bVYs78s2GEQEQWMCSURGd7awnLDJZO6w9W1WFtYHuwwiIgCwoSSiAxtS2mlIcZMNqTkhANbSiuDHQYRUYsxoSQiw7I7tA59Nndz7Kyogt2hBTsMIqIWYUJJRIb1WUFojT8MtfYQUfhgQklEhrS5tLJDXbS8NdRoTnZ9E5EhMaEkIsOxO7QO8XOKbYFd30RkREwoichw1hwI7a7hUG8fEYUeJpREZCh2hwZ7XWh1dddnr3OySklEhsKEkogMZX1xRbBDaBffl4RHO4koNDChJCJDKTfoBcybq8weHu0kotDAhJKIDGProaPBDqFdhVt7ici4mFASkWHsrjgR7BDaVbi1l4iMiwklERmCQ9OgiWBH0b404Wo3EVFHx4SSiAxh7xF7sEMIin1h2m4iMhYmlERkCMXHq4MdQlCEa7uJyFiYUBKRIRxz1PmcPuGs7sjLSceDE0Y3uHxeTjryctJx28hBbRBdyz08eayMLS8nHTOvuwrXDeyJvJx0jOvbBUdPtltRFCiKguHDhwc5YpcbbrgBqqrKuLKzs5GdnS0f69yfb46srCwoioLMzMxWjpyI2gITSqIOzmw2y3/Kqur5kV2/fr18TlEUpKent0kMcXFxXolCSUkJIiIi5PRrr722Tbatq3V6D6D84K3XUWN3dQn/9Z+vtcl2bxs5SCZ7re2XH77D1nVr5WNFVZGUmoa4xCQoqgpbdKzPdgebw+HAokWLIIQrNlVVkZ6ejvT0dKiqioiIiIC3sWTJEgDAwYMH8d133wW8PiJqW+ZgB0BETSeEwIwZM/DCCy8AAK6//vqgxFFQUIDu3bujrs5VPbvxxhvx2mttk9AB/k9MWTpvDgAgNj4BsfGJbbb9trLu0w/k/dsffxYXXz3R53wd7cScjz/+WN6fPHkyFi5c2OrbOO+882C1WuFwOHDLLbdg8+bNrb4NImpFgog6NJPJJADIW2RkpBBCiKqqKo/pAERaWppcLiYmxuv5pKQk8csvv8h5YmNjBQBhMpnEWWedJeezWCziP//5j9d8AMTu3bs9Yrrttts84v3www9FXFycx3a7desmjh07JoQQokuXLnJ6TU2NXC4yMlJuWwgh/vrXvwqz2eyxHrPVKqY/O1fkby8Sy7YekNMvHHONyN9eJG+T7n9YKKrqel5RxJU33CLnTU7PEPnbi8SCNRuE2Wr1eo2S0zLEwu+2iPztRUKt99rrt95n/07kby8SkVHRXs/FxieKF97/wiMeX7fk9Ayf6750/GS5XtVkEvnbi8TeiuPy+WHDhsnX7KWXXpKvm347++yzW7yvvfPOO2L06NENzjNs2DCfcQ8bNkxkZWXJxzr9cVZWVpP3Ed2gQYNcr4OqtrhNRNQ+2OVNZBB6d3d1dTXee+89TJgwAQAQFRXlc/7jx48DgEc3dXl5OQYOHOg1r6Zp2Lhxo3xcW1uL0aNHQ/NRGevVq5ecPmPGDLz00kvyufXr1+Oyyy7D0aNHPba9d+9eZGRkAADmz58v57/99tsBuCqe1dWuk08uvPBCOBwOPP3007ICqq+nzuHAjo0bAACf5b8t13PFxJtOtbGkGIuffRzCefL3voXAewtf8WrHscoK1DkcXq9RWfFBzLjyQgCALTrWYxlFVWW3NABUV528TqTb8seOHMa9Yy712l59iSmpnutWFCiqisSUzl7z1vi4XtLChQtx++23y9dNb8OGDRvQrVs3v9stKCjA8uXLfd5uvvlm/Pvf/8bvf/97v8tnZmZ6vF6Aa99s6ljHpuwjuquuugoA4HQ6sXfv3iatn4iCJNgZLRE1TK8Gqqoq+vbtKwCIjIwMWb27//77fVYon3nmGY/1ZGZmyvmKi4uFEJ6Vx7lz5wohTlWFAIhJkyZ5zaffZsyY4RVrdna2fP7rr78WQgiRl5cnpy1atEgIIURERIQAIGw2mxBCiD/+8Y9ynsLCQrFu3Tr5+P333xebfzsi8rcXiZsenCVmvblS5G8vEkMv/5Ocx73yd8aAc+T0C/401muaXqFctG6buPmhJz2WjYiK8lqneyWxfpXx+ntnejxOSk2T877y1aZGq5SXjp8s57/n+Zfl9PoVyi2lR7wqlPp7oiiK2L9/vxBCiDPPPFPOt2PHDp/70+jRo31WGOvfLrvsMr/75LJly+R8U6ZMkdObUqFs6j4ihBA//PCD1/5JRB0TK5REBuJ+okJdXR1UVcUzzzzjc96FCxd6nIVbWFgon1u/fr3HvIqiYNq0aQCARYsW+Z3P3csvv4zKykqPaUVFRfL++eefD0VRkJ+fL6ctXrwYAHDNNdcAAOx2OzZt2oRPP/0UgOvkn4yMDAwePFhWZK+44gr0S03A+AHdsX71R+jRz1VhPVZx2GdcxQWnKlnTn5kLAJj61PNe81msVqx8eZ7HGdY1VVV+2+vL56uWIq93hly+vKRYPrf75x+bta6G1PqoUOoVaCGEPCPafZzhggULfK5r1apVEEL4vZWXlwMAPvroo1aL311T9xEAOOOMM+T9AwcOtEk8RNQ6mFASGUi/fv0QHx8vH59//vk+57vooouwbds2j7Nw3dXU1LQ4hpSUFACurvfOnTvj8GHfiZ2qql632FhXF7L7CTwTJ05E1clE7sYbb5TTCwoKMHToUHmGuaPaji3ffY17R18EAIjpFN/iNgDA3X8aicOlJfKxojbvcPjojdeg8NddwMnXWFE8l69z1AYUnzuLSWnweV+vtcVi8TnvH/7wB48rA9S/JSUlAQD+9Kc/tVr8zYlb30cAYMeOHfJ+W13BgIhaBxNKIoN55JFH5P0VK1b4nGfTpk3yfmlpKTRNQ0JCgt91CiHw4osvAgBuuunUeMTBgwd7zfvbb7/Jf+41NTVIS0vDoUOHAABpaWlyvnfeeQeapkHTNGzbtg3Dhg3DqlWrAAAmkwk5OTkAgK1bt8pl5sxxnbWtaRoee+wxfPrpp6isrMQvpUcQHRfn2v6B/QCAM889Ty63b8cv8n5a11PjB+f/7W4AwP8+eI9XO8qLT1XK8rcX4a0Nu2D2kYRZIyLlffcxpfu2bZH3X1v7M1ZsK0R0XCev5VuDWTV5TYuJiZH3169fL1/rb775Bpdccgmeeuopn+t67bXXsHr1ap+3uJOv8Z/+9Cf5XrW2pu4jgOfZ5O2R4BJRy/GyQUQGc9ddd2HYsGGIiorCaaed5nOenj17yq5LvaLYmDvvvBNTpkyRVU1FUfxeCujgwYPo2rUrDhw4AIfDgYyMDOzduxdvvfWWrJpeffXVUBRFrq++RYsW4Xe/+518nJWVBZPJlTjZ7Xa88soreOWVV+RJG/p64hJdFbSLxl6HBY/8FYDrepR3PP7/AAD3/ONl3DribADA5yuX4vNVy2QV0V1cYhIO/+aqUDZ0jcmsM3qjaO+vrjb17QJFVTH92XlIzeqGY0cqAAA3De3nd/nWEOGjQjlnzhzceuutAIBzzjmnwdfa3WmnnYaRI0f6fG7hwoV45513sHTp0sACbkBz9hE9uVRVtcETjYgo+FihJDKgs88+G7179/b7/BdffOGRSMbFxeGss87yO7/JZMK5554r/7FbLBYsX75cJni+FBQU4PTTTwfgOis8OzsbXbp0wbvvvisrXfr6zGYzcnNzPZYfPHiwR5Vt9uzZ8r7NZkNCQoJMNvT1dEo+Dc+t+ljGrF97ct0np67nmJSahuvu+ZtHF/TIPO+Lrj/x1r8RGRUtH3dKSkZSqndiOf3Z+YiKjZOPhdOJo+VlePyNleiUlHwq5ugYdOud67V8a0iPjfSadsstt2DevHmw2WyuuE6+RlarFRdeeGGLtnPVVVe1aTIJuK4v2dR95KeffgIA9OnTp01jIqLAKaIpX2mJKCTFxcXh2LFjMJlM8hI97alXr17YtWtXk7a/ckex17QP3nod/5r1IABg4XdbDHlx86YYc0Za4zOFmG+++UZWMtetW+dz+AURdRysUBJRuxs9ejRsNht27doFAMjLy2t0GYvq3e37++tuRMTJCt3Td97k9XywTRrcB2P7ZPq8rXjxH01ah692h4Px48cDgDzrn4g6No6hJKJ2t2nTJnlB7h49ejSpmzXWasbhau8zp5ds/LXV42st9hPHTl1gvZ7Dpb81aR1x1vA8TBcUFAQ7BCJqBnZ5E5Eh7Cg/jq1lx4IdRrvLTY5Fr6SYxmckIgoidnkTkSF0i7cFO4SgyA7TdhORsTChJCJDsJpMaOT63iHHpLjaTUTU0TGhJCLD6JEQ3fhMIaRnYni1l4iMiwklERlG39PiGp8phPRJDq/2EpFxMaEkIkNJivT9G9WhJtkWHu0kotDAhJKIDGVwmv/fJA8lg1LDo51EFBqYUBKRodisJtjMoX3osplV2Kw8GYeIjCO0j8pEFJJGdElufCYDC/X2EVHoYUJJRIZjs5rQMyEq2GG0iV4JUaxOEpHhMKEkIkM6M6UTIkyhdQiLMKnITekU7DCIiJottI7GRBRWRnYNra7hUGsPEYUPJpREZFg2qwm9QqTrm13dRGRkTCiJyNByUzohNdoa7DACkhptZVc3ERkaE0oiMryhmUlINOgFzxMjLRiamRTsMIiIAsKEkohCwoisZMMllYmRFozI4rhJIjI+RQghgh0EEVFrWVtYjpITjmCH0ajUaCsrk0QUMphQElHI2VJaiZ0VVcEOw69eCVEcM0lEIYUJJRGFJLtDw2cFZajRnMEORYowqRjZNZlncxNRyGFCSUQhbXNpJXZ1gGolq5JEFMqYUBJRyLM7NKw5UAZ7XftXK21mFSO6sCpJRKGNCSURhQ27Q8P64gqUV9e2+baSbRYMSk1gIklEYYEJJRGFpa2HjmJ3xQlorXgENClAz8Ro9EmOa72VEhEZABNKIgprDk3DviN2FB+vxlFHHWqdTT8kWlQFcVYz0mIikR1vg9XEaiQRhScmlERE9Tg0DUXHqlGjCcya/SQio2Jw9/SpMKsmRJgUpMdGMnkkInLDhJKIqAEREREAgJqamiBHQkTUcfGnF4mIiIgoIEwoiYiIiCggTCiJiIiIKCBMKImIiIgoIEwoiYiIiCggTCiJiIiIKCBMKImIiIgoIEwoiYiIiCggTCiJiIiIKCBMKImIiIgoIEwoiYiIiCggTCiJiIiIKCBMKImIiIgoIEwoiYiIiCggTCiJiIiIKCBMKImIiIgoIEwoiYiIiCggTCiJiIiIKCBMKImIiIgoIEwoiYiIiCgg5mAHQETUEVRWViIvLw9HjhzxmF5bWwsAOOecczymx8fHIz8/H506dWqvEImIOiwmlEREAD788EOsXr3a7/MbNmzwucw111zTlmERERmCIoQQwQ6CiKgjsFgsqKura9K8ZrNZVi+JiMIdx1ASEZ109913t8m8REShjhVKIiI3TalSsjpJROSJFUoiIjdNqTyyOklE5IkVSiKiehqqUrI6SUTkjRVKIqJ6GqpAsjpJROSNFUoiIh98VSlZnSQi8o0VSiIiH3xVIlmdJCLyjRVKIiI/3KuUrE4SEfnHCiURkR/uFUlWJ4mI/GOFkoioAYqiAAB4qCQi8o8JJRFRPQ5NQ9GxatRoTlQ7aqEJwGo2wWJSEWFSkR4bCavJFOwwiYg6DCaURBTWHJqGvUfsKD5ejWOOOtQ6m35ItKgKYq1mpMVEolu8jUkmEYUtJpREFJa2HjqK3RUnoLXiEdCkAD0To9EnOa71VkpEZABMKIkobNgdGtYXV6C8uu3P1k6KtGBwWgJsVlYtiSj0MaEkopBnd2j4vKAM1Zqz3bdtM6sY0SWZiSURhTQmlEQU0jaXVmJXRVWww0CvhCjkpnQKdhhERG2CCSURhSS7Q8NnBWWoCUJV0p8Ik4qRXVmtJKLQw4SSiELOltJK7OwAVUl/WK0kolDDhJKIQsrawnKUnHAEO4xGpUZbMTQzKdhhEBG1CiaURBQy1uwvw+F2OIO7tSRGWjAiKznYYRARBYy/5U1EIcFoySQAHK6uxZr9ZcEOg4goYEwoicjw1haWGy6Z1B2ursXawvJgh0FEFBAmlERkaFtKKw0xZrIhJScc2FJaGewwiIhajAklERmW3aF16LO5m2NnRRXsDi3YYRARtQgTSiIyrM8KQmv8Yai1h4jCBxNKIjKkzaWVHeqi5a2hRnOy65uIDIkJJREZjt2hdYifU2wL7PomIiNiQklEhrPmQGh3DYd6+4go9DChJCJDsTs02OtCq6u7Pnudk1VKIjIUJpREZCjriyuCHUK7+L4kPNpJRKGBCSURGUq5QS9g3lxl9vBoJxGFBiaURGQYWw8dDXYI7Src2ktExsWEkogMY3fFiWCH0K7Crb1EZFxMKInIEByaBk0EO4r2pQlXu4mIOjomlERkCHuP2IMdQlDsC9N2E5GxMKEkIkMoPl4d7BCCIlzbTUTGwoSSqJ1kZ2dDURQoihLsUFps+PDhsg3Lly9v120fc9S16/bc5eWkIy8nHbeNHAQAWPDYA3La2g/ebdNtH22g3S+++KJ8P+z2U5XMkSNHyumKomD48OGIi4uDoigwm81yPvfnmyM2NhaKouB3v/td8xvUAu5tURQFzzzzTLtst63Vb9fUqVODHRJRizGhJEMzm81eB2X9lpeXF5SY9O1nZ2d7TE9PT4eqqoiIiGiT7U6dOtXn66CqKrp37469e/e2yXbbS60z8AGUrZUIJqZ0hqKqUFQV0bFxAcfVkIbafc899wAAzjzzTNhsNgDAl19+ic8//1zOo6oqMjMzkZycDFVVERcXeLyPPvooAGD9+vWorGzf3x5XVRWdO3cGcOpLWnO+3Pj7fDaVfsxpyetYP6GPiIiAqvLfMIUG7skUMlRV9bhlZmYGOyQPa9euhaZpqK5uny5M/R+VEAJ79uxBTk5Ou2y3LXS0E1PG3nEXVvxSiBW/FKL/+Re0+fZ8tX/NmjWyKjl//nw5/d///re8v2DBAmiahiVLlmDPnj3QNA2HDx8OOJ577rlHVtpvuOGGgNfXVFOmTIGmae26zbZUXV0NrYPt20QtxYSSQoamaR63F154AcuXL/fZnVS/SuFe3Rs7dqxH5fPaa6/12M7ChQsRHR3tUQVMTU2V29Lt37/fo4vbV5e33W5Hnz59PNZlsVhw1113yXmaE5tu2LBh0DQNVVVVMrF0OBzYtGkTAGDDhg1ISkry2G5MTAxWrVrlsZ4BAwbI56Ojo3HkyBGvbbnH5/4a79y5E6mpqR7bsFqtOHjwYLPbHmE2e1QU9SrjzOuuAgDMvO4qOe3lR/+Ksb0zkJeTjrG9M/Dm32cDAG4bOQgfvb1IrmPO3bchLycd1w3s6fM1bIivSud1A3siLycd4/p2wb1XXSKfv+bMLPz87dceyz9yw9UyxrycdFyd2xUrXzmVFNbY7bh5+Fny+QizGSaTCb1795bz/OUvfwHg+uKgd1lnZ2fj+eefl/Pceuut8n3x1eXty8svvwybzebxvpxzzjle86WlpQEAPvroo+a8dJLD4cDAgQNbtcL566+/IjEx0SN2k8mECy64oNHP5zPPPAOLxeK17KhRo+QyiqLIBPDYsWMewz8a2jZROGBCSVRPfn6+R9Vg6dKl2LBhAwBg8eLFuPHGG1FVVeWxTGlpKeLj4726r/RqqT+pqanYtm2bx7S6ujq88MILmDZtWrNia6qSkhIMGjRIVqr0f6gnTpzAmDFj8M033wAArrnmGvz0009yuaqqKmzevLlJ2zh8+DBycnLw22+/eUyvra1FeXk5gOa3vak+fmcxhHB1EwshsGrBfNiPH0diSqrHfIqiQFFVxCUmtXhbvjg1DXu3bZGP62pr8fSdk+Xjab8fhi3ffS1jBACtrg5vzZmND5e4Et4Hrv0DKkp/0wN1rdfpxK5du+QyO3bsAAAkJibKaenp6R6x6EMeUlM92+7PwoULcfvtt8squr5vbNiwAd26dfOYd/DgwQDgMXbTl1WrVmH58uVetwkTJmDjxo3o3LlzqyWVQ4cORUVFhUfsTqcTGzdubPTzuX79etTV1Xkt+9lnn2HChAlyfl/Lx8fHN7htonDAhJJCRv2xgy2VkpICIQTGjh0rp82dOxcAPBKd++67D0IICCHw5JNP4uKLL/ZI9rKysmS11Jc333wTR4+6fgklOTkZQgiPhO3FF19sVmzuvvrqK5hMJkRFRcHpdAIArFYrBgwYgHHjxslkZsyYMXA6nZg1a5ZcVv/nmZ+fL6ft3r0bVVVVPqtbCQkJXvfHjBkjt5GTkyNfp7lz5yIzM7NFbW+q7Jw+yN9ehKwz+shpX76/Ek+98y4uHX8qsfvL31/Cil8K8eKn37V4W/5cf+9M5G8vguXkeNmak0nXoaJCFO39FQCQktEF+duL8OYPO+X+uvg51/tw+LdiAEBUTCzytx3EltIj2L17Nx588EG5DT3pc08W165diylTpsjHS5cuhaZpmDlzZpPinj59OgDXZ2n//v1wOp0488wzAQD79u3Dzp075bxnn322vN/Q+NwxY8bg6quv9rrp+1dNTU2Lk8p9+/ZBCIFx48YBgKygd+/eHU6nE0II/PDDD5g5c2ajn88pU6bg888/hxACTqcTxcXFct7//ve/AFy9ICaTCYDrxCR9+YsvvrjBbeuEEDJpJQo1TCgpZNQfQ9lSelfiH/7wBzlt3759AFzdXIBrYP6zzz4rn3/ggQeavZ23335b3r/99tsBALm5uTIp85WINhRbfXoiqSgKunXrhu3btwMAtm7dKufR/6m7/9MrKSnx2H5iYiK6d+8Om82Gvn37em1n1qxZMmHUE1P35PDHH3+U96dNm4bExMQWtb2ppj3jSrB7nDlATjuwc0eL19dsioLRN98JAIhLSPR4avWKd+T90oMHkJeTjonn9JLJd83JyvfZIy4CAFQdP4a8nHT0T0vCsGHD0LPnqe55/f2NjY1ttdCPHz8OwJX4ZGVlQVEUj/dywYIF8n7Xrl3lffdEsz593/B3S01NRU1Njc8vRs01YMAAAK6ub32IxdixY3122denqiquvPJK+YVU79IHXElvW26bKBQwoaSQUX8MJeDZReVwOJq0ntNPPx0A5FmzADy6J4OpqbENGzZM/sN2Op3Ys2ePV5dle9ErOi3hXmmurXX9Uy/Y1XBymH2yMmm2WOQ0PflqD+77nNLIFxv9THH9psc87ekXcN09f0Ni51SYLRZomobi4mJcf/31+PVXV4VTf230Lzlt0Y76N4vba1pQUCDv9+jRw+96/F2FQb+VlJTAZrPh3nvvDTjmdevWYfr06ejcuTMsFgtqa2uxb98+XHTRRY0ue/HFF+PEiRMyZvf3sSmf/0C2TRQKmFBSSBsyZIi8r1fKbrnllhavT68G1dXVeXQ/ulcrdY2dzT1+/Hh5/6WXXgIAbNmyRY7DCiQRa4h7lVG/tNITTzwhp+ldqPr2Dx8+jL1798Jut3tUN3UPPfSQTA4eeughAJDdpAAwcOBAef/FF1/E4cOHm9z2Pn1OdVtv+uoL1zoeanniERsfL+9XlJW2eD0tNWrsqZOo4hKTsHTzfnm2+PgZ9+Py628GAPzntZeQ1as3XvniRyzdvB+v578nl1uyZAkAIDIyEgC8xqkGIiYmRt5fv369/HL2zTff4JJLLsFTTz0ln3cfu9u9e3e/6/ziiy+wevVqr9ukSZMAuL4clZaWenxJaqmHHnoI1113HUpKSuBwOPDXv/4VgCshXL9+vce89T+feld0fHw8nE6n1/w6fd+sra1t8baJQlHDp/sRGVxGRgZUVYXT6cSGDRtgsVgCGsM0b948TJ7sGoc3e/ZsPPXUUxBCQFEU3H///QBc15arqanBb7/9BpPJhOjoaDle0N3EiRMxZcoUHD16FGVlZV7jPvWu4Na2fPlypKenQwiBlStXQlVVjwqMnrCMHj1adonrlVFf9CTQ/f7KlSvl2MitW7d6tO28885rctuvv/563Hmnq/v4y3fz8fX//RvOALrDz7nwEqx48QUAwGtPPoTXn3oEA4ePwt9eWtTIkq3jtPRMpGZ1Q8n+vTh6uBxX9+3iOunm5OufnJ6Byfc/hPcXv4LyEtcYPkVRPN6fP/3pTwBcY1M3btzYKpcB0s2ZMwe33norAOCcc87x2rY7PUlqLBH0d9H0Cy64ANu3b8fq1as9EtlAPP/88/LLUf3Y9TGf/j6f+nHiyJEjXp8Jd/Hx8SgtLUV1dTVUVYXZbIbD4WjStolCGSuUFPIWLFggqwp1dXXN/lUQd5MmTcLrr7+OqKgoAKe6wk477TQ5z3PPPSe7y5xOp+xG86WkpMTr+pBmsxkzZszwuLZga0pNTcX3338vzw7W2xAdHY2VK1fivPPOAwCsWLECubm5crnIyMgmX8syMTERW7dulReg1lksFiQluc6qbkrbY2Ji8Ne//tXjrNlhV17V3CZLPfudhe65/eVj4XSivKSoxetrif/96Bv0GXQuFOXk4Vd//eM64fKJfwYA9Bs6HGaz5eTTrufNZjOmT5+Ofv36AQD+/ve/A3AN9fjuu9Y5seiWW27BvHnzZJKob9tqteLCCy/0mFc/aeXSSy9t0bZMJhPWrVvXaskk4Pqyop845h77c889J48B/j6fr776qseyw4cP99lLsHjxYo/59EplU7ZNFMoU0VEGhxERNWDljuLGZwpRY85I8zk9KioKdrsd/fv3l9cYbQ9z5syRYx6PHDmCTp06ten23CvYqqri1VdfDYmLm0dGRqK2tlaO8Z0yZUqbfZEkamvs8iYiQ7CoSqv8/KIvY/v4/1WlFb8Utsk2m8qi+r8E1pw5c3DnnXfip59+gt1ub5VxiE2h//TikCFD2jyZrM/pdLbquNFgasrZ40RGwQolERnCmv1lOFxd2/iMLZCXk+73ufzt7dslXl9SpAUXZCUHNQYiosawQklEhpAWE9lmCWWwk8aGpMVEBjsEIqJG8aQcIjKEbvHt053b0WSHabuJyFiYUBKRIVhNJpha/ouahmRSXO0mIuromFASkWH0SIgOdgjtqmdieLWXiIyLCSURGUbf0+KCHUK76pMcXu0lIuNiQklEhpIUaWl8phCQbAuPdhJRaGBCSUSGMjgtIdghtItBqeHRTiIKDUwoichQbFYTbObQPnTZzCpsVp6MQ0TGEdpHZSIKSSO6hPaFvkO9fUQUephQEpHh2Kwm9EyICnYYbaJXQhSrk0RkOEwoiciQzkzphAhTaB3CIkwqclPa97exiYhaQ2gdjYkorIzsGlpdw6HWHiIKH0woiciwbFYTeoVI1ze7uonIyJhQEpGh5aZ0Qmq0NdhhBCQ12squbiIyNCaURGR4QzOTkGjQC54nRlowNDMp2GEQEQWECSURhYQRWcmGSyoTIy0YkcVxk0RkfIoQQgQ7CCKi1rK2sBwlJxzBDqNRqdFWViaJKGQwoSSikLOltBI7K6qCHYZfvRKiOGaSiEIKE0oiCkl2h4bPCspQozmDHYoUYVIxsmsyz+YmopDDhJKIQtrm0krs6gDVSlYliSiUMaEkopBnd2hYc6AM9rr2r1bazCpGdGFVkohCGxNKIgobdoeG9cUVKK+ubfNtJdssGJSawESSiMICE0oiCktbDx3F7ooT0FrxCGhSgJ6J0eiTHNd6KyUiMgAmlEQU1hyahn1H7Cg+Xo2jjjrUOpt+SLSoCuKsZqTFRCI73garidVIIgpPTCiJiOpxaBqKjlWjRhOYNftJREbF4O7pU2FWTYgwKUiPjWTySETkhgklEVEDIiIiAAA1NTVBjoSIqOPiTy8SERERUUCYUBIRERFRQJhQEhEREVFAmFASERERUUCYUBIRERFRQJhQEhEREVFAmFASERERUUCYUBIRERFRQJhQEhEREVFAmFASERERUUCYUBIRERFRQJhQEhEREVFAmFASERERUUCYUBIRERFRQJhQEhEREVFAmFASERERUUCYUBIRERFRQJhQEhEREVFAmFASERERUUCYUBIRERFRQMzBDoCIqKN49tlnUVRU5DGtrq4OAHDXXXd5TE9PT8f999/fXqEREXVoihBCBDsIIqJgW7hwIW688cZmLfP666/jhhtuaJuAiIgMhAklEREATdNgsVjQ1EOioiiora2FyWRq48iIiDo+jqEkIgJgMplw1VVXNXn+MWPGMJkkIjqJFUoiopOaWqVkdZKIyBMrlEREJzW1SsnqJBGRJ1YoiYjcNFalZHWSiMgbK5RERG4aq1KyOklE5I0VSiKievxVKVmdJCLyjRVKIqJ6/FUpWZ0kIvKNFUoiIh/qVylZnSQi8o8VSiIiH+pXKVmdJCLyjxVKIiI/NE2D2WwG4PpNbyaURES+MaEkIqrHoWkoOlaNGs2Jn7b+AlU1IadXT1hMKiJMKtJjI2FlcklEJDGhJKKw5tA07D1iR/Hxahxz1KHW2fRDokVVEGs1Iy0mEt3ibUwyiShsMaEkorC09dBR7K44Aa0Vj4AmBeiZGI0+yXGtt1IiIgNgQklEYcPu0LC+uALl1bVtvq2kSAsGpyXAZmXVkohCHxNKIgp5doeGzwvKUK05233bNrOKEV2SmVgSUUhjQklEIW1zaSV2VVQFOwz0SohCbkqnYIdBRNQmmFASUUiyOzR8VlCGmiBUJf2JMKkY2ZXVSiIKPUwoiSjkbCmtxM4OUJX0h9VKIgo1TCiJKKSsLSxHyQlHsMNoVGq0FUMzk4IdBhFRq2BCSUQhY83+MhxuhzO4W0tipAUjspKDHQYRUcD4W95EFBKMlkwCwOHqWqzZXxbsMIiIAsaEkogMb21hueGSSd3h6lqsLSwPdhhERAFhQklEhraltNIQYyYbUnLCgS2llcEOg4ioxZhQEpFh2R1ahz6buzl2VlTB7tCCHQYRUYswoSQiw/qsILTGH4Zae4gofDChJCJD2lxa2aEuWt4aajQnu76JyJCYUBKR4dgdWof4OcW2wK5vIjIiJpREZDhrDoR213Cot4+IQg8TSiIyFLtDg70utLq667PXOVmlJCJDYUJJRIayvrgi2CG0i+9LwqOdRBQamFASkaGUG/QC5s1VZg+PdhJRaGBCSUSGsfXQ0WCH0K7Crb1EZFxMKInIMHZXnAh2CO0q3NpLRMbFhJKIDMGhadBEsKNoX5pwtZuIqKNjQklEhrD3iD3YIQTFvjBtNxEZCxNKIjKE4uPVwQ4hKMK13URkLEwoicgQLuvdFXk56Xhwwuhgh9Kujjrq5P3s7GwoigJFUYIYkX/ffPMNIiMjZYyKomD58uXy/tSpUwG0vB2LFy+Wyx0+fLgtmkBELcSEkqiDMJvN8p+lqnp+NNevX+/xTzo9Pb1NYoiLi/P6R19SUoKIiAg5/dprr22TbTdk/vz5qLG7un7/+s/XmrzcdQN7Ii8nHeP6dmnRdm8bOQh5OenIy2mb17spap2nBo6mp6dDVVVEREQELZ6GjB49GjU1NQAg44yPj4eqqlBVFampqQGtf9KkSYiMjAQAXHrppQHHS0SthwklUQckhMCMGTPk4+uvvz4ocRQUFKBLly5wOBwAgBtvvBHvvPNOu8fx6KOPAgBi4xMQG5/Y7tsPNv3EnLVr10LTNFRXd8xu8CNHjgAAoqKiZJwXX3wxNE2DpmmYOXNmwNu45JJLAAAbNmwIeF1E1HqYUBJ1UAsWLAAA2O127Ny50+98sbGxHtVLRVGQnJyMbdu2yXn0yqPZbMbAgQPlfFarFf/97399rvfXX3/F6aefjro6V5frbbfdhtdeO1Ud/Oijj9CpUyeP7Z5++uk4fvw4AKBr165yup6QAoDNZpPbBoAHHngAFovFYz2RkZF48803AQCapqG8vBwAcM7ISzxinHHFBbKCmJeTjrzeGbjp/P4AgLycdFRXuS6749Q0Oc+Cxx5AeUkxrumX7blsTjpuu3AQjh1xdaWO69sFZUUH5bb0eWZed1Wj226ur9//D56Z+me/zxcdcyWQvrqKr7vuOphMJo/XLyoqCps2bZLzjBs3zqsCft5553lsQ3+uT58+iImJkY+7d+/epDYoiiL3laqqKrm/+ery9sXhcKBfv35QVVXOb7PZsHTpUo/55s2bB8D1pWv+/PlNio2I2h4TSqIORu/urq6uxnvvvYcJEyYAcFV9fNETOPcko7y8HAMHDvSaV9M0bNy4UT6ura3F6NGjofm4NE2vXr3k9BkzZuCll16Sz61fvx6XXXYZjh496rHtvXv3IiMjAwA8/tnffvvtAFwVT726duGFF8LhcODpp5+WiYi+npqaGnz33XcA4JHEXjHxJnn/ubtuReGvu3ByQddfIVBZdggAYDmZsOoUVYWiqkhM6YxjlRWoO5nkur9uZcUHMePKCwEAtuhYn8snpaY1um1fDhUVYu0H7/q8vfjQvVj/6Qd44pbrfC5b4+d6Sd988w2WLFkCp9Pp0Ra73Y5du1zxjRo1CitWrPB4j4UQWLt2LXr06OG1zm3btuHEiVPXv9yzZw/+/Gf/ya6u/jANVVURFxfX6HK61NRUbN68GUII2Y7q6mpce+21+PLLL+V8+hcVwDWmkog6CEFEHYLJZBIAhKqqom/fvgKAyMjIEGazWQAQ999/vwAgAIi0tDS53DPPPOOxnszMTDlfcXGxEEKI2NhYOW3u3LlCCCEGDRokp02aNMlrPv02Y8YMr1izs7Pl819//bUQQoi8vDw5bdGiRUIIISIiIgQAYbPZhBBC/PGPf5TzFBYWinXr1snH77//vlz/3LlzxRdffCGEEOKaa66R8+RvL5K3zO49BQBhMpvltNfW/iz+eNMd8nFkVLTrNTWZPJZdtG6buPmhJz2mRURFeW0nOT2jxduufxt80e+9Xltft7OGXei17JbSI0IIIbKysuR8Qgjx+OOPe7yeQghRV1cnHn74YbFnzx4hhJDPq6oqSktLRV1dnXxfAIj9+/d7zVdeXi6+/fZbn/tbU/bh2NhYOW3ZsmVyPVOmTPHZjnfeeUc+vuCCC4QQQuzevVtO69Kli8d2rFarACA6d+7cpLiIqO2xQknUAS1ZsgQAcPDgQdTV1UFVVTzzzDM+5124cKFHN2FhYaF8bv369R7zKoqCadOmAQAWLVrkdz53L7/8MiorKz2mFRUVyfvnn38+FEVBfn6+nKZXjq655hoArorZpk2b8OmnnwJwdcFnZGRg8ODBsrJ1xRVXQFVVREdH49///jeGDBkCACgrK/MZ18VXTwQAaHV1rhNv+mRixhUjEJuQ4LctOovVipUvz/Posq6pqmp0uUC2/T/zX0X+9iK/t4XfbQEAbPx6jdeytX4qlLfccou8n5mZCVVVER8fj19++QXdunXzqOz17NkTp512GkwmE0aNGiWnv/rqqx7r7NOnDxITE+XrD5yqgreVN954Q97/4osvoCiKR/W0uLjYY36LxQIAHXYsKVE4YkJJ1AH169cP8fHx8vH555/vc76LLroI27ZtgxCuhKN+t6N+xm1LpKSkAHD90+7cubPfy7ToZ/C632JjXd3F7t3VEydORNXJpO3GG2+U0wsKCjB06FA5zrOqqgqfffYZ+vd3jUdMSkryud0rJ9+CaU+9gJSMLrBYrXA6nThWcRhvzZmNdZ980GDb7v7TSBwuLZGPFbV5h8KWbHv27ZO9xmy6324YkgsAGDzqMq9lLSbfl9dJTU3FTz/9hP79+yM6OhqAK/lbsWIFrrzyyma1SZfQhIS8LeljPN1v9Yd71NbWAoA845uIgo8JJVEH9cgjj8j7K1as8DmP+4kXpaWl0DStwYRACIEXX3wRAHDTTafGIw4ePNhr3t9++01enqimpgZpaWk4dMg1RjAtLU3O984778izeLdt24Zhw4Zh1apVAACTyYScnBwAwNatW+Uyc+bMAeAa0/nYY4/h008/RWVlJTRNk4n0nj17AAAjR46Uy+3b8Yu8v3rlO1BMCl5cvQ7v/LxPVvgA4LOVrhM5TGZXJUucHGOoKy8+VWHN316Etzbsgvlk1cudNeJUwuI+BrEp265vyuw5eOT1ZT5vtpgYAMCgUZfif+a/6rWsWTX5XOe2bdvw1ltvYcOGDTh+/DicTqes3n333XcYPny4nHfXrl04dOgQNE3D6tWr5fSmjI9sa/o4YQDIzc2V+5PD4cC0adPw8MMPe8yvJ5Rdu3Zt1ziJqAHB7nMnIhf3MZS6H374Qfzyyy/yMeqNaRsyZEiD4/GWLVsmhPAeG6koisf9uro6r/l0Xbp0kdMsFosoLCwUX3/9td/11T+suI+TBCCysrLkc8eOHfNYh/t6MjIyhBCuMYH6tIuuvk6OK+w14Gy/27/l4adE/vYikXVGn1PTFUUoqioWrNkgEjunNvi66ds497IrPdupqmLGc//bpG0353b/vFfFuZf9we/zeyuOCyG8xx4uWrTIbxxDhgwRQggxcuRIv+3s3r271741bNgwr2nuYyKbsg83dwylEELEx8f73afcY9q/f7+cPm/evCbFRURtjxVKog7s7LPPRu/evf0+/8UXX8iuacA1NvGss87yO7/JZMK5554ru8gtFguWL18Ok8l3BQxwdUmffvrpAFyVoezsbHTp0gXvvvuuPItXX5/ZbEZubq7H8oMHD0bMyQocAMyePVvet9lsSEhIgKIoEELI9XTu3FmejW4ymWS3t3t38sBhI2E5eYFvfTlFVTH4ot/jsgmTAQD3zf2XnAdCQDidcNTU4Im3/o3IqGi5rk5JyUhK9b54+fRn5yMq9tSZysLpxNHysiZtuzl+d/Hvce8/Xvb7fHqs767dfv36yeEFehwA0KNHD3z99dcAgNWrV2Ps2LEe77GiKBg6dCh2797d7Fjbym+//Ybc3Fx5Brc4ebZ3SkqKHPcLQN5v7DJERNS+FOF+FCKikBQXF4djx47BZDLJS/S0p169emHXrl0t3v78+fNlIrHwuy1hd3HzMWe4hhgkJiaioqICqqr6vNRTOIiMjERNTQ0GDRrU4MlkRNS+WKEkojYzevRo2Gw2eU3EvLy8Fq1n6tSpiLDZAABP33lTI3OHFouq4LvvvoPNZkNFRQUA1xnd7e2JJ56AyWTyeUtMbJ8Ef/HixfJEs08++aRdtklETWMOdgBEFLo2bdokL+3So0cPr189aY4PtxXgcHVta4VmGHFWMw4cOCBfx7i4OKxZs6bd4ygpKZEXUK9Pv8B9W5s0aRImTZrULtsiouZhlzcRGcKO8uPYWnYs2GG0u9zkWPRKiml8RiKiIGKXNxEZQrd4W7BDCIrsMG03ERkLE0oiMgSryQQ/1/cOWSbF1W4ioo6OCSURGUaPhOjGZwohPRPDq71EZFxMKInIMPqeFtf4TCGkT3J4tZeIjIsJJREZSlKk908khqJkW3i0k4hCAxNKIjKUwWn+f6s8lAxKDY92ElFoYEJJRIZis5pgM4f2octmVmGz8mQcIjKO0D4qE1FIGtElOdghtKlQbx8RhR4mlERkODarCT0TooIdRpvolRDF6iQRGQ4TSiIypDNTOiHCFFqHsAiTityUTsEOg4io2ULraExEYWVk19DqGg619hBR+GBCSUSGZbOa0CtEur7Z1U1ERsaEkogMLTelE1KjrcEOIyCp0VZ2dRORoTGhJCLDG5qZhESDXvA8MdKCoZlJwQ6DiCggTCiJKCSMyEo2XFKZGGnBiCyOmyQi41OEECLYQRARtZa1heUoOeEIdhiNSo22sjJJRCGDCSURhZwtpZXYWVEV7DD86pUQxTGTRBRSmFASUUiyOzR8VlCGGs0Z7FCkCJOKkV2TeTY3EYUcJpREFNI2l1ZiVweoVrIqSUShjAklEYU8u0PDmgNlsNe1f7XSZlYxogurkkQU2phQElHYsDs0rC+uQHl1bZtvK9lmwaDUBCaSRBQWmFASUVjaeugodlecgNaKR0CTAvRMjEaf5LjWWykRkQEwoSSisObQNOw7Ykfx8WocddSh1tn0Q6JFVRBnNSMtJhLZ8TZYTaxGElF4YkJJRFSPQ9NQdKwaNZrArNlPIjIqBndPnwqzakKESUF6bCSTRyIiN0woiYgaEBERAQCoqakJciRERB0Xf3qRiIiIiALChJKIiIiIAsKEkoiIiIgCwoSSiIiIiALChJKIiIiIAsKEkoiIiIgCwoSSiIiIiALChJKIiIiIAsKEkoiIiIgCwoSSiIiIiALChJKIiIiIAsKEkoiIiIgCwoSSiIiIiALChJKIiIiIAsKEkoiIiIgCwoSSiIiIiALChJKIiIiIAsKEkoiIiIgCwoSSiIiIiALChJKIiIiIAmIOdgBERB1FQUEBjhw54jHN6XQCAH7++WeP6fHx8ejatWt7hUZE1KEpQggR7CCIiIJt+fLluPrqq5u1zLJlyzBu3Lg2ioiIyDiYUBIRATh8+DCSkpKatUx5eTkSExPbKCIiIuPgGEoiIgCJiYkYPHhwk+cfMmQIk0kiopNYoSQiOqk5VUpWJ4mITmGFkojopKZWKVmdJCLyxAolEZGbplQpWZ0kIvLECiURkZvGqpSsThIReWOFkoionoaqlKxOEhF5Y4WSiKgef1VKVieJiHxjhZKIyAdfVUpWJ4mIfGOFkojIh/pVSlYniYj8Y4WSiMgP9yolq5NERP6Zgx0AEVFH49A0FB2rRo2w4MlXFsNktaKozoRD5ccQYVKRHhsJq8kU7DCJiDoMViiJKKw5NA17j9hRfLwaxxx1qHU2/ZBoURXEWs1Ii4lEt3gbk0wiCltMKIkoLG09dBS7K05Aa8UjoEkBeiZGo09yXOutlIjIAJhQElHYsDs0rC+uQHl1bZtvKynSgsFpCbBZWbUkotDHhJKIQp7doeHzgjJUa85237bNrGJEl2QmlkQU0phQElFI21xaiV0VVcEOA70SopCb0inYYRARtQkmlEQUkuwODZ8VlKEmCFVJfyJMKkZ2ZbWSiEIPE0oiCjlbSiuxswNUJf1htZKIQg0TSiIKKWsLy1FywhHsMBqVGm3F0MykxmckIjIAJpREFDLW7C/D4XY4g7u1JEZaMCIrOdhhEBEFjL/lTUQhwWjJJAAcrq7Fmv1lwQ6DiChgTCiJyPDWFpYbLpnUHa6uxdrC8mCHQUQUECaURGRoW0orDTFmsiElJxzYUloZ7DCIiFqMCSURGZbdoXXos7mbY2dFFewOLdhhEBG1CBNKIjKszwpCa/xhqLWHiMIHE0oiMqTNpZUd6qLlraFGc7Lrm4gMiQklERmO3aF1iJ9TbAvs+iYiI2JCSUSGs+ZAaHcNh3r7iCj0MKEkIkOxOzTY60Krq7s+e52TVUoiMhQmlERkKOuLK4IdQrv4viQ82klEoYEJJREZSrlBL2DeXGX28GgnEYUGJpREZBhbDx0NdgjtKtzaS0TGxYSSiAxjd8WJYIfQrsKtvURkXEwoicgQHJoGTQQ7ivalCVe7iYg6OiaURGQIe4/Ygx1CUOwL03YTkbEwoSQiQyg+Xh3sEIIiXNtNRMbChJJCQnZ2NhRFgaIowQ6lxYYPHy7bsHz5cr/zLV++XM43derUdowwuI456oIdAgDguoE9kZeTjnF9u3hM/3DJIuTlpCMvJx01dnuD8zbH0TZs9+LFi2GxWOT+ZDabMXXqVK/9MC4uTj7fHHfeeScURYHJZGqL8L3oceq30047rV222xIt+RzfcMMNUFVVLpedne3z2Of+fCDc160oCuLi4gJaH4U2JpTkl9ls9jiYuN/y8vKCEpO/A2V6ejpUVUVERESbbNf9n6z7TVVVdO/eHXv37m2T7foSHx8PVVWhqipSU1PbbbtN1VbJfa2zYw+gXPTsYwCArr16I8JmAwDEJSZBUVXYomNbvN62bPett96KujpXwqqqKuLi4pCamir3r/j4+IDW/89//hOKosDpdGLy5MmtEHHTuX8+9OQt0AQrmBwOBxYtWgQhXPuDqqpIT09v1WOf/tnVv0jo6yZqiuZ93aSwVf+gkpmZGaRIfFu7dm27bk9VVTidTgghsGfPHuTk5KCmpqZdtn3xxRdDC7MTNTr6iSlb1q2Fo9rVNX3Lw0/K6S9++l2rrN+habC2QZVP32fT09Nx8OBBOX3mzJmtto2cnBxs27YNS5cuxaJFi1ptvQ2JjY3F0aOhdcmljz/+WN6fPHkyFi5c2Obb1I+rcXFxOHbsWJtvj4yNXz2oSTRN87i98MILfrts6lcR3at7Y8eO9ah8XnvttR7bWbhwIaKjoz2qgKmpqXJbuv3793tUwXxVxex2O/r06eOxLovFgrvuukvO05zYdMOGDYOmaaiqqpKJtsPhwKZNmwAAGzZsQFJSksd2Y2JisGrVKo/1DBgwQD4fHR2NI0eOeG3LPT79Nfb1un/22Wder5vFYsF1110n17Vq1SrExsZ6zJOYmIgNGzbIedy7NgcOHCjni4iIwGeffebz9XBnNpuxf/9++Vhffvjw4c16beorOlaNFx++T3Ypr175jnzuntEXyemHD5Vi5SvzMa5vFzktLycdY3tn4JEbrvZYp/7cTef3l13TeTnp+Me9U/DR0sUY1yfTtWyfTHy4pOFEaOHTj7raq6roc84QOd1Xl/dD1+chr3eGR3wTBvbwWN+DE0ZjrNs8NqsVY8eOlc+77wPDhw9HRESEfHzeeec1GKv78vL1LSqSXZq+urx9OXToELKysjzey06dOuG77zyT6LvvvhuAK3ndsmVLo7H5MnnyZMyfP79Fy/qif85jYmLkNLvdLtvRq1cvAKcqdO5tjI2NxSeffCKXcz/2XH/99R6f6b1796J79+5yWlZWVoviHT58OP7whz/Ix4sWLZLvfVN7BD766CN06tTJoy2nn346jh8/3qKYiOpjQkntKj8/36O6tnTpUpnQLF68GDfeeCOqqqo8liktLZXdvO70bjl/UlNTsW3bNo9pdXV1eOGFFzBt2rRmxdZUJSUlGDRoEA4fPgwA8iB/4sQJjBkzBt988w0A4JprrsFPP/0kl6uqqsLmzZubtS13l19+uXzd9G3W1dXJ7X355ZcYM2aM/Oehz1NRUYFBgwahpKTEY32apmHjxo3yscPh8PiH5k/9MVb6e5SZmdnk18aXGs2JWx95Wj5+5x/PyvsFu3YAAKJi45B4Wgp2/7wRzpPvo74NIQS2fPc1nr/nTq91V5YdQnXVqes9fvXeKix45K9wOl2/Fy6cTvzriQcbbPfBvb8CAGI6xTc437//9U/88v23wMluS5yMr8Ztn7/z4iHY/uN62bUJAE6nE/n5+Rg1apTXOr/66is4HA75eO3atXj55ZcbjMPf5yk5ObnB5dxlZmaioKDgZDNc7Th69CiGDh3qUe286aab5P3nnnvO7/o2bNiA5cuXe92WLl2KxYsXY9q0aa2WVF544YUAXPuenuTed9998vm///3vAFyfZyGER7J2/PhxXHbZZT7X++abb8r7VVVVOP3007Fnzx45raCgADfccEOz483MzPRKGPXPVVOsX78el112maza6uvau3cvMjIymh0PkS9MKKlJ6o8dbKmUlBQIITyqLXPnzgUAjyTvvvvugxACQgg8+eSTXt28WVlZslrqy5tvvikPnsnJyRBCeCRsL774YrNic/fVV1/BZDIhKipKJh1WqxUDBgzAuHHjZCIwZswYOJ1OzJo1Sy47YcIEAK7kVbd7925UVVX5POEhISHB5/369IRi1KhRsiv+448/xgMPPAAAuP766+W8s2bNgtPpxJgxYwC4kq1x48Z5rfOZZ56BEEKOzaqf6Pty+PBhjyqM/h4tWbKkya+NL7WaEyaTCV16nOHaTmkJaux2/PLDdzJ5vGjseADAZRNuxGOLViB/exFWbDuIV77aJNfz/ecfe60bioLX1v6MUWNPbd9kNmPZ1gM4Y8A5AFxJZXlJsf/4alzd3fFJDZ8Esm3Denn/7Z/3IX/bQSzZ+Csuv/7PAIDfCgvw2wFXkmaJiMDbP+/Da2t/hnIy+fNVJY6MjERdXZ1Hsvavf/2rwTj8fZ7ck5+GTJs2Te5z06dPh9PplF2yQghcffWparDJZJLHjJ9//tnvOn//+9/j6quv9rq59xS0NKnU9719+/YBcH1Z1N14440AgHfecVW9zWYzrrzySgCuBLimpkZ+ps4991wArgTfPXnUjRo1CkIIj5OQ7rnnHo/hMO5d1021ZMkSj5inTJkiP1dNcc0118j7X3/9NZxOpxwHf/ToUSxevBgAsG/fPr/HA6LGMKGkJtErTY1VBRvzl7/8BQA8ql36QV4fo2M2m/Hss6cqUHpS1Bxvv/22vH/77bcDAHJzc2VS5isRbSi2+vREUlEUdOvWDdu3bwcAbN26Vc6jJ43u49H0SqC+/cTERHTv3h02mw19+/b12s6sWbNkYu2efNWXnp4OAFi9erXsop4+fbrsanavQOrxuCe1v/zyi8f6FEXB/fffDwCtdqZsU18bX+pOnpgy49lTCf6LD92LRc+eek0m/88jAFz76uzbJ8nu4luGDZDz1PoY5xqXkIhOicnoc/bv5LTM7r1gMpmQldNHTtvx049+49MTZZtbF6ovV0y6Wd4f3y8bY3tn4ubhZ8lpn+Wf2m9zf3cerFYrOiUmo2u30+X0+pXcyy+/HCaTCbfddpucVlZW1mAcgfr000/l/blz50JRFFxyySVymvt7DZwag93QOLzS0lK5r/u66V/uHn300YDjT0xMRFpaGgDgxx9/hKZpKC8vBwD5mQGA9957D5GRkfKL9Lfffiuf++GHH7zWO2/ePACuJF/33HPPwWq1yiQzGF3MRUVF8v75558PRVE8Pv96QkkUCCaU1CT1x1ACnifquHe5NeT0013/GG0nz4IF4NG1F0xNjW3YsGHyn5zT6cSePXvQrVu3dovTl/3792P8+PFISkqC2WyGw+HA9u3bMWDAgBatz/29ba9LvjTErLoqXN36nAlbtCtp++6TD7D3F1fVOSWzq5z38T9fixr7yWqqosjqnj/Wk//8rW5JQFRM7MnF3arxJ79E+KLPV32i4Z9K7Hfu+Xj4X28jvVt3WCMjIYQTVceO4v/eeBVvPf+03+Ua6hXQEyP38YDt+Zmq/2VTP1vcnf4FLKaBhLv+2Nr6t+nTpwNwVc5bwwsvvCBjGzZsmJz++uuvA3B9wfz88889zqp2p58d7653794+5+1IfL1fsbEtvwoBka7j7vXU4Q0Zcurkgx9/dFVvbrnllhavTz+o1dXV4cEHT41Zc69W6qqrG77Y8/jx4+X9l156CQCwZcsWVFRUAGi7JMm9yqh3KT3xxBNymn4ZE337hw8fxt69e2G3272qOgDw0EMPyX+oDz30kN/t3nfffZg1axbKyspQW1uLSy+9FMCpRN/98kJ6PO6XfurTpw9ai3t1xr0S3NTXxheL6dSh6srJtwJwdTNrJ/+pX3/Pqf1FnxYVG4f8bQfx9NL3W9SO5rCcHBZwpPxQg/Nt/GoN9u3chnkffIW3N+1B/vZTlaP1n36AkXmn9tst676Bw+FA5eEyFOz5VU5vykk3bc19LOdVV10lv2hWVlZi4sSJmDNnjnxe0zSZlPXv39/vOr/99lusXr3a6+beRbxgwQL8+c9/bpU2jBs3DlarVW4bcB2DunZ1fTn58MMP5bwff/wxNE1Dz549W2Xb7U3/0gG4uvb192vbtm0YNmxYoyfFETUFLxtELZaRkSEvn7NhwwZYLBaf39qbat68efJadbNnz8ZTTz0lB8Tr3a8RERGoqanBb7/9BpPJhOjoaJ+XB5k4cSKmTJmCo0ePoqyszKvCo3eDt7bly5cjPT0dQgisXLkSqqp6VIv0MU+jR4+WXU56ZdQXPQGuf7++uXPn4vnnnwfgqmbVr6q88cYbuOCCCwC4ktSHH35YztPY2bzNdeaZZ2LHDteJMmazGaqq4o033mjya+NLhFtCee30e7HixedPtdFkwtDfnxqmoKgqhNNV+cvrnXHqBJg2lNGtB/Zu24LjR/y/RwDw7UfvYfWKJVj87OOuE3LcYuvZfyA6Z3ZF5y5d8duBAtTW1GB8v2yP5UeOHNkW4Tfb/PnzsWDBAtTW1iI/P19+6dHfk9jYWDkO77XXXpPL3XvvvX7X2atXL3l2dX0333wzzjnnnIC+sPpy1VVXeYxNnDRpkrx/7rnnypP63Lvzjeitt97C+eefDwC4+uqrPd4rotbCCiUFZMGCBbLaVldX5zH+qLkmTZqE119/HVFRUQBOddu5j+F77rnnZJLkdDpxooEuxpKSEuTk5HhMM5vNmDFjRqtegsRdamoqvv/+eyQmJgI41Ybo6GisXLlSVpdWrFiB3NxcuVxkZKRXrE2hv/a5ubnyddG3GRUVhRUrVgBwjQtbuXKl7HLU50lISMD333/fqhdIf+utt9CpUyf52Ol0orS0tMmvjS/psZEej88YcLa836vfWR7P3fHEc1D1CrQQ6HPOkFOP28gNf30UgKutOzZ5j63T5Q45D9ZIm4wNAKAo6Nl/IKbOdn0h+Ocn3yHnrHM8vgSpqoq8vDysXr26TeJviYKCAlnNA1zvp6qq6NKlCyZOnCin6190IiIiPPb55njllVc8xoi2lvpjB/VucAB49dVXccYZZ8jHERERuPzyy1s9hvZw3nnn4d1335VDEfTPntlsbvF7QlSfIvg1hchQHnzwQcyePRuA62ze1uoC7OhW7jh1lvWbf5+NVQtcXwrmffAV0rt1D1ZY0vgBp8NRXY3snD6Y82/XSStX52ZBq6tFhM2GJRt/bWQN/o05I63xmToovRLdHhfjdr8At6qq6NOnT6OX47JaraitrUWXLl3kZZDIZejQoVi3bp0cAxuKF4yn1sMKJZGBdO/eXSaTgOflQNpLZGQkTCaTz5v7BZ9b4vTTT/e77hfunYIPlyzChLO6y2SyU1Jyh0gmAWDy/a6zzPdt/wXvv/EqrjnTlUwCQLfeZ7Z4vRa1ZZfpmjBhgt/XsqFhFq3p9ttvl5XL9vhlF3dOp7PBKwf06NFDJpNA8M90bmjfb+iSWm2pqKhIJpNEjWFCSWQg+q/QqKqKWbNmNXjWbFvRr8vn6+br136ao6yszP+6fytGwa7tqLHbAQDWSBv+X/5HrdCi1nHZhMnI316E/O1FOLhnN+pOJirxySl4+NW3G1navzhry4a6FxYW+n0t2/qyQrqXXnoJQoh2+6nQo0ePelxq6NAh/ydJ7du3TyaT48ePx4gRI9olRn8a2vcLCwuDEpN+XUr9xuokNYRd3kRkCDvKj2NrWfj9nnBucix6JbX/FwciouZghZKIDKFbvK3xmUJQdpi2m4iMhQklERmC1WSCqeW/+mlIJsXVbiKijo4JJREZRo+E6GCH0K56JoZXe4nIuJhQEpFh9D0trvGZQkif5PBqLxEZFxNKIjKUpEhLsENoF8m28GgnEYUGJpREZCiD0xKCHUK7GJQaHu0kotDAhJKIDMVmNcFmDu1Dl82swmblyThEZByhfVQmopA0oktysENoU6HePiIKPUwoichwbFYTeiZEBTuMNtErIYrVSSIyHCaURGRIZ6Z0QoQptA5hESYVuSmdgh0GEVGzhdbRmIjCysiuodU1HGrtIaLwwYSSiAzLZjWhV4h0fbOrm4iMjAklERlabkonpEZbgx1GQFKjrezqJiJDY0JJRIY3NDMJiQa94HlipAVDM5OCHQYRUUCYUBJRSBiRlWy4pDIx0oIRWRw3SUTGpwghRLCDICJqLWsLy1FywhHsMBqVGm1lZZKIQgYTSiIKOVtKK7GzoirYYfjVKyGKYyaJKKQwoSSikGR3aPisoAw1mjPYoUgRJhUjuybzbG4iCjlMKIkopG0urcSuDlCtZFWSiEIZE0oiCnl2h4Y1B8pgr2v/aqXNrGJEF1YliSi0MaEkorBhd2hYX1yB8uraNt9Wss2CQakJTCSJKCwwoSSisLT10FHsrjgBrRWPgCYF6JkYjT7Jca23UiIiA2BCSURhzaFp2HfEjuLj1TjqqEOts+mHRIuqIM5qRlpMJLLjbbCaWI0kovDEhJKIqB6HpqHoWDVqNIE6p4ZaTcBiUmBWTYgwKUiPjWTySETkhgklEREREQWEP71IRERERAFhQklEREREAWFCSUREREQBYUJJRERERAFhQklEREREAWFCSUREREQBYUJJRERERAFhQklEREREAWFCSUREREQBYUJJRERERAFhQklEREREAWFCSUREREQBYUJJRERERAFhQklEREREAWFCSUREREQBYUJJRERERAFhQklEREREAWFCSUREREQB+f+DN335UmKUAwAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -237,7 +279,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 38, "id": "f678050e", "metadata": {}, "outputs": [], @@ -264,7 +306,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 39, "id": "b3bf152b", "metadata": {}, "outputs": [ @@ -272,7 +314,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_2659995/2248456176.py:16: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n", + "/tmp/ipykernel_2662699/2248456176.py:16: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n", " plt.tight_layout()\n" ] }, From 6aa25244efdbc27c2a6c4f6e9179b471645e4359 Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" Date: Sat, 3 May 2025 05:55:36 +0000 Subject: [PATCH 10/22] feat: integrate graph drawing feature into tracker --- notebooks/03_orcabridge_tracker.ipynb | 86 +++++++-------------------- src/orcabridge/tracker.py | 19 ++++++ 2 files changed, 39 insertions(+), 66 deletions(-) diff --git a/notebooks/03_orcabridge_tracker.ipynb b/notebooks/03_orcabridge_tracker.ipynb index 729ca3aa..cefc583a 100644 --- a/notebooks/03_orcabridge_tracker.ipynb +++ b/notebooks/03_orcabridge_tracker.ipynb @@ -18,7 +18,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 1, "id": "f28a62af", "metadata": {}, "outputs": [], @@ -41,7 +41,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 2, "id": "56136d16", "metadata": {}, "outputs": [], @@ -51,17 +51,17 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 3, "id": "c7d4def1", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "-2515677326234209445" + "-5112745833299839431" ] }, - "execution_count": 29, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -72,17 +72,17 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 4, "id": "197b5816", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "-2515677326234209445" + "-5112745833299839431" ] }, - "execution_count": 30, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -93,7 +93,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 5, "id": "c32938d6", "metadata": {}, "outputs": [], @@ -128,7 +128,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 6, "id": "e763a55e", "metadata": {}, "outputs": [], @@ -153,7 +153,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 7, "id": "3cdc6e7f", "metadata": {}, "outputs": [], @@ -164,7 +164,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 8, "id": "71d18d81", "metadata": {}, "outputs": [ @@ -193,7 +193,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 9, "id": "2cdf8d30", "metadata": {}, "outputs": [], @@ -211,32 +211,21 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 10, "id": "7a91ffaa", "metadata": {}, - "outputs": [], - "source": [ - "G = DEFAULT_TRACKER.generate_graph()\n", - "labels = DEFAULT_TRACKER.generate_namemap()" - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "id": "42f5bb99", - "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_2662699/828196166.py:13: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n", + "/home/eywalker/workspace/orcabridge/src/orcabridge/tracker.py:87: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n", " plt.tight_layout()\n" ] }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAApQAAAHzCAYAAACe1o1DAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAPYQAAD2EBqD+naQAAgPVJREFUeJzt3XlYVGX/BvD7DDMMAww7CoiCbALuC+KSaS5ppqmZ5lK5tGurWb/KTFPb3jJNS6vXUt/KstwzzTLXMtx3RBFFUXBhk23YZp7fH+OcQAZEBh1muD/XNdelZ87ynJnDcPN9nueMJIQQICIiIiKqIYW1G0BEREREto2BkoiIiIgswkBJRERERBZhoCQiIiIiizBQEhEREZFFGCiJiIiIyCIMlERERERkEQZKIiIiIrIIAyURERERWYSBkoiIiIgswkBJRERERBZhoCQiIiIiizBQEhEREZFFGCiJiIiIyCIMlERERERkEQZKIiIiIrIIAyURERERWYSBkoiIiIgsorR2A4iI6hqDECgo0aPUIGAQxodCkqCQJCgVEpxVDlBIkrWbSURUZzBQElG9ZhACOUWlyC4qQXZhCTJ1JcgpKoGhim0UANzUKnhpVPBwUsFDrYKbWsmQSUT1liSEENZuBBHRnZapK8aZ7AJcyNXBcP1TUAJwKx+IZddXSECgVoNQT2d4OjnWbmOJiOo4Bkoiqjf0BoGUXB2SsvJxraj0lgPkzZj2565WIszTBYFaDRwUrFoSkf1joCQiu6c3CCRk5CEpOx+lhjv3kadUSAj1dEGklyuDJRHZNQZKIrJrGbpi7EvLRn6J3mptcFE5IMbfA14adoUTkX1ioCQiu6Q3CMSn5yIxK7/Wu7Zvlen44Z4uiPbRslpJRHaHgZKI7E6mrhh7rVyVrAyrlURkjxgoiciuXMzVYU9qNgDrViUrY6pNdgzwQCOtxqptISKqLQyURGQ3krMLcODyNWs3o9ra+bkj2N3Z2s0gIrIYv3qRiOyCrYVJADhw6RqSrxVYuxlERBZjoCQim3cxV2dzYdLkwKVruJirs3YziIgswkBJRDYtU1csj5m0VXtSs5GpK7Z2M4iIaoyBkohslt4gsDct29rNqBV707Khv4M3XSciqk0MlERks+LTc5Ffoq+Ts7lvhQCQX6JHfHqutZtCRFQjDJREZJMydMVIzMq3djNqVWJWPru+icgmMVASkc3RGwT2pWXD3r5vRgK7vonINjFQEpHNScjMs4uu7huZur4TMvOs3RQiolvCQElENkVvEEiys67uGyVl5bNKSUQ2hYGSiGzKhVwdSu08bJUaBC7w3pREZEMYKInIppy28+qkSX05TyKyDwyURGQzMnXFuFZUau1m3BHXiko545uIbAYDJRHZjDPZBXY3s7syEoznS0RkCxgoicgmGIRxXKF9j578l4BxvKhB1JczJiJbxkBJRDYhp6gUdj4XpwKDAHLrSRc/Edk2BkoisgnZRSXWboJVZNXT8yYi28JASRaZPn06JElCcHDwLW23bds2SJIESZKQnJx8W9pmC7766itIkoQxY8ZYuyl1luk6+d+SJVYZP7ll1XIMjQzA0MgAXLmQckePLQHILmSgrIper0dISAiUSiUSEhKs0oayn2fbtm2zShvMEULg1VdfRUBAABQKhfx5GxwcDEmSMH36dAD8PKbawUBJZhUWFmLOnDno0qULPDw8oFar0aRJE/Tu3RuffPLJHW3Lvn37MHDgQPj7+0OtVqNhw4bo3Lmz/GFoq0pKSjBr1iwAwKRJk2q8n7S0NCgUCnzxxRe11bQ6Ke82fTPOX7+uwdDIAFw4k1jr+36mZ0cMjQzA8vkf12h7ASBTZ3mgNIWFJUuWlFuelpaGhx9+GE2bNpXXGTFiRKX7eeaZZxAQEABRZlxncHBwtUJUcnKyRaGrsj9eHRwc8PLLL0Ov19vkZ0KPHj0gSRLGjh1b6/tes2YNPv74Y6SlpSEyMhKxsbFQq9Vo27YtYmNjERgYWOvHpPqLgZIqyMjIQKdOnTBp0iT8888/KCkpQUREBBQKBbZv345XXnnljrXl3Llz6NWrF9avX4+CggI0b94carUae/bswYoVK+5YOwCguLh2b+Hyyy+/ICUlBS1atEDr1q1rvJ9169YBAB544IHaalqdpCvR35b97vlzEwKahiIwJPy27N9SOUUlt21izuXLl/HTTz9BkiQ4OTlVua4QAuvWrcMDDzyAzZs3Y968edDr/31P4uLiMGPGjNvSzpt5+OGH4eDggJUrV+LKlStWaUNddPz4cQCAv78/4uPjERcXB39/f6xevRpxcXF44oknrNxCsicMlFTBc889h8OHDwMAXnzxRWRkZODo0aNITk5Geno6Fi9eXOX2er0es2fPRnR0NNRqNdzd3dGnTx/s3LnT7PoJCQno0aMHnJycEBYWVi4obty4ETk5OdBqtTh//jwOHDiA8+fP4/Lly3j//ffL7efYsWN48MEH4e3tDUdHR4SEhOCNN96ATvfvN46YqwaYq3yYuoReffVVjB8/Hh4eHujbty8AY7B89913ERUVBScnJ3h4eKB79+64cOGCvP13332HmJgYODs7Q6vVol+/fjh06FC59v7www8AgIEDB1b5et7M2rVrERMTg4CAAABAamoqxo8fj4CAAPl1mDlzJkpLjZM79u/fD0dHR0iShKVLlwIADh48CJVKBUmS8M033wAAvv/+e3Ts2BE+Pj5QqVTw9PRE3759sWfPHvnYZbvKFi1ahLvvvhsajQZdunRBUlIS1q5di4iICLi7u2PEiBHIycmp8Bq//vrreO655+Dl5QV3d3dMmDABRUVFFc6zbKS6cCYRH7/4FMZ1boGHWwbhhf5347cflpZbf//2P/HGwwPxaEwkRrYJwcR7u2D2y08j71q2vE5pSQkO7tyKjr36yss2fPs1nry7HUa1DcXcyRNRkJdboS2H/96Ot0YPxrguLfFwyyA80j4Cb40ejAM7tgAArlxIwdDIAFxNNV4TP33+idxtDgBnTxzD9LHD8Xi3Nni4ZTBGtQ3Faw/dh+3rVpY7zrY1P+Plwb3h7uYGrVaLqKgoPProo+XWqepaM70/JuPGjSt3rTdr1gzp6ek4c+YMGjZsWOE8y9q7dy/S0tIwaNAgKBQKzJs3D23btkV2djamTJmCnj17VvpH15IlS9C0aVP5//fccw8kSUKPHj2qdT326NED77zzDgDjH5k3VlwbNGiAmJgYlJaW1vgPzczMTPn4N/PTTz8hJCQEGo0G/fv3x8WLFyusc+jQIfTq1UvuWXFxcUFMTAy+++47eR1JkrB9+3YAwNKlS8t1O1+4cAH9+/dH48aNodFooNFo0KJFC8ydO7dchbgyPXr0wNSpUwEYK9GmfQOo0OVdmY0bN6J79+7QarXQaDTo1q0btm7dWq3XiOohQVRGVlaWcHBwEABE69athV6vr3L9adOmCQAiKChIXvb4448LGH//i7CwMOHl5SUACKVSKbZt2yaEEGLr1q3yOi4uLiIiIkK4ubkJAEKhUIgDBw4IIYT4/PPP5WXvv/++OHjwoCguLq7Qjvj4eOHq6ioACFdXVxEVFSUkSRIARJ8+feT1unfvLgCIMWPGVHkOQUFBAoBwdHQUGo1GtGzZUtx3331CCCEGDBggt93f319ERkYKBwcHcfDgQSGEEB9++KH8fEREhAgICJDPMz4+Xj6Gn5+fACBWrVpVrffGnJycHKFWq8W7774rhBAiPT1dNG7cWAAQWq1WtGrVSiiVSgFAjBs3Tt5u1qxZAoDw8vISKSkpok2bNgKAGDJkiLzOiy++KJycnERERIRo3bq1UKvV8n7T0tKEEOXfR7VaLSIiIoSjo6P83qvVahEZGSm/F6+//nqF11itVgtvb2/RtGlTeV8vv/yyvJ5p2cT35oiVCali/m9/CWet8VpxdfcUTcL/3f/Dz08WKxNSxTe7jgqlytgOn4BGIqhZtHBxcxcAxMLNu8XKhFSxMiFVTF20TAAQ7y5bK1YmpIrXFyyRj+fm5S18/AOEk7OzvMy07bg33hFKlUo0bBwkmka3EE7OLgKAcFAqxew1f4hFOw6K8Nbt5DZ4NfQX4a3bifDW7cTKhFTx2mdfC4VCIXwDAkXT6BbC1d1DPsabX/xPrExIFbPX/CGfV0homGjRooV8jZvc7Frbv3+/iI2NldcJCQkRsbGxYvDgwRWuJdP78fDDD5u91t544w2h1WpFYWGhEEKIvLw8ERMTI/+cmH62zVm/fr18jQEQUVFRIjY2Vjz77LPVuh6fffZZ0ahRI/lYsbGxIjY2Vqxfv14+xgsvvCAAiBEjRlTajqKiInH27FmzjzfffFMAEB999FGl2wshxMGDB4VCoRAAhLu7uwgNDRUuLi7yuW3dulUIIcTq1auFQqEQQUFBom3btsLT01Nex9Tu2NhYodVqjdepj498XqmpqeLgwYMCgAgMDBRt27YVDRo0kLf/7LPPqmxjVa+ZEP++19OmTRNClP85Pnv2rBBCiB9//FG+/oKCguSfTwcHB7Fly5abHp/qHwZKKmf37t3yB8tzzz0nLx80aJC8HIBYvHixEKJiGDt9+rT8IfTiiy8KIYTIzs6WP8DuvvtuIUT5DzBTyEhLSxMeHh7lfqldunSp3Aep6ZflgAEDxJ49e+T2PfbYY3KYPH/+vBBCiDlz5sjbmD4AbzVQ+vj4yPsrLS0V27dvL/f6mAJ3cnKyyMjIEPn5+cL5egB55513hBBClJSUiA4dOggA4pFHHhFCCJGbmyvvxxSea+Knn34SAMTx48eFEEJMnz5dABANGzYUV65cEUIIsWbNGgFASJIkEhMT5XPp0qWLvK4pHKenp8v7PnXqlMjPz5f/n5iYKLd50aJFFd7HJ554QgghxJQpU+Rls2bNEkII8cgjjwgA8i+0sq9xeHi4yMnJEUIIMXLkSPkXYHZ2thCiYqC8Z8hwAUA0CY8Uyw6eNga8N2cYt3NyEt/tOyX+s+I3AUBoXFzFskNJYmVCqlhx4qL48OcN4vsDp+VA2W/UGOHh4yt+jr8gViakiqj2HQUA4dckWHy3P1H8dDxFNO/YpUKgXPjnHvG/PSfk/SzdHS80Lsaw99CzL8nLfQMCBQAxfOIkednKhFSxaOch8fVfh+X//3D4jPALMv7CvvuBoWJlQqqY/Ol/BQAREBwirubpyl2DQohqX2tlX0PTz605NwuU0dHRYtiwYfL7Hh4eLlq0aCHc3d1Fly5dhLOzsxxQzDl79myF0GVSnevR3M9pWbNnzxYARIcOHSptw/79+4Vara7ycbNQabqW3d3dxaVLl4QQQjz66KMVzi0tLU1+XgghdDqdCAsLq/DemPtMEsL4uWkKd0IIodfrxd133y0AiLvuuqvS9pVV2WtWnUAZHBwsAIjx48cLg8EgDAaDGDJkyC0dn+oXdnlTpRSKfy+PZs2aVWuc3/79++XumFGjRgEA3N3d0b9/fwDGCTY3GjlyJADAz88P99xzDwDg6NGjAICGDRviyJEjeO211xAVFQVJkpCfn4/169ejW7duOHnyJABjdxwAdOvWDY0bNy53/MqOWx1Dhw6V9+fg4IDdu3fLz73++uvyaxQUFAQvLy8cP34cBQXGbzeZNm0aJEmCSqWSjx8XFwcAuHbtmrwfrVZbo7YBxu7usLAwREdHA4DcHX358mU0aNAAkiRh8ODBAAAhhNx+BwcHfPvtt3BxccHly5cBAN988w28vb3lfWdlZWHQoEHw8vKCQqFAePi/YwxTU1MrtMXUdV926IBpWUhIiNyuGw0YMEB+DUwTQoqLi3Hq1Cmz55x49BAA4HxiAka1DcPQyAAsfu9t43aFhTh3Kh6NwyPQsHEQdPl5GN+lFSY/eC8+e/0lZF29DCdnZ3lfe7f8jg739JHfx5TTxmO2uas7NC4ucHBwQKc+91VoQ2lxEea/8RLGdWmJYdGBGBMbDV1+HgAg88ols+0uS5IkLP3wHTzRrS2GNW+Mka1DcOncWQBA1hXjaxTZLgau7h5ITT6DsEB/xMbGYsKECfI+qnut1YbTp08jPj4egwYNAgAUFRXhmWeewcGDB+Hh4YF3330Xf/zxR7W6Ys2pzvV4M25ubgDK/2zdqF27digsLKzyERMTI3evm2Mal9i1a1d5mMCwYcMqrCdJEl555RUEBARAqVRCo9Hg9OnTAMz//NxIqVTiP//5D4KCgqBSqeDg4IAdO3ZUe3tLXL16VZ7t/c0330ChUEChUGD16tUAUO5zkMhEae0GUN3SrFkzODg4QK/XY9euXfLyDz/8EOPGjUNUVNQdb1PDhg3x4Ycf4sMPP0RGRga+/vpr/N///R+KioqwceNGNGvWrNr7Mo0hKjuZoKpfQDcbV1aVqKgo+ZeciekXZNnleXl5Ndp/aWkpfv31Vzz++OMVntNqtXLILMu5TJi6fPkyCgsL5f+bftmZ2tS3b19kZ2fDyckJbdu2hUqlkn+RlH39TEznpFQqKywzve41DRzmuHl6oWGT4ArLFQoHOKqd8NHK37B97QokHjmIlKRT2L5uBbat/RmvzP0SXfoNxOmjh5FxKQ0xPftW3PlNvPvMY7h07iwclEo0iYiESu2Es/HHUFpSDIPecNPtP33tORzZtROSJCEwLAJOzi64cPoUdPl5MFx/bT19G2DuL1uxfd0K5J49iZPxx/HVV19h0aJF2LVrV7k/+Kq61mrDmjVroFQqcf/99wMA+vbtK48pNunSpQu6dOlS42NUdT1Wh2l87o2vQ1n79u1DTEzMTfc1b968Wzq2OY888gg2b94MSZIQHR0NV1dXxMfHIzc31+zPz41eeuklLFq0CAAQHh4OLy8vJCUlIT09vVrb15aQkBD4+vpWWF5cXAxHR8c71g6q+1ihpHLc3d0xfPhwAMYP32nTpt3Sh1f79u3l8LBs2TIAxsC2YcMGAECHDh0qbLN8+XIAwJUrV+TbibRs2RIAsGnTJixZsgS5ucaJEd7e3rjvvn8rRu7u7gAg/5LYuXOnPDnGdPyyx23QoAEAIDHReIsYnU6HX3/9tdLzKTuhAQBiY2Plf3/00UdyQEpJSUFmZiaaN28OjUYDAOjXrx/++ecfxMXFIS4uDgsXLsSUKVMAGAOfKayeO3eu3DHeeOMNREZGolevXvKy1atXIzIyEpGRkfIEgO3btyM7O1uuQJZ9HZRKJX788Uf52H/88QcmTJiAIUOGADAGxkcffRR6vR5t2rQBALz22mtyxffkyZPIzs4GYKxQ7N+/H3Pnzq30dbLEr7/+Kofqn376CQDg6OiIiIgIs+uHtTC211nrhilffosPlq/HB8vX480vlmLgmCcR0aY9CvJycSEpEfc9Mh4vfvQZPl71O1p37Q4AiN9rrNzt3bIJTs7OaNWlm7zvxmHGYx76ewcKCwqg1+uxe/Nv5Y6fm5UpVxNHPP8qZq/ZjEmzF1a4VgBAff1aKNSV/07uU4cOAAB6DxuNub9sxZQvv4WTs0u5dTIvX8K1rAwMfmIiFn+3DPHx8YiMjITBYMBff/1V7WsNgLxefn6+2df0ZtauXYvu3bvDw8OjwnPJycno0aNHuWXmrteyf8zc2I6bXY9lty8oKDD7h4np56hsJf1Gbdq0QVpamtnHtGnTAACffvopnn/++Ur30bx5cwDA33//Lc8oNzcRyFQhfvLJJ3Hs2DFs2LABrq6uFdYzndeNr4lp+3vvvRenTp3Ctm3b0KhRo0rbVZt8fX0RFBQEwFjV/euvv+Rr63//+x9mzpzJMEkVWbO/neqm9PR00apVK3lMjZubm2jTpo08tglVjKEUoupJOabxRTdOymnWrJlwdzdOmlAoFGL//v1CCCEWLlwobxsZGSnatGkjT/rw8vISFy9eFEJUf1LOl19+KR+3Q4cOIjg4WB5gb24MpbkxYTdOyomKihJKpVKelPPee+/JzwcEBIjWrVvLr0HZ/T300EMCgHjrrbfK7X/MmDEV2rN48eIKY5yef/554evrW27i1JUrV8oNxG/durUICQkRKpVKlP1xN71HoaGhIi8vT9x3333ya1JSUiIyMzPliQamSUll339zY69M7625tlY1TtXFxUX4+PiIkJAQeTvT+FshKo6hnLdhh3B2NU5kUGs0omlUc+ET0EgoHByEb0CgWJmQKj7b9LfxWnD3EE0iokRA01B5P8/M+EisTEgVTSKiRGyf/uXGNv7f59/I67l7+wifgEZC5aguN4ZyxYmLwtvP33hdqlSiSXikcHX3kCfv9Bg8XN5fbJ/7rq/nKEJbtBb3DDE+16xtB/laDwyLEC5u7vLEnOYxncXKhFTx9jc/Gn/+vLxFy1atyk1a2rRp0y1da23btpV/NmJiYsQbb7whhBDiwoULIjQ0VISGhsqTt1xdXeVlpmtKoVCIefPmVfhZqIy5a8BgMAhvb28BQHh6eoqOHTvK+7zZ9SiEEGvXrpX3GR4eLmJjY0VSUpJ8zE6dOgkA4vPPP692O8vKysoS33333U3XO3DggPzZ4u7uLk8+u/HnwDQmVKFQiOjoaOHh4SFPzOnevbu8v5dffller23btqJv375CCCFGjRol7zMiIkL4+PjI721l40hvZMkYyu+//15e5uvrW+53wI3jPYmE4BhKMsPb2xtxcXH48MMP0b59exgMBiQkJECj0aBv37744osvylXFbvTll1/io48+QlRUFM6fP4+SkhL07t0bW7ZsqVDJAIx/3Tds2BCFhYUICQnBDz/8gHbt2gEAevbsiZdffhmtWrWSb1/k6uqK++67D5s2bZJvlRMVFYV//vkHQ4YMgaOjIxITExEcHIzXX38da9eulY81btw4vPDCC/Dx8cHp06fRp08fvPjii7f0+qxcuRKzZs1CZGQkMjIycPHiRXTu3Bk+Pj4AjBXGpUuXIiYmBllZWTh9+jQaNGiAZ555Bg8++KC8H9PY0V9++eWWjm+ydu1aDBgwoFzXp6+vL+Li4jBu3Dh4e3vj+PHj0Ol06NatG+bMmSNv9/XXX8u3ZHFxccF///tfeHh4YN++fZgxYwY8PT3x888/Izo6GgaDAY6OjjVu5828+OKLeOSRR5CVlQWtVounn34aH3zwQYX1TPW/RiFheO/HX9C530ConTRIOX0KwmBA27vuwYgXXwMAaD08cc+Q4XD39sGVC+eRcSkVjULCMPrlN9B72ChcSjmH86dOlLtdEAB07NUP4954Bx6+DaDLz0No89YYeX2fcjskCa/OW4Swlm2gUDjAYNDjxY8+g9bDq0KbR774f4ho3R4KhQJJxw7j/CnjN7k89/5ctIjtCpVajWKdDuPeeAdBEeWHkzRsHISu/QfB2VWL04mJuHr1Klq3bo2vvvoK9957L4DqX2vz5s1Dy5YtUVxcjL1798rjU0tKSpCUlISkpCT5tlJ5eXnyMsB4fRoMBnn8ZE1JkoT//ve/CAsLQ05ODvbs2YNz585V63oEjGNtn3zySXh7eyMxMRG7d++Wx5BeuXIFe/fuhVKpxEMPPVSj9nl4eGD06NE3Xa9t27ZYtmwZgoODUVhYiKCgICxcuLDCekuWLME999wDJycnFBQUYO7cuWjVqlWF9SZPnozevXvD2dkZBw8elMfAfvLJJxg0aBBcXV2Rm5uLV1991eJbjN2KUaNGYf369ejevTt0Oh1OnjwJrVaLxx57jPevJLMkIW7THXOJqEolJSUIDQ1FSkoKjhw5InfzV8fBgwfRrl07rF271mZvaB4cHIxz585h2rRp1fqGky3J6bX2fd6/LPkK//toJr75+wi0Hp61ss/bxUOtQs9gH6sdf9CgQUhJScGBAwes1oabmTdvHl588UWMGDFCvr8rEd1ZnJRDZCUqlQpvvfUWnn76aXz88cfVvqkyYAyj06ZNQ58+fW5jC+sWL40K14pKauXrF70a+uHxt2bV+TApwXje1tS1a9db+mPnTtPr9Zg7dy4UCoU8DrK+6NSpU6XP1eYsf6LqYIWSiKziViuUydcKcOBS5TPy7VU7P3cEuzvffEWqd8xNBDPhr3a601ihJCKrMN3nrro81Nat1FmLZz09b7o5hkaqSzgph4hsgptaCUXlBRm7pJAArZp/9xNR3cdASUQ2QSFJCNRqUF8ypQQgUKuBoopuTSKiuoKBkohsRoiHc61MyrEFAkCoJ8dOEpFtYKAkIpvhpXGEez3pAnZXK+HpxG8jISLbwEBJRDYlzNPl5ivZgfpynkRkHxgoicimBGo1UNr57BylwjhelIjIVjBQEpFNcVBICLXz6l2opwsc7Dw0E5F9YaAkIpsT6eUKF5WD3c34lgC4qBwQ6eVq7aYQEd0SBkoisjkOCgkd/D3sbsa3ABDj78HqJBHZHAZKIrJJ3hpHhNtZ13e4pwu8NJzZTUS2h4GSiGxWtI/WLrq+TV3d0T5aazeFiKhGGCiJyGY5KCTE+HtYuxm1gl3dRGTLGCiJyKZ5aRzRMcDD2s2wSMcAD3Z1E5FNY6AkIpvXSKtBOz93azejRtr5uaMR7zlJRDaOgZKI7EKwu7PNhcp2fu4Iduf3dROR7ZOEEPZ25w0iqscu5uqwJzUbAOrkbYVMoyQ7BniwMklEdoOBkojsTqauGHvTspFford2UypwUTkgxp9jJonIvjBQEpFd0hsE4tNzkZiVDwnWrVaajh/u6YJoHy1ncxOR3WGgJCK7lqErxj4rVytZlSQie8dASUR2T28QSMjMQ1JWPkoNd+4jT6mQEOrpgkgvV1YliciuMVASUb2hNwhcyNXhdFY+rhWV1npXuGl/HmolQj1dEKjVMEgSUb3AQElE9VKmrhhnsgtwIVcHU9HyVgNm2fUVEhCo1SDU0xmeTuzaJqL6hYGSiOo1gxDILSpFVlEJsgtLkKkrQU5RCQxVbKMA4KZWwUujgoeTCp5qFbRqJRQSq5FEVD8xUBIR3cAgBApK9Cg1CEx65RU4KFX48IP3oZAkKBUSnFUODI9ERGUord0AIqK6RiFJcHU0fjympyQDAGdoExFVgV+9SEREREQWYaAkIiIiIoswUBIRERGRRRgoiYiIiMgiDJREREREZBEGSiIiIiKyCAMlEREREVmEgZKIiIiILMJASUREREQWYaAkIiIiIoswUBIRERGRRRgoiYiIiMgiDJREREREZBEGSiIiIiKyCAMlEREREVmEgZKIiIiILMJASUREREQWYaAkIiIiIoswUBIRERGRRRgoiYiIiMgikhBCWLsRRETWlpeXh1mzZiEnJ6fc8g0bNgAA+vfvX265m5sb3nrrLbi6ut6xNhIR1VUMlEREAFJTU9G4cWMIIaBUKuXlpaWlAFBhmSRJSElJQUBAwB1vKxFRXcMubyIiAAEBARgxYgQcHBxQUlIiP4QQEEKUW+bg4ICRI0cyTBIRXccKJRHRdSdPnkRUVBRu9rEoSRISEhIQERFxh1pGRFS3sUJJRHRds2bNMHLkyHLd2zdSKpUYNWoUwyQRURmsUBIRlXGzKiWrk0REFbFCSURURlVVSlYniYjMY4WSiOgGlVUpWZ0kIjKPFUoiohuYq1KyOklEVDlWKImIzLixSsnqJBFR5VihJCIyw1SllCQJkiSxOklEVAVWKImIKnHy5ElERkbK/2agJCIyj4GSiKgKPXr0AABs27bNqu0gIqrLGCiJiG5gEAIFJXqUGgQMwvhQSBIUkgSlQoKzygEKSbJ2M4mI6ozKvw6CiKgeMAiBnKJSZBeVILuwBJm6EuQUlcBQxTYKAG5qFbw0Kng4qeChVsFNrWTIJKJ6ixVKIqqXMnXFOJNdgAu5OhiufwpKAG7lA7Hs+goJCNRqEOrpDE8nx9ptLBFRHcdASUT1ht4gkJKrQ1JWPq4Vld5ygLwZ0/7c1UqEebogUKuBg4JVSyKyfwyURGT39AaBhIw8JGXno9Rw5z7ylAoJoZ4uiPRyZbAkIrvGQElEdi1DV4x9adnIL9FbrQ0uKgfE+HvAS8OucCKyTwyURGSX9AaB+PRcJGbl13rX9q0yHT/c0wXRPlpWK4nI7jBQEpHdydQVY6+Vq5KVYbWSiOwRAyUR2ZWLuTrsSc0GYN2qZGVMtcmOAR5opNVYtS1ERLWFgZKI7EZydgEOXL5m7WZUWzs/dwS7O1u7GUREFlNYuwFERLXB1sIkABy4dA3J1wqs3QwiIosxUBKRzbuYq7O5MGly4NI1XMzVWbsZREQWYaAkIpuWqSuWx0zaqj2p2cjUFVu7GURENcZASUQ2S28Q2JuWbe1m1Iq9adnQ38GbrhMR1SYGSiKyWfHpucgv0dfJ2dy3QgDIL9EjPj3X2k0hIqoRBkoiskkZumIkZuVbuxm1KjErn13fRGSTGCiJyOboDQL70rJhb983I4Fd30RkmxgoicjmJGTm2UVX941MXd8JmXnWbgoR0S1hoCQim6I3CCTZWVf3jZKy8lmlJCKbwkBJRDblQq4OpXYetkoNAhd4b0oisiEMlERkU07beXXSpL6cJxHZBwZKIrIZmbpiXCsqtXYz7ohrRaWc8U1ENoOBkohsxpnsArub2V0ZCcbzJSKyBQyURGQTDMI4rtC+R0/+S8A4XtQg6ssZE5EtY6AkIpuQU1QKO5+LU4FBALn1pIufiGwbAyUR2YTsohJrN8EqsurpeRORbWGgJCKbkF1YYnb85JxXJmBoZAC2rPyxyu2HRgZgaGQAls//+PY0sIa2rV2B5/reheEtmhjPY9VyzH/9JQyNDMDbjw5FdqExUEqSBEmSsGTJEus2+LpNmzahVatWcHJygiRJmD59OqZPnw5JkhAcHCyvFxwcLD9/K6ZNmwZJkvDmm2/WbsOJ6LZgoCSq43r06CGHidatW5d7LiMjAxqNRn7+9ddfvy1tGDt2rHwMk8LCQvTv3x+SJMHJyQnr16+/Lcc2ydSVVBg/mXL6FHZtXAcPH190G/jgbTnu8vkfY2hkAJ7p2bHW930tIx0L33oFaefOwN3bF+Gt28Hdyxt+TYIQ3rodAsMikKmrexVKg8GAESNG4OjRo9BqtYiNjUVgYCACAwMRGxuLtm3bWnyM5557Dmq1GvPmzUN6enottJqIbieltRtARNV35MgR7NixA3fffTcAYNGiRSgsLLzj7SgoKMADDzyAP//8ExqNBmvWrMG99957245nEALXzHT9/v7j/2AwGNC57wCoHB1v2/Fvl9TkJJSWGM9r+uLlaBQSBgBo36M3hk14GQCQU1RS5ybmpKamIjs7GwDw3XffoW/fvvJzTzzxRK0cw9fXF3369MH69evx7bff4uWXX66V/RLR7cEKJZGNUKlUAID58+cDAPR6PRYsWCAvv9GYMWMQHh4OrVYLR0dHBAUF4YUXXkBOTo68jqny2KNHD3z++ecICgqCk5MT7rvvPqSkpJjdb15eHvr164c///wTLi4uWL9+fbkwmZqaivHjxyMgIACOjo4ICQnBzJkzUVpqnFwydepUSJKEJk2awGAwyNsNHToUkiShX79+AIC4uDj06tUL3t7ecNZo8HTPjvhg4jhcOp8MABBC4K8NawEAHe7pU66NySfj8frDAzCiVVNMGtQbJ/bvrnAeRYU6fDBxHJ7tFYtRbUPxcMtgTOzbFT/M+w9Kio33f3z70aH46fNPAABXUy/I3eZbVi03vhf/9yIm9u2K0e3C8XDLIDzdMwZfz3oLBXm5Zl+7spbP/xhvjR4i//+F/ndjaGQAju3eVa7L2wCgoERvdh8JCQkYNmwYfH194ejoiKioKCxcuPCmx67M2bNnsXr16irXWbJkCRo3biz/v1+/fnJXvLkub3Nudo2YDBgwAADwww8/1OyEiOiOYaAkshFt2rRBSEgI1qxZgwsXLmDdunU4f/48HnroIbPrr127FllZWQgNDUXjxo1x/vx5zJ8/H48//niFdePi4vDqq6/CxcUFJSUl+O233zB48GAIM5WxPn36YOfOndBqtdi4cSN69uwpP5eRkYFOnTph8eLFyMvLQ1RUFFJSUvD222/jqaeeAgA89dRTcHBwQEpKCjZv3gzAWPH87bffABiDsMFgwIABA7BlyxaoVCpEREaiqFCHvX9uQnpaKgAg9WwScjIzAABhLdvIbSgq1OHdpx5F4uEDEMIAfWkJ3nv6sQrnUVpcjL1/bkJxUSECgkPg7u2NS+fOYsWCuVg29wMAQGBYBLwa+gMAlCpHhLduJ3dLA8CeLZuQfy0bfk2C4O0XgPTUi9jw3TdYMOWVKt5JI28/fwSGhsv/bxrVHOGt28HZ1bViW81Mb09MTESnTp2wYsUKGAwGNGvWDCdPnsSECRMwY8aMSo9bUFCA5ORks4/p06dj2LBhWL58eaXb+/r6ok2bNvL/o6KiEBsbC19f35ueM1C9a8SkY0fjMIODBw8iP5/fHERUlzFQEtkIhUKBiRMnorS0FAsXLpQrlc8//7zZ9bdv34709HQcOnQISUlJmDJlCgBgzZo1FbrJ9Xo99u7di/j4eCxYsAAAcODAAWzatKnCfuPi4iBJEn799Vd069at3HOfffYZUlJS0LBhQyQlJeHw4cNYsWIFAGNl6/Tp02jcuDHuv/9+AMA333wDANi4cSMKCgrg5uaGwYMHIysrCxkZxrC4f/9+bPtnDxbvOoo5v2xF47AIAEDaubMAAGdXLVzdPeQ27Fy/GpmX0wAAry9Ygk9/3Y4xr0+rcB5qjTPmrt+Gr/86jI9X/4Gvtu3H3Q8MBQD8fb3y+dS099H7oZEAAE/fBvhg+Xp8sHw92vfoDQCY+e1KLIk7jtlrNmPBH/9g6DMvAgD2/PkbiouqHorQe9hoPPn2+/L/X5v/DT5Yvh4hzVtVWNdcl/d7772Ha9euoUWLFkhJScHRo0cxZ84cAMAHH3yA3FzzVdJNmzYhMjLS7GP58uVwcHDA6NGjKw2V999/f7kq5oIFCxAXFye/pzdTnWvEJCgoCABQWlqK5OTkau2fiKyDgZLIhowfPx4uLi6YP38+tm7divbt26Nz585m1928eTNatGghT9p59913ARh/OV+9erXcui1btkTz5s0BACNHjpSXHz161Oy+hRCYO3cuSkrKj2vcs2cPAODy5cto0KABJEnC4MGD5W127zZ2PT/77LMAjOE2KysLK1euBAAMGzYMGo0G3t7e8nmFhYXhrg7t8MmkZ3H2xDFoPb0AQO5WdnIpX9FLSTwFAFBrNGjb7R4AQNd+D1Q4B0mhwI51K/Fc37vwcMtgDI0MwI51xnZkXbls9rxvdGTXTrw08B6MbB2CoZEBWPnFpwAAfWmpXD2tDeYCpem1PnbsGFxcXCBJEl566SUAgE6nw5EjR8zua8iQISgsLKz0kZubC39/f8yaNavW2m+u3Te7RgDAzc1N/ve1a9duS3uIqHZwUg6RDfHw8MAjjzyCL7/8EkDl1cnvv/8ekydPBgD4+/ujcePGSE9Px5kzZwAYK5I1NWnSJHzyySdYtWoVHnroIfz8889wvGFCjFarRXR0dIVtnZ2dAQB9+/ZFaGgokpKSsHjxYnmG+JgxY+R1//zzTyxbtgx///03jhw7jrjff8XfG9Yi6+plDH58AjTXg2Rhgfmu0LIz0s1Z/d/PsOorY5XXNyAQHr4NkHEpDZmX08qN7azMjl9WYel/jF3Lnr4NEeQfhZysTFxOOQcAMOhvvo/qUlRxLj4+PggNDa2w3MHBwez6K1aswLBhw6o8nkqlwrx5826tkbfoZtcIgHLjfcuGSyKqe1ihJLIxzz33HADjWLYRI0aYXScuLg6A8Zf22bNnsXv37ipnYR89ehQnTpwAgHJdnS1btqyw7uzZs+XbE61btw6DBw9GUVERACAmJgYAoFQq8eOPPyIuLg5xcXH4448/MGHCBAwZYpyEIkkSnn76aQDA22+/jdzcXDRt2hR33XUXAGOlateuXRg7diy++eYbbN7xF3oNNVZO4/caz80/uCkAoCA3B/k5/1avGocbu8QLCwpw6K9tAIB/NlW8pdGpQ/sBAAHBIfhiyx68u2wtgiMrBhy1RgPAODaz7JhS0/YaF1cs/DMOH/z0K1p37V7xxa0F5gKl6bV2d3fHhg0b5Nd6/fr1ePnll9GpUyez+xo4cCDS0tLMPsaPHy+/d6b3qrZV9xoBgHPnzsnrNm3a9La0h4hqByuURDamRYsWyMjIgFKphFqtNrtOq1bGcXi5ubkICQmBWq2usstQrVajffv2aNq0KRISEgAYJwGVvR1MWe+//z5UKhVmzpyJjRs34oEHHsCaNWswceJELFq0CBcvXkSzZs0QFRWF3NxcpKSkoKSkBI899u/kmPHjx2Pq1KnyZIvHHntMrirq9Xr07t0bWq3WOKNYkpBwPfAGNTOGvkZNw+Dm5Y2czAwkHT+CVp2N4zm7DRiC5fM+RuaVS3j/2bHwCwpGeuqFCucQ1Cwa+7dtRmryGTzbKxalpaUoNnMLJtOtfHIyM/B8v25w9fDASx9/LrdDl5+HCb07Q+noiIJKxi1aSqmoGCjfeOMNrF69GklJSWjcuDEiIiKQmZmJixcvIjAwEA8//LDZfanVavj5+Zl9btq0aRg8eDAGDhxYq+0v61auEVP3eNu2beHi4nLb2kRElmOFksgGeXl5VdkF+Pjjj2PSpEnw8fFBbm4uevToUeXM3w4dOmDevHnIz8+HSqXCvffeizVr1lTZbTxjxgzMnDkTAPD7779jwIABcHFxQVxcHMaNGwdvb28cP34cOp0O3bp1kyeMmHh7e2P48OHy/8sGCQcHBzzzzDNo2rQpLl68iDNJSfBt1BgPjH8Gwyca70coSRLu6j8IALBv6x/ytmonDd788n/lZn6/Nv/rCu0f+vQL6DF4OFzc3FGQl4e7+j+AfqPGVFivfY8+6D1sNLQenkg7dwaJhw+gWKdDr4dGYuDYp+Hm6QVdfh5adOyMES9MrvT1qikFAGdVxe7rZs2a4Z9//sGwYcPg7OyM48ePw2AwoF+/fvL7cquaNGlyW8MkYKysV/caMQ2FKDuul4jqJkmYuy8IEdULY8eOxdKlS9G9e3ds27btjh//gw8+wBtvvIFu3bphx44dVa67JTm9wvd5p5w+hUkP9ISbtw+++HOPTd7c/GY81Cr0DPaxdjPuuKtXr6Jx48ZQqVRITk6Gt7e3tZtERFVglzcR3XGrVq3CsmXLsHHjRgDAq6++etNtvDQqXCsq//WLjcMi0OW+B/DXr2uw85dV6DnU/JhSa/nqnTdwJt78TPmn3n7P7C2CypJgPO/6aP78+SgqKsIrr7zCMElkAxgoieiOO3LkCFauXAlfX19MmTKlWt2sHk6qCt/lDQAvz16Al2cvqP1G1oILp08h8fABs88V5OXddHsB43nXRzNmzKhymAYR1S3s8iYim5BdWIIt59Kt3Yw7rleQD9zraagkItvBSTlEZBPc1EqYmexs1xQSoFWzI4mI6j4GSiKyCQpJQqBWg/qSKSUAgVpNlTc1JyKqKxgoichmhHg4mx1HaY8EgFBP55uuR0RUFzBQEpHN8NI4wr2edAG7q5XwdLK/2yARkX1ioCQimxLmWT++MaW+nCcR2QcGSiKyKYFajdmvIrQnSoVxvCgRka1goCQim+KgkBBq59W7UE8XONh5aCYi+8JASUQ2J9LLFS4qB7ub8S0BcFE5INLL1dpNISK6JQyURGRzHBQSOvh72N2MbwEgxt+D1UkisjkMlERkk7w1jgi3s67vcE8XeGk4s5uIbA8DJRHZrGgfrV10fZu6uqN9tNZuChFRjTBQEpHNclBIiPH3sHYzagW7uonIljFQEpFN89I4omOAh7WbYZGOAR7s6iYim8ZASUQ2r5FWg3Z+7tZuRo2083NHI95zkohsHAMlEdmFYHdnmwuV7fzcEezO7+smItsnCSHs7c4bRFSPXczVYU9qNgDUydsKmUZJdgzwYGWSiOwGAyUR2Z1MXTH2pmUjv0Rv7aZU4KJyQIw/x0wSkX1hoCQiu6Q3CMSn5yIxKx8SrFutNB0/3NMF0T5azuYmIrvDQElEdi1DV4x9Vq5WsipJRPaOgZKI7J7eIJCQmYekrHyUGu7cR55SISHU0wWRXq6sShKRXWOgJKJ6Q28QuJCrw+msfFwrKq31rnDT/jzUSoR6uiBQq2GQJKJ6gYGSiOqlTF0xzmQX4EKuDqai5a0GzLLrKyQgUKtBqKczPJ3YtU1E9QsDJRHVawYhkFtUiqyiEmQXliBTV4KcohIYqthGAcBNrYKXRgUPJxU81Spo1UooJFYjiah+YqAkIrqBQQgUlOhRahCY9MorcFCq8OEH70MhSVAqJDirHBgeiYjKUFq7AUREdY1CkuDqaPx4TE9JBgDO0CYiqgK/epGIiIiILMJASUREREQWYaAkIiIiIoswUBIRERGRRRgoiYiIiMgiDJREREREZBEGSiIiIiKyCAMlEREREVmEgZKIiIiILMJASUREREQWYaAkIiIiIoswUBIRERGRRRgoiYiIiMgiDJREREREZBEGSiIiIiKyCAMlEREREVmEgZKIiIiILMJASUREREQWYaAkIiIiIoswUBIRERGRRZTWbgARUV1QUlKCn376CTk5OeWWJycnAwAWLlxYbrmbmxuGDx8OlUp1p5pIRFRnSUIIYe1GEBFZ29mzZxESEgIAkCRJXm76iDS37MyZM2jatOkdbCURUd3ELm8iIgBNmzZFr1694ODgACGE/DApu8zBwQG9evVimCQiuo4VSiKi63bt2oWuXbtWa92///4bXbp0uc0tIiKyDaxQEhFd16VLF7lKWRlTdZJhkojoX6xQEhGVUZ0qJauTRETlsUJJRFRGVVVKVieJiMxjhZKI6AZVVSlZnSQiqogVSiKiG5irUrI6SURUOVYoiYjMMFelZHWSiMg8ViiJiMwwVSklSYIkSaxOEhFVgRVKIqJKlK1SsjpJRFQ5BkoioiqYvg3n7NmzVm4JEVHdxUBJRHQDgxAoKNGj1CBQqtfDAECpUEAhSVAqJDirHKAo893eRET1ndLaDSAisiaDEMgpKkV2UQmyC0uQqStBTlEJDFVsowDgplbBS6OCh5MKHmoV3NRKhkwiqrdYoSSieilTV4wz2QW4kKuD4fqnoATgVj4Qy66vkIBArQahns7wdHKs3cYSEdVxDJREVG/oDQIpuTokZeXjWlHpLQfImzHtz12tRJinCwK1GjgoWLUkIvvHQElEdk9vEEjIyENSdj5KDXfuI0+pkBDq6YJIL1cGSyKyawyURGTXMnTF2JeWjfwSvdXa4KJyQIy/B7w07AonIvvEQElEdklvEIhPz0ViVn6td23fKtPxwz1dEO2jZbWSiOwOAyUR2Z1MXTH2WrkqWRlWK4nIHjFQEpFduZirw57UbADWrUpWxlSb7BjggUZajVXbQkRUWxgoichuJGcX4MDla9ZuRrW183NHsLuztZtBRGQxhbUbQERUG2wtTALAgUvXkHytwNrNICKyGAMlEdm8i7k6mwuTJgcuXcPFXJ21m0FEZBEGSiKyaZm6YnnMpK3ak5qNTF2xtZtBRFRjDJREZLP0BoG9adnWbkat2JuWDf0dvOk6EVFtYqAkIpsVn56L/BJ9nZzNfSsEgPwSPeLTc63dFCKiGmGgJCKblKErRmJWvrWbUasSs/LZ9U1ENomBkohsjt4gsC8tG/b2fTMS2PVNRLaJgZKIbE5CZp5ddHXfyNT1nZCZZ+2mEBHdEgZKIrIpeoNAkp11dd8oKSufVUoisikMlERkUy7k6lBq52Gr1CBwgfemJCIbwkBJRDbltJ1XJ03qy3kSkX1goCQim5GpK8a1olJrN+OOuFZUyhnfRGQzGCiJyGacyS6wu5ndlZFgPF8iIlvAQElENsEgjOMK7Xv05L8EjONFDaK+nDER2TIGSiKyCTlFpbDzuTgVGASQW0+6+InItjFQEpFNyC4qsXYTrCKrnp43EdkWBkqiO2T69OmQJAnBwcHWbkqNLVmyBJIkQZIkJCcn39FjZxeWWG385DM9O2JoZACWz/8YAHBs9y4MjQzA0MgAXLmQctuOK8F43pU5ceIEHBwcEBISAr1eLy//9ttvERERAZVKBUmSsGTJEowdOxaSJKFHjx7/7v/6e7lkyZJbateYMWMgSRK++uqrWzyjmjG10/Q4dOjQHTnu7RYcHFzuvLZt22btJhHVGAMl2bQePXpU+GVjeqxZs8YqbTL9kpg+fXq55YGBgYiNjUXbtm1vy3G3bdtW4TXQarVo3rw5Zs2ahfx8274NTaauxOLxk7UVBJ1dXRHeuh3CW7eDytHRwlZVTsB43pV55513YDAY8OKLL8LBwQEAcOXKFTz++ONITExEw4YNERsbC19fX4SGhiI2NhbR0dEWt+uVV14BAMyaNQslJXeughoVFYXY2Fi4uLgA+PePtFv546ayn8/qMn3mjB079pa3DQ4OLhfo27Zti9jY2Bq1g6iuUVq7AUS1wdHRsUJQ8/LyslJrzHviiSfwxBNP3JFjhYSEwNfXF+fPn0d8fDymTp2KPXv2YN26dXfk+LXNIASu1aGu35DmrfDB8vV35Fg5RSUwCAGFVL4+e/nyZaxcuRIODg4YOXKkvPzUqVNyyPvzzz/RrFkzAMD999+PqVOn1kqbWrVqhRYtWuDYsWNYv349hgwZUiv7vZkFCxaUC2S2bvXq1QCMFVgiW8cKJdkFf39/xMXFlXvcfffdSE5ONtuddGOVomx1b+3atbj77ruh0WgQGRmJ9evLB4fExESMGjUKfn5+cHR0RGBgICZPniwf69y5cwCM1SPTPgHzXd56vR6zZ89GdHQ01Go13N3d0adPH+zcuVNe51baZjJ16lTExcUhJSVFroD88ssvyMrKAgBkZmZi4sSJaNy4MVQqFRo2bIhHHnkE58+fL7ef+fPno1GjRnBxccHo0aNx7dq1Cscq276yr3Fubi4mT56M0NBQODo6wtvbG/369YNOp7vlc3dQKHC5TEXRVGXcsmo5AGDLquXysqNxf2Pyg/diZOsQTH7wXpw6tB8AsHz+x5g25iF5H8/2jsXQyADMf/0ls69hVcxVOue//hKGRgbg7UeHYuP3i/FMz44Y3S4c7z39GLKuXim3/fZ1K/HaQ/dhZJsQjG4XjplPjMLZE8fk5/V6Pb6b/R6e7d0Jw1s1hY+3Nzp06ICPPvpIXmfFihUoLS1Fx44d0aBBAwDGa6xbt27yOpGRkfL7Yq7L25yEhAQMGzYMvr6+cHR0RFRUFBYuXFhhvQEDBgAAfvjhh1t78a4zGAz4/PPPa7XCmZeXh2effRaNGzeGWq2Gr68vunbtiqVLl9705/PQoUPo1asX/P39oVar4eLigpiYGHz33Xfy/iVJwvbt2wEAS5cuLTf8o6pjE9UHDJRENxg2bBguXboESZJw8uRJjBo1CpmZmQCA06dPo2PHjvjhhx+Qnp6OsLAw6PV6bN68GWq1GrGxsXC83gXaqFEjxMbGVtml9fTTT2Py5Mk4ceIEmjRpAqVSic2bN6Nnz57yL67qtq26CgsL0b17dyxYsACXLl1CREQEcnJy8P3336Nz5864evUqAGMAfeGFF5CamgoXFxfs3LkTU6ZMqdYxiouL0aNHD8yePRtnzpxBQEAAvLy88Pvvv6OoqKhG515d7z71CIp0Ouj1pTgbfwyfTHoW+tJSePv5IzA0XF6vaVRzhLduB78mQTU+ljknD+3D//4zE0qVIwoL8rF/+2Ys/fAd+fk1iz7HvNeeR9Kxw/DxC4CzqxaH/tqGt0YPxoWkRADAb98vxur/fob0tIsIaBoKTy9vHD16FL/++qu8n7/++gsAEBMTIy8LDAxEVFSU/P82bdogNjYWbm5u1Wp7YmIiOnXqhBUrVsBgMKBZs2Y4efIkJkyYgBkzZpRbt2PHjgBQ7g8Ac86fP4/k5OQKj19++QXPP/88Hn744VoLlW+//Ta++OILXL16Fc2bN4dWq8Xu3buxdevWm/58JicnY9u2bVCr1WjevDnUajX27duHRx99VH7dY2NjodVqAQA+Pj7y9mq1uspjE9ULgsiGde/eXcA41KzCQwghzp49K/9/69at8nZBQUECgJg2bZoQQoitW7fK602aNEkIIcTatWvlZRs3bhRCCDFu3DgBQKhUKvH333/L+ztw4ECl+zaZNm2aACCCgoKEEEKcPn1aSJIkAIgXX3xRCCFEdna2vP3dd999S20ru15ISIiIjY0V/v7+8rKBAwcKIYT45ptv5GWrV68WQgixf/9+oVAoBADx9ttvCyGEuOuuuwQAERoaKnJzc0Vpaano0aOHvO3Zs2eFEELs3r1bNGvWTDRr1kzs3r1bCCHE0qVL5fX+85//yK/BsWPHRFFRUY3OfeHm3WJlQqpYmZAqL5v43hyxMiFVTHxvjrzs8SkzxcqEVDH+zRnysk83bBcrE1LFO0tXmN3fzR6+AYECgBg+cVKl++kxeLgAIBQKhZi95g+xMiFVxPa5TwAQHj6+YmVCqlh28LRQazQCgHj4+cliZUKq+OnYeRHaorXxvB8YKlYmpIr7Rhuvs97DRomVCakio6BI5Obmij179sivZfv27QUA8cknn5S7zsq+Zqb3SAghxowZIwCI7t27y8tM6y1evFgIIcTYsWMFANGiRQuRn58vhBBi7ty5AoDQaDQiJydH3nb//v3y9nl5eaIy3t7eQq1WV/qQJEkMGTJEFBcXV7oPcz/D5gwYMEAAELNmzZKXZWRkiEOHDsn/r+znMy0tTVy6dEn+v06nE2FhYQKAeOSRR+Tlps+cMWPG3PKxLT0/orqMFUqyC46OjnK14GZVwZt59NFHAaDc5IXLly8DAHbv3g0A6N69O7p06SI/X5OJNvv374e4ftPqUaNGAQDc3d3Rv39/AMC+fftuqW1lnTlzBrt370ZOTg6io6MxY8YMuWty7969AABnZ2cMHjwYANCuXTt5rJ3puMePHwcA9O3bF66urnBwcMCDDz5Y4VgdO3ZEQkICEhIS5KqV6XVSq9WYNGmSvG7z5s3h6OhYo3Ovru6DjN3agWER8rJr6ek13t+tahIRieDI5sY2hBrbkJ1urPqmnD6Foutd/svnf4yhkQEY3qIJko4dBgCcOnwAANC+Rx9IkoTNPy/Dk3e3wwP9+mDWrFnlxgWbhh+YKma1Yc+ePQCAY8eOwcXFBZIk4aWXXgIA6HQ6HDlyRF63bNXT3FAIk/T0dBQWFlb6mDx5MlavXl1u3zU1cOBAAMYhH0FBQejbty/mz5+Phg0b3nRbSZLwyiuvICAgAEqlEhqNBqdPnwYApKam3tZjE9kDTsohu2AaQ3mjsoPdy95WpapfgB4eHgAApfLfHw9RR76tpLptW7x4cY1mod4Olkw4KLutwWB8//Jzc6rcxsXNHQDg4GCd989F6y7/2zTz2pzA0HBoXMuHQa2HJwCgbbce+GjVJuz6bT3OJcQj6VQ8/t6xA0uWLMHp06fh6uoqB7q8vLxaPwcfHx+EhoZWWF72fHJy/n0fqupSd3V1vekdBoYPH442bdrcekNv8NRTTyEyMhLr1q3D0aNHsX//fvz+++/4+eefcezYsSq3feSRR7B582ZIkoTo6Gi4uroiPj4eubm55T47bsexiewBK5Rk10yTFQDj7FcA2Lx5M7Kzs2u0P1Plc/v27XIVDgAOHz4s/9vZ2RkAbvpLtH379nJgWrZsGQBj0N2wYQMAoEOHDjVq482YxtwVFBTIt1Y6cOAATp48We64zZsbq2y///478vPzodfr5VmpZe3ZsweRkZGIjIyUK1ym16moqAhz586V1z1x4gSKi4urfe5l37/U5DMAgH9++6XG567WaOR/F+ru/PdkNw6LgKOTEwCgzV334P0ff8EHy9fjg+Xr8dS09zH06RcAAMkn4+Hm5Y3RL7+ON7/8H7btMv6xdPnyZfl9Cg83jgc1TTKpDaZrw93dHRs2bJAnuK1fvx4vv/wyOnXqJK9rOq6fnx9cXV0r3eeZM2eQlpZW4bFx40ZIkoRhw4bh+++/rzJ8V9eePXvQvHlzfPzxx9i0aZM8ae348ePIyMgAUPnPp+kP0ieffBLHjh3Dhg0bzJ5XZdtX59hE9oyBkuyaRqNB586dARjvndezZ08MGjQICkXNLv0333wTHh4eKCkpQdeuXdG8eXM0atQIY8aMkdeJjIwEAMybNw8xMTEYN26c2X2FhoZi/PjxAIBPP/0U4eHhCAkJwblz56BUKvHOO++Y3c5SI0eORIsWLQAYJ/k0b94cXbt2hcFgQEBAAJ577jkAwOTJkwEYJyKFhIQgJCQEu3btqrC/goICnDx5EidPnkRBgTGkjRgxAu3atQNgfN2bNm2KiIgItGjRAgUFBdU+9/DwcDRp0gQAMHfyRLz92EP474zqTQwyx69xEJQqFQDgnfEP4/WHB+Cf3+7M7X8AQK1xxrBnXwYArF/6FZ7q3h6vDO6NMbHN8eqDfXH4b+NkpF0bf8HTPTrg6Xs64NUH+6JrjPG1dHZ2liuHptnclgwPuNEbb7wBNzc3JCUloXHjxmjbti2CgoLg5+eH//u//yu3rumPh7Kzys1p0KAB/Pz8Kjz69u2LL774AsuWLStXcbfEvHnz4Ofnh6ZNm6J9+/bo27cvAOMEHNNwgcp+Plu1agUAWLRoEZo3b47Q0FAUFhZWOIZp+1WrVqFdu3bo169ftY9NZM8YKMnuLVmyRP6ld+HCBSxYsACNGzeu0b7CwsKwZ88ejBw5Et7e3khMNM7K7dWrl7zOrFmz0KlTJygUCuzbtw9Hjx6tdH9ffvklPvroI0RFReH8+fMoKSlB7969sWXLltt2vz0nJyds374dEyZMgJ+fH06dOgWtVovRo0fjn3/+ga+vLwBg0KBBmDNnDvz8/JCbm4sOHTpg1qxZ1TqGo6Mjtm7dKofJixcvIiMjA71794Zara72uSuVSixfvhxt27ZFSVER8q5l47XPvq7xuWs9vTB+ykz4+AfgWvpVJB4+gKz0KzffsBY9+PTzeP6DTxHWsg3ycrJx6Xwy3L29ce+IxxB7r3EMaXSHWLTpdg8MBoHziScBIdCzZ09s3LhRHvbw0EMPQalUIi4uDum1NEa0WbNm+OeffzBs2DA4Ozvj+PHjMBgM6NevH2bOnFluXVMFruw9MG+FJEl46qmnai1MAsZ7bXbr1g06nQ5Hjx6Fk5MTBg4ciA0bNsgV8cp+PpcsWYJ77rkHTk5OKCgowNy5c+WQWdbkyZPRu3dvODs74+DBg3Kgr86xieyZJOrK4DAioipsSU6vl9/n7aFWoWewj9nnRowYgeXLl2PevHl4/vnn71ibjhw5gtatW6Nx48ZISkqC6nrV93YxBbKoqCi4ubnh22+/lbv8bdmQIUOQlpYmD5/ZunWrXd24neoXTsohIpvgpVHhWpHlX79ozusPD6j0uTv1jTjmSDCed2WmTZuGn3/+GXPnzsWECRNqZRxidXz8sfE7zadOnXrbw2RZJ06cAHDz8cm24uDBg7U6BpbImlihJCKbkHytAAcuVT473xJDIwMqfW5lws1vGXM7tfNzR7C7s1XbQER0M6xQEpFN8FDfvkqYtUNjVTxv43kTEdUWTsohIpvgplZCUc/mNigkQKvm3/1EVPcxUBKRTVBIEgK1GtSXTCkBCNRqoOAMYSKyAQyURGQzQjycb8uknLpIAAj15NhJIrINDJREZDO8NI5wryddwO5qJTydHK3dDCKiamGgJCKbEubpYu0m3BH15TyJyD4wUBKRTQnUaqC089k5SoVxvCgRka1goCQim+KgkBBq59W7UE8XONh5aCYi+8JASUQ2J9LLFS4qB7ub8S0BcFE5INLL1dpNISK6JQyURGRzHBQSOvh72N2MbwEgxt+D1UkisjkMlERkk7w1jgi3s67vcE8XeGk4s5uIbA8DJRHZrGgfrV10fZu6uqN9tNZuChFRjTBQEpHNclBIiPH3sHYzagW7uonIljFQEpFN89I4omOAh7WbYZGOAR7s6iYim8ZASUQ2r5FWg3Z+7tZuRo2083NHI95zkohsHAMlEdmFYHdnmwuV7fzcEezO7+smItsnCSHs7c4bRFSPXczVYU9qNgDUydsKmUZJdgzwYGWSiOwGAyUR2Z1MXTH2pmUjv0Rv7aZU4KJyQIw/x0wSkX1hoCQiu6Q3CMSn5yIxKx8SrFutNB0/3NMF0T5azuYmIrvDQElEdi1DV4x9Vq5WsipJRPaOgZKI7J7eIJCQmYekrHyUGu7cR55SISHU0wWRXq6sShKRXWOgJKJ6Q28QuJCrw+msfFwrKq31rnDT/jzUSoR6uiBQq2GQJKJ6gYGSiOqlTF0xzmQX4EKuDqai5a0GzLLrKyQgUKtBqKczPJ3YtU1E9QsDJRHVawYhkFtUiqyiEmQXliBTV4KcohIYqthGAcBNrYKXRgUPJxU81Spo1UooJFYjiah+YqAkIrqBQQgUlOhRahCY9MorcFCq8OEH70MhSVAqJDirHBgeiYjKUFq7AUREdY1CkuDqaPx4TE9JBgDO0CYiqgK/epGIiIiILMJASUREREQWYaAkIiIiIoswUBIRERGRRRgoiYiIiMgiDJREREREZBEGSiIiIiKyCAMlEREREVmEgZKIiIiILMJASUREREQWYaAkIiIiIoswUBIRERGRRRgoiYiIiMgiDJREREREZBEGSiIiIiKyCAMlEREREVmEgZKIiIiILMJASUREREQWYaAkIiIiIoswUBIRERGRRZTWbgARUV1x+PBh5OTklFuWkZEBANi5c2e55W5ubmjduvUdaxsRUV0mCSGEtRtBRGRtiYmJiIiIuKVtTp06hfDw8NvUIiIi28EubyIiAGFhYWjRogUkSbrpugqFAi1atEBYWNgdaBkRUd3HQElEBECSJMycORPV6bQxGAyYNWtWtcInEVF9wC5vIqLrhBBo1aoV4uPjYTAYzK6jUCgQHR2NI0eOMFASEV3HCiUR0XWmKmVlYRJgdZKIyBxWKImIyqiqSsnqJBGReaxQEhGVUVWVktVJIiLzWKEkIrqBuSolq5NERJVjhZKI6AbmqpSsThIRVY4VSiIiM0xVymPHjgEAWrRoweokEVElWKEkIjLDVKU0YXWSiKhyrFASEVVCCAEvLy8AQGZmJgMlEVElGCiJiG5gEAIFJXqUGgQupqZCSBIC/PygkCQoFRKcVQ5QMFwSEckYKImoXjMIgZyiUmQXlSC7sASZuhLkFJWg8lubG8cKualV8NKo4OGkgodaBTe1kiGTiOotBkoiqpcydcU4k12AC7k6GK5/CkoAbuUDsez6CgkI1GoQ6ukMTyfH2m0sEVEdx0BJRPWG3iCQkqtDUlY+rhWV3nKAvBnT/tzVSoR5uiBQq4GDglVLIrJ/DJREZPf0BoGEjDwkZeej1HDnPvKUCgmhni6I9HJlsCQiu8ZASUR2LUNXjH1p2cgv0VutDS4qB8T4e8BLw65wIrJPDJREZJf0BoH49FwkZuXXetf2rTIdP9zTBdE+WlYricjuMFASkd3J1BVjr5WrkpVhtZKI7BEDJRHZlYu5OuxJzQZg3apkZUy1yY4BHmik1Vi1LUREtYWBkojsRnJ2AQ5cvmbtZlRbOz93BLs7W7sZREQW43d5E5FdsLUwCQAHLl1D8rUCazeDiMhiDJREZPMu5upsLkyaHLh0DRdzddZuBhGRRRgoicimZeqK5TGTtmpPajYydcXWbgYRUY0xUBKRzdIbBPamZVu7GbVib1o29HfwputERLWJgZKIbFZ8ei7yS/R1cjb3rRAA8kv0iE/PtXZTiIhqhIGSiGxShq4YiVn51m5GrUrMymfXNxHZJAZKIrI5eoPAvrRs2Nv3zUhg1zcR2SYGSiKyOQmZeXbR1X0jU9d3QmaetZtCRHRLGCiJyKboDQJJdtbVfaOkrHxWKYnIpjBQEpFNuZCrQ6mdh61Sg8AF3puSiGwIAyUR2ZTTdl6dNKkv50lE9oGBkohsRqauGNeKSq3djDviWlEpZ3wTkc1goCQim3Emu8DuZnZXRoLxfImIbAEDJRHZBIMwjiu079GT/xIwjhc1iPpyxkRkyxgoicgm5BSVws7n4lRgEEBuPeniJyLbxkBJRDYhu6jE2k2wiqx6et5EZFsYKInIJjw7bgyGRgZgy8ofrd2UO0YCkF34b6CcPn06JElCcHCw1dpUlatXr+LBBx+El5eX3M7k5GRIkgRJkrBt2zYANT+P06dPw8HBAU2bNkVxMScsEdUlDJREdUSPHj3kX7ytW7cu91xGRgY0Go38/Ouvv35b2jB27Fj5GCaFhYXo378/JEmCk5MT1q9ff1uOXZX4+Hj8vnYVPHx80W3gg9Xebv7rL2FoZADefnRojY67fP7HGBoZgGd6dqzR9pYSADJ1/wbKwMBAxMbGom3btlZpz83MmjULq1evRk5ODtq3b4+2bdtCrVYjNjYWsbGxcHNzs2j/YWFhGDx4MJKTk/HNN9/UUquJqDYwUBLVQUeOHMGOHTvk/y9atAiFhYV3vB0FBQUYMGAANm7cCI1Gg3Xr1mHAgAF3vB0LFy6EwWBA574DoHJ0vOPHt6acohJ5Ys4TTzyBuLg4rF692sqtMu/48eMAgGHDhmHfvn1YvXo1/P39ERcXh7i4OLRr187iY4waNQqA8ZogorqDgZKojlGpVACA+fPnAwD0ej0WLFggL7/RmDFjEB4eDq1WC0dHRwQFBeGFF15ATk6OvI6p8tijRw98/vnnCAoKgpOTE+677z6kpKSY3W9eXh769euHP//8Ey4uLli/fj3uvfde+fnU1FSMHz8eAQEBcHR0REhICGbOnInSUuMkkqlTp0KSJDRp0gQGg0HebujQoZAkCf369QMAxMXFoVevXvD29oaTkxOCg4MxePBgJCUlAQCEEPhx+XIAQId7+pRr47pvvsDz93XDyDYheLRDM0wa1BtL/zMDAPBMz47YtuYnAMDxvf9gaGQAhkYG4NjuXSgq1OGDiePwbK9YjGobiodbBmNi3674Yd5/UHK9K/XtR4fip88/AQBcTb0gb79l1fKbHvtWXb5wHrv/2Gj2OQOAghI9APNdxRs2bEDnzp3h4eEBZ2dnhIWF4eGHH0ZWVta/r9O6dbjrrrvg6uoKJycntG3bFl9//XW545gq07Nnz8YjjzwCrVaLRo0aYdasWdU6B0mS8OeffwIAfvzxR/l6M9flbfY8DQZ8+umnaNGiBZycnODp6Ylhw4bh7Nmz5da777774ODggCNHjiA+Pr5abSOi24+BkqiOadOmDUJCQrBmzRpcuHAB69atw/nz5/HQQw+ZXX/t2rXIyspCaGgoGjdujPPnz2P+/Pl4/PHHK6wbFxeHV199FS4uLigpKcFvv/2GwYMHQ5i5NU2fPn2wc+dOaLVabNy4ET179pSfy8jIQKdOnbB48WLk5eUhKioKKSkpePvtt/HUU08BAJ566ik4ODggJSUFmzdvBmCseP72228AjEHYYDBgwIAB2LJlC1QqFaKiolBQUIC1a9fKQffUqVNIv3oVABDWso3chr1bNmHpf2Yg9WwSGgQ2gWeDhkg7dwb//Gbskm8a3QJunl4AAI2LK8Jbt0N463ZwdnVFaXEx9v65CcVFhQgIDoG7tzcunTuLFQvmYtncDwAAgWER8GroDwBQqhzl7d29vG96bHOKdAW4ciHF7OOn+bPx8UtP4e8Na81uW9lXTV69ehVDhgxBXFwc3N3dER4ejoyMDPz000+4du0aAOC7777DoEGD8Pfff8PV1RV+fn44dOgQnnjiCbz77rsV9vnGG29gy5YtcHJyQmpqKqZOnYo//vij0vMyiY2NhVarBQD4+PggNjYW0dHRN93O5LnnnsNLL72E48ePIywsDA4ODlixYgW6dOmCK1euyOs5OzujefPmAICdO3dWe/9EdJsJIqoTunfvLgCI2NhYMXv2bAFAvPnmm+Kee+4RAMSuXbsEjMPqxP/93//J2x06dKjcfqZMmSIACKVSKXQ6nRBCiDFjxsjLjh07JoQQ4osvvpD3t3HjxnLrmR6SJIkdO3ZUaOv06dMFANGwYUNx5coVIYQQa9askbdJTEwUQgjxwAMPCADi4YcfFkIIsWLFCgFAuLm5iYKCApGeni4f68KFC/L+jx07Ji5fviyEEOKXX34RAISzq1asTEiVH2Nee1sAEK26dJOX/XjkrHh32Vr5/z0GDxcARPOYzuW2XX70nJi7flu5ZXc/MFQAEN5+/vKy4RMnCQDCNyDwlo994+O1+V8LlaO60odS5SgUDg5i0icLK2ybUVAkhBBi2rRpAoAICgoSQgixb98+AUBotVpRUFAghBDCYDCIPXv2iLy8PCGEEE2aNJGvq8LCQmEwGMSQIUMEAKHRaER+fr4QQsjvQ+fOnUVRUZG4evWqUKlUFa636lzDY8aMkZedPXtW3vfWrVvNnseZM2eEJEkCgFi6dKkQQojc3FwRGBgoAIi33nqr3HEGDhwoAIjJkydXq11EdPuxQklUB40fPx4uLi6YP38+tm7divbt26Nz585m1928eTNatGghT9oxVZ1KS0tx9Xplz6Rly5ZydWfkyJHy8qNHj5rdtxACc+fORUlJ+VvX7NmzBwBw+fJlNGjQAJIkYfDgwfI2u3fvBgA8++yzAIA1a9YgKysLK1euBGAcY6fRaODt7S2fV1hYGFq2bImRI0fi4MGD8PHxAQC50ubk4lquDW3u6gGlyhFHdu3EuM4tMGXUIPzvo1lQazRmz6UsSaHAjnUr8Vzfu/Bwy2AMjQzAjnXGtmVduXzT7Wty7Ng+9+HHI2crfXy3/xQ8fRtgxcJPK2xb2c3NmzdvjpCQEOTm5qJBgwZo164dxo4di7S0NLi4uODKlSs4f/48AODBBx+EWq2GJEkYMWIEAECn08njHk2GDx8OR0dH+Pj4oEGDBgCM7/PttG/fPrlKPmbMGEiSBK1WiwsXLgAwVtbLMk3uMV0bRGR9Sms3gIgq8vDwwCOPPIIvv/wSAPD888+bXe/777/H5MmTAQD+/v5o3Lgx0tPTcebMGQDG8Zc1NWnSJHzyySdYtWoVHnroIfz8889wvGFCjFarNdut6ezsDADo27cvQkNDkZSUhMWLF8szxMeMGSOv++eff2LZsmX4+++/ER8fjxUrVuDHH39EWloaXn31VTk8FBbklztGk4hIzF2/FTvXr8bZE8eQnBCPhANf488Vy/Dpr9vhGxBY6bmt/u9nWPWVcYyqb0AgPHwbIONSGjIvp5Ub71mZmhz7n9/W4+OXnqpyv0qVCo9PqThmUSGZ/8JJJycn7N+/H99++y12796N+Ph4fPvtt/jf//6Hn376Cd27d7/pudzIw8Pj3/Yojb8ixB38tp42bdpArVaXWxYUFFTu/6bxwZbOGiei2sMKJVEd9dxzzwEAfH195YrSjUyVG61Wi7Nnz2L37t3lJs7c6OjRozhx4gQAYPn1iS6AsXJ5o9mzZ8u3J1q3bh0GDx6MoqIiAEBMTAwAY+D48ccf5Vm8f/zxByZMmIAhQ4YAME7UePrppwEAb7/9NnJzc9G0aVPcddddAIxBZdeuXRg7diy++eYbxMXFyWM/TbPcw8PDAQAFuTnIz/m3IpWafAaSJGH4xEn4v8++wbwNO+DsqkWRTofTRw8DgFwxLNSV/07sU4f2AwACgkPwxZY9eHfZWgRHVgzGpu2LCnXlQlV1jn2jDj37YNHOQ2YfPYeOgINSiZdnL0Rsn/sqbFtZoMzJycGJEyfw3HPP4bvvvsOBAwfk93/Hjh1o0KABmjRpAgBYtWoVioqKjJOcfjTey1Oj0cgVa2tq3769fKuqsWPHytfTP//8g48++ggvvPBCufXPnTsH4N9rg4isjxVKojqqRYsWyMjIgFKprFCxMWnVqhUAIDc3FyEhIVCr1VV2A6rVarRv3x5NmzZFQkICAGNFqG/fvmbXf//996FSqTBz5kxs3LgRDzzwANasWYOJEydi0aJFuHjxIpo1a4aoqCjk5uYiJSUFJSUleOyxx+R9jB8/HlOnTkV+vrHC+Nhjj8nhQa/Xo3fv3tBqtWjcuDEUCoU8c9d0bs2aNYOPry/Sr15F0vEjaNW5GwAgfu8/WDj1VXj6NoSHry+upaejIC8XCgcHNA6LAAA0ahoKAEg6dhgvD+wJtbMz3ln6M4KaRWP/ts1ITT6DZ3vForS0FMVmbsvUKCQMAJCTmYHn+3WDq4cHXvr482od+0YqRzU8fRuYfW74xEno2KsfYnqa/2NAqTAfKK9cuYIuXbrA09MTgYGBKC4uxsmTJ8u9fu+++y4effRR7N69W57dbwpkU6ZMkavJ1hQSEoInn3wSX331FV566SV8+umncHV1xblz55CTk4PFixfL51NQUCB303fr1s2azSaiMlihJKrDvLy8quzWe/zxxzFp0iT4+PggNzcXPXr0wIwZld+6pkOHDpg3bx7y8/OhUqlw7733Ys2aNeVuZH6jGTNmYObMmQCA33//HQMGDICLiwvi4uIwbtw4eHt74/jx49DpdOjWrRvmzJlTbntvb28MHz5c/n/ZsOng4IBnnnkGTZs2xcWLF3H69GkEBwdj8uTJePvttwEYq5wjHn4YALBv67+zjZtGtURsn/ugVKlw4XQiCnUFiGjdHpPnfoXAUGPlqufQkeh07/1w1rrhfGICEg8fgEFvwNCnX0CPwcPh4uaOgrw83NX/AfQb9W83vEn7Hn3Qe9hoaD08kXbuDBIPH0CxTletY98K34DASsOkAoCzyqH8MoVCfm3Hjh2Lhg0b4uzZs0hJSUFkZCTee+89PPHEEwCARx55BGvXrkXXrl2Rm5uLS5cuoU2bNli0aBGmTJlyy229XRYuXIg5c+agZcuWSE1Nxblz5xAcHIxJkyahR48e8nobN26EXq9Hq1atbmkWORHdXpK4k4NjiMgqxo4di6VLl6J79+5V3gvwdvnggw/wxhtvoFu3buVu2F5d8fHxaNmyJdy8ffDFn3vq1c3NPdQq9Aw2TlB69tln8cUXX6Bz587YtWuXlVtmHQ8++CBWr16NL774Qh5OQUTWxy5vIrptVq1ahWXLlmHjRuNNu1999dUa7Sc6Ohr3DnoQv61egZ2/rELPoebHlNobCYCXRoX09HQ8/fTT+PXXXwEY7xF6px04cAATJkww+1y7du2wYMGC296G06dPY+3atQgODsb48eNv+/GIqPoYKInotjly5AhWrlwJX19fTJkyBQMHDqzxvhYuXooD78+rxdbVfQKAh5MKeVlZWLVqFby9vTF69Gi89tprd7wtOTk58u2gbuTk5HRH2hAWFmbRnQuI6PZhlzcR2YTswhJsOZdu7Wbccb2CfODuZP5rN4mI6gpOyiEim+CmVqKSyc52SyEBWjU7koio7mOgJCKboJAkBGo1qC+ZUgIQqNVUeg9KIqK6hIGSiGxGiIcz6ssYHQEg1NP694gkIqoOBkoishleGke415MuYHe1Ep5O9ef2SERk2xgoicimhHm6WLsJd0R9OU8isg8MlERkUwK1mkq/itBeKBXG8aJERLaCgZKIbIqDQkKonVfvQj1d4GDnoZmI7AsDJRHZnEgvV7ioHOxuxrcEwEXlgEgvV2s3hYjoljBQEpHNcVBI6ODvYXczvgWAGH8PVieJyOYwUBKRTfLWOCLczrq+wz1d4KXhzG4isj0MlERks6J9tHbR9W3q6o720Vq7KURENcJASUQ2y0EhIcbfw9rNqBXs6iYiW8ZASUQ2zUvjiI4BHtZuhkU6Bniwq5uIbBoDJRHZvEZaDdr5uVu7GTXSzs8djXjPSSKycQyURGQXgt2dbS5UtvNzR7A7v6+biGyfJISwtztvEFE9djFXhz2p2QBQJ28rZBol2THAg5VJIrIbDJREZHcydcXYm5aN/BK9tZtSgYvKATH+HDNJRPaFgZKI7JLeIBCfnovErHxIsG610nT8cE8XRPtoOZubiOwOAyUR2bUMXTH2WblayaokEdk7Bkoisnt6g0BCZh6SsvJRarhzH3lKhYRQTxdEermyKklEdo2BkojqDb1B4EKuDqez8nGtqLTWu8JN+/NQKxHq6YJArYZBkojqBQZKIqqXMnXFOJNdgAu5OpiKlrcaMMuur5CAQK0GoZ7O8HRi1zYR1S8MlERUrxmEQG5RKbKKSpBdWIJMXQlyikpgqGIbBQA3tQpeGhU8nFTwVKugVSuhkFiNJKL6iYGSiOgGBiFQUKJHqUFg0iuvwEGpwocfvA+FJEGpkOCscmB4JCIqQ2ntBhAR1TUKSYKro/HjMT0lGQA4Q5uIqAr86kUiIiIisggDJRERERFZhIGSiIiIiCzCQElEREREFmGgJCIiIiKLMFASERERkUUYKImIiIjIIgyURERERGQRBkoiIiIisggDJRERERFZhIGSiIiIiCzCQElEREREFmGgJCIiIiKLMFASERERkUUYKImIiIjIIgyURERERGQRBkoiIiIisggDJRERERFZhIGSiIiIiCzCQElEREREFlFauwFERHVFQUEBiouLyy0rKSkBAGRnZ5db7ujoCGdn5zvVNCKiOk0SQghrN4KIyNqSk5MREREhB8ibUalUOHXqFIKDg29vw4iIbAC7vImIAAQEBMDX17fa6zdo0AABAQG3sUVERLaDgZKICMYu7GnTplV7/WnTpsHR0fE2toiIyHawy5uI6Lri4mI0bdoUaWlpqOyjUZIkBAQE4MyZMwyURETXsUJJRHSdqUpZ1d/ZQghWJ4mIbsAKJRFRGVVVKVmdJCIyjxVKIqIyqqpSsjpJRGQeK5RERDcwV6VkdZKIqHKsUBIR3cBclZLVSSKiyrFCSURkhqlKmZqaCgBo1KgRq5NERJVghZKIyIwb70vJ6iQRUeVYoSQiqkRxcTHc3d0BANeuXWOgJCKqhNLaDSAiqmsMQqCgRI9Sg4QVv/4GIUnI0wOKwhIoFRKcVQ5QSJK1m0lEVGewQklE9ZpBCOQUlSK7qATZhSXI1JUgp6gEhiq2UQBwU6vgpVHBw0kFD7UKbmolQyYR1VsMlERUL2XqinEmuwAXcnUwXP8UlADcygdi2fUVEhCo1SDU0xmeTuwaJ6L6hYGSiOoNvUEgJVeHpKx8XCsqveUAeTOm/bmrlQjzdEGgVgMHBauWRGT/GCiJyO7pDQIJGXlIys5HqeHOfeQpFRJCPV0Q6eXKYElEdo2BkojsWoauGPvSspFfordaG1xUDojx94CXhl3hRGSfGCiJyC7pDQLx6blIzMqv9a7tW2U6frinC6J9tKxWEpHdYaAkIruTqSvGXitXJSvDaiUR2SMGSiKyKxdzddiTmg3AulXJyphqkx0DPNBIq7FqW4iIagsDJRHZjeTsAhy4fM3azai2dn7uCHZ3tnYziIgsxu/yJiK7YGthEgAOXLqG5GsF1m4GEZHFGCiJyOZdzNXZXJg0OXDpGi7m6qzdDCIiizBQEpFNy9QVy2MmbdWe1Gxk6oqt3QwiohpjoCQim6U3COxNy7Z2M2rF3rRs6O/gTdeJiGoTAyUR2az49Fzkl+jr5GzuWyEA5JfoEZ+ea+2mEBHVCAMlEdmkDF0xErPyrd2MWpWYlc+ubyKySQyURGRz9AaBfWnZsLfvm5HArm8isk0MlERkcxIy8+yiq/tGpq7vhMw8azeFiOiWMFASkU3RGwSS7Kyr+0ZJWfmsUhKRTWGgJCKbciFXh1I7D1ulBoELvDclEdkQBkoisimn7bw6aVJfzpOI7AMDJRHZjExdMa4VlVq7GXfEtaJSzvgmIpvBQElENuNMdoHdzeyujATj+RIR2QIGSiKyCQZhHFdo36Mn/yVgHC9qEPXljInIljFQEpFNyCkqhZ3PxanAIIDcetLFT0S2jYGSiGxCdlGJtZtgFVn19LyJyLYwUJJdmD59OiRJQnBwsLWbUmNLliyBJEmQJAnJycmVrpecnCyvt23btjvWPmvLLiypE+Mn57/+EoZGBuDtR4eWW34hKRHDogPxbO9O0Ov1Va5bXRKM5327nD59Gr1794abmxskSUKPHj2wbdu2Ctfh2LFj5edvxdatWyFJErp27Vr7jTfD1E7T46WXXrojx62Jmvwcb9q0Ca1atYKTkxMkScL06dPNfvYFBwfLz1vCtG/TY+zYsRbtj+wbAyVVqkePHuU+TMo+1qxZY5U2VfZBGRgYiNjYWLRt2/a2HLfsL1nTQ6vVonnz5pg1axby8+/cLV7UajViY2MRGxsLNze3O3bc6rpd4T5TV1Knx0/+9PlsGAwG3P/YE3BwcAAA+DUJQnjrdggMi6jRPgWM5327vPLKK/jzzz9RUlKCmJgYREdHw83NTb6+1Gq1Rfu/55570K5dO+zatQu//fZbLbX65nx8fBAbGytfg6bwZmnAsiaDwYARI0bg6NGj0Gq1iI2NRWBgYK1+9pl+dk1/SJj27ePjY/G+yf4prd0AqvscHR0rfFh5eXlZqTXmPfHEE3jiiSfuyLFCQkLg6+uL8+fPIz4+HlOnTsWePXuwbt26O3J8f39/xMXF3ZFj1RUGIXCtDnf9ZqdfRdzvG6BwcEC3+wfLy4dNeBnDJrxs0b5zikpgEAIKqfbrs8ePHwcAvPTSS3j//ffl5bV5fY0aNQoHDhzAwoUL0a9fv1rbb1Xuv/9+LFmy5I4c605JTU1FdnY2AOC7775D37595edu12ef6XN17NixWLp06W05BtkPVijppkwBpuzj7rvvrrTL5sYqYtnq3tq1a3H33XdDo9EgMjIS69evL3esxMREjBo1Cn5+fnB0dERgYCAmT54sH+vcuXMAgHfeeUfeJ2C+KqbX6zF79mxER0dDrVbD3d0dffr0wc6dO+V1bqVtJlOnTkVcXBxSUlIQGxsLAPjll1+QlZUFAMjMzMTEiRPRuHFjqFQqNGzYEI888gjOnz9fbj/z589Ho0aN4OLigtGjR+PatWsVjlW2fabX2NzrfunSJYwePRr+/v5Qq9Xw8/NDz549sWHDBnlf58+fx2OPPQY/Pz+oVCoEBgZiwoQJyMzMlNcp27X5+eefIzg4GFqtFgMGDMClS5fMvh5l9ejRA++88w4A4Ny5c3I7Tb/cq/va3KigRI/D/+zE0MgADI0MQGryGfm5Dd9+jaGRAXg0JhLFRYU4e+IYpo8djse7tcHDLYMxqm0oXnvoPmxft7LcPk37WvqfGZj/fy9iVNtQTLy3C/Zv/xMXziRiyqhBGNU2FG+OGIgLSYlVtu+fTeuhLy1FeMs2cPf+t5pjrst725qf8crg3hjdLhyj24Xjhf5349PXni+3vy0rf8SrD/bFyNYhGNE2FF26dsXatWvl58teA0uWLMGAAQPg7OyMpk2b4uuvv66yrWW3T0pKAgB88MEHcpemuS5vc4qKijBt2jSEh4fD0dERDRo0wPjx45Genl5uvQEDBgAANmzYYPYar47ffvsN8fHxNdrWnG7dukGSJDzyyCPyMr1ejwYNGkCSJHzwwQcAgNdffx3NmzeHh4cHVCoVAgICMGbMGKSlpcnble0W3rhxIyIiIuSf6fz8fMyaNQu+vr7w9/fHtGnTatTeJUuWoHHjxvL/+/XrJ7/31e0RSE1Nxfjx4xEQEABHR0eEhIRg5syZKC3lpC+qHQyUdEcNGzYMly5dgiRJOHnyJEaNGiUHmtOnT6Njx4744YcfkJ6ejrCwMOj1emzevFnu5nV0dAQANGrUSO6Wq8zTTz+NyZMn48SJE2jSpAmUSiU2b96Mnj17Yvv27bfUtuoqLCxE9+7dsWDBAly6dAkRERHIycnB999/j86dO+Pq1asAjAH0hRdeQGpqKlxcXLBz505MmTLllo5V1oQJE7Bs2TLk5eWhRYsWcHR0xLZt27Bnzx4AwJUrV9C5c2d8++23yM7ORkREBC5fvoyFCxeie/fuKCwsLLe/Xbt2YfLkyXB0dEReXh5+/fVXvPLKKzdtR3R0NBo1agTAWNk2vUe+vr7Vfm3MKTUItOx0FwKCQwAAW1ctl5+L+90Ymrve9wAc1U64cjEFx/fsgkrliMbhEVA5qpF07DDmvfY89m/bXGHfG79bjCNxf0HlqMal88mYM+lZzBg/AplXLgMATh7aj8/fnFTleZ/Yb3ydQ1u2qXK95ITj+OyNl5CcEA8P3wZo0KgxMi6lYUeZsLti4Vx8PmUSzsQfhZu3NzSuWuz+5x8MHjwY3333XYV9PvXUUzh+/DhUKhWSk5Px1FNPISEhocp2VPbzFBoaWuV2ZT344IOYMWMGzp49i6ioKBQVFWHx4sXo3r07dLp/vzYyIiIC7u7uKC0trbLymZmZieTk5AqPs2fP4qWXXsI999xTa6Hy2WefBQCsWrVKDrk7d+7E1atXoVAo5KD522+/4eLFi2jcuDHCwsJw6dIl/O9//8OgQYPM7nf48OFQKBQoKCjAsmXLEBMTg/feew9ubm64dOkSZsyYgU2bNt1ye319fdGmTRv5/1FRUfLPVXVkZGSgU6dOWLx4MfLy8hAVFYWUlBS8/fbbeOqpp265PUTmMFDSTZWtNJWtCtbE888/j1OnTuHHH38EAOTm5sqh57333kN2djZUKhV27NiB+Ph4pKWlYfHixXKV1N/fH4CxK8ZULTUnKSkJ33zzDQDgxRdfRGJiIs6cOYOgoCCUlpbi7bffvqW2lTVz5kx06tQJjRs3xu7duwEAAwcOhKenJ3744QccO3YMAPDzzz/j+PHj+Pvvv6FQKJCamorPPvsMAPCf//wHABAaGoozZ87g7NmziImJqXAsZ2dnNGvWDM2aNYOzs3Olr2tiorGC9sUXX2D//v04f/48Ll68iBEjRgAAPv/8c6SmpkKhUGDXrl04fvw4fv75ZwDAsWPH8MMPP5Tbn16vR1xcHE6dOoUhQ4YAAP78889Kj2+yYMECufutbGX7/vvvr/ZrY45BCEiShHtHPAYA2LZ2BfR6Pa5lpOPEfuN70GPwQwCAiNbt8d8dB/HFlj34eNXv+O+OA/ALagoA+GvD2gr79gsKxoI/dmHSnC8AALr8PASGRmDBH/9g/JSZAIBTh/ejqLDy79a+dO4sAKBBo8aVrgMAaeeSIYRAQHAI5m/ciTm/bMH/9iZgxrerAACFBQVY+eU8AEBsn/uwcPNufPHnbrTrYLw23nrrrQr7HDRoEM6cOSNX3g0Gw00neVT28zR16tQqtzPZvn27XP3esmULDh8+jISEBGg0GsTHx2PZsmXyupIkoUmTJgCMfzRWZubMmYiMjKzwiIqKQnJyMjIzM2scKoODgyGEkHtNHnroIfj6+kKn08nX/sqVxlDfs2dPBAYGAgC+/fZbZGZm4ujRozhx4gS++uorAMDevXvl6m5ZX3zxBRISEuRJSCdOnMAff/yBxMREBAUFATBOVLpV999/P1avXi3/f8GCBfLPVXV89tlnSElJQcOGDZGUlITDhw9jxYoVAIzVT9P7Mn36dAghbHpyI1kPAyXdVNlK082qgjfz6KOPAjBWskwuXzZWgkzhrHv37ujSpYv8fE0Gm+/fvx/i+g2hR40aBQBwd3dH//79AQD79u27pbaVdebMGezevRs5OTmIjo7GjBkz5F9Ke/fuBWAMgoMHDwYAtGvXDs2aNSt3XNPYtb59+8LV1RUODg548MEHKxyrY8eOSEhIQEJCAjp27Fjp+Q4cOBAAMGbMGISFhWHAgAH47rvvEBAQUK5dzZo1Q7t27QAAgwcPlkPqja9Hy5Yt0bp163Kvh7nX4lZU97Uxx3Rz73uGDIejkxMyL6fh0F/bsHvzbzAYDPALaorIdsbXR5IkLP3wHTzRrS2GNW+Mka1D5MCXdaXiObTu0h0qR3W5MNi+ey9IkoSGgUHysmsZGZW2Lz8vFwCgcXGp8jWIbBcDV3cPpCafwdhOzfH68Pvx33fekJ9POX0SxderxV37D4JCoYDKUY0BgwYDMP5xd2Mld/To0ZAk6abXbW0q+4dW9+7dIUkSAgIC5MrkjX/omSaPVdXlPWfOHBQWFlb6OHToEK5evYqFCxda3H5HR0eMHz8eAPDNN99ACCEHtjFjxsjrHTp0CDExMXB1dYUkSXjyySfl51JTUyvs1/RzaApknp6e6Nq1KxQKhRwob/d7Y47p/bp8+bLcrW/6GRRCyJ+9RJbgpBy6qcomgZStVJpukwJU/UvDw8MDAKBU/nvpiTryTSDVbdvixYvr3O0z3n33XXTt2hWbNm3CsWPHsGPHDvz666/Ytm0bfv3111ven+m1AMq/HtZimpDi6u6Bu/oPwpZVy7F11XIUXA9yPQY9JK/76WvP4ciunZAkCYFhEXBydsGF06egy8+Docx1auLs6goAcHD49zw1rloA5a9xVHGdOrsY91FYUPVXJXr6NsDcX7Zi+7oVSDp+BOdPJeCPn77DnyuW4d0f1lVa/a+qU8DaP1Pm/sD08/Mr9/+cnBwAqPKuBM899xw+//zzKo/l7++P559/vsp1quuZZ57BRx99hL179+Lrr7/GxYsXodVq5T/s/vrrL4wZMwZCCHh7eyM6Ohp5eXk4ceIEgPKfeSam8zO9F2XP1/TeWvPzTqvVlvvDw6Sq3g+i6mKFkmqsQYMG8r9PnToFANi8ebM8E/FWmX4xbd++vdxfzIcPH5b/bfrgu9ltetq3by9/gJu6365duyZ303Xo0KFGbbwZU7d1QUGBfGulAwcO4OTJk+WO27x5cwDA77//jvz8fOj1+nJdWiZ79uyRu/7Mdb+b/P333+jevTvmzZuHLVu2yF1zO3bsKNeukydP4sCBAwCANWvWoOB6AKrN18P0HhUUFJT75Vnd18acsjOc+440VpD2bvkdx/fsgiRJ6P7Av4Hy1CHj+fUeNhpzf9mKKV9+CyfnqiuHlvIPNnapX029UOV6mZcv4VpWBgY/MRGvzPkSn/66HY1CwmAwGJCwfw8ahzWDo5MTAODvDetgMBhQUlyEX69PyAkKCqr2uLnbqezwjDfeeEMe2vDXX39h+vTpePzxx+XnhRDypKvw8PBK9/n+++8jLS2twiM1NRVRUVHw8/PD1q1bERFRs1sw3Sg4OFiedW66X+XQoUPl63f37t3y9Xv06FHs2bMHjz32WK0c+04zvV9KpRI//vij/H798ccfmDBhgjyshcgSDJRUYxqNBp07dwZgvJ9dz549MWiQsZuuJt588014eHigpKQEXbt2RfPmzdGoUaNyXVCRkZEAgHnz5iEmJgbjxo0zu6/Q0FC5S+vTTz9FeHg4QkJCcO7cOSiVSnkmcm0bOXIkWrRoAcA4yad58+bo2rUrDAYDAgIC8NxzzwEAJk+eDMA4piwkJAQhISHYtWtXhf0VFBTg5MmTOHnypBz+zHn99dfh7e2NsLAwtG/fXj73Vq1aAQAmTpwIf39/GAwGdOnSBS1atMCwYcMAAC1atMDIkSNr7TUwvUdXr15Fs2bN0KlTJ5w5c6bar405SsW/gTKsZRuENm+F0pJilJaUILpDJzQI/Le7OqhZFADgzxXL8OKAHph4bxeUFBfV2vmZE9Xe+MdQ0rHDVa6XknQKrwzqjXFdWuKVwb3xbO9OuHjGOH6tSUQknJydMfTpFwAAu//YgGd7x+KZXrHYt9f4x8SsWbNu41lUX48ePeTb1gwePBiRkZHybOj77ruv3OzwU6dO4dq1a1AqlejUqVOl+9RqtfDz86vw8Pf3x7x587B161Z5eERtMU3OMf2BWvazxvSzAxiHgERFReGjjz6q1ePfKRMnTkSjRo2QlZWFZs2aoU2bNggNDYW3t3e5cyayBAMlWWTJkiXo1q0bAODChQtYsGBBudtb3IqwsDDs2bMHI0eOhLe3tzzRpFevXvI6s2bNQqdOnaBQKLBv3z4cPXq00v19+eWX+OijjxAVFYXz58+jpKQEvXv3xpYtW275Gz+qy8nJCdu3b8eECRPg5+eHU6dOQavVYvTo0fjnn3/k6tKgQYMwZ84c+Pn5ITc3Fx06dKhRWDCF94cffhgdOnRATk4Ojh49Cg8PD4wYMUIe29mgQQPExcXh0UcfhYeHB06ePImGDRvimWeewfbt2+F0vSpWGwYMGIAnn3xSfg93796NgoKCar825jirHMp9S07fUf/+Euw++KFy6z73/ly0iO0KlVqNYp0O4954B0ERUbV2fuZ07jsADkolTh0+gJysimMtpevvU8PGQejafxCcXbVITT6DnMwMBEdG45kZH6HNXT0AAA89+xImvDsbIdEtkZORgYLcHHTu3Blr1qwpd5sba1uzZg3efvtthIeH48yZM7h06RKioqLw1ltvyX84AJBvv9W/f3+4u7vX6Fi9e/eW/1CpTf3795fHNgYFBaF79+7yc3369MGHH34ojw2NjIyslfGb1uDr64u4uDiMGzcO3t7eOH78OHQ6Hbp164Y5c+ZYu3lkJyRRVwawEVG17N69W670nDx5sta6AOu6Lcnp8vd5nzq0H2+MGAgnZ2cs2nEImuvjIK3pk0nP4O8N6/D4lJno/6ixy3fWk6NxcOdW3HX/YLw8e0GN9uuhVqFnsO1+U0m7du1w8OBB/Pbbb+Vuxn07mG7A7ePjg9DQUIwYMeKmX7/Yr18/bNq0CVOnTsWMGTNua/tszaJFi7Bo0SIkJSUhPT0dY8aMsbsbxlPtsf5oeyKqtlmzZmHx4sUAIHeV32lDhgwpd2PnslavXi3fiqYmZs6cWekkotHPTQK8/PDTgjmI32ccY9tn+KN1IkwCwPCJr+Cf39Zj/f8WoUWnu/Dd7Hdx+G/j/U5bd7m7RvuUAHhpVDXa9tdff8XMmTPNPnf//fdX+xZBltiyZQsOHjyILl263PYwWVZ6ejrS09Or7GJ/9913sWPHDvz+++9wdnbGxIkT71j7zKnq2p86dWq1bxFUmy5cuMAZ4FRtDJRENmTz5s24cOECOnbsiIULF1plBvbBgwflbyy6UVGRZWMVk5KSKv0F9tBjWSgwOOCvX9fAydkFXfsPwsiXXrPoeLUpMDQcP8cbJ+Uc270L+7dthoePL7oPegjdBw+r0T4FAA+nmgXKq1evVvpa3o7uY3N69ux5R2c1L1mypNoVtD/++AM7d+5EeHg45syZg4YNG97ext1EVdd+VTf9v52mT59u099/TncWu7yJyCZkF5Zgy7n0m69oZ3oF+cC9hqGSiOhO4aQcIrIJbmolFDX/kiabpJAArZodSURU9zFQEpFNUEgSArUa1JdMKQEI1GrK3YOTiKiuYqAkIpsR4uGM+jJGRwAI9eQ3mBCRbWCgJCKb4aVxhHs96QJ2Vyvh6eRo7WYQEVULAyUR2ZQwz9v7NYp1RX05TyKyDwyURGRTArWacl/FaI+UCuN4USIiW8FASUQ2xUEhIdTOq3ehni5wsPPQTET2hYGSiGxOpJcrXG74fm97IAFwUTkg0qtufPsPEVF1MVASkc1xUEjo4O9hdzO+BYAYfw9WJ4nI5jBQEpFN8tY4ItzOur7DPV3gpeHMbiKyPQyURGSzon20dtH1berqjvbRWrspREQ1wkBJRDbLQSEhxt/D2s2oFezqJiJbxkBJRDbNS+OIjgEe1m6GRToGeLCrm4hsGgMlEdm8RloN2vm5W7sZNdLOzx2NeM9JIrJxDJREZBeC3Z1tLlS283NHsDu/r5uIbJ8khLC3O28QUT12MVeHPanZAFAnbytkGiXZMcCDlUkishsMlERkdzJ1xdiblo38Er21m1KBi8oBMf4cM0lE9oWBkojskt4gEJ+ei8SsfEiwbrXSdPxwTxdE+2g5m5uI7A4DJRHZtQxdMfZZuVrJqiQR2TsGSiKye3qDQEJmHpKy8lFquHMfeUqFhFBPF0R6ubIqSUR2jYGSiOoNvUHgQq4Op7Pyca2otNa7wk3781ArEerpgkCthkGSiOoFBkoiqpcydcU4k12AC7k6mIqWtxowy66vkIBArQahns7wdGLXNhHVLwyURFSvGYRAblEpsopKkF1YgkxdCXKKSmCoYhsFADe1Cl4aFTycVPBUq6BVK6GQWI0kovqJgZKI6AYGIVBQokepQcAgjA+FJEEhSVAqJDirHBgeiYjKYKAkIiIiIovwqxeJiIiIyCIMlERERERkEQZKIiIiIrIIAyURERERWYSBkoiIiIgswkBJRERERBZhoCQiIiIiizBQEhEREZFFGCiJiIiIyCIMlERERERkEQZKIiIiIrIIAyURERERWYSBkoiIiIgswkBJRERERBZhoCQiIiIiizBQEhEREZFFGCiJiIiIyCIMlERERERkkf8HJXkWqb58zOYAAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -246,19 +235,7 @@ } ], "source": [ - "pos = nx.drawing.nx_agraph.graphviz_layout(G, prog=\"dot\")\n", - "nx.draw(\n", - " G,\n", - " pos,\n", - " labels=labels,\n", - " node_size=2000,\n", - " node_color=\"lightblue\",\n", - " with_labels=True,\n", - " font_size=10,\n", - " font_weight=\"bold\",\n", - " arrowsize=20,\n", - ")\n", - "plt.tight_layout()" + "DEFAULT_TRACKER.draw_graph()" ] }, { @@ -279,7 +256,7 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 11, "id": "f678050e", "metadata": {}, "outputs": [], @@ -306,18 +283,10 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 12, "id": "b3bf152b", "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/ipykernel_2662699/2248456176.py:16: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n", - " plt.tight_layout()\n" - ] - }, { "data": { "image/png": "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", @@ -330,22 +299,7 @@ } ], "source": [ - "G = tracker.generate_graph()\n", - "labels = tracker.generate_namemap()\n", - "\n", - "pos = nx.drawing.nx_agraph.graphviz_layout(G, prog=\"dot\")\n", - "nx.draw(\n", - " G,\n", - " pos,\n", - " labels=labels,\n", - " node_size=2000,\n", - " node_color=\"lightblue\",\n", - " with_labels=True,\n", - " font_size=10,\n", - " font_weight=\"bold\",\n", - " arrowsize=20,\n", - ")\n", - "plt.tight_layout()" + "tracker.draw_graph()" ] }, { diff --git a/src/orcabridge/tracker.py b/src/orcabridge/tracker.py index 6eedc63e..a5295f97 100644 --- a/src/orcabridge/tracker.py +++ b/src/orcabridge/tracker.py @@ -2,6 +2,7 @@ from typing import Dict, Collection, List import networkx as nx from .base import Operation, Invocation +import matplotlib.pyplot as plt class Tracker: @@ -67,6 +68,24 @@ def generate_graph(self): return G + def draw_graph(self): + G = self.generate_graph() + labels = self.generate_namemap() + + pos = nx.drawing.nx_agraph.graphviz_layout(G, prog="dot") + nx.draw( + G, + pos, + labels=labels, + node_size=2000, + node_color="lightblue", + with_labels=True, + font_size=10, + font_weight="bold", + arrowsize=20, + ) + plt.tight_layout() + def __enter__(self): self.activate() return self From 8204aa9d1c59e5bd975f07512f9a564daba8e780 Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" Date: Sat, 3 May 2025 06:47:52 +0000 Subject: [PATCH 11/22] feat: add pod_function decorator for simple pod function creation --- src/orcabridge/pod.py | 39 +++++++++++++++++++++++++++++++++++++-- 1 file changed, 37 insertions(+), 2 deletions(-) diff --git a/src/orcabridge/pod.py b/src/orcabridge/pod.py index bb0a4348..f76b01cd 100644 --- a/src/orcabridge/pod.py +++ b/src/orcabridge/pod.py @@ -12,6 +12,41 @@ from .types import Tag, Packet, PodFunction import json import shutil +import functools + + +def function_pod( + output_keys: Optional[Collection[str]] = None, + force_computation: bool = False, + skip_memoization: bool = False, +): + """ + Decorator that wraps a function in a FunctionPod instance. + + Args: + output_keys: Keys for the function output + force_computation: Whether to force computation + skip_memoization: Whether to skip memoization + + Returns: + FunctionPod instance wrapping the decorated function + """ + + def decorator(func): + # Create a FunctionPod instance with the function and parameters + pod = FunctionPodWithDirStorage( + function=func, + output_keys=output_keys, + force_computation=force_computation, + skip_memoization=skip_memoization, + ) + + # Update the metadata to make the pod look more like the original function + functools.update_wrapper(pod, func) + + return pod + + return decorator class Pod(Operation): @@ -60,8 +95,8 @@ def __init__( self, function: PodFunction, output_keys: Optional[Collection[str]] = None, - force_computation=False, - skip_memoization=False, + force_computation: bool = False, + skip_memoization: bool = False, ) -> None: super().__init__() self.function = function From 0bdc325e09dd67997001ab0989cc5dd0980ddf07 Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" Date: Sat, 3 May 2025 06:49:04 +0000 Subject: [PATCH 12/22] feat: add rshift operator for simple mapping --- src/orcabridge/base.py | 26 +++++++++++++++++++++++++- src/orcabridge/mapper.py | 28 +++++++++++++++++++++++++++- 2 files changed, 52 insertions(+), 2 deletions(-) diff --git a/src/orcabridge/base.py b/src/orcabridge/base.py index 777cf74e..8e242488 100644 --- a/src/orcabridge/base.py +++ b/src/orcabridge/base.py @@ -1,5 +1,15 @@ from .types import Tag, Packet -from typing import Optional, Tuple, List, Dict, Any, Collection, Callable, Iterator +from typing import ( + Optional, + Tuple, + List, + Dict, + Any, + Collection, + Callable, + Iterator, + Mapping, +) from .utils.hash import hash_dict import networkx as nx @@ -173,3 +183,17 @@ def __len__(self) -> int: This method is not guaranteed to be efficient and should be used with caution. """ return sum(1 for _ in self) + + def __rshift__(self, transformer: Any) -> "SyncStream": + """ + Returns a new stream that is the result of applying the mapping to the stream. + The mapping is applied to each packet in the stream and the resulting packets + are returned in a new stream. + """ + from .mapper import MapPackets + + # TODO: extend to generic mapping + if isinstance(transformer, dict): + return MapPackets(transformer)(self) + elif isinstance(transformer, Callable): + return transformer(self) diff --git a/src/orcabridge/mapper.py b/src/orcabridge/mapper.py index 64ea35fc..e6a6ae48 100644 --- a/src/orcabridge/mapper.py +++ b/src/orcabridge/mapper.py @@ -40,7 +40,7 @@ def __hash__(self) -> int: return hash(self.__class__) -class MapKeys(Mapper): +class MapPackets(Mapper): """ A Mapper that maps the keys of the packet in the stream to new keys. The mapping is done using a dictionary that maps old keys to new keys. @@ -277,3 +277,29 @@ def __hash__(self) -> int: # explicitly shown to signify that no two cachestreams are the same # unless they are the same instance return super().__hash__() + + +def tag( + mapping: Dict[str, str], drop_unmapped: bool = True +) -> Callable[[SyncStream], SyncStream]: + def transformer(stream: SyncStream) -> SyncStream: + """ + Transform the stream by renaming the keys in the tag. + The mapping is a dictionary that maps the old keys to the new keys. + """ + return MapTags(mapping, drop_unmapped=drop_unmapped)(stream) + + return transformer + + +def packet( + mapping: Dict[str, str], drop_unmapped: bool = True +) -> Callable[[SyncStream], SyncStream]: + def transformer(stream: SyncStream) -> SyncStream: + """ + Transform the stream by renaming the keys in the packet. + The mapping is a dictionary that maps the old keys to the new keys. + """ + return MapPackets(mapping, drop_unmapped=drop_unmapped)(stream) + + return transformer From cfae659ee8c4b6e3297795d20bcee1101a2eb67e Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" Date: Sat, 3 May 2025 22:58:02 +0000 Subject: [PATCH 13/22] refactor: data storage for pod into its own class --- src/orcabridge/pod.py | 152 +++++----------------------------------- src/orcabridge/store.py | 136 +++++++++++++++++++++++++++++++++++ 2 files changed, 152 insertions(+), 136 deletions(-) create mode 100644 src/orcabridge/store.py diff --git a/src/orcabridge/pod.py b/src/orcabridge/pod.py index f76b01cd..215eaf46 100644 --- a/src/orcabridge/pod.py +++ b/src/orcabridge/pod.py @@ -10,6 +10,7 @@ from .mapper import Join from .stream import SyncStream, SyncStreamFromGenerator from .types import Tag, Packet, PodFunction +from .store import DataStore import json import shutil import functools @@ -17,6 +18,8 @@ def function_pod( output_keys: Optional[Collection[str]] = None, + store_name: Optional[str] = None, + data_store: Optional[DataStore] = None, force_computation: bool = False, skip_memoization: bool = False, ): @@ -34,8 +37,10 @@ def function_pod( def decorator(func): # Create a FunctionPod instance with the function and parameters - pod = FunctionPodWithDirStorage( + pod = FunctionPod( function=func, + store_name=store_name, + data_store=data_store, output_keys=output_keys, force_computation=force_computation, skip_memoization=skip_memoization, @@ -95,6 +100,8 @@ def __init__( self, function: PodFunction, output_keys: Optional[Collection[str]] = None, + store_name=None, + data_store: Optional[DataStore] = None, force_computation: bool = False, skip_memoization: bool = False, ) -> None: @@ -103,6 +110,8 @@ def __init__( if output_keys is None: output_keys = [] self.output_keys = output_keys + self.store_name = self.function.__name__ if store_name is None else store_name + self.data_store = data_store if data_store is not None else NoOpDataStore() self.skip_memoization = skip_memoization self.force_computation = force_computation @@ -114,37 +123,6 @@ def __hash__(self) -> int: function_hash = function_content_hash(self.function) return hash((function_hash, tuple(self.output_keys))) - def process(self, packet: Packet) -> Packet: - memoized_packet = self.retrieve_memoized(packet) - if not self.force_computation and memoized_packet is not None: - return memoized_packet - - values = self.function(**packet) - if len(self.output_keys) == 0: - values = [] - elif len(self.output_keys) == 1: - values = [values] - elif isinstance(values, Iterable): - values = list(values) - elif len(self.output_keys) > 1: - raise ValueError( - "Values returned by function must be a pathlike or a sequence of pathlikes" - ) - - if len(values) != len(self.output_keys): - raise ValueError( - "Number of output keys does not match number of values returned by function" - ) - - output_packet: Packet = {k: v for k, v in zip(self.output_keys, values)} - - if not self.skip_memoization: - # output packet may be modified by the memoization process - # e.g. if the output is a file, the path may be changed - output_packet = self.memoize(packet, output_packet) - - return output_packet - def forward(self, *streams: SyncStream) -> SyncStream: # if multiple streams are provided, join them if len(streams) > 1: @@ -159,7 +137,9 @@ def forward(self, *streams: SyncStream) -> SyncStream: def generator() -> Iterator[Tuple[Tag, Packet]]: n_computed = 0 for tag, packet in stream: - memoized_packet = self.retrieve_memoized(packet) + memoized_packet = self.data_store.retrieve_memoized( + self.store_name, packet + ) if not self.force_computation and memoized_packet is not None: yield tag, memoized_packet continue @@ -185,7 +165,9 @@ def generator() -> Iterator[Tuple[Tag, Packet]]: if not self.skip_memoization: # output packet may be modified by the memoization process # e.g. if the output is a file, the path may be changed - output_packet = self.memoize(packet, output_packet) + output_packet = self.data_store.memoize( + self.store_name, packet, output_packet + ) n_computed += 1 logger.info(f"Computed item {n_computed}") @@ -200,105 +182,3 @@ def memoize( def retrieve_memoized(self, packet: Packet) -> Optional[Packet]: return None - - -class FunctionPodWithDirStorage(FunctionPod): - """ - A FunctionPod that stores the output in the specified directory. - The output is stored in a subdirectory named store_name, creating it if it doesn't exist. - If store_name is None, the function name is used as the directory name. - The output is stored in a file named based on the hash of the input packet. - """ - - def __init__( - self, - function: PodFunction, - output_keys: Optional[List[str]] = None, - store_dir="./pod_data", - store_name=None, - copy_files=True, - preserve_filename=True, - **kwargs, - ) -> None: - super().__init__(function, output_keys, **kwargs) - self.store_dir = Path(store_dir) - if store_name is None: - store_name = self.function.__name__ - self.store_name = store_name - self.data_dir = self.store_dir / self.store_name - # Create the data directory if it doesn't exist - self.data_dir.mkdir(parents=True, exist_ok=True) - self.copy_files = copy_files - self.preserve_filename = preserve_filename - - def memoize( - self, packet: Packet, output_packet: Packet, overwrite: bool = False - ) -> Packet: - packet_hash = hash_dict(packet) - output_dir = self.data_dir / f"{packet_hash}" - info_path = output_dir / "_info.json" - - if info_path.exists() and not overwrite: - logger.info( - f"Entry for packet {packet} already exists, and will not be overwritten" - ) - return False - else: - output_dir.mkdir(parents=True, exist_ok=True) - if self.copy_files: - new_output_packet = {} - # copy the files to the output directory - for key, value in output_packet.items(): - if self.preserve_filename: - relative_output_path = Path(value).name - if (output_dir / relative_output_path).exists(): - raise ValueError( - f"File {relative_output_path} already exists in {output_path}" - ) - else: - # preserve the suffix of the original if present - relative_output_path = key + Path(value).suffix - - output_path = output_dir / relative_output_path - if output_path.exists() and not overwrite: - # TODO: handle case where it's a directory - raise ValueError( - f"File {relative_output_path} already exists in {output_path}" - ) - shutil.copy(value, output_path) - # register the key with the new path - new_output_packet[key] = str(relative_output_path) - output_packet = new_output_packet - # store the packet in a json file - with open(info_path, "w") as f: - json.dump(output_packet, f) - logger.info(f"Stored output for packet {packet} at {output_path}") - - # retrieve back the memoized packet and return - # TODO: consider if we want to return the original packet or the memoized one - output_packet = self.retrieve_memoized(packet) - if output_packet is None: - raise ValueError(f"Memoized packet {packet} not found after storing it") - - return output_packet - - def retrieve_memoized(self, packet: Packet) -> Optional[Packet]: - packet_hash = hash_dict(packet) - output_dir = self.data_dir / f"{packet_hash}" - info_path = output_dir / "_info.json" - - if info_path.exists(): - with open(info_path, "r") as f: - output_packet = json.load(f) - # update the paths to be absolute - for key, value in output_packet.items(): - output_packet[key] = str(output_dir / value) - logger.info(f"Retrieved output for packet {packet} from {info_path}") - return output_packet - else: - logger.info(f"No memoized output found for packet {packet}") - return None - - def clear_store(self) -> None: - # delete the folder self.data_dir and its content - shutil.rmtree(self.data_dir) diff --git a/src/orcabridge/store.py b/src/orcabridge/store.py new file mode 100644 index 00000000..956f4517 --- /dev/null +++ b/src/orcabridge/store.py @@ -0,0 +1,136 @@ +from .types import Tag, Packet +from typing import Optional, Collection +from pathlib import Path +from .utils.hash import hash_dict +import shutil +import logging +import json + +logger = logging.getLogger(__name__) + + +class DataStore: + def memoize( + self, + store_name: str, + packet: Packet, + output_packet: Packet, + overwrite: bool = False, + ) -> Packet: ... + + def retrieve_memoized( + self, store_name: str, packet: Packet + ) -> Optional[Packet]: ... + + +class NoOpDataStore(DataStore): + """ + An empty data store that does not store anything. + This is useful for testing purposes or when no memoization is needed. + """ + + def memoize( + self, + store_name: str, + packet: Packet, + output_packet: Packet, + overwrite: bool = False, + ) -> Packet: + return output_packet + + def retrieve_memoized(self, store_name: str, packet: Packet) -> Optional[Packet]: + return None + + +class DirDataStore(DataStore): + def __init__( + self, + store_dir="./pod_data", + copy_files=True, + preserve_filename=True, + ) -> None: + self.store_dir = Path(store_dir) + # Create the data directory if it doesn't exist + self.store_dir.mkdir(parents=True, exist_ok=True) + self.copy_files = copy_files + self.preserve_filename = preserve_filename + + def memoize( + self, + store_name: str, + packet: Packet, + output_packet: Packet, + overwrite: bool = False, + ) -> Packet: + + packet_hash = hash_dict(packet) + output_dir = self.store_dir / store_name / f"{packet_hash}" + info_path = output_dir / "_info.json" + + if info_path.exists() and not overwrite: + raise ValueError( + f"Entry for packet {packet} already exists, and will not be overwritten" + ) + else: + output_dir.mkdir(parents=True, exist_ok=True) + if self.copy_files: + new_output_packet = {} + # copy the files to the output directory + for key, value in output_packet.items(): + if self.preserve_filename: + relative_output_path = Path(value).name + if (output_dir / relative_output_path).exists(): + raise ValueError( + f"File {relative_output_path} already exists in {output_path}" + ) + else: + # preserve the suffix of the original if present + relative_output_path = key + Path(value).suffix + + output_path = output_dir / relative_output_path + if output_path.exists() and not overwrite: + # TODO: handle case where it's a directory + raise ValueError( + f"File {relative_output_path} already exists in {output_path}" + ) + shutil.copy(value, output_path) + # register the key with the new path + new_output_packet[key] = str(relative_output_path) + output_packet = new_output_packet + # store the packet in a json file + with open(info_path, "w") as f: + json.dump(output_packet, f) + logger.info(f"Stored output for packet {packet} at {output_path}") + + # retrieve back the memoized packet and return + # TODO: consider if we want to return the original packet or the memoized one + output_packet = self.retrieve_memoized(store_name, packet) + if output_packet is None: + raise ValueError(f"Memoized packet {packet} not found after storing it") + + return output_packet + + def retrieve_memoized(self, store_name: str, packet: Packet) -> Optional[Packet]: + packet_hash = hash_dict(packet) + output_dir = self.store_dir / store_name / f"{packet_hash}" + info_path = output_dir / "_info.json" + + if info_path.exists(): + with open(info_path, "r") as f: + output_packet = json.load(f) + # update the paths to be absolute + for key, value in output_packet.items(): + output_packet[key] = str(output_dir / value) + logger.info(f"Retrieved output for packet {packet} from {info_path}") + return output_packet + else: + logger.info(f"No memoized output found for packet {packet}") + return None + + def clear_store(self, store_name: str) -> None: + # delete the folder self.data_dir and its content + shutil.rmtree(self.store_dir / store_name) + + def clear_all_stores(self) -> None: + # delete the folder self.data_dir and its content + shutil.rmtree(self.store_dir) From 7bcc4b653c05f870da55fc84fd62b1e50528995d Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" Date: Sat, 3 May 2025 22:58:20 +0000 Subject: [PATCH 14/22] chore: add example json files --- examples/dataset2/info_day1.json | 6 ++++++ examples/dataset2/info_day2.json | 6 ++++++ examples/dataset2/info_day3.json | 6 ++++++ examples/dataset2/info_day4.json | 6 ++++++ examples/dataset2/info_day5.json | 6 ++++++ 5 files changed, 30 insertions(+) create mode 100644 examples/dataset2/info_day1.json create mode 100644 examples/dataset2/info_day2.json create mode 100644 examples/dataset2/info_day3.json create mode 100644 examples/dataset2/info_day4.json create mode 100644 examples/dataset2/info_day5.json diff --git a/examples/dataset2/info_day1.json b/examples/dataset2/info_day1.json new file mode 100644 index 00000000..84cbfa5f --- /dev/null +++ b/examples/dataset2/info_day1.json @@ -0,0 +1,6 @@ +{ + "name": "Day 1 experiment", + "description": "This is the first day of the experiment.", + "experimenter": "John Doe", + "date": "2023-10-01" +} \ No newline at end of file diff --git a/examples/dataset2/info_day2.json b/examples/dataset2/info_day2.json new file mode 100644 index 00000000..842cbd89 --- /dev/null +++ b/examples/dataset2/info_day2.json @@ -0,0 +1,6 @@ +{ + "name": "Day 2 experiment", + "description": "This is the second day of the experiment.", + "experimenter": "John Doe", + "date": "2023-10-02" +} \ No newline at end of file diff --git a/examples/dataset2/info_day3.json b/examples/dataset2/info_day3.json new file mode 100644 index 00000000..891e4808 --- /dev/null +++ b/examples/dataset2/info_day3.json @@ -0,0 +1,6 @@ +{ + "name": "Day 3 experiment", + "description": "This is the third day of the experiment.", + "experimenter": "Mary Smith", + "date": "2023-10-05" +} \ No newline at end of file diff --git a/examples/dataset2/info_day4.json b/examples/dataset2/info_day4.json new file mode 100644 index 00000000..3778fc8a --- /dev/null +++ b/examples/dataset2/info_day4.json @@ -0,0 +1,6 @@ +{ + "name": "Day 3 experiment", + "description": "This is the fourth day of the experiment.", + "experimenter": "Mary Smith", + "date": "2023-10-06" +} \ No newline at end of file diff --git a/examples/dataset2/info_day5.json b/examples/dataset2/info_day5.json new file mode 100644 index 00000000..6cf194c2 --- /dev/null +++ b/examples/dataset2/info_day5.json @@ -0,0 +1,6 @@ +{ + "name": "Day 5 experiment", + "description": "This is the fifth day of the experiment.", + "experimenter": "Paul Brown", + "date": "2023-10-09" +} \ No newline at end of file From ba0137f35dd92cbd07ed31c67d58e81633b7722f Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" Date: Sun, 4 May 2025 01:32:14 +0000 Subject: [PATCH 15/22] refactor: change from preview to head --- src/orcabridge/base.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/orcabridge/base.py b/src/orcabridge/base.py index 8e242488..c13c9683 100644 --- a/src/orcabridge/base.py +++ b/src/orcabridge/base.py @@ -164,7 +164,7 @@ def keys(self) -> Tuple[List[str], List[str]]: tag, packet = next(iter(self)) return list(tag.keys()), list(packet.keys()) - def preview(self, n: int = 1) -> None: + def head(self, n: int = 5) -> None: """ Print the first n elements of the stream. This method is useful for previewing the stream From ff933b00df09e50097cc8f03cd1a4412e929b050 Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" Date: Sun, 4 May 2025 01:32:28 +0000 Subject: [PATCH 16/22] fix: repr string for MapPackets --- src/orcabridge/mapper.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/orcabridge/mapper.py b/src/orcabridge/mapper.py index e6a6ae48..56f7a3c5 100644 --- a/src/orcabridge/mapper.py +++ b/src/orcabridge/mapper.py @@ -73,7 +73,7 @@ def generator(): def __repr__(self) -> str: map_repr = ", ".join([f"{k} ⇒ {v}" for k, v in self.key_map.items()]) - return f"MapKeys({map_repr})" + return f"packets({map_repr})" def __hash__(self) -> int: return hash( @@ -112,7 +112,7 @@ def generator(): def __repr__(self) -> str: map_repr = ", ".join([f"{k} ⇒ {v}" for k, v in self.tag_map.items()]) - return f"MapTags({map_repr})" + return f"tags({map_repr})" def __hash__(self) -> int: return hash( From 8a5c50882679183bf872365d20c1222bdf588a8f Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" Date: Sun, 4 May 2025 01:33:00 +0000 Subject: [PATCH 17/22] fix: data store import --- src/orcabridge/pod.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/orcabridge/pod.py b/src/orcabridge/pod.py index 215eaf46..7ea9a6c3 100644 --- a/src/orcabridge/pod.py +++ b/src/orcabridge/pod.py @@ -10,7 +10,7 @@ from .mapper import Join from .stream import SyncStream, SyncStreamFromGenerator from .types import Tag, Packet, PodFunction -from .store import DataStore +from .store import DataStore, NoOpDataStore import json import shutil import functools From 216b1b777313ef2c2f17c2818f3542f019666605 Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" Date: Sun, 4 May 2025 01:33:37 +0000 Subject: [PATCH 18/22] doc: update tutorial notebooks with convenience features --- .../01_orcabridge_core_concepts copy.ipynb | 5 - notebooks/02_orcabridge_basic_usage.ipynb | 515 +++++++++++++++--- notebooks/03_orcabridge_qol_features.ipynb | 486 +++++++++++++++++ notebooks/03_orcabridge_tracker.ipynb | 335 ------------ notebooks/04_orcabridge_tracker.ipynb | 354 ++++++++++++ 5 files changed, 1266 insertions(+), 429 deletions(-) create mode 100644 notebooks/03_orcabridge_qol_features.ipynb delete mode 100644 notebooks/03_orcabridge_tracker.ipynb create mode 100644 notebooks/04_orcabridge_tracker.ipynb diff --git a/notebooks/01_orcabridge_core_concepts copy.ipynb b/notebooks/01_orcabridge_core_concepts copy.ipynb index 48aae52d..590b9777 100644 --- a/notebooks/01_orcabridge_core_concepts copy.ipynb +++ b/notebooks/01_orcabridge_core_concepts copy.ipynb @@ -59,11 +59,6 @@ "* Different pipeline DAG defintion -- In `orcapod` the directed acyclic graph (DAG) for the `pipeline` should be defined using YAML file (or less frequently using API on `pipeline` struct in the Rust library). In `orcabridge` you will find that a `pipeline` DAG is defined dynamically through a series of application of `operation`. This is very much akin to how some DAG-based neural network library like TensorFlow defines a computation graph. While this works well for simple examples, it is rather difficult to track changes to the pipeline defined dynamically/programmatically using version control system. Since *how* you define the pipeline DAG is strictly speaking an orthogonal problem to the everything else that concerns the operation of the `pipeline`, no effort will be given to align the DAG definition in `orcabridge` and `orcapod`.\n", "* Limited usage of a `stream` -- Currently `orcabrdige` only support single producer single consumer (SCSP) `stream`x, whereas in `orcapod`, `stream` should support single producer multiple consumer (SPMC) paradigm. While the same stream can be used in multiple downstream operations, each iteration of the stream actually results in recomputations of the entire chain of pipeline leading up to that stream. This inefficiency can be ameliorated by `CacheStream` operation after particularly computationally expensive segment of the pipeline. Using storage-backed `FunctionPod` will also help ameliorate the cost of recomputation by retrieving memoized computation result instead of recomputing." ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [] } ], "metadata": { diff --git a/notebooks/02_orcabridge_basic_usage.ipynb b/notebooks/02_orcabridge_basic_usage.ipynb index d0e783ba..39019218 100644 --- a/notebooks/02_orcabridge_basic_usage.ipynb +++ b/notebooks/02_orcabridge_basic_usage.ipynb @@ -37,7 +37,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -53,16 +53,24 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[0m\u001b[01;32mday1.txt\u001b[0m* \u001b[01;32mday2.txt\u001b[0m* \u001b[01;32mday3.txt\u001b[0m* \u001b[01;32mday4.txt\u001b[0m*\n" + ] + } + ], "source": [ "ls ../examples/dataset1" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -79,9 +87,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Packet {'txt_file': PosixPath('../examples/dataset1/day1.txt')} with tag {'file_name': 'day1'}\n", + "Packet {'txt_file': PosixPath('../examples/dataset1/day2.txt')} with tag {'file_name': 'day2'}\n", + "Packet {'txt_file': PosixPath('../examples/dataset1/day3.txt')} with tag {'file_name': 'day3'}\n", + "Packet {'txt_file': PosixPath('../examples/dataset1/day4.txt')} with tag {'file_name': 'day4'}\n" + ] + } + ], "source": [ "for tag, packet in dataset1():\n", " print(f\"Packet {packet} with tag {tag}\")" @@ -89,9 +108,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Packet {'txt_file': PosixPath('../examples/dataset1/day1.txt')} with tag {'file_name': 'day1'}\n", + "Packet {'txt_file': PosixPath('../examples/dataset1/day2.txt')} with tag {'file_name': 'day2'}\n", + "Packet {'txt_file': PosixPath('../examples/dataset1/day3.txt')} with tag {'file_name': 'day3'}\n", + "Packet {'txt_file': PosixPath('../examples/dataset1/day4.txt')} with tag {'file_name': 'day4'}\n" + ] + } + ], "source": [ "# equivalent to above but more natural without the need to call `dataset1()`\n", "for tag, packet in dataset1:\n", @@ -107,7 +137,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -123,9 +153,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Packet {'data': PosixPath('../examples/dataset1/day1.txt')} with tag {'date': 'day1'}\n", + "Packet {'data': PosixPath('../examples/dataset1/day2.txt')} with tag {'date': 'day2'}\n", + "Packet {'data': PosixPath('../examples/dataset1/day3.txt')} with tag {'date': 'day3'}\n", + "Packet {'data': PosixPath('../examples/dataset1/day4.txt')} with tag {'date': 'day4'}\n" + ] + } + ], "source": [ "for tag, packet in dataset1_custom:\n", " print(f\"Packet {packet} with tag {tag}\")" @@ -154,9 +195,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Packet {'bin_data': PosixPath('../examples/dataset2/session_day1.bin')} with tag {'file_name': 'session_day1'}\n", + "Packet {'bin_data': PosixPath('../examples/dataset2/session_day3.bin')} with tag {'file_name': 'session_day3'}\n", + "Packet {'bin_data': PosixPath('../examples/dataset2/session_day4.bin')} with tag {'file_name': 'session_day4'}\n", + "Packet {'bin_data': PosixPath('../examples/dataset2/session_day5.bin')} with tag {'file_name': 'session_day5'}\n" + ] + } + ], "source": [ "dataset2 = GlobSource(\"bin_data\", \"../examples/dataset2\", \"*.bin\")\n", "\n", @@ -220,24 +272,41 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Once you have created `source` from which streams can be formed, you can alter the stream by applying various `mappers`. More precisely, a `mapper` can work on tags and/or packets." + "Once you have created a `source` from which streams can be formed, you can alter the stream by applying various `mappers`. More precisely, a `mapper` can work on tags and/or packets." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Map keys\n", - "Likey one of the most common mapper operation to be found in Orcapod pipeline is `MapKeys` mapper. As the name implies, it let's you alter the keys (argument names) found in the `packet`." + "### Map packets\n", + "Likely one of the most common mapper operation to be found in Orcapod pipeline is `MapPackets` mapper. As the name implies, it let's you alter the keys (argument names) found in the `packet`." ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from orcabridge.mapper import MapKeys\n", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Before mapping:\n", + "Packet {'txt_file': PosixPath('../examples/dataset1/day1.txt')} with tag {'file_name': 'day1'}\n", + "Packet {'txt_file': PosixPath('../examples/dataset1/day2.txt')} with tag {'file_name': 'day2'}\n", + "Packet {'txt_file': PosixPath('../examples/dataset1/day3.txt')} with tag {'file_name': 'day3'}\n", + "Packet {'txt_file': PosixPath('../examples/dataset1/day4.txt')} with tag {'file_name': 'day4'}\n", + "After mapping:\n", + "Mapped Packet {'content': PosixPath('../examples/dataset1/day1.txt')} with tag {'file_name': 'day1'}\n", + "Mapped Packet {'content': PosixPath('../examples/dataset1/day2.txt')} with tag {'file_name': 'day2'}\n", + "Mapped Packet {'content': PosixPath('../examples/dataset1/day3.txt')} with tag {'file_name': 'day3'}\n", + "Mapped Packet {'content': PosixPath('../examples/dataset1/day4.txt')} with tag {'file_name': 'day4'}\n" + ] + } + ], + "source": [ + "from orcabridge.mapper import MapPackets\n", "\n", "print(\"Before mapping:\")\n", "for tag, packet in dataset1:\n", @@ -245,10 +314,10 @@ "\n", "\n", "# create a new stream mapping packet keys 'txt_file' to 'content'\n", - "key_mapper = MapKeys(key_map={\"txt_file\": \"content\"})\n", + "packet_mapper = MapPackets(key_map={\"txt_file\": \"content\"})\n", "\n", "print(\"After mapping:\")\n", - "for tag, packet in key_mapper(dataset1):\n", + "for tag, packet in packet_mapper(dataset1):\n", " print(f\"Mapped Packet {packet} with tag {tag}\")" ] }, @@ -256,7 +325,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "You'd notice that for each packet, the key `txt_file` was replaced with `content` without altering the pointed `path` or the associated tag. As the keys of the packets will be used as the name of arguments when invoking pods on a stream, we will see that `MapKeys` are commonly used to *map* the correct path to the argument." + "You'd notice that for each packet, the key `txt_file` was replaced with `content` without altering the pointed `path` or the associated tag. As the keys of the packets will be used as the name of arguments when invoking pods on a stream, we will see that `MapPackets` are commonly used to *map* the correct path to the argument." ] }, { @@ -269,9 +338,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'day': 'day1'} {'txt_file': PosixPath('../examples/dataset1/day1.txt')}\n", + "{'day': 'day2'} {'txt_file': PosixPath('../examples/dataset1/day2.txt')}\n", + "{'day': 'day3'} {'txt_file': PosixPath('../examples/dataset1/day3.txt')}\n", + "{'day': 'day4'} {'txt_file': PosixPath('../examples/dataset1/day4.txt')}\n" + ] + } + ], "source": [ "from orcabridge.mapper import MapTags\n", "\n", @@ -297,17 +377,28 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "key_mapper = MapKeys(key_map={\"txt_file\": \"content\"})\n", - "key_mapped_stream = key_mapper(dataset1)\n", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mapped Packet {'content': PosixPath('../examples/dataset1/day1.txt')} with tag {'day': 'day1'}\n", + "Mapped Packet {'content': PosixPath('../examples/dataset1/day2.txt')} with tag {'day': 'day2'}\n", + "Mapped Packet {'content': PosixPath('../examples/dataset1/day3.txt')} with tag {'day': 'day3'}\n", + "Mapped Packet {'content': PosixPath('../examples/dataset1/day4.txt')} with tag {'day': 'day4'}\n" + ] + } + ], + "source": [ + "packet_mapper = MapPackets(key_map={\"txt_file\": \"content\"})\n", + "key_mapped_stream = packet_mapper(dataset1)\n", "\n", "tag_mapper = MapTags(tag_map={\"file_name\": \"day\"})\n", - "tag_and_key_mapped = tag_mapper(key_mapped_stream)\n", + "tag_and_packet_mapped = tag_mapper(key_mapped_stream)\n", "\n", - "for tag, packet in tag_and_key_mapped:\n", + "for tag, packet in tag_and_packet_mapped:\n", " print(f\"Mapped Packet {packet} with tag {tag}\")" ] }, @@ -327,13 +418,24 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mapped Packet {'content': PosixPath('../examples/dataset1/day1.txt')} with tag {'day': 'day1'}\n", + "Mapped Packet {'content': PosixPath('../examples/dataset1/day2.txt')} with tag {'day': 'day2'}\n", + "Mapped Packet {'content': PosixPath('../examples/dataset1/day3.txt')} with tag {'day': 'day3'}\n", + "Mapped Packet {'content': PosixPath('../examples/dataset1/day4.txt')} with tag {'day': 'day4'}\n" + ] + } + ], "source": [ "# totally valid, but difficult to read and thus not recommended\n", "for tag, packet in MapTags(tag_map={\"file_name\": \"day\"})(\n", - " MapKeys(key_map={\"txt_file\": \"content\"})(dataset1)\n", + " MapPackets(key_map={\"txt_file\": \"content\"})(dataset1)\n", "):\n", " print(f\"Mapped Packet {packet} with tag {tag}\")" ] @@ -358,9 +460,27 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dataset 1:\n", + "Tag: {'file_name': 'day1'}, Packet: {'txt_file': PosixPath('../examples/dataset1/day1.txt')}\n", + "Tag: {'file_name': 'day2'}, Packet: {'txt_file': PosixPath('../examples/dataset1/day2.txt')}\n", + "Tag: {'file_name': 'day3'}, Packet: {'txt_file': PosixPath('../examples/dataset1/day3.txt')}\n", + "Tag: {'file_name': 'day4'}, Packet: {'txt_file': PosixPath('../examples/dataset1/day4.txt')}\n", + "\n", + "Dataset 2:\n", + "Tag: {'file_name': 'session_day1'}, Packet: {'bin_data': PosixPath('../examples/dataset2/session_day1.bin')}\n", + "Tag: {'file_name': 'session_day3'}, Packet: {'bin_data': PosixPath('../examples/dataset2/session_day3.bin')}\n", + "Tag: {'file_name': 'session_day4'}, Packet: {'bin_data': PosixPath('../examples/dataset2/session_day4.bin')}\n", + "Tag: {'file_name': 'session_day5'}, Packet: {'bin_data': PosixPath('../examples/dataset2/session_day5.bin')}\n" + ] + } + ], "source": [ "# dataset 1\n", "print(\"Dataset 1:\")\n", @@ -382,7 +502,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -417,9 +537,32 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "01 Tag: {'day': 'day1', 'file_name': 'session_day1'}, Packet: {'txt_file': PosixPath('../examples/dataset1/day1.txt'), 'bin_data': PosixPath('../examples/dataset2/session_day1.bin')}\n", + "02 Tag: {'day': 'day1', 'file_name': 'session_day3'}, Packet: {'txt_file': PosixPath('../examples/dataset1/day1.txt'), 'bin_data': PosixPath('../examples/dataset2/session_day3.bin')}\n", + "03 Tag: {'day': 'day1', 'file_name': 'session_day4'}, Packet: {'txt_file': PosixPath('../examples/dataset1/day1.txt'), 'bin_data': PosixPath('../examples/dataset2/session_day4.bin')}\n", + "04 Tag: {'day': 'day1', 'file_name': 'session_day5'}, Packet: {'txt_file': PosixPath('../examples/dataset1/day1.txt'), 'bin_data': PosixPath('../examples/dataset2/session_day5.bin')}\n", + "05 Tag: {'day': 'day2', 'file_name': 'session_day1'}, Packet: {'txt_file': PosixPath('../examples/dataset1/day2.txt'), 'bin_data': PosixPath('../examples/dataset2/session_day1.bin')}\n", + "06 Tag: {'day': 'day2', 'file_name': 'session_day3'}, Packet: {'txt_file': PosixPath('../examples/dataset1/day2.txt'), 'bin_data': PosixPath('../examples/dataset2/session_day3.bin')}\n", + "07 Tag: {'day': 'day2', 'file_name': 'session_day4'}, Packet: {'txt_file': PosixPath('../examples/dataset1/day2.txt'), 'bin_data': PosixPath('../examples/dataset2/session_day4.bin')}\n", + "08 Tag: {'day': 'day2', 'file_name': 'session_day5'}, Packet: {'txt_file': PosixPath('../examples/dataset1/day2.txt'), 'bin_data': PosixPath('../examples/dataset2/session_day5.bin')}\n", + "09 Tag: {'day': 'day3', 'file_name': 'session_day1'}, Packet: {'txt_file': PosixPath('../examples/dataset1/day3.txt'), 'bin_data': PosixPath('../examples/dataset2/session_day1.bin')}\n", + "10 Tag: {'day': 'day3', 'file_name': 'session_day3'}, Packet: {'txt_file': PosixPath('../examples/dataset1/day3.txt'), 'bin_data': PosixPath('../examples/dataset2/session_day3.bin')}\n", + "11 Tag: {'day': 'day3', 'file_name': 'session_day4'}, Packet: {'txt_file': PosixPath('../examples/dataset1/day3.txt'), 'bin_data': PosixPath('../examples/dataset2/session_day4.bin')}\n", + "12 Tag: {'day': 'day3', 'file_name': 'session_day5'}, Packet: {'txt_file': PosixPath('../examples/dataset1/day3.txt'), 'bin_data': PosixPath('../examples/dataset2/session_day5.bin')}\n", + "13 Tag: {'day': 'day4', 'file_name': 'session_day1'}, Packet: {'txt_file': PosixPath('../examples/dataset1/day4.txt'), 'bin_data': PosixPath('../examples/dataset2/session_day1.bin')}\n", + "14 Tag: {'day': 'day4', 'file_name': 'session_day3'}, Packet: {'txt_file': PosixPath('../examples/dataset1/day4.txt'), 'bin_data': PosixPath('../examples/dataset2/session_day3.bin')}\n", + "15 Tag: {'day': 'day4', 'file_name': 'session_day4'}, Packet: {'txt_file': PosixPath('../examples/dataset1/day4.txt'), 'bin_data': PosixPath('../examples/dataset2/session_day4.bin')}\n", + "16 Tag: {'day': 'day4', 'file_name': 'session_day5'}, Packet: {'txt_file': PosixPath('../examples/dataset1/day4.txt'), 'bin_data': PosixPath('../examples/dataset2/session_day5.bin')}\n" + ] + } + ], "source": [ "dataset1_retagged = MapTags(tag_map={\"file_name\": \"day\"})(dataset1)\n", "\n", @@ -456,9 +599,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Tag: {'day': 'day1'}, Packet: {'bin_data': PosixPath('../examples/dataset2/session_day1.bin')}\n", + "Tag: {'day': 'day3'}, Packet: {'bin_data': PosixPath('../examples/dataset2/session_day3.bin')}\n", + "Tag: {'day': 'day4'}, Packet: {'bin_data': PosixPath('../examples/dataset2/session_day4.bin')}\n", + "Tag: {'day': 'day5'}, Packet: {'bin_data': PosixPath('../examples/dataset2/session_day5.bin')}\n" + ] + } + ], "source": [ "from orcabridge.mapper import Transform\n", "\n", @@ -486,9 +640,19 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Tag: {'day': 'day1'}, Packet: {'txt_file': PosixPath('../examples/dataset1/day1.txt'), 'bin_data': PosixPath('../examples/dataset2/session_day1.bin')}\n", + "Tag: {'day': 'day3'}, Packet: {'txt_file': PosixPath('../examples/dataset1/day3.txt'), 'bin_data': PosixPath('../examples/dataset2/session_day3.bin')}\n", + "Tag: {'day': 'day4'}, Packet: {'txt_file': PosixPath('../examples/dataset1/day4.txt'), 'bin_data': PosixPath('../examples/dataset2/session_day4.bin')}\n" + ] + } + ], "source": [ "# change filename to day for dataset1\n", "tag_mapper = MapTags(tag_map={\"file_name\": \"day\"})\n", @@ -551,7 +715,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ @@ -573,7 +737,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ @@ -592,9 +756,24 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "File ../examples/dataset1/day1.txt has 24 lines.\n", + "Tag: {'file_name': 'day1'}, Packet: {}\n", + "File ../examples/dataset1/day2.txt has 15 lines.\n", + "Tag: {'file_name': 'day2'}, Packet: {}\n", + "File ../examples/dataset1/day3.txt has 27 lines.\n", + "Tag: {'file_name': 'day3'}, Packet: {}\n", + "File ../examples/dataset1/day4.txt has 22 lines.\n", + "Tag: {'file_name': 'day4'}, Packet: {}\n" + ] + } + ], "source": [ "# apply the function pod on a stream\n", "processed_stream = function_pod(dataset1)\n", @@ -614,7 +793,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "metadata": {}, "outputs": [], "source": [ @@ -648,14 +827,52 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Computing stats for file: ../examples/dataset2/session_day1.bin\n", + "[-1.08209134 -0.66806394 0.42870206 -0.09321731 -3.14078305 1.33520433\n", + " 1.11085152 1.31931842 -1.19915697 0.07701737 1.30020807 0.27541194\n", + " 0.84430062 0.18236837 -0.83039631 -1.66166191 0.8720775 -1.72170657\n", + " -0.01962253 -0.18050553 1.35478472 0.69928177 0.7314272 -0.06915687\n", + " -0.08364667 -0.45551653 0.70752188 1.02283734 -0.18612795 0.8767394\n", + " -1.542636 1.04685484 -2.1311672 -1.34874222 0.61977577 -0.33880262\n", + " 0.6624482 0.60257325 -3.04901544 -0.20685843 -0.08997232 0.88932232]\n", + "Tag: {'file_name': 'session_day1'}, Packet: {'stats': PosixPath('/tmp/tmpkvszterb/statistics.json')}\n", + "Computing stats for file: ../examples/dataset2/session_day3.bin\n", + "[ 0.56114059 -1.34902274 1.0665563 0.71890802 0.65244834 1.04369548\n", + " 0.54872876 2.19365207 0.53864286 -1.44108823 -0.55651539 0.1603561\n", + " -0.93869224 0.64645323 -1.08815337 1.40972393 -0.14662931 1.34692375\n", + " 0.38400938 -1.23004316 1.34426647 -0.07620065 -0.91983972 0.23537101\n", + " 0.91515395 0.8064348 0.81470895 -1.04466683 -0.25893558 -1.46253167\n", + " 1.39972807 -0.13940519]\n", + "Tag: {'file_name': 'session_day3'}, Packet: {'stats': PosixPath('/tmp/tmptq70w_c5/statistics.json')}\n", + "Computing stats for file: ../examples/dataset2/session_day4.bin\n", + "[ 0.70078854 1.18137906 -0.44361437 -0.389409 0.29719038 0.2523247\n", + " -0.97418716 0.49301127 0.07900351 -0.29965042 -0.25810762 -2.78777445\n", + " -1.24321702 0.13011593 1.07826637 -0.33177479 -0.78337033 -1.30075356\n", + " -0.15710138 0.51927589 0.08671884 0.02058063 0.20778149 -1.40382559\n", + " -0.69978105 -1.10525753 0.1945444 0.82623748 0.17467868]\n", + "Tag: {'file_name': 'session_day4'}, Packet: {'stats': PosixPath('/tmp/tmpbklxiav3/statistics.json')}\n", + "Computing stats for file: ../examples/dataset2/session_day5.bin\n", + "[ 1.9125739 -0.05252076 0.33347618 0.31627214 0.47141153 -0.71088615\n", + " -0.74745805 0.53959117 -0.14395142 -0.28713782 -0.29422236 -1.00231383\n", + " 0.69566576 -0.25895608 -0.9660761 -0.78504297 -1.91668262 0.89452296\n", + " -0.82748688 -0.19792482 0.07305616 0.36133414 1.7164791 0.64364619\n", + " -0.73146429 0.96324864 -1.05981222 -0.59502066 0.15084192]\n", + "Tag: {'file_name': 'session_day5'}, Packet: {'stats': PosixPath('/tmp/tmpyyu7uuv3/statistics.json')}\n" + ] + } + ], "source": [ "fp_stats = FunctionPod(compute_stats, output_keys=[\"stats\"])\n", "\n", "# change the key from 'bin_data' to 'bin_file', matching the function's input\n", - "mapped_dataset2 = MapKeys(key_map={\"bin_data\": \"bin_file\"})(dataset2)\n", + "mapped_dataset2 = MapPackets(key_map={\"bin_data\": \"bin_file\"})(dataset2)\n", "\n", "for tag, packet in fp_stats(mapped_dataset2):\n", " print(f\"Tag: {tag}, Packet: {packet}\")" @@ -670,9 +887,47 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Computing stats for file: ../examples/dataset2/session_day1.bin\n", + "[-1.08209134 -0.66806394 0.42870206 -0.09321731 -3.14078305 1.33520433\n", + " 1.11085152 1.31931842 -1.19915697 0.07701737 1.30020807 0.27541194\n", + " 0.84430062 0.18236837 -0.83039631 -1.66166191 0.8720775 -1.72170657\n", + " -0.01962253 -0.18050553 1.35478472 0.69928177 0.7314272 -0.06915687\n", + " -0.08364667 -0.45551653 0.70752188 1.02283734 -0.18612795 0.8767394\n", + " -1.542636 1.04685484 -2.1311672 -1.34874222 0.61977577 -0.33880262\n", + " 0.6624482 0.60257325 -3.04901544 -0.20685843 -0.08997232 0.88932232]\n", + "Tag: {'file_name': 'session_day1'}, Packet: {'stats': PosixPath('/tmp/tmpe8mkncg3/statistics.json')}\n", + "Computing stats for file: ../examples/dataset2/session_day3.bin\n", + "[ 0.56114059 -1.34902274 1.0665563 0.71890802 0.65244834 1.04369548\n", + " 0.54872876 2.19365207 0.53864286 -1.44108823 -0.55651539 0.1603561\n", + " -0.93869224 0.64645323 -1.08815337 1.40972393 -0.14662931 1.34692375\n", + " 0.38400938 -1.23004316 1.34426647 -0.07620065 -0.91983972 0.23537101\n", + " 0.91515395 0.8064348 0.81470895 -1.04466683 -0.25893558 -1.46253167\n", + " 1.39972807 -0.13940519]\n", + "Tag: {'file_name': 'session_day3'}, Packet: {'stats': PosixPath('/tmp/tmp8a18mk4f/statistics.json')}\n", + "Computing stats for file: ../examples/dataset2/session_day4.bin\n", + "[ 0.70078854 1.18137906 -0.44361437 -0.389409 0.29719038 0.2523247\n", + " -0.97418716 0.49301127 0.07900351 -0.29965042 -0.25810762 -2.78777445\n", + " -1.24321702 0.13011593 1.07826637 -0.33177479 -0.78337033 -1.30075356\n", + " -0.15710138 0.51927589 0.08671884 0.02058063 0.20778149 -1.40382559\n", + " -0.69978105 -1.10525753 0.1945444 0.82623748 0.17467868]\n", + "Tag: {'file_name': 'session_day4'}, Packet: {'stats': PosixPath('/tmp/tmpx3qugl6g/statistics.json')}\n", + "Computing stats for file: ../examples/dataset2/session_day5.bin\n", + "[ 1.9125739 -0.05252076 0.33347618 0.31627214 0.47141153 -0.71088615\n", + " -0.74745805 0.53959117 -0.14395142 -0.28713782 -0.29422236 -1.00231383\n", + " 0.69566576 -0.25895608 -0.9660761 -0.78504297 -1.91668262 0.89452296\n", + " -0.82748688 -0.19792482 0.07305616 0.36133414 1.7164791 0.64364619\n", + " -0.73146429 0.96324864 -1.05981222 -0.59502066 0.15084192]\n", + "Tag: {'file_name': 'session_day5'}, Packet: {'stats': PosixPath('/tmp/tmp0a356pkt/statistics.json')}\n" + ] + } + ], "source": [ "# everytime you run the following loop, new computations are performed and\n", "# saved in a different set of temporary files\n", @@ -703,16 +958,54 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Computing stats for file: ../examples/dataset2/session_day1.bin\n", + "[-1.08209134 -0.66806394 0.42870206 -0.09321731 -3.14078305 1.33520433\n", + " 1.11085152 1.31931842 -1.19915697 0.07701737 1.30020807 0.27541194\n", + " 0.84430062 0.18236837 -0.83039631 -1.66166191 0.8720775 -1.72170657\n", + " -0.01962253 -0.18050553 1.35478472 0.69928177 0.7314272 -0.06915687\n", + " -0.08364667 -0.45551653 0.70752188 1.02283734 -0.18612795 0.8767394\n", + " -1.542636 1.04685484 -2.1311672 -1.34874222 0.61977577 -0.33880262\n", + " 0.6624482 0.60257325 -3.04901544 -0.20685843 -0.08997232 0.88932232]\n", + "Tag: {'file_name': 'session_day1'}, Packet: {'stats': PosixPath('/tmp/tmpn5thbtoi/statistics.json')}\n", + "Computing stats for file: ../examples/dataset2/session_day3.bin\n", + "[ 0.56114059 -1.34902274 1.0665563 0.71890802 0.65244834 1.04369548\n", + " 0.54872876 2.19365207 0.53864286 -1.44108823 -0.55651539 0.1603561\n", + " -0.93869224 0.64645323 -1.08815337 1.40972393 -0.14662931 1.34692375\n", + " 0.38400938 -1.23004316 1.34426647 -0.07620065 -0.91983972 0.23537101\n", + " 0.91515395 0.8064348 0.81470895 -1.04466683 -0.25893558 -1.46253167\n", + " 1.39972807 -0.13940519]\n", + "Tag: {'file_name': 'session_day3'}, Packet: {'stats': PosixPath('/tmp/tmpgdredw2e/statistics.json')}\n", + "Computing stats for file: ../examples/dataset2/session_day4.bin\n", + "[ 0.70078854 1.18137906 -0.44361437 -0.389409 0.29719038 0.2523247\n", + " -0.97418716 0.49301127 0.07900351 -0.29965042 -0.25810762 -2.78777445\n", + " -1.24321702 0.13011593 1.07826637 -0.33177479 -0.78337033 -1.30075356\n", + " -0.15710138 0.51927589 0.08671884 0.02058063 0.20778149 -1.40382559\n", + " -0.69978105 -1.10525753 0.1945444 0.82623748 0.17467868]\n", + "Tag: {'file_name': 'session_day4'}, Packet: {'stats': PosixPath('/tmp/tmp5dvgc23y/statistics.json')}\n", + "Computing stats for file: ../examples/dataset2/session_day5.bin\n", + "[ 1.9125739 -0.05252076 0.33347618 0.31627214 0.47141153 -0.71088615\n", + " -0.74745805 0.53959117 -0.14395142 -0.28713782 -0.29422236 -1.00231383\n", + " 0.69566576 -0.25895608 -0.9660761 -0.78504297 -1.91668262 0.89452296\n", + " -0.82748688 -0.19792482 0.07305616 0.36133414 1.7164791 0.64364619\n", + " -0.73146429 0.96324864 -1.05981222 -0.59502066 0.15084192]\n", + "Tag: {'file_name': 'session_day5'}, Packet: {'stats': PosixPath('/tmp/tmpwh1a8zyb/statistics.json')}\n" + ] + } + ], "source": [ "from orcabridge.mapper import CacheStream\n", "\n", "# create a cache stream operation\n", "cache_stream = CacheStream()\n", "# change the key from 'bin_data' to 'bin_file', matching the function's input\n", - "mapped_dataset2 = MapKeys(key_map={\"bin_data\": \"bin_file\"})(dataset2)\n", + "mapped_dataset2 = MapPackets(key_map={\"bin_data\": \"bin_file\"})(dataset2)\n", "stats_stream = fp_stats(mapped_dataset2)\n", "\n", "# now cache the stream\n", @@ -732,9 +1025,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Tag: {'file_name': 'session_day1'}, Packet: {'stats': PosixPath('/tmp/tmpn5thbtoi/statistics.json')}\n", + "Tag: {'file_name': 'session_day3'}, Packet: {'stats': PosixPath('/tmp/tmpgdredw2e/statistics.json')}\n", + "Tag: {'file_name': 'session_day4'}, Packet: {'stats': PosixPath('/tmp/tmp5dvgc23y/statistics.json')}\n", + "Tag: {'file_name': 'session_day5'}, Packet: {'stats': PosixPath('/tmp/tmpwh1a8zyb/statistics.json')}\n" + ] + } + ], "source": [ "for tag, packet in cached_stream:\n", " print(f\"Tag: {tag}, Packet: {packet}\")" @@ -760,35 +1064,57 @@ "source": [ "Although the simple `FunctionPod` worked as expected, it's lack of ability to store computation results significantly limits its utility. You certainly wouldn't want to be computing everything from scratch if it can be avoided.\n", "\n", - "This is where storage-backed function pods step in. As the name indicates, these are `FunctionPod` that has a stroage back-end that allows for the computation results to be **memoized**, such that if the same function call with identical inputs occur, the *memoized* result will be returned instead of computing it again.\n", + "The good news is that you can easily equip a function pod with an ability to store and retrieve previously stored packets. All you have to do is create an instance of `DataStore` and pass it in at the construction of the `FunctionPod`.\n", "\n", - "Let's take a look at a specific example of stroage-backed function pod, `FunctionpodWithDirStorage`, which as the name suggests, stores the computation results into a directory you specify. If you omit the directory specification, it will automatically create and store the result in the local directory `./pod_data`" + "Here we are going to configure and use `DirDataStore` where all `packets` and output `packet` contents are stored in a designated directory." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 26, "metadata": {}, "outputs": [], "source": [ - "from orcabridge.pod import FunctionPodWithDirStorage\n", + "from orcabridge.store import DirDataStore\n", "\n", + "data_store = DirDataStore(\"./pod_data\")" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ "# use default storage directory of './pod_data'. You could specify a different directory by passing `store_dir` argument\n", - "fp_stats_stored = FunctionPodWithDirStorage(compute_stats, output_keys=[\"stats\"])" + "fp_stats_stored = FunctionPod(\n", + " compute_stats, output_keys=[\"stats\"], data_store=data_store\n", + ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Once created, stored `FunctionPod` can be used in an identical fashion to a regular `FunctionPod`" + "Now your `FunctionPod` is equipped with an ability to store and retrieve stored packets!" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Tag: {'file_name': 'session_day1'}, Packet: {'stats': 'pod_data/compute_stats/4f87e2b3-fe44-ea43-6eee-70f63e6d0e95/statistics.json'}\n", + "Tag: {'file_name': 'session_day3'}, Packet: {'stats': 'pod_data/compute_stats/eb5c269e-d64d-278a-abc1-afe50716d21a/statistics.json'}\n", + "Tag: {'file_name': 'session_day4'}, Packet: {'stats': 'pod_data/compute_stats/ba148557-207e-9a7e-6ee2-353dc861cefa/statistics.json'}\n", + "Tag: {'file_name': 'session_day5'}, Packet: {'stats': 'pod_data/compute_stats/8de9dd2c-fa49-bae2-9c60-d4e84cba136e/statistics.json'}\n" + ] + } + ], "source": [ "for tag, packet in fp_stats_stored(mapped_dataset2):\n", " print(f\"Tag: {tag}, Packet: {packet}\")" @@ -803,9 +1129,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Tag: {'file_name': 'session_day1'}, Packet: {'stats': 'pod_data/compute_stats/4f87e2b3-fe44-ea43-6eee-70f63e6d0e95/statistics.json'}\n", + "Tag: {'file_name': 'session_day3'}, Packet: {'stats': 'pod_data/compute_stats/eb5c269e-d64d-278a-abc1-afe50716d21a/statistics.json'}\n", + "Tag: {'file_name': 'session_day4'}, Packet: {'stats': 'pod_data/compute_stats/ba148557-207e-9a7e-6ee2-353dc861cefa/statistics.json'}\n", + "Tag: {'file_name': 'session_day5'}, Packet: {'stats': 'pod_data/compute_stats/8de9dd2c-fa49-bae2-9c60-d4e84cba136e/statistics.json'}\n" + ] + } + ], "source": [ "for tag, packet in fp_stats_stored(mapped_dataset2):\n", " print(f\"Tag: {tag}, Packet: {packet}\")" diff --git a/notebooks/03_orcabridge_qol_features.ipynb b/notebooks/03_orcabridge_qol_features.ipynb new file mode 100644 index 00000000..338d3766 --- /dev/null +++ b/notebooks/03_orcabridge_qol_features.ipynb @@ -0,0 +1,486 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "58c56103", + "metadata": {}, + "source": [ + "# QoL Improving Features of `orcabridge`" + ] + }, + { + "cell_type": "markdown", + "id": "b16b1b64", + "metadata": {}, + "source": [ + "In the [previous notebook](./02-02-advanced-usage.ipynb), we explored the `orcabridge` package and learned how to build and execute a simple pipeline using concepts like `streams`, `operations` and `pods`." + ] + }, + { + "cell_type": "markdown", + "id": "90a30ec7", + "metadata": {}, + "source": [ + "For an example, we saw that we can define a function pod to wrap a function and to feed in a stream with the packet keys properly mapped into argument names expected by the pod:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "f5339f87", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Tag: {'file_name': 'day1'}, Packet: {'output_data': 'path/to/result/file'}\n", + "Tag: {'file_name': 'day2'}, Packet: {'output_data': 'path/to/result/file'}\n", + "Tag: {'file_name': 'day3'}, Packet: {'output_data': 'path/to/result/file'}\n", + "Tag: {'file_name': 'day4'}, Packet: {'output_data': 'path/to/result/file'}\n" + ] + } + ], + "source": [ + "from orcabridge.source import GlobSource\n", + "from orcabridge.pod import FunctionPod\n", + "from orcabridge.mapper import MapPackets\n", + "\n", + "source = GlobSource(\"text_file\", \"../examples/dataset1\", \"*.txt\")\n", + "\n", + "\n", + "def process_data(data):\n", + " # perform data processing on data\n", + " # return result file path\n", + " return \"path/to/result/file\"\n", + "\n", + "\n", + "fp_process = FunctionPod(process_data, [\"output_data\"])\n", + "\n", + "packet_mapper = MapPackets({\"text_file\": \"data\"}) # map packet key text_file to data\n", + "\n", + "# chain them together into a pipeline\n", + "mapped_stream = packet_mapper(source)\n", + "processed_data_stream = fp_process(mapped_stream)\n", + "\n", + "processed_data_stream.head() # see the first 5 packets" + ] + }, + { + "cell_type": "markdown", + "id": "d9b7f902", + "metadata": {}, + "source": [ + "While separately creating all `mapper` and `pods` and then chaining them helps to rigorously define the data pipeline, admittedly it can get quite verbose and cumbersome.\n", + "\n", + "Fortunately, `orcabrdige` has a number of quality-of-life (QoL) improving features that will help you much more quickly create and combine `operations` and `streams` to define your pipeline without losing the full expressivity. In this notebook, we will explore such QoL improvement features together." + ] + }, + { + "cell_type": "markdown", + "id": "78e8c206", + "metadata": {}, + "source": [ + "## `function_pod` decorator for simple `FunctionPod` creation" + ] + }, + { + "cell_type": "markdown", + "id": "f398fcfd", + "metadata": {}, + "source": [ + "We saw that we can use `FunctionPod` class to wrap an existing function and to associate `output_keys` to rigorously define a `FunctionPod` object that can be used to perform computations on streams of data.\n", + "\n", + "Often, you'd want to define a function intending to only use it as a `FunctionPod`. In that case, you can simplify the `FunctionPod` creation by decorating the function with the `function_pod` decorator:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "9703d751", + "metadata": {}, + "outputs": [], + "source": [ + "from orcabridge.pod import function_pod\n", + "import json\n", + "import tempfile\n", + "from pathlib import Path\n", + "\n", + "json_source = GlobSource(\"json_file\", \"../examples/dataset2\", \"*.json\")\n", + "\n", + "\n", + "@function_pod([\"output_data\"])\n", + "def extract_name_from_json(json_file):\n", + " with open(json_file, \"r\") as f:\n", + " data = json.load(f)\n", + " output_data = {\"info\": \"\"}\n", + " if \"name\" in data:\n", + " output_data[\"info\"] = data[\"name\"]\n", + " output_path = Path(tempfile.mkdtemp()) / \"output.json\"\n", + " with open(output_path, \"w\") as f:\n", + " json.dump(output_data, f)\n", + " return output_path" + ] + }, + { + "cell_type": "markdown", + "id": "f3ffe3d6", + "metadata": {}, + "source": [ + "With the above code, the decorator takes the decorated function and creates a FunctionPod with the specified output arguments (\"output_data\" in this case).\n", + "\n", + "The name `extract_name_from_json` now holds the resulting `FunctionPod` that can be immeidately applied to a stream." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "1e2b5d86", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Tag: {'file_name': 'info_day1'}, Packet: {'output_data': PosixPath('/tmp/tmpn0nn30b3/output.json')}\n", + "Tag: {'file_name': 'info_day2'}, Packet: {'output_data': PosixPath('/tmp/tmpqg13bjib/output.json')}\n", + "Tag: {'file_name': 'info_day3'}, Packet: {'output_data': PosixPath('/tmp/tmp1f_08m5t/output.json')}\n", + "Tag: {'file_name': 'info_day4'}, Packet: {'output_data': PosixPath('/tmp/tmpq3x8a298/output.json')}\n", + "Tag: {'file_name': 'info_day5'}, Packet: {'output_data': PosixPath('/tmp/tmp_cma7686/output.json')}\n" + ] + } + ], + "source": [ + "extract_name_from_json(json_source).head() # preview the first 5 packets" + ] + }, + { + "cell_type": "markdown", + "id": "1ca2aa60", + "metadata": {}, + "source": [ + "If you need to access the original function, it can be retrieved by accessing the `function` attribute" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "c5dc8a46", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'info': 'Day 2 experiment'}\n" + ] + } + ], + "source": [ + "output_path = extract_name_from_json.function(\"../examples/dataset2/info_day2.json\")\n", + "\n", + "with open(output_path, \"r\") as f:\n", + " data = json.load(f)\n", + " print(data) # {'info': 'John Doe'}" + ] + }, + { + "cell_type": "markdown", + "id": "bea0880a", + "metadata": {}, + "source": [ + "## Mapping tags and packets with `>>` operator" + ] + }, + { + "cell_type": "markdown", + "id": "7a1e38e4", + "metadata": {}, + "source": [ + "As you chain multiple pods together forming a complex pipeline, you are bound to make frequent use of `MapPackets` to *rename* the output argument from one pod into another argunemt name for the next pod. We have already seen how this can be achieved by creating a specific instance of `MapPackets`, initializing the object with a dictionary defining the name mapping." + ] + }, + { + "cell_type": "markdown", + "id": "af660c4f", + "metadata": {}, + "source": [ + "Consider the following data source and function pod:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "c30e1e4a", + "metadata": {}, + "outputs": [], + "source": [ + "json_files = GlobSource(\"json_file\", \"../examples/dataset2\", \"*.json\")\n", + "\n", + "\n", + "@function_pod([\"line_count\"])\n", + "def count_lines(text_file):\n", + " with open(text_file, \"r\") as f:\n", + " lines = f.readlines()\n", + " line_count = len(lines)\n", + " output_path = Path(tempfile.mkdtemp()) / \"line_count.json\"\n", + " with open(output_path, \"w\") as f:\n", + " json.dump({\"line_count\": line_count}, f)\n", + " return output_path" + ] + }, + { + "cell_type": "markdown", + "id": "6788ff05", + "metadata": {}, + "source": [ + "If I want to apply the function pod to count and save the number of lines present in the JSON files from the data source, I will have to create a `MapPackets` that renames the output argument `\"json_file\"` itno `\"text_file\"` expected by the `count_lines` function." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "2d171b0e", + "metadata": {}, + "outputs": [], + "source": [ + "json_to_text = MapPackets(\n", + " {\"json_file\": \"text_file\"}\n", + ") # map packet key json_file to text_file" + ] + }, + { + "cell_type": "markdown", + "id": "c7994b9b", + "metadata": {}, + "source": [ + "Finally we can chain them together into a functional pipeline:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "d48fc20c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Tag: {'file_name': 'info_day1'}, Packet: {'line_count': PosixPath('/tmp/tmpbrelyuro/line_count.json')}\n", + "Tag: {'file_name': 'info_day2'}, Packet: {'line_count': PosixPath('/tmp/tmp1mgotcqw/line_count.json')}\n", + "Tag: {'file_name': 'info_day3'}, Packet: {'line_count': PosixPath('/tmp/tmp8mjlafrx/line_count.json')}\n", + "Tag: {'file_name': 'info_day4'}, Packet: {'line_count': PosixPath('/tmp/tmpvs_r2obl/line_count.json')}\n", + "Tag: {'file_name': 'info_day5'}, Packet: {'line_count': PosixPath('/tmp/tmpha6qrjs2/line_count.json')}\n" + ] + } + ], + "source": [ + "line_info = count_lines(json_to_text(json_files))\n", + "\n", + "line_info.head() # preview the first 5 packets" + ] + }, + { + "cell_type": "markdown", + "id": "09d9da59", + "metadata": {}, + "source": [ + "This is all fine until you start having many more `Pods` and `streams` in your pipeline that needs to be connected together. Many of these connection would need the `MapPackets` `mapper` to be inserted for the function to work properly -- that could be a lot of `MapPackets` you have to create!" + ] + }, + { + "cell_type": "markdown", + "id": "063cc9e7", + "metadata": {}, + "source": [ + "Because `MapPackets` is such a common operation, `orcabridge` provides a very simple shortcut for creating a *mapped stream* from another stream using right shift (`>>`) operator." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "10437185", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Tag: {'file_name': 'info_day1'}, Packet: {'text_file': PosixPath('../examples/dataset2/info_day1.json')}\n", + "Tag: {'file_name': 'info_day2'}, Packet: {'text_file': PosixPath('../examples/dataset2/info_day2.json')}\n", + "Tag: {'file_name': 'info_day3'}, Packet: {'text_file': PosixPath('../examples/dataset2/info_day3.json')}\n", + "Tag: {'file_name': 'info_day4'}, Packet: {'text_file': PosixPath('../examples/dataset2/info_day4.json')}\n", + "Tag: {'file_name': 'info_day5'}, Packet: {'text_file': PosixPath('../examples/dataset2/info_day5.json')}\n", + "Tag: {'file_name': 'info_day1'}, Packet: {'line_count': PosixPath('/tmp/tmp_o8blef4/line_count.json')}\n", + "Tag: {'file_name': 'info_day2'}, Packet: {'line_count': PosixPath('/tmp/tmp7s3mk_9p/line_count.json')}\n", + "Tag: {'file_name': 'info_day3'}, Packet: {'line_count': PosixPath('/tmp/tmpdv672rbb/line_count.json')}\n", + "Tag: {'file_name': 'info_day4'}, Packet: {'line_count': PosixPath('/tmp/tmpbvxkwo29/line_count.json')}\n", + "Tag: {'file_name': 'info_day5'}, Packet: {'line_count': PosixPath('/tmp/tmp26qs4pk8/line_count.json')}\n" + ] + } + ], + "source": [ + "mapped_stream = json_files >> {\"json_file\": \"text_file\"}\n", + "\n", + "mapped_stream.head()\n", + "\n", + "count_lines(mapped_stream).head()" + ] + }, + { + "cell_type": "markdown", + "id": "3cd02672", + "metadata": {}, + "source": [ + "That's it! Hopefully you'd agree that this is far more convenient than having to define your own `MapPackets` mapper! Using the `>>` operator, the whole pipeline would have looked like:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "9be9f86d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Tag: {'file_name': 'info_day1'}, Packet: {'line_count': PosixPath('/tmp/tmpcscf2auv/line_count.json')}\n", + "Tag: {'file_name': 'info_day2'}, Packet: {'line_count': PosixPath('/tmp/tmpwtsrkvg4/line_count.json')}\n", + "Tag: {'file_name': 'info_day3'}, Packet: {'line_count': PosixPath('/tmp/tmpw4cj_kso/line_count.json')}\n", + "Tag: {'file_name': 'info_day4'}, Packet: {'line_count': PosixPath('/tmp/tmpyo6pc_fw/line_count.json')}\n", + "Tag: {'file_name': 'info_day5'}, Packet: {'line_count': PosixPath('/tmp/tmp3up8exm6/line_count.json')}\n" + ] + } + ], + "source": [ + "# preview the first 5 packets\n", + "count_lines(json_files >> {\"json_file\": \"text_file\"}).head()" + ] + }, + { + "cell_type": "markdown", + "id": "24a4d11e", + "metadata": {}, + "source": [ + "Not only is this simpler to type, we believe it actually makes the pipeline creation more intuitive and expressive of your intention!" + ] + }, + { + "cell_type": "markdown", + "id": "18ec64f3", + "metadata": {}, + "source": [ + "### Mapping tags and advanced mapping" + ] + }, + { + "cell_type": "markdown", + "id": "05e8ff25", + "metadata": {}, + "source": [ + "We just saw how the rightshift operator can be used to simplify the `MapPackets` operation creation. How about `MapTags`? We can get `MapTags` equivalent operation also by using the rightshift (`>>`) operator, but with the help of an additional function: `tag()`." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "b0164e6e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Tag: {'experiment_day': 'info_day1'}, Packet: {'json_file': PosixPath('../examples/dataset2/info_day1.json')}\n", + "Tag: {'experiment_day': 'info_day2'}, Packet: {'json_file': PosixPath('../examples/dataset2/info_day2.json')}\n", + "Tag: {'experiment_day': 'info_day3'}, Packet: {'json_file': PosixPath('../examples/dataset2/info_day3.json')}\n", + "Tag: {'experiment_day': 'info_day4'}, Packet: {'json_file': PosixPath('../examples/dataset2/info_day4.json')}\n", + "Tag: {'experiment_day': 'info_day5'}, Packet: {'json_file': PosixPath('../examples/dataset2/info_day5.json')}\n" + ] + } + ], + "source": [ + "from orcabridge.mapper import tag, packet\n", + "\n", + "(json_files >> tag({\"file_name\": \"experiment_day\"})).head()" + ] + }, + { + "cell_type": "markdown", + "id": "ac34eed4", + "metadata": {}, + "source": [ + "Now if you were to closely inspect `MapPackets` and `MapPackets`, you would know that it is capable of taking in some additional arguments such as `drop_unmapped`. Using `tag()` and `packet()` helper functions would let you specify those arguments as well while using the `>>` operator." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "b366b19c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Tag: {'file_name': 'info_day1'}, Packet: {}\n", + "Tag: {'file_name': 'info_day2'}, Packet: {}\n", + "Tag: {'file_name': 'info_day3'}, Packet: {}\n", + "Tag: {'file_name': 'info_day4'}, Packet: {}\n", + "Tag: {'file_name': 'info_day5'}, Packet: {}\n" + ] + } + ], + "source": [ + "# no packet key matches `data_file`: by default, this will lead to an empty packet\n", + "(json_files >> {\"data_file\": \"file_path\"}).head()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "b3920086", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Tag: {'file_name': 'info_day1'}, Packet: {'json_file': PosixPath('../examples/dataset2/info_day1.json')}\n", + "Tag: {'file_name': 'info_day2'}, Packet: {'json_file': PosixPath('../examples/dataset2/info_day2.json')}\n", + "Tag: {'file_name': 'info_day3'}, Packet: {'json_file': PosixPath('../examples/dataset2/info_day3.json')}\n", + "Tag: {'file_name': 'info_day4'}, Packet: {'json_file': PosixPath('../examples/dataset2/info_day4.json')}\n", + "Tag: {'file_name': 'info_day5'}, Packet: {'json_file': PosixPath('../examples/dataset2/info_day5.json')}\n" + ] + } + ], + "source": [ + "# you can preseve unmapped packet key by using `packet` function with `drop_unmapped=False`\n", + "(json_files >> packet({\"data_file\": \"file_path\"}, drop_unmapped=False)).head()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "venv", + "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.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/03_orcabridge_tracker.ipynb b/notebooks/03_orcabridge_tracker.ipynb deleted file mode 100644 index cefc583a..00000000 --- a/notebooks/03_orcabridge_tracker.ipynb +++ /dev/null @@ -1,335 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "d698bea9", - "metadata": {}, - "source": [ - "## Using Tracker" - ] - }, - { - "cell_type": "markdown", - "id": "5be82e8a", - "metadata": {}, - "source": [ - "In this notebook, I'll demonstrate using `Tracker` and related features of `orcabridge` to keep *track* of all `operations` you are using in a pipeline and to automatically construct computation graph based on it." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "f28a62af", - "metadata": {}, - "outputs": [], - "source": [ - "from orcabridge.tracker import Tracker\n", - "from orcabridge.source import GlobSource\n", - "from orcabridge.pod import FunctionPodWithDirStorage\n", - "import orcabridge.mapper as router\n", - "import networkx as nx\n", - "import matplotlib.pyplot as plt" - ] - }, - { - "cell_type": "markdown", - "id": "110970a8", - "metadata": {}, - "source": [ - "As before let's construct a simple data pipeline that reads files and counts the number of lines, saving that information into another file. We will then chain it with another function that converts JSON to YAML." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "56136d16", - "metadata": {}, - "outputs": [], - "source": [ - "gs = GlobSource(\"data_file\", \"../examples/dataset1\", \"*.txt\")" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "c7d4def1", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "-5112745833299839431" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "hash(gs)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "197b5816", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "-5112745833299839431" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "hash(gs)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "c32938d6", - "metadata": {}, - "outputs": [], - "source": [ - "import tempfile\n", - "from pathlib import Path\n", - "import json\n", - "import yaml\n", - "\n", - "\n", - "# function to count lines in a file and save it as JSON\n", - "def count_lines(file: str):\n", - " with open(file, \"r\") as f:\n", - " n = len(f.readlines())\n", - " tmp_dir = tempfile.mkdtemp()\n", - " data_file = Path(tmp_dir) / \"data.json\"\n", - " data = dict(lines=n)\n", - " with open(data_file, \"w\") as f:\n", - " json.dump(data, f)\n", - " return data_file\n", - "\n", - "\n", - "def json_to_yaml(json_file: str):\n", - " with open(json_file, \"r\") as f:\n", - " data = json.load(f)\n", - " tmp_dir = tempfile.mkdtemp()\n", - " yaml_path = Path(tmp_dir) / Path(json_file).with_suffix(\".yaml\").name\n", - " with open(yaml_path, \"w\") as f:\n", - " yaml.dump(data, f)\n", - " return yaml_path" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "e763a55e", - "metadata": {}, - "outputs": [], - "source": [ - "# prepare a few MapKey mappers to take care of name differences\n", - "rename_to_file = router.MapKeys({\"data_file\": \"file\"})\n", - "\n", - "count_fp = FunctionPodWithDirStorage(count_lines, [\"stats\"])\n", - "\n", - "rename_to_json = router.MapKeys({\"stats\": \"json_file\"})\n", - "\n", - "convert_fp = FunctionPodWithDirStorage(json_to_yaml, [\"yaml_file\"])" - ] - }, - { - "cell_type": "markdown", - "id": "787b26ca", - "metadata": {}, - "source": [ - "With all steps defined, let's chain them together to form a full pipeline." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "3cdc6e7f", - "metadata": {}, - "outputs": [], - "source": [ - "line_info_json = count_fp(rename_to_file(gs))\n", - "line_info_yaml = convert_fp(rename_to_json(line_info_json))" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "71d18d81", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Tag: {'file_name': 'day1'}, Packet: {'yaml_file': 'pod_data/json_to_yaml/16207fa7-72aa-be99-3d44-e034a5ba8823/data.yaml'}\n", - "Tag: {'file_name': 'day2'}, Packet: {'yaml_file': 'pod_data/json_to_yaml/6c450b34-8835-afa9-2c07-c2d214749c3b/data.yaml'}\n", - "Tag: {'file_name': 'day3'}, Packet: {'yaml_file': 'pod_data/json_to_yaml/21c8f435-47d2-13ee-cdb2-9c31eb54093b/data.yaml'}\n", - "Tag: {'file_name': 'day4'}, Packet: {'yaml_file': 'pod_data/json_to_yaml/9f94dfb0-bded-6e79-dea1-494515af4886/data.yaml'}\n" - ] - } - ], - "source": [ - "line_info_yaml.preview(0)" - ] - }, - { - "cell_type": "markdown", - "id": "d6a0b378", - "metadata": {}, - "source": [ - "It turns out that `orcabrdige` comes with a default tracker that's been tracking all the execution that's been going on all this time!" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "2cdf8d30", - "metadata": {}, - "outputs": [], - "source": [ - "from orcabridge import DEFAULT_TRACKER" - ] - }, - { - "cell_type": "markdown", - "id": "19a999a7", - "metadata": {}, - "source": [ - "We can generate computation graph and appropriate name labels from the `DEFAULT_TRACKER` and plot it out." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "7a91ffaa", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/eywalker/workspace/orcabridge/src/orcabridge/tracker.py:87: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n", - " plt.tight_layout()\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "DEFAULT_TRACKER.draw_graph()" - ] - }, - { - "cell_type": "markdown", - "id": "3c02d58c", - "metadata": {}, - "source": [ - "## Explicitly tracking computation pipeline with a tracker" - ] - }, - { - "cell_type": "markdown", - "id": "db480859", - "metadata": {}, - "source": [ - "While the `DEFAULT_TRACKER` offers a nice catch-all tracker, sometimes you'd want to explicitly control what gets tracked. To do so, you would want to create your own tracker, and define the computation using the tracker's context manager. Let's see an example." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "f678050e", - "metadata": {}, - "outputs": [], - "source": [ - "# instantiate a new tracker\n", - "tracker = Tracker()\n", - "\n", - "# start a context manager to track the pipeline\n", - "with tracker:\n", - " # chain the operations into a pipeline inside the context manager\n", - " line_info_json = count_fp(rename_to_file(gs))\n", - "\n", - "# construct the latter half OUTSIDE of the context manager\n", - "line_info_yaml = convert_fp(rename_to_json(line_info_json))" - ] - }, - { - "cell_type": "markdown", - "id": "f7d3484f", - "metadata": {}, - "source": [ - "In the example above, you would notice that only first half of the pipeline is chained together within the `tracker` context manager. Let's now see what the graph looks like." - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "b3bf152b", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "tracker.draw_graph()" - ] - }, - { - "cell_type": "markdown", - "id": "73992089", - "metadata": {}, - "source": [ - "As expected, the `tracker` only tracked the first half othe pipeline!" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "venv", - "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.10.12" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/notebooks/04_orcabridge_tracker.ipynb b/notebooks/04_orcabridge_tracker.ipynb new file mode 100644 index 00000000..0150311a --- /dev/null +++ b/notebooks/04_orcabridge_tracker.ipynb @@ -0,0 +1,354 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "d698bea9", + "metadata": {}, + "source": [ + "## Using Tracker" + ] + }, + { + "cell_type": "markdown", + "id": "5be82e8a", + "metadata": {}, + "source": [ + "In this notebook, I'll demonstrate using `Tracker` and related features of `orcabridge` to keep *track* of all `operations` you are using in a pipeline and to automatically construct computation graph based on it." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "f28a62af", + "metadata": {}, + "outputs": [], + "source": [ + "from orcabridge.tracker import Tracker\n", + "from orcabridge.source import GlobSource\n", + "from orcabridge.store import DirDataStore\n", + "from orcabridge.pod import function_pod\n", + "from orcabridge.mapper import tag, packet\n", + "import orcabridge.mapper as router\n", + "import networkx as nx\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "id": "110970a8", + "metadata": {}, + "source": [ + "As before let's construct a simple data pipeline that reads files and counts the number of lines, saving that information into another file. We will then chain it with another function that converts JSON to YAML." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "56136d16", + "metadata": {}, + "outputs": [], + "source": [ + "gs = GlobSource(\"data_file\", \"../examples/dataset1\", \"*.txt\")" + ] + }, + { + "cell_type": "markdown", + "id": "8137ce66", + "metadata": {}, + "source": [ + "We are also going to define a few functions to serve as function pods. We are using convenience function `function_pod` to decorate the function to immediately turn them into a `FunctionPod` as was covered [in previous notebook](./03_orcabridge_qol_features.ipynb)." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "c32938d6", + "metadata": {}, + "outputs": [], + "source": [ + "import tempfile\n", + "from pathlib import Path\n", + "import json\n", + "import yaml\n", + "\n", + "# use default data store location of `./pod_data`\n", + "data_store = DirDataStore()\n", + "\n", + "\n", + "# function to count lines in a file and save it as JSON\n", + "@function_pod([\"stats\"], data_store=data_store)\n", + "def count_lines(file: str):\n", + " with open(file, \"r\") as f:\n", + " n = len(f.readlines())\n", + " tmp_dir = tempfile.mkdtemp()\n", + " data_file = Path(tmp_dir) / \"data.json\"\n", + " data = dict(lines=n)\n", + " with open(data_file, \"w\") as f:\n", + " json.dump(data, f)\n", + " return data_file\n", + "\n", + "\n", + "@function_pod([\"yaml_file\"], data_store=data_store)\n", + "def json_to_yaml(json_file: str):\n", + " with open(json_file, \"r\") as f:\n", + " data = json.load(f)\n", + " tmp_dir = tempfile.mkdtemp()\n", + " yaml_path = Path(tmp_dir) / Path(json_file).with_suffix(\".yaml\").name\n", + " with open(yaml_path, \"w\") as f:\n", + " yaml.dump(data, f)\n", + " return yaml_path\n", + "\n", + "\n", + "# function to extract keys from a JSON file and save them as a list in another JSON file\n", + "@function_pod([\"key_info\"], data_store=data_store)\n", + "def extract_keys(json_file: str):\n", + " with open(json_file, \"r\") as f:\n", + " data = json.load(f)\n", + " keys = list(data.keys())\n", + " tmp_dir = tempfile.mkdtemp()\n", + " keys_file = Path(tmp_dir) / \"keys.json\"\n", + " with open(keys_file, \"w\") as f:\n", + " json.dump(keys, f)\n", + " return keys_file" + ] + }, + { + "cell_type": "markdown", + "id": "787b26ca", + "metadata": {}, + "source": [ + "With all steps defined, let's chain them together to form a full pipeline. Note that we are using the `>>` operator to map packet keys on the fly to match expected arguments for each pod." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "3cdc6e7f", + "metadata": {}, + "outputs": [], + "source": [ + "line_info_json = count_lines(gs >> {\"data_file\": \"file\"})\n", + "line_info_yaml = json_to_yaml(line_info_json >> {\"stats\": \"json_file\"})\n", + "line_info_keys = extract_keys(line_info_json >> {\"stats\": \"json_file\"})" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "71d18d81", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Tag: {'file_name': 'day1'}, Packet: {'key_info': 'pod_data/extract_keys/16207fa7-72aa-be99-3d44-e034a5ba8823/keys.json'}\n", + "Tag: {'file_name': 'day2'}, Packet: {'key_info': 'pod_data/extract_keys/6c450b34-8835-afa9-2c07-c2d214749c3b/keys.json'}\n", + "Tag: {'file_name': 'day3'}, Packet: {'key_info': 'pod_data/extract_keys/21c8f435-47d2-13ee-cdb2-9c31eb54093b/keys.json'}\n", + "Tag: {'file_name': 'day4'}, Packet: {'key_info': 'pod_data/extract_keys/9f94dfb0-bded-6e79-dea1-494515af4886/keys.json'}\n" + ] + } + ], + "source": [ + "line_info_keys.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "2950e1d5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Tag: {'file_name': 'day1'}, Packet: {'yaml_file': 'pod_data/json_to_yaml/16207fa7-72aa-be99-3d44-e034a5ba8823/data.yaml'}\n", + "Tag: {'file_name': 'day2'}, Packet: {'yaml_file': 'pod_data/json_to_yaml/6c450b34-8835-afa9-2c07-c2d214749c3b/data.yaml'}\n", + "Tag: {'file_name': 'day3'}, Packet: {'yaml_file': 'pod_data/json_to_yaml/21c8f435-47d2-13ee-cdb2-9c31eb54093b/data.yaml'}\n", + "Tag: {'file_name': 'day4'}, Packet: {'yaml_file': 'pod_data/json_to_yaml/9f94dfb0-bded-6e79-dea1-494515af4886/data.yaml'}\n" + ] + } + ], + "source": [ + "line_info_yaml.head()" + ] + }, + { + "cell_type": "markdown", + "id": "ff85672b", + "metadata": {}, + "source": [ + "We have now defined a nontrivial data pipeline that counts the number of lines in files and output that info to JSON. We then convert the JSON files into YAML files. On the other branch of the pipeline, we take the JSON files and extract a list of keys found in the JSON and save it as yet another JSON file." + ] + }, + { + "cell_type": "markdown", + "id": "1abdf7d6", + "metadata": {}, + "source": [ + "As your pipeline grows, it can get qutie tricky to keep track of exactly who connects to what and it can be easy to lose sight of exactly what's going on in the pipeline. This is exactly where `Tracker` comes in handy. As the name suggeests, a `Tracker` can keep track of all pipeline-defining computations you have run, and then generate helpful information such as graphs or plot the graph as an image for visualization." + ] + }, + { + "cell_type": "markdown", + "id": "27346fa5", + "metadata": {}, + "source": [ + "You may think that the sensible next step is to create and setup a `Tracker` to keep track of the pipeline. It turns out that `orcabridge` comes with a default tracker that has been tracking all of the pipeline-defining operation all this time, secretly without you knowing!\n", + "\n", + "Let's access and use the default tracker." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "2cdf8d30", + "metadata": {}, + "outputs": [], + "source": [ + "from orcabridge import DEFAULT_TRACKER" + ] + }, + { + "cell_type": "markdown", + "id": "19a999a7", + "metadata": {}, + "source": [ + "As we will see shortly, `DEFAULT_TRACKER` is just an ordinary instance of `Tracker` that has been instantiated and activated at the time of the first import of `orcabridge`. Consequently, it has been keeping track of all `operation` execution that you have performed thus far. Let's use its `draw_graph()` to display the computation graph it has detected." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "7a91ffaa", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/eywalker/workspace/orcabridge/src/orcabridge/tracker.py:87: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n", + " plt.tight_layout()\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "DEFAULT_TRACKER.draw_graph()" + ] + }, + { + "cell_type": "markdown", + "id": "3b8fd7d0", + "metadata": {}, + "source": [ + "Does that match what you thought of the pipeline thus far? You might notice that while we used the convenience operator `>>` to map packet keys, the corresponding `MapPackets` mapper actually shows up in the graph. Remember that `>>` is just for convenience, making the creation of `MapPackets` and `MapTags` more accesible." + ] + }, + { + "cell_type": "markdown", + "id": "3c02d58c", + "metadata": {}, + "source": [ + "## Explicitly tracking computation pipeline with a tracker" + ] + }, + { + "cell_type": "markdown", + "id": "db480859", + "metadata": {}, + "source": [ + "While the `DEFAULT_TRACKER` can serve as a nice catch-all tracker, sometimes you'd want to explicitly control what gets tracked so that you can visualize specific section of the entire computation graph. \n", + "\n", + "To do so, you would want to create your own tracker, and define the computation using the tracker's context manager. Let's see an example." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "f678050e", + "metadata": {}, + "outputs": [], + "source": [ + "# instantiate a new tracker\n", + "tracker = Tracker()\n", + "\n", + "# start a context manager to track the pipeline\n", + "with tracker:\n", + " line_info_json = count_lines(gs >> {\"data_file\": \"file\"})\n", + " line_info_keys = extract_keys(line_info_json >> {\"stats\": \"json_file\"})\n", + "\n", + "# perform the conversion outside of the tracker\n", + "line_info_yaml = json_to_yaml(line_info_json >> {\"stats\": \"json_file\"})" + ] + }, + { + "cell_type": "markdown", + "id": "f7d3484f", + "metadata": {}, + "source": [ + "In the example above, you would notice that only first half of the pipeline is chained together within the `tracker` context manager. Let's now see what the graph looks like." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "b3bf152b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "tracker.draw_graph()" + ] + }, + { + "cell_type": "markdown", + "id": "73992089", + "metadata": {}, + "source": [ + "As you can see, the tracker only tracked one branch of the computation graph, leaving the other branch outside of the computation graph it has constructed and visualized." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "venv", + "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.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 2e0933ba60bc82a27d7141455c5c06afecdd9a2c Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" Date: Mon, 5 May 2025 04:14:57 +0000 Subject: [PATCH 19/22] feat: add robust hashing logic for tracking and memoization --- src/orcabridge/base.py | 286 ++++++++++++++++++++++----- src/orcabridge/mapper.py | 91 ++++++--- src/orcabridge/pod.py | 65 ++++-- src/orcabridge/source.py | 37 ++-- src/orcabridge/store.py | 19 +- src/orcabridge/stream.py | 3 +- src/orcabridge/tracker.py | 8 +- src/orcabridge/utils/hash.py | 85 ++++++++ src/orcabridge/utils/name.py | 72 ------- src/orcabridge/utils/stream_utils.py | 11 ++ 10 files changed, 474 insertions(+), 203 deletions(-) diff --git a/src/orcabridge/base.py b/src/orcabridge/base.py index c13c9683..aa1d12ff 100644 --- a/src/orcabridge/base.py +++ b/src/orcabridge/base.py @@ -9,12 +9,150 @@ Callable, Iterator, Mapping, + Union, ) -from .utils.hash import hash_dict +from .utils.hash import hash_dict, stable_hash +import hashlib import networkx as nx +import json +from collections.abc import Mapping, Collection +from typing import Any, Dict, List, Set, Tuple, Union -class Operation: +class HashableMixin: + """A mixin that provides content-based hashing functionality.""" + + def identity_structure(self) -> Any: + """ + Return a structure that represents the identity of this object. + By default, returns None to indicate that no custom structure is provided. + Subclasses should override this method to provide meaningful representations. + + Returns: + None to indicate no custom structure (use default hash) + """ + return None + + def content_hash(self, char_count: Optional[int] = 16) -> str: + """ + Generate a stable string hash based on the object's content. + + Returns: + str: A hexadecimal digest representing the object's content + """ + # Get the identity structure + structure = self.identity_structure() + + # If no custom structure is provided, use the superclass's hash + if structure is None: + # Convert the default hash to a stable string + return hashlib.sha256(str(super().__hash__()).encode()).hexdigest() + + # Generate a hash from the identity structure + return self._hash_structure(structure, char_count=char_count) + + def content_hash_int(self, hexdigits=16) -> int: + """ + Generate a stable integer hash based on the object's content. + + Returns: + int: An integer representing the object's content + """ + # pass in char_count=None to get the full hash + return int(self.content_hash(char_count=None)[:hexdigits], 16) + + def __hash__(self) -> int: + """ + Hash implementation that uses the identity structure if provided, + otherwise falls back to the superclass's hash method. + + Returns: + int: A hash value based on either content or identity + """ + # Get the identity structure + structure = self.identity_structure() + + # If no custom structure is provided, use the superclass's hash + if structure is None: + return super().__hash__() + + # Generate a hash and convert to integer + hash_hex = self._hash_structure(structure, char_count=None) + return int(hash_hex[:16], 16) + + def _hash_structure(self, structure: Any, char_count: Optional[int] = 16) -> str: + """ + Helper method to compute a hash string from a structure. + + Args: + structure: The structure to hash + + Returns: + str: A hexadecimal hash digest of the structure + """ + processed = self._process_structure(structure) + json_str = json.dumps(processed, sort_keys=True).encode() + return hashlib.sha256(json_str).hexdigest()[:char_count] + + def _process_structure(self, obj: Any) -> Any: + """ + Recursively process a structure to prepare it for hashing. + + Args: + obj: The object or structure to process + + Returns: + A processed version of the structure with HashableMixin objects replaced by their hashes + """ + # Handle None + if obj is None: + return "None" + + # If the object is a HashableMixin, use its content_hash + if isinstance(obj, HashableMixin): + # Don't call content_hash on self to avoid cycles + if obj is self: + # Use the superclass's hash for self + return str(super(HashableMixin, self).__hash__()) + return obj.content_hash() + + # Handle basic types + if isinstance(obj, (str, int, float, bool)): + return str(obj) + + # Handle named tuples (which are subclasses of tuple) + if hasattr(obj, "_fields") and isinstance(obj, tuple): + # For namedtuples, convert to dict and then process + return self._process_structure( + {field: value for field, value in zip(obj._fields, obj)} + ) + + # Handle mappings (dict-like objects) + if isinstance(obj, Mapping): + return { + str(k): self._process_structure(v) + for k, v in sorted(obj.items(), key=lambda x: str(x[0])) + } + + # Handle sets and frozensets specifically + if isinstance(obj, (set, frozenset)): + # Process each item first, then sort the processed results + processed_items = [self._process_structure(item) for item in obj] + return sorted(processed_items, key=str) + + # Handle collections (list-like objects) + if isinstance(obj, Collection): + return [self._process_structure(item) for item in obj] + + # For bytes and bytearray, convert to hex representation + if isinstance(obj, (bytes, bytearray)): + return obj.hex() + + # For other objects, just use their string representation + return str(obj) + + +class Operation(HashableMixin): """ Operation defines a generic operation that can be performed on a stream of data. It is a base class for all operations that can be performed on a collection of streams @@ -25,35 +163,39 @@ class Operation: information is stored as Invocation object and attached to the output stream. """ - def get_invocation(self, *streams: "SyncStream") -> str: - """ - Given a list of streams to perform the operation on, define - the invocation ID that would uniquely identify this particular - invocation of the operation. This ID is used to track each distinct - invocation of the operation and its associated streams. - The default implementation is to use the hash of the streams - as the invocation ID. This is sensitive to the order of the streams. + def __init__(self, label: Optional[str] = None, **kwargs) -> None: + super().__init__(**kwargs) + self._label = label - For operations that are not sensitive to the order of the streams, - this method should be overridden to provide a more appropriate - invocation ID. For example, a join operation may want to use the - hash of the joined streams instead of the individual stream hashes. + @property + def label(self) -> Optional[str]: """ - # default implementation where ID is stream order sensitive - invocation_id = hash((self, tuple(streams))) - return Invocation(self, invocation_id, streams) + The label of the operation. This is used to refer to the operation in the tracker + """ + if self._label is None: + # if the label is not set, use the class name as the label + self._label = self.__class__.__name__ - def __call__(self, *streams: "SyncStream") -> "SyncStream": - # if any source is passed in as a stream, invoke it to extract stream first - from .source import Source + return self._label - streams = [s() if isinstance(s, Source) else s for s in streams] + def identity_structure(self, *streams: "SyncStream") -> Any: + # Default implementation of identity_structure for the operation only + # concerns the operation class and the streams if present. Subclasses of + # Operations should override this method to provide a more meaningful + # representation of the operation. + return (self.__class__.__name__, streams) + + def __call__(self, *streams: "SyncStream") -> "SyncStream": + # trigger call on source if passed as stream + streams = [ + stream() if isinstance(stream, Source) else stream for stream in streams + ] output_stream = self.forward(*streams) # create an invocation instance - invocation = self.get_invocation(*streams) + invocation = Invocation(self, streams) # label the output_stream with the invocation information - output_stream.source = invocation + output_stream.invocation = invocation # delay import to avoid circular import from .tracker import Tracker @@ -71,7 +213,7 @@ def __repr__(self): def forward(self, *streams: "SyncStream") -> "SyncStream": ... -class Invocation: +class Invocation(HashableMixin): """ This class represents an invocation of an operation on a collection of streams. It contains the operation, the invocation ID, and the streams that were used @@ -83,57 +225,72 @@ class Invocation: def __init__( self, operation: Operation, - invocation_id: int, streams: Collection["SyncStream"], ) -> None: self.operation = operation - self.invocation_id = invocation_id self.streams = streams - def __repr__(self) -> str: - return f"Invocation({self.operation}, ID:{self.invocation_id})" + # @property + # def invocation_id(self) -> int: + # """ + # The invocation ID is a unique identifier for the invocation. + # It is used to track the invocation in the tracker. + # """ + # return hash(self) def __hash__(self) -> int: - return self.invocation_id + return super().__hash__() + + def __repr__(self) -> str: + return f"Invocation({self.operation}, ID:{hash(self)})" + + def identity_structure(self) -> int: + # default implementation is streams order sensitive. If an operation does + # not depend on the order of the streams, it should override this method + return self.operation.identity_structure(*self.streams) def __eq__(self, other: Any) -> bool: if not isinstance(other, Invocation): return False - return ( - self.operation == other.operation - and self.invocation_id == other.invocation_id - ) + return hash(self) == hash(other) def __lt__(self, other: Any) -> bool: if not isinstance(other, Invocation): return NotImplemented if self.operation == other.operation: - return self.invocation_id < other.invocation_id - return self.operation < other.operation + return hash(self) < hash(other) + # otherwise, order by the operation + return hash(self.operation) < hash(other.operation) -class Stream: +class Stream(HashableMixin): """ A stream is a collection of tagged-packets that are generated by an operation. The stream is iterable and can be used to access the packets in the stream. - A stream has propery `source` that is an instance of Invocation that generated the stream. + A stream has propery `invocation` that is an instance of Invocation that generated the stream. This may be None if the stream is not generated by an operation. """ - def __init__(self): - self._source: Optional[Invocation] = None + def __init__(self, **kwargs) -> None: + super().__init__(**kwargs) + self._invocation: Optional[Invocation] = None + + def identity_structure(self) -> Any: + if self.invocation is not None: + return self.invocation.identity_structure() + return super().identity_structure() @property - def source(self) -> Optional[Invocation]: - return self._source + def invocation(self) -> Optional[Invocation]: + return self._invocation - @source.setter - def source(self, value: Invocation) -> None: + @invocation.setter + def invocation(self, value: Invocation) -> None: if not isinstance(value, Invocation): - raise TypeError("source must be an instance of Invocation") - self._source = value + raise TypeError("invocation field must be an instance of Invocation") + self._invocation = value def __iter__(self) -> Iterator[Tuple[Tag, Packet]]: raise NotImplementedError("Subclasses must implement __iter__ method") @@ -145,11 +302,16 @@ class SyncStream(Stream): will have to wait for the stream to finish before proceeding. """ - def __hash__(self) -> int: - if self.source is not None: + def content_hash(self) -> str: + if ( + self.invocation is not None + ): # and hasattr(self.invocation, "invocation_id"): # use the invocation ID as the hash - return self.source.invocation_id - return super().__hash__() + return self.invocation.content_hash() + return super().content_hash() + + def __hash__(self) -> int: + return hash(self.content_hash()) def keys(self) -> Tuple[List[str], List[str]]: """ @@ -197,3 +359,29 @@ def __rshift__(self, transformer: Any) -> "SyncStream": return MapPackets(transformer)(self) elif isinstance(transformer, Callable): return transformer(self) + + def __mul__(self, other: "SyncStream") -> "SyncStream": + """ + Returns a new stream that is the result joining with the other stream + """ + from .mapper import Join + + if not isinstance(other, SyncStream): + raise TypeError("other must be a SyncStream") + return Join()(self, other) + + +class Source(Operation, SyncStream): + """ + A base class for all sources in the system. A source can be seen as a special + type of Operation that takes no input and produces a stream of packets. + For convenience, the source itself is also a stream and thus can be used + as an input to other operations directly. + """ + + def __init__(self, label: Optional[str] = None, **kwargs) -> None: + super().__init__(label=label, **kwargs) + self._invocation = None + + def __iter__(self) -> Iterator[Tuple[Tag, Packet]]: + yield from self() diff --git a/src/orcabridge/mapper.py b/src/orcabridge/mapper.py index 56f7a3c5..14f972b7 100644 --- a/src/orcabridge/mapper.py +++ b/src/orcabridge/mapper.py @@ -2,7 +2,13 @@ from .stream import SyncStream, SyncStreamFromGenerator from .base import Operation -from .utils.stream_utils import join_tags, batch_tag, batch_packet +from .utils.stream_utils import ( + join_tags, + check_packet_compatibility, + batch_tag, + batch_packet, +) +from .utils.hash import function_content_hash, stable_hash from .types import Tag, Packet from typing import Iterator, Tuple @@ -15,6 +21,10 @@ class Mapper(Operation): class Join(Mapper): + def identity_structure(self, *streams): + # Join does not depend on the order of the streams -- convert it onto a set + return (self.__class__.__name__, set(streams)) + def forward(self, *streams: SyncStream) -> SyncStream: """ Joins two streams together based on their tags. @@ -29,6 +39,10 @@ def generator(): for left_tag, left_packet in left_stream: for right_tag, right_packet in right_stream: if (joined_tag := join_tags(left_tag, right_tag)) is not None: + if not check_packet_compatibility(left_packet, right_packet): + raise ValueError( + f"Packets are not compatible: {left_packet} and {right_packet}" + ) yield joined_tag, {**left_packet, **right_packet} return SyncStreamFromGenerator(generator) @@ -37,7 +51,7 @@ def __repr__(self) -> str: return "Join()" def __hash__(self) -> int: - return hash(self.__class__) + return stable_hash(self.__class__.__name__) class MapPackets(Mapper): @@ -75,10 +89,12 @@ def __repr__(self) -> str: map_repr = ", ".join([f"{k} ⇒ {v}" for k, v in self.key_map.items()]) return f"packets({map_repr})" - def __hash__(self) -> int: - return hash( - (self.__class__, tuple(sorted(self.key_map.items())), self.drop_unmapped) - ) + def identity_structure(self, *streams): + return ( + self.__class__.__name__, + tuple(sorted(self.key_map.items())), + self.drop_unmapped, + ) + tuple(streams) class MapTags(Operation): @@ -89,9 +105,9 @@ class MapTags(Operation): drop_unmapped=False, in which case unmapped tags will be retained. """ - def __init__(self, tag_map: Dict[str, str], drop_unmapped: bool = True) -> None: + def __init__(self, key_map: Dict[str, str], drop_unmapped: bool = True) -> None: super().__init__() - self.tag_map = tag_map + self.key_map = key_map self.drop_unmapped = drop_unmapped def forward(self, *streams: SyncStream) -> SyncStream: @@ -100,25 +116,36 @@ def forward(self, *streams: SyncStream) -> SyncStream: stream = streams[0] - def generator(): + def generator() -> Iterator[Tuple[Tag, Packet]]: for tag, packet in stream: if self.drop_unmapped: - tag = {v: tag[k] for k, v in self.tag_map.items() if k in tag} + tag = {v: tag[k] for k, v in self.key_map.items() if k in tag} else: - tag = {self.tag_map.get(k, k): v for k, v in tag.items()} + tag = {self.key_map.get(k, k): v for k, v in tag.items()} yield tag, packet return SyncStreamFromGenerator(generator) def __repr__(self) -> str: - map_repr = ", ".join([f"{k} ⇒ {v}" for k, v in self.tag_map.items()]) + map_repr = ", ".join([f"{k} ⇒ {v}" for k, v in self.key_map.items()]) return f"tags({map_repr})" def __hash__(self) -> int: - return hash( - (self.__class__, tuple(sorted(self.tag_map.items())), self.drop_unmapped) + return stable_hash( + ( + self.__class__.__name__, + tuple(sorted(self.key_map.items())), + self.drop_unmapped, + ) ) + def identity_structure(self, *streams): + return ( + self.__class__.__name__, + tuple(sorted(self.tag_map.items())), + self.drop_unmapped, + ) + tuple(streams) + class Filter(Mapper): """ @@ -137,7 +164,7 @@ def forward(self, *streams: SyncStream) -> SyncStream: stream = streams[0] - def generator(): + def generator() -> Iterator[Tuple[Tag, Packet]]: for tag, packet in stream: if self.predicate(tag, packet): yield tag, packet @@ -147,8 +174,11 @@ def generator(): def __repr__(self) -> str: return f"Filter({self.predicate})" - def __hash__(self) -> int: - return hash((self.__class__, self.predicate)) + def identity_structure(self, *streams): + return ( + self.__class__.__name__, + function_content_hash(self.predicate), + ) + tuple(streams) class Transform(Mapper): @@ -168,7 +198,7 @@ def forward(self, *streams: SyncStream) -> SyncStream: stream = streams[0] - def generator(): + def generator() -> Iterator[Tuple[Tag, Packet]]: for tag, packet in stream: yield self.transform(tag, packet) @@ -177,8 +207,11 @@ def generator(): def __repr__(self) -> str: return f"Transform({self.transform})" - def __hash__(self) -> int: - return hash((self.__class__, self.transform)) + def identity_structure(self, *streams): + return ( + self.__class__.__name__, + function_content_hash(self.transform), + ) + tuple(streams) class Batch(Mapper): @@ -226,10 +259,13 @@ def generator() -> Iterator[Tuple[Tag, Packet]]: def __repr__(self) -> str: return f"Batch(size={self.batch_size}, drop_last={self.drop_last})" - def __hash__(self) -> int: - return hash( - (self.__class__, self.batch_size, self.tag_processor, self.drop_last) - ) + def identity_structure(self, *streams): + return ( + self.__class__.__name__, + self.batch_size, + function_content_hash(self.tag_processor), + self.drop_last, + ) + tuple(streams) class CacheStream(Mapper): @@ -273,10 +309,9 @@ def clear_cache(self) -> None: def __repr__(self) -> str: return f"CacheStream(active:{self.is_cached})" - def __hash__(self) -> int: - # explicitly shown to signify that no two cachestreams are the same - # unless they are the same instance - return super().__hash__() + def identity_structure(self, *streams): + # treat every CacheStream as a different stream + return None def tag( diff --git a/src/orcabridge/pod.py b/src/orcabridge/pod.py index 7ea9a6c3..6f81880c 100644 --- a/src/orcabridge/pod.py +++ b/src/orcabridge/pod.py @@ -3,9 +3,9 @@ logger = logging.getLogger(__name__) from pathlib import Path -from typing import List, Optional, Tuple, Iterator, Iterable, Collection -from .utils.hash import hash_dict -from .utils.name import get_function_signature, function_content_hash +from typing import List, Optional, Tuple, Iterator, Iterable, Collection, Literal, Any +from .utils.hash import function_content_hash, hash_dict, stable_hash +from .utils.name import get_function_signature from .base import Operation from .mapper import Join from .stream import SyncStream, SyncStreamFromGenerator @@ -20,6 +20,8 @@ def function_pod( output_keys: Optional[Collection[str]] = None, store_name: Optional[str] = None, data_store: Optional[DataStore] = None, + function_hash_mode: Literal["signature", "content", "name", "custom"] = "name", + custom_hash: Optional[int] = None, force_computation: bool = False, skip_memoization: bool = False, ): @@ -39,9 +41,11 @@ def decorator(func): # Create a FunctionPod instance with the function and parameters pod = FunctionPod( function=func, + output_keys=output_keys, store_name=store_name, data_store=data_store, - output_keys=output_keys, + function_hash_mode=function_hash_mode, + custom_hash=custom_hash, force_computation=force_computation, skip_memoization=skip_memoization, ) @@ -87,8 +91,6 @@ def generator() -> Iterator[Tuple[Tag, Packet]]: return SyncStreamFromGenerator(generator) - def __hash__(self) -> int: ... - def process(self, packet: Packet) -> Packet: ... @@ -102,27 +104,35 @@ def __init__( output_keys: Optional[Collection[str]] = None, store_name=None, data_store: Optional[DataStore] = None, + function_hash_mode: Literal["signature", "content", "name", "custom"] = "name", + custom_hash: Optional[int] = None, + label: Optional[str] = None, force_computation: bool = False, skip_memoization: bool = False, + **kwargs, ) -> None: - super().__init__() + super().__init__(label=label, **kwargs) self.function = function if output_keys is None: output_keys = [] self.output_keys = output_keys self.store_name = self.function.__name__ if store_name is None else store_name self.data_store = data_store if data_store is not None else NoOpDataStore() + self.function_hash_mode = function_hash_mode + self.custom_hash = custom_hash self.skip_memoization = skip_memoization self.force_computation = force_computation + @property + def label(self) -> str: + if self._label is None: + return self.store_name + return self._label + def __repr__(self) -> str: func_sig = get_function_signature(self.function) return f"FunctionPod:{func_sig} ⇒ {self.output_keys}" - def __hash__(self) -> int: - function_hash = function_content_hash(self.function) - return hash((function_hash, tuple(self.output_keys))) - def forward(self, *streams: SyncStream) -> SyncStream: # if multiple streams are provided, join them if len(streams) > 1: @@ -138,7 +148,7 @@ def generator() -> Iterator[Tuple[Tag, Packet]]: n_computed = 0 for tag, packet in stream: memoized_packet = self.data_store.retrieve_memoized( - self.store_name, packet + self.store_name, self.content_hash(), packet ) if not self.force_computation and memoized_packet is not None: yield tag, memoized_packet @@ -166,7 +176,7 @@ def generator() -> Iterator[Tuple[Tag, Packet]]: # output packet may be modified by the memoization process # e.g. if the output is a file, the path may be changed output_packet = self.data_store.memoize( - self.store_name, packet, output_packet + self.store_name, self.content_hash(), packet, output_packet ) n_computed += 1 @@ -175,10 +185,25 @@ def generator() -> Iterator[Tuple[Tag, Packet]]: return SyncStreamFromGenerator(generator) - def memoize( - self, packet: Packet, output_packet: Packet, overwrite: bool = False - ) -> Packet: - return output_packet - - def retrieve_memoized(self, packet: Packet) -> Optional[Packet]: - return None + def identity_structure(self, *streams) -> Any: + if self.function_hash_mode == "content": + function_hash = function_content_hash(self.function) + elif self.function_hash_mode == "signature": + function_hash = get_function_signature(self.function) + elif self.function_hash_mode == "name": + function_hash = self.store_name + elif self.function_hash_mode == "custom": + if self.custom_hash is None: + raise ValueError("Custom hash function not provided") + function_hash = self.custom_hash + else: + raise ValueError( + f"Unknown function hash mode: {self.function_hash_mode}. " + "Must be one of 'content', 'signature', 'name', or 'custom'." + ) + + return ( + self.__class__.__name__, + function_hash, + tuple(self.output_keys), + ) + tuple(streams) diff --git a/src/orcabridge/source.py b/src/orcabridge/source.py index 5ab626de..b6c7086b 100644 --- a/src/orcabridge/source.py +++ b/src/orcabridge/source.py @@ -1,25 +1,10 @@ -from .base import Operation +from .base import Source from .stream import SyncStream, SyncStreamFromGenerator from .types import Tag, Packet -from typing import Iterator, Tuple, Optional, Callable +from typing import Iterator, Tuple, Optional, Callable, Any from os import PathLike from pathlib import Path - - -class Source(Operation, SyncStream): - """ - A base class for all sources in the system. A source can be seen as a special - type of Operation that takes no input and produces a stream of packets. - For convenience, the source itself is also a stream and thus can be used - as an input to other operations directly. - """ - - def __init__(self) -> None: - super().__init__() - self._source = self - - def __iter__(self) -> Iterator[Tuple[Tag, Packet]]: - yield from self() +from .utils.hash import function_content_hash, stable_hash class GlobSource(Source): @@ -58,9 +43,11 @@ def __init__( name: str, file_path: PathLike, pattern: str = "*", + label: Optional[str] = None, tag_function: Optional[Callable[[PathLike], Tag]] = None, + **kwargs, ) -> None: - super().__init__() + super().__init__(label=label, **kwargs) self.name = name self.file_path = file_path self.pattern = pattern @@ -79,7 +66,11 @@ def generator() -> Iterator[Tuple[Tag, Packet]]: def __repr__(self) -> str: return f"GlobSource({str(Path(self.file_path) / self.pattern)}) ⇒ {self.name}" - def __hash__(self) -> int: - return hash( - (self.__class__, self.name, self.file_path, self.pattern, self.tag_function) - ) + def identity_structure(self, *streams) -> Any: + return ( + self.__class__.__name__, + self.name, + str(self.file_path), + self.pattern, + function_content_hash(self.tag_function), + ) + tuple(streams) diff --git a/src/orcabridge/store.py b/src/orcabridge/store.py index 956f4517..f96be5a9 100644 --- a/src/orcabridge/store.py +++ b/src/orcabridge/store.py @@ -13,13 +13,14 @@ class DataStore: def memoize( self, store_name: str, + content_hash: str, packet: Packet, output_packet: Packet, overwrite: bool = False, ) -> Packet: ... def retrieve_memoized( - self, store_name: str, packet: Packet + self, store_name: str, content_hash: str, packet: Packet ) -> Optional[Packet]: ... @@ -32,13 +33,16 @@ class NoOpDataStore(DataStore): def memoize( self, store_name: str, + content_hash: str, packet: Packet, output_packet: Packet, overwrite: bool = False, ) -> Packet: return output_packet - def retrieve_memoized(self, store_name: str, packet: Packet) -> Optional[Packet]: + def retrieve_memoized( + self, store_name: str, content_hash: str, packet: Packet + ) -> Optional[Packet]: return None @@ -58,13 +62,14 @@ def __init__( def memoize( self, store_name: str, + content_hash: int, packet: Packet, output_packet: Packet, overwrite: bool = False, ) -> Packet: packet_hash = hash_dict(packet) - output_dir = self.store_dir / store_name / f"{packet_hash}" + output_dir = self.store_dir / store_name / content_hash / str(packet_hash) info_path = output_dir / "_info.json" if info_path.exists() and not overwrite: @@ -104,15 +109,17 @@ def memoize( # retrieve back the memoized packet and return # TODO: consider if we want to return the original packet or the memoized one - output_packet = self.retrieve_memoized(store_name, packet) + output_packet = self.retrieve_memoized(store_name, content_hash, packet) if output_packet is None: raise ValueError(f"Memoized packet {packet} not found after storing it") return output_packet - def retrieve_memoized(self, store_name: str, packet: Packet) -> Optional[Packet]: + def retrieve_memoized( + self, store_name: str, content_hash: str, packet: Packet + ) -> Optional[Packet]: packet_hash = hash_dict(packet) - output_dir = self.store_dir / store_name / f"{packet_hash}" + output_dir = self.store_dir / store_name / content_hash / str(packet_hash) info_path = output_dir / "_info.json" if info_path.exists(): diff --git a/src/orcabridge/stream.py b/src/orcabridge/stream.py index 6c389bb2..a4c697a4 100644 --- a/src/orcabridge/stream.py +++ b/src/orcabridge/stream.py @@ -13,8 +13,9 @@ def __init__( generator_factory: Callable[[], Iterator[Tuple[Tag, Packet]]], tag_keys: Optional[List[str]] = None, packet_keys: Optional[List[str]] = None, + **kwargs, ) -> None: - super().__init__() + super().__init__(**kwargs) self.tag_keys = tag_keys self.packet_keys = packet_keys self.generator_factory = generator_factory diff --git a/src/orcabridge/tracker.py b/src/orcabridge/tracker.py index a5295f97..ea50c3eb 100644 --- a/src/orcabridge/tracker.py +++ b/src/orcabridge/tracker.py @@ -61,10 +61,10 @@ def generate_graph(self): for operation, invocations in self.invocation_lut.items(): for invocation in invocations: for upstream in invocation.streams: - # if upstream.source is not in the graph, add it - if upstream.source not in G: - G.add_node(upstream.source) - G.add_edge(upstream.source, invocation, stream=upstream) + # if upstream.invocation is not in the graph, add it + if upstream.invocation not in G: + G.add_node(upstream.invocation) + G.add_edge(upstream.invocation, invocation, stream=upstream) return G diff --git a/src/orcabridge/utils/hash.py b/src/orcabridge/utils/hash.py index 8cadd1c7..e4105028 100644 --- a/src/orcabridge/utils/hash.py +++ b/src/orcabridge/utils/hash.py @@ -3,6 +3,7 @@ import uuid from uuid import UUID from typing import Dict, Union +import inspect # arbitrary depth of nested dictionaries T = Dict[str, Union[str, "T"]] @@ -20,3 +21,87 @@ def hash_dict(d: T) -> UUID: hash_uuid = uuid.UUID(hash_object.hexdigest()) return hash_uuid + + +import hashlib + + +def stable_hash(s): + """Create a stable hash that returns the same integer value across sessions.""" + # Convert input to bytes if it's not already + if not isinstance(s, bytes): + s = str(s).encode("utf-8") + + hash_hex = hashlib.sha256(s).hexdigest() + return int(hash_hex[:16], 16) + + +def function_content_hash(func): + """ + Compute a hash based on the function's source code, name, module, and closure variables. + """ + components = [] + + # Add function name + components.append(f"name:{func.__name__}") + + # Add module + components.append(f"module:{func.__module__}") + + # Get the function's source code + try: + source = inspect.getsource(func) + # Clean up the source code + source = source.strip() + components.append(f"source:{source}") + except (IOError, TypeError): + # If we can't get the source (e.g., built-in function), use the function's string representation + components.append(f"repr:{repr(func)}") + + # Add closure variables if any + if func.__closure__: + closure_values = [] + for cell in func.__closure__: + # Try to get a stable representation of the cell content + try: + # For simple immutable objects + if isinstance(cell.cell_contents, (int, float, str, bool, type(None))): + closure_values.append(repr(cell.cell_contents)) + # For other objects, we'll use their string representation + else: + closure_values.append(str(cell.cell_contents)) + except: + # If we can't get a stable representation, use the cell's id + closure_values.append(f"cell_id:{id(cell)}") + + components.append(f"closure:{','.join(closure_values)}") + + # Add function attributes that affect behavior + if hasattr(func, "__defaults__") and func.__defaults__: + defaults_str = ",".join(repr(d) for d in func.__defaults__) + components.append(f"defaults:{defaults_str}") + + if hasattr(func, "__kwdefaults__") and func.__kwdefaults__: + kwdefaults_str = ",".join( + f"{k}={repr(v)}" for k, v in func.__kwdefaults__.items() + ) + components.append(f"kwdefaults:{kwdefaults_str}") + + # Function's code object properties (excluding filename and line numbers) + code = func.__code__ + code_props = { + "co_argcount": code.co_argcount, + "co_posonlyargcount": getattr(code, "co_posonlyargcount", 0), # Python 3.8+ + "co_kwonlyargcount": code.co_kwonlyargcount, + "co_nlocals": code.co_nlocals, + "co_stacksize": code.co_stacksize, + "co_flags": code.co_flags, + "co_code": code.co_code, + "co_names": code.co_names, + "co_varnames": code.co_varnames, + } + components.append(f"code_properties:{repr(code_props)}") + + # Join all components and compute hash + combined = "\n".join(components) + return hashlib.sha256(combined.encode("utf-8")).hexdigest() diff --git a/src/orcabridge/utils/name.py b/src/orcabridge/utils/name.py index 154ba4d9..6a44380b 100644 --- a/src/orcabridge/utils/name.py +++ b/src/orcabridge/utils/name.py @@ -4,7 +4,6 @@ import re import inspect -import hashlib import pickle import types import ast @@ -31,77 +30,6 @@ def snake_to_pascal(name: str) -> str: return "".join(x.title() for x in components) -def function_content_hash(func): - """ - Compute a hash based on the function's source code, name, module, and closure variables. - """ - components = [] - - # Add function name - components.append(f"name:{func.__name__}") - - # Add module - components.append(f"module:{func.__module__}") - - # Get the function's source code - try: - source = inspect.getsource(func) - # Clean up the source code - source = source.strip() - components.append(f"source:{source}") - except (IOError, TypeError): - # If we can't get the source (e.g., built-in function), use the function's string representation - components.append(f"repr:{repr(func)}") - - # Add closure variables if any - if func.__closure__: - closure_values = [] - for cell in func.__closure__: - # Try to get a stable representation of the cell content - try: - # For simple immutable objects - if isinstance(cell.cell_contents, (int, float, str, bool, type(None))): - closure_values.append(repr(cell.cell_contents)) - # For other objects, we'll use their string representation - else: - closure_values.append(str(cell.cell_contents)) - except: - # If we can't get a stable representation, use the cell's id - closure_values.append(f"cell_id:{id(cell)}") - - components.append(f"closure:{','.join(closure_values)}") - - # Add function attributes that affect behavior - if hasattr(func, "__defaults__") and func.__defaults__: - defaults_str = ",".join(repr(d) for d in func.__defaults__) - components.append(f"defaults:{defaults_str}") - - if hasattr(func, "__kwdefaults__") and func.__kwdefaults__: - kwdefaults_str = ",".join( - f"{k}={repr(v)}" for k, v in func.__kwdefaults__.items() - ) - components.append(f"kwdefaults:{kwdefaults_str}") - - # Function's code object properties (excluding filename and line numbers) - code = func.__code__ - code_props = { - "co_argcount": code.co_argcount, - "co_posonlyargcount": getattr(code, "co_posonlyargcount", 0), # Python 3.8+ - "co_kwonlyargcount": code.co_kwonlyargcount, - "co_nlocals": code.co_nlocals, - "co_stacksize": code.co_stacksize, - "co_flags": code.co_flags, - "co_code": code.co_code, - "co_names": code.co_names, - "co_varnames": code.co_varnames, - } - components.append(f"code_properties:{repr(code_props)}") - - # Join all components and compute hash - combined = "\n".join(components) - return hashlib.sha256(combined.encode("utf-8")).hexdigest() - - def get_function_signature(func): """ Returns a string representation of how the function arguments were defined. diff --git a/src/orcabridge/utils/stream_utils.py b/src/orcabridge/utils/stream_utils.py index 7ae6b6ce..654a2562 100644 --- a/src/orcabridge/utils/stream_utils.py +++ b/src/orcabridge/utils/stream_utils.py @@ -24,6 +24,17 @@ def join_tags(tag1: Mapping[K, V], tag2: Mapping[K, V]) -> Optional[Mapping[K, V return joined_tag +def check_packet_compatibility(packet1: Packet, packet2: Packet) -> bool: + """ + Checks if two packets are compatible. If the packets have the same key, the value must be the same or False will be returned. + If the packets have different keys, they are compatible. + """ + for k in packet1.keys(): + if k in packet2 and packet1[k] != packet2[k]: + return False + return True + + def batch_tag(all_tags: Sequence[Tag]) -> Tag: """ Batches the tags together. Grouping values under the same key into a list. From 438bc21663fa63afc191c7516287d3b604b1cd1c Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" Date: Mon, 5 May 2025 05:06:14 +0000 Subject: [PATCH 20/22] refactor: move hashing and add simpler labeling logic --- notebooks/04_orcabridge_tracker.ipynb | 114 ++++++++++-- src/orcabridge/base.py | 157 +---------------- src/orcabridge/hashing.py | 242 ++++++++++++++++++++++++++ src/orcabridge/mapper.py | 2 +- src/orcabridge/pod.py | 8 +- src/orcabridge/source.py | 2 +- src/orcabridge/store.py | 2 +- src/orcabridge/tracker.py | 13 +- src/orcabridge/utils/hash.py | 107 ------------ 9 files changed, 365 insertions(+), 282 deletions(-) create mode 100644 src/orcabridge/hashing.py delete mode 100644 src/orcabridge/utils/hash.py diff --git a/notebooks/04_orcabridge_tracker.ipynb b/notebooks/04_orcabridge_tracker.ipynb index 0150311a..ff16fb1a 100644 --- a/notebooks/04_orcabridge_tracker.ipynb +++ b/notebooks/04_orcabridge_tracker.ipynb @@ -48,7 +48,7 @@ "metadata": {}, "outputs": [], "source": [ - "gs = GlobSource(\"data_file\", \"../examples/dataset1\", \"*.txt\")" + "data_source = GlobSource(\"data_file\", \"../examples/dataset1\", \"*.txt\")" ] }, { @@ -127,7 +127,7 @@ "metadata": {}, "outputs": [], "source": [ - "line_info_json = count_lines(gs >> {\"data_file\": \"file\"})\n", + "line_info_json = count_lines(data_source >> {\"data_file\": \"file\"})\n", "line_info_yaml = json_to_yaml(line_info_json >> {\"stats\": \"json_file\"})\n", "line_info_keys = extract_keys(line_info_json >> {\"stats\": \"json_file\"})" ] @@ -142,10 +142,10 @@ "name": "stdout", "output_type": "stream", "text": [ - "Tag: {'file_name': 'day1'}, Packet: {'key_info': 'pod_data/extract_keys/16207fa7-72aa-be99-3d44-e034a5ba8823/keys.json'}\n", - "Tag: {'file_name': 'day2'}, Packet: {'key_info': 'pod_data/extract_keys/6c450b34-8835-afa9-2c07-c2d214749c3b/keys.json'}\n", - "Tag: {'file_name': 'day3'}, Packet: {'key_info': 'pod_data/extract_keys/21c8f435-47d2-13ee-cdb2-9c31eb54093b/keys.json'}\n", - "Tag: {'file_name': 'day4'}, Packet: {'key_info': 'pod_data/extract_keys/9f94dfb0-bded-6e79-dea1-494515af4886/keys.json'}\n" + "Tag: {'file_name': 'day1'}, Packet: {'key_info': 'pod_data/extract_keys/cf978f9c23318c91/c4c3939c-aced-18ac-8a7c-330f07780bbd/keys.json'}\n", + "Tag: {'file_name': 'day2'}, Packet: {'key_info': 'pod_data/extract_keys/cf978f9c23318c91/61e78af0-346a-00f7-df3d-f2ec1693a84e/keys.json'}\n", + "Tag: {'file_name': 'day3'}, Packet: {'key_info': 'pod_data/extract_keys/cf978f9c23318c91/92fbcba4-a642-4105-8be2-c01ce9c3e12e/keys.json'}\n", + "Tag: {'file_name': 'day4'}, Packet: {'key_info': 'pod_data/extract_keys/cf978f9c23318c91/9e7da977-1ed3-03a2-ffd5-a3d626c286d8/keys.json'}\n" ] } ], @@ -163,10 +163,10 @@ "name": "stdout", "output_type": "stream", "text": [ - "Tag: {'file_name': 'day1'}, Packet: {'yaml_file': 'pod_data/json_to_yaml/16207fa7-72aa-be99-3d44-e034a5ba8823/data.yaml'}\n", - "Tag: {'file_name': 'day2'}, Packet: {'yaml_file': 'pod_data/json_to_yaml/6c450b34-8835-afa9-2c07-c2d214749c3b/data.yaml'}\n", - "Tag: {'file_name': 'day3'}, Packet: {'yaml_file': 'pod_data/json_to_yaml/21c8f435-47d2-13ee-cdb2-9c31eb54093b/data.yaml'}\n", - "Tag: {'file_name': 'day4'}, Packet: {'yaml_file': 'pod_data/json_to_yaml/9f94dfb0-bded-6e79-dea1-494515af4886/data.yaml'}\n" + "Tag: {'file_name': 'day1'}, Packet: {'yaml_file': 'pod_data/json_to_yaml/0a2282eda2b641e6/c4c3939c-aced-18ac-8a7c-330f07780bbd/data.yaml'}\n", + "Tag: {'file_name': 'day2'}, Packet: {'yaml_file': 'pod_data/json_to_yaml/0a2282eda2b641e6/61e78af0-346a-00f7-df3d-f2ec1693a84e/data.yaml'}\n", + "Tag: {'file_name': 'day3'}, Packet: {'yaml_file': 'pod_data/json_to_yaml/0a2282eda2b641e6/92fbcba4-a642-4105-8be2-c01ce9c3e12e/data.yaml'}\n", + "Tag: {'file_name': 'day4'}, Packet: {'yaml_file': 'pod_data/json_to_yaml/0a2282eda2b641e6/9e7da977-1ed3-03a2-ffd5-a3d626c286d8/data.yaml'}\n" ] } ], @@ -228,13 +228,13 @@ "name": "stderr", "output_type": "stream", "text": [ - "/home/eywalker/workspace/orcabridge/src/orcabridge/tracker.py:87: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n", + "/home/eywalker/workspace/orcabridge/src/orcabridge/tracker.py:92: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n", " plt.tight_layout()\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -285,7 +285,7 @@ "\n", "# start a context manager to track the pipeline\n", "with tracker:\n", - " line_info_json = count_lines(gs >> {\"data_file\": \"file\"})\n", + " line_info_json = count_lines(data_source >> {\"data_file\": \"file\"})\n", " line_info_keys = extract_keys(line_info_json >> {\"stats\": \"json_file\"})\n", "\n", "# perform the conversion outside of the tracker\n", @@ -328,6 +328,94 @@ "source": [ "As you can see, the tracker only tracked one branch of the computation graph, leaving the other branch outside of the computation graph it has constructed and visualized." ] + }, + { + "cell_type": "markdown", + "id": "8a02717c", + "metadata": {}, + "source": [ + "## Labeling operations" + ] + }, + { + "cell_type": "markdown", + "id": "74984946", + "metadata": {}, + "source": [ + "All operations accept `label` keyword argument when creating and also has property `.label` where you can change it at any time you like. If `label` attribute of an operation is not `None`, the value will be used instead to label the operation node in the graph. In fact, you can change the label after the pipeline construction, and the change will still be reflected the next time you draw the graph!" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "b5ea2dde", + "metadata": {}, + "outputs": [], + "source": [ + "data_source.label = \"LocalDataStore\"\n", + "\n", + "count_lines.label = \"CountLines\"" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "cfc2e1c3", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "tracker.draw_graph()" + ] + }, + { + "cell_type": "markdown", + "id": "7482ce7f", + "metadata": {}, + "source": [ + "You can always get the orginal label back by setting label to `None`:" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "8d4664a1", + "metadata": {}, + "outputs": [], + "source": [ + "count_lines.label = None" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "1ac44e76", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "tracker.draw_graph()" + ] } ], "metadata": { diff --git a/src/orcabridge/base.py b/src/orcabridge/base.py index aa1d12ff..67b4a36c 100644 --- a/src/orcabridge/base.py +++ b/src/orcabridge/base.py @@ -1,155 +1,16 @@ +from orcabridge.hashing import HashableMixin from .types import Tag, Packet from typing import ( Optional, Tuple, List, - Dict, Any, Collection, Callable, Iterator, - Mapping, - Union, ) -from .utils.hash import hash_dict, stable_hash -import hashlib -import networkx as nx -import json -from collections.abc import Mapping, Collection -from typing import Any, Dict, List, Set, Tuple, Union - - -class HashableMixin: - """A mixin that provides content-based hashing functionality.""" - - def identity_structure(self) -> Any: - """ - Return a structure that represents the identity of this object. - By default, returns None to indicate that no custom structure is provided. - Subclasses should override this method to provide meaningful representations. - - Returns: - None to indicate no custom structure (use default hash) - """ - return None - - def content_hash(self, char_count: Optional[int] = 16) -> str: - """ - Generate a stable string hash based on the object's content. - - Returns: - str: A hexadecimal digest representing the object's content - """ - # Get the identity structure - structure = self.identity_structure() - - # If no custom structure is provided, use the superclass's hash - if structure is None: - # Convert the default hash to a stable string - return hashlib.sha256(str(super().__hash__()).encode()).hexdigest() - - # Generate a hash from the identity structure - return self._hash_structure(structure, char_count=char_count) - - def content_hash_int(self, hexdigits=16) -> int: - """ - Generate a stable integer hash based on the object's content. - - Returns: - int: An integer representing the object's content - """ - # pass in char_count=None to get the full hash - return int(self.content_hash(char_count=None)[:hexdigits], 16) - - def __hash__(self) -> int: - """ - Hash implementation that uses the identity structure if provided, - otherwise falls back to the superclass's hash method. - - Returns: - int: A hash value based on either content or identity - """ - # Get the identity structure - structure = self.identity_structure() - - # If no custom structure is provided, use the superclass's hash - if structure is None: - return super().__hash__() - - # Generate a hash and convert to integer - hash_hex = self._hash_structure(structure, char_count=None) - return int(hash_hex[:16], 16) - - def _hash_structure(self, structure: Any, char_count: Optional[int] = 16) -> str: - """ - Helper method to compute a hash string from a structure. - - Args: - structure: The structure to hash - - Returns: - str: A hexadecimal hash digest of the structure - """ - processed = self._process_structure(structure) - json_str = json.dumps(processed, sort_keys=True).encode() - return hashlib.sha256(json_str).hexdigest()[:char_count] - - def _process_structure(self, obj: Any) -> Any: - """ - Recursively process a structure to prepare it for hashing. - - Args: - obj: The object or structure to process - - Returns: - A processed version of the structure with HashableMixin objects replaced by their hashes - """ - # Handle None - if obj is None: - return "None" - - # If the object is a HashableMixin, use its content_hash - if isinstance(obj, HashableMixin): - # Don't call content_hash on self to avoid cycles - if obj is self: - # Use the superclass's hash for self - return str(super(HashableMixin, self).__hash__()) - return obj.content_hash() - - # Handle basic types - if isinstance(obj, (str, int, float, bool)): - return str(obj) - - # Handle named tuples (which are subclasses of tuple) - if hasattr(obj, "_fields") and isinstance(obj, tuple): - # For namedtuples, convert to dict and then process - return self._process_structure( - {field: value for field, value in zip(obj._fields, obj)} - ) - - # Handle mappings (dict-like objects) - if isinstance(obj, Mapping): - return { - str(k): self._process_structure(v) - for k, v in sorted(obj.items(), key=lambda x: str(x[0])) - } - - # Handle sets and frozensets specifically - if isinstance(obj, (set, frozenset)): - # Process each item first, then sort the processed results - processed_items = [self._process_structure(item) for item in obj] - return sorted(processed_items, key=str) - - # Handle collections (list-like objects) - if isinstance(obj, Collection): - return [self._process_structure(item) for item in obj] - - # For bytes and bytearray, convert to hex representation - if isinstance(obj, (bytes, bytearray)): - return obj.hex() - - # For other objects, just use their string representation - return str(obj) +from collections.abc import Collection +from typing import Any, List, Tuple class Operation(HashableMixin): @@ -168,16 +29,16 @@ def __init__(self, label: Optional[str] = None, **kwargs) -> None: self._label = label @property - def label(self) -> Optional[str]: + def label(self) -> str: """ - The label of the operation. This is used to refer to the operation in the tracker + Overwrite this method to attain a custom label logic for the operation. """ - if self._label is None: - # if the label is not set, use the class name as the label - self._label = self.__class__.__name__ - return self._label + @label.setter + def label(self, value: str) -> None: + self._label = value + def identity_structure(self, *streams: "SyncStream") -> Any: # Default implementation of identity_structure for the operation only # concerns the operation class and the streams if present. Subclasses of diff --git a/src/orcabridge/hashing.py b/src/orcabridge/hashing.py new file mode 100644 index 00000000..2dc47dd9 --- /dev/null +++ b/src/orcabridge/hashing.py @@ -0,0 +1,242 @@ +# a function to hash a dictionary of key value pairs into uuid +from collections.abc import Collection, Mapping +import hashlib +import uuid +from uuid import UUID +from typing import Any, Dict, Optional, Union +import inspect +import json + +# arbitrary depth of nested dictionaries +T = Dict[str, Union[str, "T"]] + + +# TODO: implement proper recursive hashing +def hash_dict(d: T) -> UUID: + # Convert the dictionary to a string representation + dict_str = str(sorted(d.items())) + + # Create a hash of the string representation + hash_object = hashlib.md5(dict_str.encode()) + + # Convert the hash to a UUID + hash_uuid = uuid.UUID(hash_object.hexdigest()) + + return hash_uuid + + +import hashlib + + +def stable_hash(s): + """Create a stable hash that returns the same integer value across sessions.""" + # Convert input to bytes if it's not already + if not isinstance(s, bytes): + s = str(s).encode("utf-8") + + hash_hex = hashlib.sha256(s).hexdigest() + return int(hash_hex[:16], 16) + + +def function_content_hash(func): + """ + Compute a hash based on the function's source code, name, module, and closure variables. + """ + components = [] + + # Add function name + components.append(f"name:{func.__name__}") + + # Add module + components.append(f"module:{func.__module__}") + + # Get the function's source code + try: + source = inspect.getsource(func) + # Clean up the source code + source = source.strip() + components.append(f"source:{source}") + except (IOError, TypeError): + # If we can't get the source (e.g., built-in function), use the function's string representation + components.append(f"repr:{repr(func)}") + + # Add closure variables if any + if func.__closure__: + closure_values = [] + for cell in func.__closure__: + # Try to get a stable representation of the cell content + try: + # For simple immutable objects + if isinstance(cell.cell_contents, (int, float, str, bool, type(None))): + closure_values.append(repr(cell.cell_contents)) + # For other objects, we'll use their string representation + else: + closure_values.append(str(cell.cell_contents)) + except: + # If we can't get a stable representation, use the cell's id + closure_values.append(f"cell_id:{id(cell)}") + + components.append(f"closure:{','.join(closure_values)}") + + # Add function attributes that affect behavior + if hasattr(func, "__defaults__") and func.__defaults__: + defaults_str = ",".join(repr(d) for d in func.__defaults__) + components.append(f"defaults:{defaults_str}") + + if hasattr(func, "__kwdefaults__") and func.__kwdefaults__: + kwdefaults_str = ",".join( + f"{k}={repr(v)}" for k, v in func.__kwdefaults__.items() + ) + components.append(f"kwdefaults:{kwdefaults_str}") + + # Function's code object properties (excluding filename and line numbers) + code = func.__code__ + code_props = { + "co_argcount": code.co_argcount, + "co_posonlyargcount": getattr(code, "co_posonlyargcount", 0), # Python 3.8+ + "co_kwonlyargcount": code.co_kwonlyargcount, + "co_nlocals": code.co_nlocals, + "co_stacksize": code.co_stacksize, + "co_flags": code.co_flags, + "co_code": code.co_code, + "co_names": code.co_names, + "co_varnames": code.co_varnames, + } + components.append(f"code_properties:{repr(code_props)}") + + # Join all components and compute hash + combined = "\n".join(components) + return hashlib.sha256(combined.encode("utf-8")).hexdigest() + + +class HashableMixin: + """A mixin that provides content-based hashing functionality.""" + + def identity_structure(self) -> Any: + """ + Return a structure that represents the identity of this object. + By default, returns None to indicate that no custom structure is provided. + Subclasses should override this method to provide meaningful representations. + + Returns: + None to indicate no custom structure (use default hash) + """ + return None + + def content_hash(self, char_count: Optional[int] = 16) -> str: + """ + Generate a stable string hash based on the object's content. + + Returns: + str: A hexadecimal digest representing the object's content + """ + # Get the identity structure + structure = self.identity_structure() + + # If no custom structure is provided, use the superclass's hash + if structure is None: + # Convert the default hash to a stable string + return hashlib.sha256(str(super().__hash__()).encode()).hexdigest() + + # Generate a hash from the identity structure + return self._hash_structure(structure, char_count=char_count) + + def content_hash_int(self, hexdigits=16) -> int: + """ + Generate a stable integer hash based on the object's content. + + Returns: + int: An integer representing the object's content + """ + # pass in char_count=None to get the full hash + return int(self.content_hash(char_count=None)[:hexdigits], 16) + + def __hash__(self) -> int: + """ + Hash implementation that uses the identity structure if provided, + otherwise falls back to the superclass's hash method. + + Returns: + int: A hash value based on either content or identity + """ + # Get the identity structure + structure = self.identity_structure() + + # If no custom structure is provided, use the superclass's hash + if structure is None: + return super().__hash__() + + # Generate a hash and convert to integer + hash_hex = self._hash_structure(structure, char_count=None) + return int(hash_hex[:16], 16) + + def _hash_structure(self, structure: Any, char_count: Optional[int] = 16) -> str: + """ + Helper method to compute a hash string from a structure. + + Args: + structure: The structure to hash + + Returns: + str: A hexadecimal hash digest of the structure + """ + processed = self._process_structure(structure) + json_str = json.dumps(processed, sort_keys=True).encode() + return hashlib.sha256(json_str).hexdigest()[:char_count] + + def _process_structure(self, obj: Any) -> Any: + """ + Recursively process a structure to prepare it for hashing. + + Args: + obj: The object or structure to process + + Returns: + A processed version of the structure with HashableMixin objects replaced by their hashes + """ + # Handle None + if obj is None: + return "None" + + # If the object is a HashableMixin, use its content_hash + if isinstance(obj, HashableMixin): + # Don't call content_hash on self to avoid cycles + if obj is self: + # Use the superclass's hash for self + return str(super(HashableMixin, self).__hash__()) + return obj.content_hash() + + # Handle basic types + if isinstance(obj, (str, int, float, bool)): + return str(obj) + + # Handle named tuples (which are subclasses of tuple) + if hasattr(obj, "_fields") and isinstance(obj, tuple): + # For namedtuples, convert to dict and then process + return self._process_structure( + {field: value for field, value in zip(obj._fields, obj)} + ) + + # Handle mappings (dict-like objects) + if isinstance(obj, Mapping): + return { + str(k): self._process_structure(v) + for k, v in sorted(obj.items(), key=lambda x: str(x[0])) + } + + # Handle sets and frozensets specifically + if isinstance(obj, (set, frozenset)): + # Process each item first, then sort the processed results + processed_items = [self._process_structure(item) for item in obj] + return sorted(processed_items, key=str) + + # Handle collections (list-like objects) + if isinstance(obj, Collection): + return [self._process_structure(item) for item in obj] + + # For bytes and bytearray, convert to hex representation + if isinstance(obj, (bytes, bytearray)): + return obj.hex() + + # For other objects, just use their string representation + return str(obj) diff --git a/src/orcabridge/mapper.py b/src/orcabridge/mapper.py index 14f972b7..ad8dfd32 100644 --- a/src/orcabridge/mapper.py +++ b/src/orcabridge/mapper.py @@ -8,7 +8,7 @@ batch_tag, batch_packet, ) -from .utils.hash import function_content_hash, stable_hash +from .hashing import function_content_hash, stable_hash from .types import Tag, Packet from typing import Iterator, Tuple diff --git a/src/orcabridge/pod.py b/src/orcabridge/pod.py index 6f81880c..91c1ff4a 100644 --- a/src/orcabridge/pod.py +++ b/src/orcabridge/pod.py @@ -4,7 +4,7 @@ from pathlib import Path from typing import List, Optional, Tuple, Iterator, Iterable, Collection, Literal, Any -from .utils.hash import function_content_hash, hash_dict, stable_hash +from .hashing import function_content_hash, hash_dict, stable_hash from .utils.name import get_function_signature from .base import Operation from .mapper import Join @@ -123,12 +123,6 @@ def __init__( self.skip_memoization = skip_memoization self.force_computation = force_computation - @property - def label(self) -> str: - if self._label is None: - return self.store_name - return self._label - def __repr__(self) -> str: func_sig = get_function_signature(self.function) return f"FunctionPod:{func_sig} ⇒ {self.output_keys}" diff --git a/src/orcabridge/source.py b/src/orcabridge/source.py index b6c7086b..ab836224 100644 --- a/src/orcabridge/source.py +++ b/src/orcabridge/source.py @@ -4,7 +4,7 @@ from typing import Iterator, Tuple, Optional, Callable, Any from os import PathLike from pathlib import Path -from .utils.hash import function_content_hash, stable_hash +from .hashing import function_content_hash, stable_hash class GlobSource(Source): diff --git a/src/orcabridge/store.py b/src/orcabridge/store.py index f96be5a9..278d124b 100644 --- a/src/orcabridge/store.py +++ b/src/orcabridge/store.py @@ -1,7 +1,7 @@ from .types import Tag, Packet from typing import Optional, Collection from pathlib import Path -from .utils.hash import hash_dict +from .hashing import hash_dict import shutil import logging import json diff --git a/src/orcabridge/tracker.py b/src/orcabridge/tracker.py index ea50c3eb..b612ba94 100644 --- a/src/orcabridge/tracker.py +++ b/src/orcabridge/tracker.py @@ -15,7 +15,9 @@ def __init__(self) -> None: self.invocation_lut: Dict[Operation, Collection[Invocation]] = {} def record(self, invocation: Invocation) -> None: - self.invocation_lut.setdefault(invocation.operation, set()).add(invocation) + invocation_list = self.invocation_lut.setdefault(invocation.operation, []) + if invocation not in invocation_list: + invocation_list.append(invocation) def reset(self) -> Dict[Operation, Collection[Invocation]]: """ @@ -29,13 +31,16 @@ def generate_namemap(self) -> Dict[Invocation, str]: namemap = {} for operation, invocations in self.invocation_lut.items(): # if only one entry present, use the operation name alone - invocations = sorted(invocations) + if operation.label is not None: + node_label = operation.label + else: + node_label = str(operation) if len(invocations) == 1: - namemap[invocations[0]] = f"{operation}" + namemap[invocations[0]] = node_label continue # if multiple entries, use the operation name and index for idx, invocation in enumerate(invocations): - namemap[invocation] = f"{operation}_{idx}" + namemap[invocation] = f"{node_label}_{idx}" return namemap def activate(self) -> None: diff --git a/src/orcabridge/utils/hash.py b/src/orcabridge/utils/hash.py deleted file mode 100644 index e4105028..00000000 --- a/src/orcabridge/utils/hash.py +++ /dev/null @@ -1,107 +0,0 @@ -# a function to hash a dictionary of key value pairs into uuid -import hashlib -import uuid -from uuid import UUID -from typing import Dict, Union -import inspect - -# arbitrary depth of nested dictionaries -T = Dict[str, Union[str, "T"]] - - -# TODO: implement proper recursive hashing -def hash_dict(d: T) -> UUID: - # Convert the dictionary to a string representation - dict_str = str(sorted(d.items())) - - # Create a hash of the string representation - hash_object = hashlib.md5(dict_str.encode()) - - # Convert the hash to a UUID - hash_uuid = uuid.UUID(hash_object.hexdigest()) - - return hash_uuid - - -import hashlib - - -def stable_hash(s): - """Create a stable hash that returns the same integer value across sessions.""" - # Convert input to bytes if it's not already - if not isinstance(s, bytes): - s = str(s).encode("utf-8") - - hash_hex = hashlib.sha256(s).hexdigest() - return int(hash_hex[:16], 16) - - -def function_content_hash(func): - """ - Compute a hash based on the function's source code, name, module, and closure variables. - """ - components = [] - - # Add function name - components.append(f"name:{func.__name__}") - - # Add module - components.append(f"module:{func.__module__}") - - # Get the function's source code - try: - source = inspect.getsource(func) - # Clean up the source code - source = source.strip() - components.append(f"source:{source}") - except (IOError, TypeError): - # If we can't get the source (e.g., built-in function), use the function's string representation - components.append(f"repr:{repr(func)}") - - # Add closure variables if any - if func.__closure__: - closure_values = [] - for cell in func.__closure__: - # Try to get a stable representation of the cell content - try: - # For simple immutable objects - if isinstance(cell.cell_contents, (int, float, str, bool, type(None))): - closure_values.append(repr(cell.cell_contents)) - # For other objects, we'll use their string representation - else: - closure_values.append(str(cell.cell_contents)) - except: - # If we can't get a stable representation, use the cell's id - closure_values.append(f"cell_id:{id(cell)}") - - components.append(f"closure:{','.join(closure_values)}") - - # Add function attributes that affect behavior - if hasattr(func, "__defaults__") and func.__defaults__: - defaults_str = ",".join(repr(d) for d in func.__defaults__) - components.append(f"defaults:{defaults_str}") - - if hasattr(func, "__kwdefaults__") and func.__kwdefaults__: - kwdefaults_str = ",".join( - f"{k}={repr(v)}" for k, v in func.__kwdefaults__.items() - ) - components.append(f"kwdefaults:{kwdefaults_str}") - - # Function's code object properties (excluding filename and line numbers) - code = func.__code__ - code_props = { - "co_argcount": code.co_argcount, - "co_posonlyargcount": getattr(code, "co_posonlyargcount", 0), # Python 3.8+ - "co_kwonlyargcount": code.co_kwonlyargcount, - "co_nlocals": code.co_nlocals, - "co_stacksize": code.co_stacksize, - "co_flags": code.co_flags, - "co_code": code.co_code, - "co_names": code.co_names, - "co_varnames": code.co_varnames, - } - components.append(f"code_properties:{repr(code_props)}") - - # Join all components and compute hash - combined = "\n".join(components) - return hashlib.sha256(combined.encode("utf-8")).hexdigest() From 3a443cdc414c701683f3fd3c20ab1e771398209d Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" Date: Mon, 5 May 2025 05:10:01 +0000 Subject: [PATCH 21/22] fix: wrong argument name used --- notebooks/02_orcabridge_basic_usage.ipynb | 60 +++++++++++------------ src/orcabridge/mapper.py | 2 +- 2 files changed, 31 insertions(+), 31 deletions(-) diff --git a/notebooks/02_orcabridge_basic_usage.ipynb b/notebooks/02_orcabridge_basic_usage.ipynb index 39019218..c90964fc 100644 --- a/notebooks/02_orcabridge_basic_usage.ipynb +++ b/notebooks/02_orcabridge_basic_usage.ipynb @@ -65,7 +65,7 @@ } ], "source": [ - "ls ../examples/dataset1" + "%ls ../examples/dataset1" ] }, { @@ -355,7 +355,7 @@ "source": [ "from orcabridge.mapper import MapTags\n", "\n", - "tag_mapper = MapTags(tag_map={\"file_name\": \"day\"})\n", + "tag_mapper = MapTags(key_map={\"file_name\": \"day\"})\n", "\n", "for tag, packet in tag_mapper(dataset1):\n", " print(tag, packet)" @@ -395,7 +395,7 @@ "packet_mapper = MapPackets(key_map={\"txt_file\": \"content\"})\n", "key_mapped_stream = packet_mapper(dataset1)\n", "\n", - "tag_mapper = MapTags(tag_map={\"file_name\": \"day\"})\n", + "tag_mapper = MapTags(key_map={\"file_name\": \"day\"})\n", "tag_and_packet_mapped = tag_mapper(key_mapped_stream)\n", "\n", "for tag, packet in tag_and_packet_mapped:\n", @@ -434,7 +434,7 @@ ], "source": [ "# totally valid, but difficult to read and thus not recommended\n", - "for tag, packet in MapTags(tag_map={\"file_name\": \"day\"})(\n", + "for tag, packet in MapTags(key_map={\"file_name\": \"day\"})(\n", " MapPackets(key_map={\"txt_file\": \"content\"})(dataset1)\n", "):\n", " print(f\"Mapped Packet {packet} with tag {tag}\")" @@ -564,7 +564,7 @@ } ], "source": [ - "dataset1_retagged = MapTags(tag_map={\"file_name\": \"day\"})(dataset1)\n", + "dataset1_retagged = MapTags(key_map={\"file_name\": \"day\"})(dataset1)\n", "\n", "for i, (tag, packet) in enumerate(join_op(dataset1_retagged, dataset2)):\n", " print(f\"{i+1:02d} Tag: {tag}, Packet: {packet}\")" @@ -655,7 +655,7 @@ ], "source": [ "# change filename to day for dataset1\n", - "tag_mapper = MapTags(tag_map={\"file_name\": \"day\"})\n", + "tag_mapper = MapTags(key_map={\"file_name\": \"day\"})\n", "retagged_dataset1 = tag_mapper(dataset1)\n", "\n", "join_op = Join()\n", @@ -842,7 +842,7 @@ " -0.08364667 -0.45551653 0.70752188 1.02283734 -0.18612795 0.8767394\n", " -1.542636 1.04685484 -2.1311672 -1.34874222 0.61977577 -0.33880262\n", " 0.6624482 0.60257325 -3.04901544 -0.20685843 -0.08997232 0.88932232]\n", - "Tag: {'file_name': 'session_day1'}, Packet: {'stats': PosixPath('/tmp/tmpkvszterb/statistics.json')}\n", + "Tag: {'file_name': 'session_day1'}, Packet: {'stats': PosixPath('/tmp/tmph9gbd0fv/statistics.json')}\n", "Computing stats for file: ../examples/dataset2/session_day3.bin\n", "[ 0.56114059 -1.34902274 1.0665563 0.71890802 0.65244834 1.04369548\n", " 0.54872876 2.19365207 0.53864286 -1.44108823 -0.55651539 0.1603561\n", @@ -850,21 +850,21 @@ " 0.38400938 -1.23004316 1.34426647 -0.07620065 -0.91983972 0.23537101\n", " 0.91515395 0.8064348 0.81470895 -1.04466683 -0.25893558 -1.46253167\n", " 1.39972807 -0.13940519]\n", - "Tag: {'file_name': 'session_day3'}, Packet: {'stats': PosixPath('/tmp/tmptq70w_c5/statistics.json')}\n", + "Tag: {'file_name': 'session_day3'}, Packet: {'stats': PosixPath('/tmp/tmptchkxdfb/statistics.json')}\n", "Computing stats for file: ../examples/dataset2/session_day4.bin\n", "[ 0.70078854 1.18137906 -0.44361437 -0.389409 0.29719038 0.2523247\n", " -0.97418716 0.49301127 0.07900351 -0.29965042 -0.25810762 -2.78777445\n", " -1.24321702 0.13011593 1.07826637 -0.33177479 -0.78337033 -1.30075356\n", " -0.15710138 0.51927589 0.08671884 0.02058063 0.20778149 -1.40382559\n", " -0.69978105 -1.10525753 0.1945444 0.82623748 0.17467868]\n", - "Tag: {'file_name': 'session_day4'}, Packet: {'stats': PosixPath('/tmp/tmpbklxiav3/statistics.json')}\n", + "Tag: {'file_name': 'session_day4'}, Packet: {'stats': PosixPath('/tmp/tmp76wnct82/statistics.json')}\n", "Computing stats for file: ../examples/dataset2/session_day5.bin\n", "[ 1.9125739 -0.05252076 0.33347618 0.31627214 0.47141153 -0.71088615\n", " -0.74745805 0.53959117 -0.14395142 -0.28713782 -0.29422236 -1.00231383\n", " 0.69566576 -0.25895608 -0.9660761 -0.78504297 -1.91668262 0.89452296\n", " -0.82748688 -0.19792482 0.07305616 0.36133414 1.7164791 0.64364619\n", " -0.73146429 0.96324864 -1.05981222 -0.59502066 0.15084192]\n", - "Tag: {'file_name': 'session_day5'}, Packet: {'stats': PosixPath('/tmp/tmpyyu7uuv3/statistics.json')}\n" + "Tag: {'file_name': 'session_day5'}, Packet: {'stats': PosixPath('/tmp/tmpl50i68wn/statistics.json')}\n" ] } ], @@ -902,7 +902,7 @@ " -0.08364667 -0.45551653 0.70752188 1.02283734 -0.18612795 0.8767394\n", " -1.542636 1.04685484 -2.1311672 -1.34874222 0.61977577 -0.33880262\n", " 0.6624482 0.60257325 -3.04901544 -0.20685843 -0.08997232 0.88932232]\n", - "Tag: {'file_name': 'session_day1'}, Packet: {'stats': PosixPath('/tmp/tmpe8mkncg3/statistics.json')}\n", + "Tag: {'file_name': 'session_day1'}, Packet: {'stats': PosixPath('/tmp/tmp5ce8eqt6/statistics.json')}\n", "Computing stats for file: ../examples/dataset2/session_day3.bin\n", "[ 0.56114059 -1.34902274 1.0665563 0.71890802 0.65244834 1.04369548\n", " 0.54872876 2.19365207 0.53864286 -1.44108823 -0.55651539 0.1603561\n", @@ -910,21 +910,21 @@ " 0.38400938 -1.23004316 1.34426647 -0.07620065 -0.91983972 0.23537101\n", " 0.91515395 0.8064348 0.81470895 -1.04466683 -0.25893558 -1.46253167\n", " 1.39972807 -0.13940519]\n", - "Tag: {'file_name': 'session_day3'}, Packet: {'stats': PosixPath('/tmp/tmp8a18mk4f/statistics.json')}\n", + "Tag: {'file_name': 'session_day3'}, Packet: {'stats': PosixPath('/tmp/tmpo07l5i_w/statistics.json')}\n", "Computing stats for file: ../examples/dataset2/session_day4.bin\n", "[ 0.70078854 1.18137906 -0.44361437 -0.389409 0.29719038 0.2523247\n", " -0.97418716 0.49301127 0.07900351 -0.29965042 -0.25810762 -2.78777445\n", " -1.24321702 0.13011593 1.07826637 -0.33177479 -0.78337033 -1.30075356\n", " -0.15710138 0.51927589 0.08671884 0.02058063 0.20778149 -1.40382559\n", " -0.69978105 -1.10525753 0.1945444 0.82623748 0.17467868]\n", - "Tag: {'file_name': 'session_day4'}, Packet: {'stats': PosixPath('/tmp/tmpx3qugl6g/statistics.json')}\n", + "Tag: {'file_name': 'session_day4'}, Packet: {'stats': PosixPath('/tmp/tmpum88t4vy/statistics.json')}\n", "Computing stats for file: ../examples/dataset2/session_day5.bin\n", "[ 1.9125739 -0.05252076 0.33347618 0.31627214 0.47141153 -0.71088615\n", " -0.74745805 0.53959117 -0.14395142 -0.28713782 -0.29422236 -1.00231383\n", " 0.69566576 -0.25895608 -0.9660761 -0.78504297 -1.91668262 0.89452296\n", " -0.82748688 -0.19792482 0.07305616 0.36133414 1.7164791 0.64364619\n", " -0.73146429 0.96324864 -1.05981222 -0.59502066 0.15084192]\n", - "Tag: {'file_name': 'session_day5'}, Packet: {'stats': PosixPath('/tmp/tmp0a356pkt/statistics.json')}\n" + "Tag: {'file_name': 'session_day5'}, Packet: {'stats': PosixPath('/tmp/tmppy2mzr9l/statistics.json')}\n" ] } ], @@ -973,7 +973,7 @@ " -0.08364667 -0.45551653 0.70752188 1.02283734 -0.18612795 0.8767394\n", " -1.542636 1.04685484 -2.1311672 -1.34874222 0.61977577 -0.33880262\n", " 0.6624482 0.60257325 -3.04901544 -0.20685843 -0.08997232 0.88932232]\n", - "Tag: {'file_name': 'session_day1'}, Packet: {'stats': PosixPath('/tmp/tmpn5thbtoi/statistics.json')}\n", + "Tag: {'file_name': 'session_day1'}, Packet: {'stats': PosixPath('/tmp/tmpom7k61_b/statistics.json')}\n", "Computing stats for file: ../examples/dataset2/session_day3.bin\n", "[ 0.56114059 -1.34902274 1.0665563 0.71890802 0.65244834 1.04369548\n", " 0.54872876 2.19365207 0.53864286 -1.44108823 -0.55651539 0.1603561\n", @@ -981,21 +981,21 @@ " 0.38400938 -1.23004316 1.34426647 -0.07620065 -0.91983972 0.23537101\n", " 0.91515395 0.8064348 0.81470895 -1.04466683 -0.25893558 -1.46253167\n", " 1.39972807 -0.13940519]\n", - "Tag: {'file_name': 'session_day3'}, Packet: {'stats': PosixPath('/tmp/tmpgdredw2e/statistics.json')}\n", + "Tag: {'file_name': 'session_day3'}, Packet: {'stats': PosixPath('/tmp/tmp1smo1jfe/statistics.json')}\n", "Computing stats for file: ../examples/dataset2/session_day4.bin\n", "[ 0.70078854 1.18137906 -0.44361437 -0.389409 0.29719038 0.2523247\n", " -0.97418716 0.49301127 0.07900351 -0.29965042 -0.25810762 -2.78777445\n", " -1.24321702 0.13011593 1.07826637 -0.33177479 -0.78337033 -1.30075356\n", " -0.15710138 0.51927589 0.08671884 0.02058063 0.20778149 -1.40382559\n", " -0.69978105 -1.10525753 0.1945444 0.82623748 0.17467868]\n", - "Tag: {'file_name': 'session_day4'}, Packet: {'stats': PosixPath('/tmp/tmp5dvgc23y/statistics.json')}\n", + "Tag: {'file_name': 'session_day4'}, Packet: {'stats': PosixPath('/tmp/tmp__qhe8vk/statistics.json')}\n", "Computing stats for file: ../examples/dataset2/session_day5.bin\n", "[ 1.9125739 -0.05252076 0.33347618 0.31627214 0.47141153 -0.71088615\n", " -0.74745805 0.53959117 -0.14395142 -0.28713782 -0.29422236 -1.00231383\n", " 0.69566576 -0.25895608 -0.9660761 -0.78504297 -1.91668262 0.89452296\n", " -0.82748688 -0.19792482 0.07305616 0.36133414 1.7164791 0.64364619\n", " -0.73146429 0.96324864 -1.05981222 -0.59502066 0.15084192]\n", - "Tag: {'file_name': 'session_day5'}, Packet: {'stats': PosixPath('/tmp/tmpwh1a8zyb/statistics.json')}\n" + "Tag: {'file_name': 'session_day5'}, Packet: {'stats': PosixPath('/tmp/tmpjhm16xjo/statistics.json')}\n" ] } ], @@ -1032,10 +1032,10 @@ "name": "stdout", "output_type": "stream", "text": [ - "Tag: {'file_name': 'session_day1'}, Packet: {'stats': PosixPath('/tmp/tmpn5thbtoi/statistics.json')}\n", - "Tag: {'file_name': 'session_day3'}, Packet: {'stats': PosixPath('/tmp/tmpgdredw2e/statistics.json')}\n", - "Tag: {'file_name': 'session_day4'}, Packet: {'stats': PosixPath('/tmp/tmp5dvgc23y/statistics.json')}\n", - "Tag: {'file_name': 'session_day5'}, Packet: {'stats': PosixPath('/tmp/tmpwh1a8zyb/statistics.json')}\n" + "Tag: {'file_name': 'session_day1'}, Packet: {'stats': PosixPath('/tmp/tmpom7k61_b/statistics.json')}\n", + "Tag: {'file_name': 'session_day3'}, Packet: {'stats': PosixPath('/tmp/tmp1smo1jfe/statistics.json')}\n", + "Tag: {'file_name': 'session_day4'}, Packet: {'stats': PosixPath('/tmp/tmp__qhe8vk/statistics.json')}\n", + "Tag: {'file_name': 'session_day5'}, Packet: {'stats': PosixPath('/tmp/tmpjhm16xjo/statistics.json')}\n" ] } ], @@ -1108,10 +1108,10 @@ "name": "stdout", "output_type": "stream", "text": [ - "Tag: {'file_name': 'session_day1'}, Packet: {'stats': 'pod_data/compute_stats/4f87e2b3-fe44-ea43-6eee-70f63e6d0e95/statistics.json'}\n", - "Tag: {'file_name': 'session_day3'}, Packet: {'stats': 'pod_data/compute_stats/eb5c269e-d64d-278a-abc1-afe50716d21a/statistics.json'}\n", - "Tag: {'file_name': 'session_day4'}, Packet: {'stats': 'pod_data/compute_stats/ba148557-207e-9a7e-6ee2-353dc861cefa/statistics.json'}\n", - "Tag: {'file_name': 'session_day5'}, Packet: {'stats': 'pod_data/compute_stats/8de9dd2c-fa49-bae2-9c60-d4e84cba136e/statistics.json'}\n" + "Tag: {'file_name': 'session_day1'}, Packet: {'stats': 'pod_data/compute_stats/eb526f4394837124/4f87e2b3-fe44-ea43-6eee-70f63e6d0e95/statistics.json'}\n", + "Tag: {'file_name': 'session_day3'}, Packet: {'stats': 'pod_data/compute_stats/eb526f4394837124/eb5c269e-d64d-278a-abc1-afe50716d21a/statistics.json'}\n", + "Tag: {'file_name': 'session_day4'}, Packet: {'stats': 'pod_data/compute_stats/eb526f4394837124/ba148557-207e-9a7e-6ee2-353dc861cefa/statistics.json'}\n", + "Tag: {'file_name': 'session_day5'}, Packet: {'stats': 'pod_data/compute_stats/eb526f4394837124/8de9dd2c-fa49-bae2-9c60-d4e84cba136e/statistics.json'}\n" ] } ], @@ -1136,10 +1136,10 @@ "name": "stdout", "output_type": "stream", "text": [ - "Tag: {'file_name': 'session_day1'}, Packet: {'stats': 'pod_data/compute_stats/4f87e2b3-fe44-ea43-6eee-70f63e6d0e95/statistics.json'}\n", - "Tag: {'file_name': 'session_day3'}, Packet: {'stats': 'pod_data/compute_stats/eb5c269e-d64d-278a-abc1-afe50716d21a/statistics.json'}\n", - "Tag: {'file_name': 'session_day4'}, Packet: {'stats': 'pod_data/compute_stats/ba148557-207e-9a7e-6ee2-353dc861cefa/statistics.json'}\n", - "Tag: {'file_name': 'session_day5'}, Packet: {'stats': 'pod_data/compute_stats/8de9dd2c-fa49-bae2-9c60-d4e84cba136e/statistics.json'}\n" + "Tag: {'file_name': 'session_day1'}, Packet: {'stats': 'pod_data/compute_stats/eb526f4394837124/4f87e2b3-fe44-ea43-6eee-70f63e6d0e95/statistics.json'}\n", + "Tag: {'file_name': 'session_day3'}, Packet: {'stats': 'pod_data/compute_stats/eb526f4394837124/eb5c269e-d64d-278a-abc1-afe50716d21a/statistics.json'}\n", + "Tag: {'file_name': 'session_day4'}, Packet: {'stats': 'pod_data/compute_stats/eb526f4394837124/ba148557-207e-9a7e-6ee2-353dc861cefa/statistics.json'}\n", + "Tag: {'file_name': 'session_day5'}, Packet: {'stats': 'pod_data/compute_stats/eb526f4394837124/8de9dd2c-fa49-bae2-9c60-d4e84cba136e/statistics.json'}\n" ] } ], diff --git a/src/orcabridge/mapper.py b/src/orcabridge/mapper.py index ad8dfd32..4fe561b1 100644 --- a/src/orcabridge/mapper.py +++ b/src/orcabridge/mapper.py @@ -142,7 +142,7 @@ def __hash__(self) -> int: def identity_structure(self, *streams): return ( self.__class__.__name__, - tuple(sorted(self.tag_map.items())), + tuple(sorted(self.key_map.items())), self.drop_unmapped, ) + tuple(streams) From a8f13c9949dbd53cea22485da6c476b4ab998a78 Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" Date: Mon, 5 May 2025 07:02:01 +0000 Subject: [PATCH 22/22] fix: superclass to Mapper --- src/orcabridge/mapper.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/orcabridge/mapper.py b/src/orcabridge/mapper.py index 4fe561b1..885ebf7c 100644 --- a/src/orcabridge/mapper.py +++ b/src/orcabridge/mapper.py @@ -97,7 +97,7 @@ def identity_structure(self, *streams): ) + tuple(streams) -class MapTags(Operation): +class MapTags(Mapper): """ A Mapper that maps the tags of the packet in the stream to new tags. Packet remains unchanged. The mapping is done using a dictionary that maps old tags to new tags.