diff --git a/.github/AGENTS.md b/.github/AGENTS.md new file mode 100644 index 0000000..7fbf5a7 --- /dev/null +++ b/.github/AGENTS.md @@ -0,0 +1,19 @@ + + + +# .github + +## Purpose +GitHub-specific configuration for the repository. Currently holds the continuous-integration workflow. + +## Subdirectories +| Directory | Purpose | +|-|-| +| `workflows/` | GitHub Actions workflow definitions (see `workflows/AGENTS.md`) | + +## For AI Agents + +### Working In This Directory +- Changes here affect CI behavior on push/PR. Validate YAML before committing. + + diff --git a/.github/workflows/AGENTS.md b/.github/workflows/AGENTS.md new file mode 100644 index 0000000..2cf3710 --- /dev/null +++ b/.github/workflows/AGENTS.md @@ -0,0 +1,29 @@ + + + +# workflows + +## Purpose +GitHub Actions CI workflow definitions that run the test suite on every push and pull request that touches package/test/build files. + +## Key Files +| File | Description | +|-|-| +| `ci.yaml` | Workflow `wrangler-dev`. Triggers on push/PR affecting `datawrangler/**`, `tests/**`, `requirements*.txt`, `setup.*`, `tox.ini`, `Makefile`, `MANIFEST.in`, or the workflows themselves. Matrix-tests Python 3.9-3.12 on `ubuntu-latest`: installs `requirements.txt` + `requirements_hf.txt`, `pip install -e .`, then runs `pytest`. Includes a guard to avoid duplicate runs on fork PRs. | + +## For AI Agents + +### Working In This Directory +- CI installs the **`[hf]`** dependencies too, so text/NLP tests run in CI and can download models — keep them deterministic enough to pass on a clean runner. +- If you add a Python version, a new top-level config file, or a new dependency file, update both the `matrix` and the `paths` triggers here. +- Local pre-push parity: run `make test`, `make lint`, and `make docs` before pushing (repo `CLAUDE.md`). + +### Testing Requirements +- The workflow's job is to run `pytest`. It does not currently run flake8 or the docs build — do those locally. + +## Dependencies + +### External +- GitHub Actions: `actions/checkout@v4`, `actions/setup-python@v4` + + diff --git a/.gitignore b/.gitignore index 8b4cb5f..d9e0500 100644 --- a/.gitignore +++ b/.gitignore @@ -135,4 +135,6 @@ dmypy.json */.idea/* *.idea/* -.vscode/* \ No newline at end of file +.vscode/* +# oh-my-claudecode tooling state +.omc/ diff --git a/AGENTS.md b/AGENTS.md new file mode 100644 index 0000000..86ed20d --- /dev/null +++ b/AGENTS.md @@ -0,0 +1,60 @@ + + +# data-wrangler + +## Purpose +`data-wrangler` (published on PyPI as `pydata-wrangler`, imported as `datawrangler` / `dw`) is a Python package that turns messy data into clean `DataFrame` objects (or lists of them). It auto-detects data types (arrays, text, DataFrames, files, URLs, null/empty) and converts them into a consistent DataFrame format, with a special emphasis on text/NLP embedding via scikit-learn and sentence-transformers. As of v0.4.0 it supports **dual backends**: pandas (default) and Polars (2-100x faster on large data) selectable with `backend='polars'`. + +## Key Files +| File | Description | +|-|-| +| `setup.py` | Package metadata; name `pydata-wrangler`, version `0.4.0`, extras `[hf]` (HuggingFace) and `[dev]` | +| `requirements.txt` | Core deps: pandas, polars>=0.20, numpy, scipy, scikit-learn, matplotlib, requests, six, dill, Pillow, tqdm | +| `requirements_hf.txt` | Optional NLP deps: torch, transformers, sentence-transformers, datasets, tokenizers, sentencepiece | +| `requirements_dev.txt` | Dev/test deps | +| `Makefile` | Dev tasks: `make test`, `make lint`, `make coverage`, `make docs`, `make dist`, `make install` | +| `tox.ini` | Multi-version test matrix (Python 3.9-3.12) | +| `setup.cfg` | flake8 / tooling config | +| `dev.yaml` | Conda environment for full ML setup (`conda env create -f dev.yaml`) | +| `HISTORY.rst` | Changelog | +| `README.rst` | Overview and quick-start examples | +| `CLAUDE.md` | Repo-specific guidance for AI agents | +| `.readthedocs.yaml` | ReadTheDocs build config | + +## Subdirectories +| Directory | Purpose | +|-|-| +| `datawrangler/` | The Python package source (see `datawrangler/AGENTS.md`) | +| `tests/` | pytest suite + sample resources (see `tests/AGENTS.md`) | +| `docs/` | Sphinx documentation and Jupyter tutorials (see `docs/AGENTS.md`) | +| `benchmarks/` | Standalone pandas-vs-Polars and import-time benchmarks (see `benchmarks/AGENTS.md`) | +| `.github/` | GitHub Actions CI configuration (see `.github/AGENTS.md`) | +| `notes/` | Session/handoff notes (working documents, not part of the package) | +| `build/`, `dist/`, `pydata_wrangler.egg-info/` | Build artifacts — do not edit by hand | + +## For AI Agents + +### Working In This Directory +- The public API surface is intentionally tiny: `dw.wrangle`, `dw.funnel`, `dw.stack`, `dw.unstack`, `dw.__version__`. Preserve these entry points. +- Version lives in `datawrangler/core/configurator.py` (`__version__`) **and** `setup.py`. Keep them in sync on release. +- Model/vectorizer/imputer defaults live in `datawrangler/core/config.ini`, not in code. Change behavior there when possible. +- Per repo `CLAUDE.md`: update docs when changing tests/examples, update `requirements*.txt` when changing deps, and re-run the full check suite (tests + lint + docs) after any fix. + +### Testing Requirements +- Run `make test` (pytest). Tests use **real** models, files, and network calls — never mocks. Many tests are parameterized over both `pandas` and `polars` backends via the `backend` fixture. +- Run `make lint` (flake8) and `make docs` (Sphinx build) before pushing. If any check triggers a change, re-run all checks. + +### Common Patterns +- **Plugin/priority dispatch**: `zoo/format.py` iterates `format_checkers = ['dataframe', 'text', 'array', 'null']` and calls the first matching `is_` / `wrangle_` pair. +- **Config-driven defaults**: `core/config.ini` + `apply_defaults` inject defaults by function/class name. +- **Lazy imports**: heavy deps (torch, transformers, sklearn submodules, polars) load on first use via `util/lazy_imports.py` to keep import time low. + +## Dependencies + +### External +- pandas, numpy, scipy, scikit-learn, matplotlib (core) +- polars>=0.20.0 (required; high-performance backend) +- requests, dill, Pillow, six, tqdm (I/O and utilities) +- torch, transformers, sentence-transformers, datasets (optional, via `[hf]` extra) + + diff --git a/CLAUDE.md b/CLAUDE.md index 31edebd..8e511fa 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -3,55 +3,52 @@ This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository. ## Project Overview -**data-wrangler** is a Python package that transforms messy data into clean pandas DataFrames, with emphasis on text data and NLP. Published as `pydata-wrangler` on PyPI. +**data-wrangler** turns messy data (arrays, text, DataFrames, files, URLs, null/empty, and nested lists of these) into clean `DataFrame` objects, with a special emphasis on text/NLP embedding. Published on PyPI as `pydata-wrangler`, imported as `datawrangler` / `dw`. As of v0.4.0 every operation supports **two backends**: pandas (default) and Polars (`backend='polars'`, 2-100x faster on large data). -## Development Commands +Per-directory `AGENTS.md` files exist throughout the tree with deeper, localized notes — consult the one nearest the code you're editing. -### Core Development Tasks -- `make test` - Run pytest test suite -- `make lint` - Run flake8 code style checks -- `make coverage` - Generate test coverage reports -- `make docs` - Build Sphinx documentation -- `pytest tests/wrangler/test_specific.py::test_function` - Run specific test +## Development Commands +- `make test` — run the pytest suite (default Python) +- `pytest tests/wrangler/test_zoo.py::test_name` — run a single test +- `make test-all` — tox across Python 3.9-3.12 +- `make lint` — flake8 +- `make coverage` — coverage report +- `make docs` — build Sphinx docs (also runs the tutorial notebooks) +- `make dist` / `make install` / `make clean` — build / install / clean artifacts -### Build and Release -- `make clean` - Clean all build artifacts -- `make dist` - Build source and wheel packages -- `make install` - Install package locally +Full dev install (text/NLP tests need the `[hf]` extra): `pip install -e ".[hf]"`, or `conda env create -f dev.yaml`. -### Testing -- `make test-all` - Run tox across Python 3.9-3.12 -- Tests located in `/tests/wrangler/` with sample data in `/tests/resources/` +**Tests use real resources, not mocks**: they download sklearn corpora and sentence-transformers models and fetch remote fixtures over HTTP, so a full run needs network access. Most DataFrame-producing tests are parameterized over both backends via the `backend` fixture in `tests/wrangler/conftest.py` (use its `assert_backend_type` / `assert_dataframes_equivalent` helpers). ## Architecture -### Core Package Structure -- `datawrangler/core/` - Configuration management via config.ini -- `datawrangler/decorate/` - Function decorators (especially `@funnel`) -- `datawrangler/io/` - File/URL loading with format auto-detection -- `datawrangler/util/` - Helper utilities -- `datawrangler/zoo/` - Data type handlers (array, dataframe, text, null) +The package is essentially **one priority-ordered dispatch loop** wrapped in decorators and fed by an I/O layer. -### Key Patterns -1. **Plugin Architecture**: `zoo/format.py` orchestrates priority-based data type detection using `is_` and `wrangle_` functions -2. **Decorator Pattern**: `@funnel` automatically converts inputs to DataFrames for function compatibility -3. **Configuration-Driven**: Uses `core/config.ini` for ML model defaults and processing options -4. **Extensible I/O**: Supports files, URLs, multiple formats with automatic detection +- **Dispatch (`zoo/format.py`)**: `wrangle(x, backend=None, **kwargs)` reads the ordered list `format_checkers = ['dataframe','text','array','null']` from `config.ini`, then calls the first matching `is_(x)` and runs `wrangle_(x, ...)`. **Order is priority** — earlier checkers win. Per-type options are passed as `_kwargs` (e.g. `text_kwargs={...}`). For list inputs, a fitted model from the first element is reused across the rest. -### Main Entry Points -- `datawrangler.wrangle()` - Primary data transformation API -- `datawrangler.decorate.funnel` - Function decorator -- `datawrangler.io.load()` and `datawrangler.io.save()` - I/O operations +- **The wrangler contract** (shared by every `wrangle_` in `zoo/`, and relied on by `decorate/`): each accepts `return_model=False` and `backend=None`. When `return_model=True` it returns `(df, model)` where `model` is a reusable `{'model', 'args', 'kwargs'}` dict — pass it back later (e.g. `text_kwargs={'model': fitted}`) to apply the same fitted transform to new data. -## Dependencies -- **Core**: pandas, numpy, scipy, scikit-learn, matplotlib -- **Optional ML**: PyTorch, HuggingFace transformers, sentence-transformers (in `requirements_hf.txt`) -- **Dev**: pytest, Sphinx, flake8 (in `requirements_dev.txt`) +- **Dual backend**: the `backend` argument threads from `wrangle` into every wrangler. pandas↔Polars conversion and Polars detection/handling live in `zoo/polars_dataframe.py` (`pandas_to_polars`, `polars_to_pandas`, `is_polars_dataframe`, `create_polars_dataframe`). A process-global default lives in `core/configurator.py` (`set_dataframe_backend` / `get_dataframe_backend` / `reset_dataframe_backend`). Predicate checks in `util/helpers.py` (`array_like`, `dataframe_like`) are **duck-typed by attribute**, not `isinstance`, so pandas- and Polars-like objects both pass. + +- **Config-as-code (`core/config.ini` + `core/configurator.py`)**: model/vectorizer/imputer defaults, the format-checker order, and the data-cache path all live in `config.ini`. **Its values are Python expressions that get `eval()`-ed** (e.g. `np.nan`, list literals, `os.getenv('HOME')`). `apply_defaults` injects a section's defaults into a function/class **by its `__name__`**; keys prefixed with `__` become positional args, others become keyword args. + +- **Lazy imports (`util/lazy_imports.py`)**: heavy deps (torch, transformers, sentence-transformers, sklearn submodules, polars) load on first use via cached `get_*` importers, keeping `import datawrangler` fast (see `benchmarks/import_time.py`). Add new heavy dependencies as `get_*` lazy importers here — never as top-level imports. + +- **I/O (`io/`)**: `load`/`save` auto-detect format by extension; remote URLs are content-hashed (`blake2b`) and cached under `~/.datawrangler/data/` (created on import). `panda_handler.load_dataframe` maps extensions to `pandas.read_*`. + +- **Decorators (`decorate/decorate.py`)**: `@funnel` runs `zoo.wrangle` on a function's input so the function can assume clean DataFrame input; `interpolate` fills missing values using imputer/interpolation defaults from `config.ini`; `pandas_stack`/`pandas_unstack` (exported as `dw.stack`/`dw.unstack`) concat/split lists of DataFrames via a MultiIndex. ## Adding New Data Types -Implement two functions in the appropriate `zoo/` module: -- `is_(obj)` - Type detection function -- `wrangle_(obj, **kwargs)` - Conversion to DataFrame +1. Implement `is_(obj)` and `wrangle_(obj, return_model=False, backend=None, **kwargs)` in a `zoo/` module (honor the wrangler contract above). +2. Export both in `zoo/__init__.py`. +3. Register `` in `supported_formats.types` in `core/config.ini` at the correct **priority position**. -## Development Environment -Use `conda env create -f dev.yaml` for full ML environment setup. \ No newline at end of file +## Gotchas +- `__version__` lives in **both** `core/configurator.py` and `setup.py` — keep them in sync on release. +- HuggingFace corpora in `zoo/text.py`/`get_corpus` must use full `namespace/name` ids (e.g. `wikimedia/wikipedia`, `cam-cst/cbt`); bare legacy names (`wikipedia`, `cbt`) break on `datasets` >= 4. +- `array_like('some string')` will try to `load()` it as a file/URL (network/FS side-effect) unless `force_literal=True`. + +## Dependencies +- **Core**: pandas, numpy, scipy, scikit-learn, matplotlib, polars>=0.20 (required), requests, dill, Pillow, six, tqdm +- **Optional NLP (`[hf]` extra / `requirements_hf.txt`)**: torch, transformers, sentence-transformers, datasets, tokenizers +- **Dev (`requirements_dev.txt`)**: pytest, Sphinx, flake8 diff --git a/HISTORY.rst b/HISTORY.rst index d952d53..4e1f273 100644 --- a/HISTORY.rst +++ b/HISTORY.rst @@ -2,6 +2,38 @@ History ======= +0.5.0 (2026-07-03) +------------------ + +**Bug-fix release: robust remote caching + correctness fixes** + +**Fixed: remote file caching (the headline fix):** + +* ``get_extension`` now strips URL query strings (``?dl=1``) and fragments (``#...``) before + detecting the file type. Previously, downloading a URL like ``https://.../data.npz?dl=1`` + (Dropbox / Google Drive share links, including the built-in text corpora) cached the file under a + polluted name (``.npz?dl=1``). That cached copy could not be re-read by extension + (``ValueError: Unknown datatype: npz?dl=1``), so the dataset was effectively re-downloaded / + re-cached instead of reused. Remote files now cache under a clean, stable name and re-loads reuse + the cached copy with no additional download. + +**Other correctness fixes:** + +* ``core.configurator.apply_defaults`` no longer raises ``KeyError`` for functions/classes that have + no section in ``config.ini`` (this had broken sklearn models such as ``TSNE``, ``MDS``, ``Isomap``). +* ``decorate.apply_stacked`` no longer crashes with ``TypeError`` when the wrapped function returns a + ``(data, model)`` tuple (``return_model=True``) on unstacked input. +* ``zoo.is_multiindex_dataframe`` no longer raises ``AttributeError`` on Polars DataFrames/LazyFrames + (which have no ``.index``). +* ``io.load`` now correctly unwraps a single-array ``.npz`` file to the underlying array. +* Fixed missing f-string prefixes in two ``zoo.text`` error messages. + +**Tests & docs:** + +* Added regression tests for the caching fix and deeper tests for the ``return_model`` contract, the + Polars helpers, backend configuration, and ``io.save`` round-trips. +* Corrected stale version strings and API-reference stubs (backend functions, the Polars module). + 0.4.0 (2025-06-14) ------------------ @@ -100,7 +132,7 @@ This release brings full compatibility with NumPy 2.0+ and pandas 2.0+ while mod * Enhanced error handling for missing dependencies **Bug Fixes:** -* Fixed numpy.str_ deprecation that broke in NumPy 2.0+ +* Fixed ``numpy.str_`` deprecation that broke in NumPy 2.0+ * Updated HuggingFace datasets import for API changes * Fixed sklearn IterativeImputer experimental import compatibility * Replaced deprecated matplotlib.pyplot.imread diff --git a/README.rst b/README.rst index 4a7f9bc..7854a38 100644 --- a/README.rst +++ b/README.rst @@ -15,9 +15,13 @@ list of ``DataFrame`` objects. The package provides code for easily wrangling d ``DataFrame`` objects, manipulating ``DataFrame`` objects in useful ways (that can be tricky to implement, but that apply to many analysis scenarios), and decorating Python functions to make them more flexible and/or easier to write. -🚀 **New**: ``data-wrangler`` now supports **high-performance Polars DataFrames** alongside pandas, delivering 2-100x speedups +🚀 **New**: ``data-wrangler`` now supports **high-performance Polars DataFrames** alongside pandas, delivering 2-100x speedups for large datasets with zero code changes. Simply add ``backend='polars'`` to any operation! +.. image:: https://raw.githubusercontent.com/ContextLab/data-wrangler/main/docs/images/demo.gif + :alt: data-wrangler live demo + :align: center + The ``data-wrangler`` package supports a variety of datatypes. There is a special emphasis on text data, whereby ``data-wrangler`` provides a simple API for interacting with natural language processing tools and datasets provided by ``scikit-learn`` and ``hugging-face`` (via sentence-transformers). The package is designed to provide sensible defaults, but also @@ -103,6 +107,7 @@ Currently supported datatypes are limited to: - ``array``-like objects (including images) - ``DataFrame``-like or ``Series``-like objects (pandas and Polars) - text data (text is embedded using natural language processing models) + or lists of mixtures of the above. **Backend Support**: All operations support both ``pandas`` (default) and ``Polars`` (high-performance) backends. Choose the backend that best fits your performance requirements and workflow preferences. diff --git a/benchmarks/AGENTS.md b/benchmarks/AGENTS.md new file mode 100644 index 0000000..b793496 --- /dev/null +++ b/benchmarks/AGENTS.md @@ -0,0 +1,35 @@ + + + +# benchmarks + +## Purpose +Standalone performance scripts that quantify the two headline claims of v0.4.0: the pandas-vs-Polars speedup and the reduced import time from lazy loading. These are runnable scripts, not part of the installed package or the pytest suite. + +## Key Files +| File | Description | +|-|-| +| `dataframe_performance.py` | Times `dw.wrangle` (and DataFrame ops) across the pandas and Polars backends over varying data sizes to demonstrate the 2-100x speedup | +| `import_time.py` | Measures `import datawrangler` startup time (via subprocess + `statistics`) to validate the lazy-import optimization | + +## For AI Agents + +### Working In This Directory +- Run directly, e.g. `python benchmarks/dataframe_performance.py`. Each script inserts the repo root on `sys.path`, so it runs against the working-tree source without installation. +- These scripts print human-readable timing tables; they are not asserted in CI. If you change import structure or backend dispatch, re-run them to confirm the performance claims still hold. + +### Testing Requirements +- No automated assertions. Correctness here means the scripts run cleanly and report sensible numbers on the current machine. + +### Common Patterns +- Timing via `time` / `statistics`; import-time measured in a fresh subprocess to avoid caching effects. + +## Dependencies + +### Internal +- `datawrangler` (imported for benchmarking) + +### External +- pandas, polars, numpy + + diff --git a/datawrangler/AGENTS.md b/datawrangler/AGENTS.md new file mode 100644 index 0000000..96250ed --- /dev/null +++ b/datawrangler/AGENTS.md @@ -0,0 +1,46 @@ + + + +# datawrangler + +## Purpose +The importable Python package (`import datawrangler as dw`). This top-level module re-exports the public API and organizes the implementation into four subpackages: `core` (config + backend state), `zoo` (data-type detection/conversion), `decorate` (function decorators), `io` (file/URL loading), and `util` (helpers + lazy imports). + +## Key Files +| File | Description | +|-|-| +| `__init__.py` | Public API. Re-exports `wrangle` (from `zoo`), `funnel`/`stack`/`unstack` (from `decorate.decorate`), and `__version__` (from `core`). Contains the package-level docstring documenting pandas vs Polars trade-offs. | + +## Subdirectories +| Directory | Purpose | +|-|-| +| `core/` | Config parsing (`config.ini`), default injection, and global backend state (see `core/AGENTS.md`) | +| `zoo/` | Data-type handlers — `is_` / `wrangle_` pairs and the `wrangle()` orchestrator (see `zoo/AGENTS.md`) | +| `decorate/` | The `@funnel` decorator family and stacking helpers (see `decorate/AGENTS.md`) | +| `io/` | `load` / `save` with local caching + remote fetch, and format-specific readers (see `io/AGENTS.md`) | +| `util/` | Predicate helpers (`array_like`, `dataframe_like`, `depth`) and lazy-import infrastructure (see `util/AGENTS.md`) | + +## For AI Agents + +### Working In This Directory +- `__init__.py` defines the entire public API. Adding a new public symbol means exporting it here and documenting it in `docs/`. +- Note the aliases: `dw.stack` == `decorate.decorate.pandas_stack`, `dw.unstack` == `pandas_unstack`. +- Import order matters: `core` is imported by nearly everything; avoid introducing circular imports (see `util/helpers.py` and `zoo/array.py` for existing lazy-import workarounds against cycles). + +### Testing Requirements +- Every subpackage has matching tests in `tests/wrangler/test_.py`. Changing a subpackage requires updating/running its test file. + +### Common Patterns +- Subpackage `__init__.py` files curate a flat public namespace (e.g. `zoo/__init__.py` surfaces `is_*`/`wrangle_*` functions from the type modules). + +## Dependencies + +### Internal +- `core` ← imported by `zoo`, `decorate`, `io` +- `util` ← imported broadly for predicates and lazy imports +- `zoo.format` ← the central dispatcher wiring the type handlers together + +### External +- pandas, numpy, polars (backends); scikit-learn, sentence-transformers (text embedding, optional) + + diff --git a/datawrangler/__init__.py b/datawrangler/__init__.py index daad630..6811837 100644 --- a/datawrangler/__init__.py +++ b/datawrangler/__init__.py @@ -2,8 +2,8 @@ Data Wrangler: Transform messy data into clean DataFrames (pandas or Polars) Data Wrangler is a Python package that automatically transforms various data types -(arrays, text, files, URLs, etc.) into clean, consistent DataFrame format using -either pandas or Polars backends. It specializes in text data processing using +(arrays, text, files, URLs, etc.) into clean, consistent DataFrame format using +either pandas or Polars backends. It specializes in text data processing using modern NLP models and offers 2-100x performance improvements with Polars. Key Features: @@ -18,25 +18,29 @@ >>> import datawrangler as dw >>> df = dw.wrangle(your_data) # pandas DataFrame (default) >>> df_fast = dw.wrangle(your_data, backend='polars') # Polars DataFrame - + # With text data using sentence-transformers - >>> text_df = dw.wrangle(["Hello world", "Another text"], + >>> text_df = dw.wrangle(["Hello world", "Another text"], ... text_kwargs={'model': 'all-MiniLM-L6-v2'}, ... backend='polars') # 2-100x faster with Polars - + # Using the @funnel decorator (backend-agnostic) >>> @dw.funnel ... def your_function(df): ... return df.mean() Backend Differences: -- pandas: + +- pandas: + * Full feature compatibility with named indexes * Index names preserved during processing * Slower performance on large datasets * Extensive ecosystem support + - Polars: - * High performance (2-100x faster on large datasets) + + * High performance (2-100x faster on large datasets) * Position-based indexing only (no named indexes) * Index names not preserved during backend conversion * Limited interpolation support in decorators @@ -51,7 +55,7 @@ pip install "pydata-wrangler[hf]" -Version: 0.3.0+ (NumPy 2.0+ and pandas 2.0+ compatible) +Version: 0.5.0+ (dual pandas/Polars backend; NumPy 2.0+ and pandas 2.0+ compatible) """ __author__ = """Contextual Dynamics Lab""" @@ -60,3 +64,7 @@ from .zoo import wrangle from .decorate.decorate import funnel, pandas_stack as stack, pandas_unstack as unstack from .core import __version__ + +__all__ = [ + 'wrangle', 'funnel', 'stack', 'unstack', '__version__' +] diff --git a/datawrangler/core/AGENTS.md b/datawrangler/core/AGENTS.md new file mode 100644 index 0000000..80ff63b --- /dev/null +++ b/datawrangler/core/AGENTS.md @@ -0,0 +1,38 @@ + + + +# core + +## Purpose +Configuration management and global backend state for the package. Parses `config.ini` into per-function default option dictionaries, injects those defaults into functions/classes, and holds the process-global DataFrame backend preference (pandas vs Polars). Also the source of truth for `__version__`. + +## Key Files +| File | Description | +|-|-| +| `configurator.py` | Config + defaults engine. Defines `__version__` (`'0.4.0'`), `get_default_options()` (parse `config.ini`), `update_dict()` (merge template + overrides, optionally `eval`-ing config strings), `apply_defaults()` (decorator/wrapper injecting `config.ini` defaults by function name), and the backend accessors `set_dataframe_backend` / `get_dataframe_backend` / `reset_dataframe_backend`. On import it also creates the `~/.datawrangler/data/` cache dir. | +| `config.ini` | Declarative defaults: the format-checker priority list (`['dataframe','text','array','null']`), default backend, default text pipeline (`CountVectorizer` → `LatentDirichletAllocation`, corpus `minipedia`), sklearn vectorizer/decomposition params, sentence-transformers model list, imputer/interpolation defaults, and the data-cache path. | +| `__init__.py` | Re-exports `configurator` symbols (`__version__`, `get_default_options`, `update_dict`, etc.) for the rest of the package. | + +## For AI Agents + +### Working In This Directory +- **`config.ini` values are Python expressions.** Loaders `eval()` them (e.g. `np.nan`, `os.getenv('HOME')`, list literals). Keep expressions valid and side-effect-free. +- Section names map to function/class names; `apply_defaults` looks up defaults by `__name__`. Keys prefixed with `__` (e.g. `__model`) become **positional** args; other keys become keyword args. +- Bump `__version__` here in lockstep with `setup.py` on release. +- `set_dataframe_backend` only accepts `'pandas'` or `'polars'` (raises `ValueError` otherwise). + +### Testing Requirements +- Covered by `tests/wrangler/test_core.py`. When adding a config section or changing defaults, add/adjust tests there. + +### Common Patterns +- Config-as-code: behavior tuning lives in `config.ini`, read once into a module-level `defaults` dict, merged per-call via `update_dict`. + +## Dependencies + +### Internal +- Imported by nearly every other subpackage (`zoo`, `decorate`, `io`) for defaults and backend state. + +### External +- `configparser` (stdlib), numpy (used inside `eval`-ed config expressions), sentence-transformers (lazily, optional) + + diff --git a/datawrangler/core/__init__.py b/datawrangler/core/__init__.py index 539ec0b..921acb5 100644 --- a/datawrangler/core/__init__.py +++ b/datawrangler/core/__init__.py @@ -1 +1,7 @@ -from .configurator import get_default_options, apply_defaults, update_dict, __version__ +from .configurator import (get_default_options, apply_defaults, update_dict, __version__, + set_dataframe_backend, get_dataframe_backend, reset_dataframe_backend) + +__all__ = [ + 'get_default_options', 'apply_defaults', 'update_dict', '__version__', 'set_dataframe_backend', + 'get_dataframe_backend', 'reset_dataframe_backend' +] diff --git a/datawrangler/core/configurator.py b/datawrangler/core/configurator.py index 67ce9d4..1f10083 100644 --- a/datawrangler/core/configurator.py +++ b/datawrangler/core/configurator.py @@ -3,9 +3,12 @@ import os import warnings import functools # used when applying default options -import numpy as np +from importlib.metadata import version as _pkg_version, PackageNotFoundError +import numpy as np # noqa: F401 (referenced via eval() of config.ini expressions such as 'np.nan') # Use lazy import to avoid loading heavy dependencies at module level + + def _get_SentenceTransformer(): try: from sentence_transformers import SentenceTransformer @@ -14,7 +17,13 @@ def _get_SentenceTransformer(): return None -__version__ = '0.4.0' +# Single source of truth for the version is the package metadata (defined by setup.py). We read it at +# runtime so the two can never drift (issue #29). The literal fallback is only used when running from an +# un-installed source checkout, where no distribution metadata exists; bumpversion keeps it in sync. +try: + __version__ = _pkg_version('pydata-wrangler') +except PackageNotFoundError: # pragma: no cover - source checkout without installed metadata + __version__ = '0.5.0' def get_default_options(fname=None): @@ -27,8 +36,8 @@ def get_default_options(fname=None): Returns ------- - :return: A dictionary whose keys are function names and whose values are dictionaries of default arguments and keyword - arguments + :return: A dictionary whose keys are function names and whose values are dictionaries of default arguments and + keyword arguments """ if fname is None: fname = os.path.join(os.path.dirname(__file__), 'config.ini') @@ -59,7 +68,7 @@ def update_dict(template, updates, from_config=False): Returns ------- :return: A new dictionary containing the union of the keys/values in template and updates, with preference given to - the updates dictionary + the updates dictionary """ template = copy(template) if from_config: @@ -110,10 +119,11 @@ def get_name(func): name = get_name(f) if name in defaults.keys(): default_kwargs = {k: eval(v) for k, v in dict(defaults[name]).items() if k[:2] != '__'} + default_args = [eval(v) for k, v in dict(defaults[name]).items() if k[:2] == '__'] else: + # no config.ini section for this function/class: fall back to no injected defaults default_kwargs = {} - - default_args = [eval(v) for k, v in dict(defaults[name]).items() if k[:2] == '__'] + default_args = [] @functools.wraps(f) def wrapped_function(*args, **kwargs): @@ -121,7 +131,7 @@ def wrapped_function(*args, **kwargs): return f(*args, **update_dict(default_kwargs, kwargs)) else: return f(*default_args, **update_dict(default_kwargs, kwargs)) - + if callable(f): return wrapped_function else: @@ -148,29 +158,29 @@ def __repr__(self): def set_dataframe_backend(backend): """ Set the global DataFrame backend preference. - + Parameters ---------- backend : str The backend to use ('pandas' or 'polars') - + Raises ------ ValueError If backend is not 'pandas' or 'polars' """ global _dataframe_backend - + if backend not in ['pandas', 'polars']: raise ValueError(f"Invalid backend: {backend}. Must be 'pandas' or 'polars'") - + _dataframe_backend = backend def get_dataframe_backend(): """ Get the current global DataFrame backend preference. - + Returns ------- str diff --git a/datawrangler/decorate/AGENTS.md b/datawrangler/decorate/AGENTS.md new file mode 100644 index 0000000..dcc7142 --- /dev/null +++ b/datawrangler/decorate/AGENTS.md @@ -0,0 +1,37 @@ + + + +# decorate + +## Purpose +Function decorators that make ordinary functions "DataFrame-aware." The headline decorator `@funnel` auto-wrangles a function's first argument into a DataFrame before the function runs, so functions can be written to assume clean DataFrame input. Also provides missing-value interpolation, list generalization, stack/unstack helpers, and sklearn-model application utilities. + +## Key Files +| File | Description | +|-|-| +| `decorate.py` | All decorators and helpers. Public (via `__init__.py`): `list_generalizer`, `funnel`, `interpolate`, `apply_stacked`, `apply_unstacked`. Also `pandas_stack` / `pandas_unstack` (re-exported at top level as `dw.stack` / `dw.unstack`). Internal helpers: `import_sklearn_models`, `get_sklearn_model`, `apply_sklearn_model`, and lazy model-list builders (`_get_reduce_models`, `_get_text_vectorizers`, `_get_impute_models`). | +| `__init__.py` | Re-exports `list_generalizer`, `funnel`, `interpolate`, `apply_stacked`, `apply_unstacked`. | + +## For AI Agents + +### Working In This Directory +- `funnel` calls `zoo.wrangle` on the incoming data, so decorator behavior depends on the zoo dispatch order and `*_kwargs` conventions — keep them consistent. +- `interpolate` fills missing values using sklearn imputers / pandas interpolation whose defaults come from `core/config.ini` (`[impute]`, `[interpolate]`, `[SimpleImputer]`, etc.). +- `pandas_stack` / `pandas_unstack` operate on lists of DataFrames using a MultiIndex to concatenate/split them; `apply_stacked` / `apply_unstacked` run a function on the stacked vs per-frame view. Polars support in these decorators is more limited than pandas (see package docstring). +- There is a known `FIXME` noting `apply_sklearn_model` partially duplicates `zoo.text.apply_text_model`; prefer consolidating over further divergence. + +### Testing Requirements +- Covered by `tests/wrangler/test_decorate.py`. Test decorated functions against arrays, text, DataFrames, and lists thereof; cover both backends where a DataFrame is produced. + +### Common Patterns +- Decorators wrap with `functools.wraps`, normalize input via `zoo.wrangle`, and support a `return_model` passthrough so fitted models (imputers, vectorizers) can be reused. + +## Dependencies + +### Internal +- `zoo` (`wrangle`, type detection), `core` (`get_default_options`, `apply_defaults`, `update_dict`), `util` (helpers) + +### External +- pandas, numpy; scikit-learn (imputers, decomposition, feature-extraction — lazily loaded) + + diff --git a/datawrangler/decorate/__init__.py b/datawrangler/decorate/__init__.py index 4877c1a..b4425a0 100644 --- a/datawrangler/decorate/__init__.py +++ b/datawrangler/decorate/__init__.py @@ -1 +1,5 @@ from .decorate import list_generalizer, funnel, interpolate, apply_stacked, apply_unstacked + +__all__ = [ + 'list_generalizer', 'funnel', 'interpolate', 'apply_stacked', 'apply_unstacked' +] diff --git a/datawrangler/decorate/decorate.py b/datawrangler/decorate/decorate.py index 8bd049a..cbf374b 100644 --- a/datawrangler/decorate/decorate.py +++ b/datawrangler/decorate/decorate.py @@ -8,7 +8,6 @@ get_sklearn_decomposition, get_sklearn_manifold, get_sklearn_feature_extraction_text, - get_sklearn_mixture, get_sklearn_impute, lazy_import_with_fallback ) @@ -17,12 +16,12 @@ _get_sklearn_impute = lazy_import_with_fallback('sklearn.impute') _get_IterativeImputer = lazy_import_with_fallback('sklearn.impute', 'IterativeImputer') -from ..zoo import wrangle -from ..zoo.text import is_sklearn_model -from ..zoo.dataframe import is_dataframe, is_multiindex_dataframe -from ..zoo.array import is_array -from ..core import get_default_options, apply_defaults, update_dict -from ..util.helpers import depth +# These package imports follow the lazy-importer setup above to avoid import cycles (hence noqa: E402). +from ..zoo import wrangle # noqa: E402 +from ..zoo.text import is_sklearn_model # noqa: E402 +from ..zoo.dataframe import is_dataframe, is_multiindex_dataframe # noqa: E402 +from ..zoo.array import is_array # noqa: E402 +from ..core import get_default_options, apply_defaults, update_dict # noqa: E402 defaults = get_default_options() @@ -47,10 +46,10 @@ def import_sklearn_models(module): # Handle experimental features like IterativeImputer if module.__name__ == 'sklearn.impute': try: - from sklearn.experimental import enable_iterative_imputer + from sklearn.experimental import enable_iterative_imputer # noqa: F401 (registers IterativeImputer) except ImportError: pass - + models = [d for d in dir(module) if hasattr(getattr(module, d), 'fit_transform')] for m in models: exec(f'from {module.__name__} import {m}', globals()) @@ -87,29 +86,29 @@ def get_sklearn_model(x): # noinspection PyBroadException try: return get_sklearn_model(eval(x)) - except: + except Exception: pass - + # Check other model categories if x in _get_reduce_models(): # noinspection PyBroadException try: return get_sklearn_model(eval(x)) - except: + except Exception: pass - + if x in _get_text_vectorizers(): # noinspection PyBroadException try: return get_sklearn_model(eval(x)) - except: + except Exception: pass - + # Try direct evaluation as fallback # noinspection PyBroadException try: return get_sklearn_model(eval(x)) - except: + except Exception: pass return None @@ -121,14 +120,17 @@ def apply_sklearn_model(model, data, *args, mode='fit_transform', return_model=F Parameters ---------- - :param model: a scikit-learn model (as defined in the *get_sklearn_model* description), or a list of models to be applied + :param model: a scikit-learn model (as defined in the *get_sklearn_model* description), or a list of models to be + applied in sequence :param data: a dataset (array or DataFrame) :param args: other arguments to pass to the model (after data) :param mode: one of 'fit', 'transform', or 'fit_transform' (default: 'fit_transform'); uses scikit-learn syntax - :param return_model: if True, both the (potentially transformed) data *and* the fitted model (or list of fitted models) + :param return_model: if True, both the (potentially transformed) data *and* the fitted model (or list of fitted + models) are returned. If False, only the (potentially transformed) data is returned. Default: False - :param kwargs: other keyword arguments to pass to *all* of the scikit-learn models (in addition to any model-specific + :param kwargs: other keyword arguments to pass to *all* of the scikit-learn models (in addition to any + model-specific keyword arguments) Returns @@ -174,6 +176,7 @@ def apply_sklearn_model(model, data, *args, mode='fit_transform', return_model=F text_vectorizers = None impute_models = None + def _get_reduce_models(): """Lazy initialization of reduce models.""" global reduce_models @@ -183,6 +186,7 @@ def _get_reduce_models(): reduce_models.extend(import_sklearn_models(get_sklearn_manifold())) return reduce_models + def _get_text_vectorizers(): """Lazy initialization of text vectorizers.""" global text_vectorizers @@ -190,6 +194,7 @@ def _get_text_vectorizers(): text_vectorizers = import_sklearn_models(get_sklearn_feature_extraction_text()) return text_vectorizers + def _get_impute_models(): """Lazy initialization of impute models.""" global impute_models @@ -197,19 +202,20 @@ def _get_impute_models(): impute_models = import_sklearn_models(get_sklearn_impute()) return impute_models + # source: https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.interpolate.html interpolation_models = ['linear', 'time', 'index', 'pad', 'nearest', 'zero', 'slinear', 'quadratic', 'cubic', 'spline', 'barycentric', 'polynomial'] def list_generalizer(f): - """ + r""" A decorator that makes a function work for either a single object or a list of objects by calling the function on each element Parameters ---------- - :param f: the function to decorate, of the form f(data, *args, **kwargs). + :param f: the function to decorate, of the form f(data, \*args, \*\*kwargs). Returns ------- @@ -217,7 +223,7 @@ def list_generalizer(f): """ @functools.wraps(f) def wrapped(data, *args, **kwargs): - if type(data) == list: + if type(data) is list: return [f(d, *args, **kwargs) for d in data] else: return f(data, *args, **kwargs) @@ -226,19 +232,20 @@ def wrapped(data, *args, **kwargs): def funnel(f): - """ - A decorator that coerces any data passed into the function into a DataFrame (pandas or Polars) or a list of DataFrames + r""" + A decorator that coerces any data passed into the function into a DataFrame (pandas or Polars) or a list of + DataFrames Parameters ---------- - :param f: a function of the form f(data, *args, **kwargs) that assumes data is either a DataFrame or a list of + :param f: a function of the form f(data, \*args, \*\*kwargs) that assumes data is either a DataFrame or a list of DataFrames Returns ------- :return: A decorated function that supports any wrangle-able data format. The decorated function accepts an optional 'backend' keyword argument ('pandas' or 'polars') to specify the DataFrame backend. - + Notes ----- The decorated function can be called with: @@ -249,11 +256,11 @@ def funnel(f): def wrapped(data, *args, **kwargs): # Extract backend parameter for consistent DataFrame backend backend = kwargs.pop('backend', None) - + wrangle_kwargs = kwargs.pop('wrangle_kwargs', {}) for fc in format_checkers: wrangle_kwargs[f'{fc}_kwargs'] = kwargs.pop(f'{fc}_kwargs', {}) - + # Pass backend to wrangle if specified if backend is not None: wrangle_kwargs['backend'] = backend @@ -264,27 +271,29 @@ def wrapped(data, *args, **kwargs): def interpolate(f): - """ + r""" A decorator that fills in missing data by imputing and/or interpolating missing values Parameters ---------- - :param f: a function of the form f(data, *args, **kwargs) that assumes the data are formatted as either a DataFrame or - a list of DataFrames, with no missing (numpy.nan) values + :param f: a function of the form f(data, \*args, \*\*kwargs) that assumes the data are formatted as either a + DataFrame or a list of DataFrames, with no missing (numpy.nan) values Returns ------- :return: A decorated function that supports any wrangle-able datatype. Pass in the following keyword arguments to - fill in missing data: + fill in missing data: + backend: str, optional ('pandas' or 'polars') - Specify the DataFrame backend. If not provided, preserves input backend. + Specify the DataFrame backend. If not provided, preserves input backend. interp_kwargs: a dictionary containing interpolation/imputation parameters: - impute_kwargs: a dictionary containing one or more scikit-learn imputation models (e.g., - {'model': 'IterativeImputer'}. The 'model' can be specified as defined in the *apply_sklearn_model* function. - Any other keywords are passed to the DataFrame's interpolate method; e.g. method='linear' will apply linear - interpolation to fill in missing values. For pandas DataFrames, supported arguments are documented at: - https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.interpolate.html - + impute_kwargs: a dictionary containing one or more scikit-learn imputation models (e.g., + {'model': 'IterativeImputer'}. The 'model' can be specified as defined in the *apply_sklearn_model* + function. + Any other keywords are passed to the DataFrame's interpolate method; e.g. method='linear' will apply linear + interpolation to fill in missing values. For pandas DataFrames, supported arguments are documented at: + https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.interpolate.html + Notes ----- Backend-specific behavior: @@ -295,18 +304,17 @@ def interpolate(f): @funnel def fill_missing(data, return_model=False, **kwargs): from ..zoo.polars_dataframe import is_polars_dataframe, pandas_to_polars - + impute_kwargs = kwargs.pop('impute_kwargs', {}) is_polars = is_polars_dataframe(data) if impute_kwargs: model = impute_kwargs.pop('model', eval(defaults['impute']['model'])) imputed_data, model = apply_sklearn_model(model, data, return_model=True, **impute_kwargs) - + # Recreate DataFrame with appropriate backend if is_polars: # For Polars, convert to pandas temporarily, then back to Polars - import polars as pl temp_df = pd.DataFrame(data=imputed_data, index=data.to_pandas().index, columns=data.columns) data = pandas_to_polars(temp_df) else: @@ -317,14 +325,13 @@ def fill_missing(data, return_model=False, **kwargs): if kwargs: kwargs = update_dict(defaults['interpolate'], kwargs, from_config=True) - + # Backend-specific interpolation if is_polars: # Polars has limited interpolation support # For now, convert to pandas, interpolate, then convert back - import warnings - warnings.warn("Polars interpolation support is limited. Converting to pandas for interpolation.", - UserWarning) + warnings.warn("Polars interpolation support is limited. Converting to pandas for interpolation.", + UserWarning) pandas_data = data.to_pandas() interpolated_data = pandas_data.interpolate(**kwargs) data = pandas_to_polars(interpolated_data) @@ -342,11 +349,11 @@ def wrapped(data, *args, **kwargs): # Extract backend parameter and pass to fill_missing (remove from kwargs for user function) backend = kwargs.pop('backend', None) interp_kwargs = kwargs.pop('interp_kwargs', {}) - + # Pass backend to fill_missing if specified if backend is not None: interp_kwargs['backend'] = backend - + return f(fill_missing(data, *args, **interp_kwargs), **kwargs) return wrapped @@ -405,8 +412,8 @@ def pandas_stack(data, names=None, keys=None, verify_integrity=False, sort=False if keys is None: keys = np.arange(len(data), dtype=int) - assert is_array(keys) or (type(keys) == list), f'keys must be None or a list or array of length len(data)' - assert len(keys) == len(data), f'keys must be None or a list or array of length len(data)' + assert is_array(keys) or (type(keys) is list), 'keys must be None or a list or array of length len(data)' + assert len(keys) == len(data), 'keys must be None or a list or array of length len(data)' if names is None: names = ['ID', *[f'ID{i}' for i in range(1, len(data[0].index.names))], None] @@ -469,7 +476,7 @@ def pandas_unstack(x): def apply_stacked(f): - """ + r""" Decorate a function to adjust how it handles data as follows: - Wrangle the data into DataFrames (the resulting DataFrames must all have the same number of columns). MultiIndex DataFrames are also supported (and can represent already-stacked datasets) @@ -480,13 +487,13 @@ def apply_stacked(f): Parameters ---------- - :param f: a function of the form f(data, *args, **kwargs) that assumes data is a single DataFrame, and that returns a - single DataFrame as output. + :param f: a function of the form f(data, \*args, \*\*kwargs) that assumes data is a single DataFrame, and that + returns a single DataFrame as output. Returns ------- :return: a decorated function that supports any wrangle-able data types, applies the original function to the full - list of datasets simultaneously, and then returns the result(s) as a new DataFrame or list of DataFrames. + list of datasets simultaneously, and then returns the result(s) as a new DataFrame or list of DataFrames. """ @funnel @@ -514,7 +521,8 @@ def helper(d, x, split): return_model = kwargs.copy().pop('return_model', False) if not stack_result: if ('return_model' in kwargs.keys()) and kwargs['return_model']: - transformed[0] = pandas_unstack(transformed[0]) + # f returned (data, model); unstack only the data half (tuples are immutable) + transformed = (pandas_unstack(transformed[0]), transformed[1]) else: transformed = pandas_unstack(transformed) @@ -524,7 +532,7 @@ def helper(d, x, split): def apply_unstacked(f): - """ + r""" Decorate a function to adjust how it handles data as follows: - Wrangle the data into a list of DataFrames. MultiIndex DataFrames are also supported (and can represent stacked datasets) @@ -534,13 +542,13 @@ def apply_unstacked(f): Parameters ---------- - :param f: a function of the form f(data, *args, **kwargs) that assumes data is a single DataFrame, and that returns - a single DataFrame as output. + :param f: a function of the form f(data, \*args, \*\*kwargs) that assumes data is a single DataFrame, and that + returns a single DataFrame as output. Returns ------- :return: A decorated function that supports any wrangle-able data types, applies the original function to the full - list of datasets separately, and then returns the result(s) as a new DataFrame or list of DataFrames. + list of datasets separately, and then returns the result(s) as a new DataFrame or list of DataFrames. """ @funnel diff --git a/datawrangler/io/AGENTS.md b/datawrangler/io/AGENTS.md new file mode 100644 index 0000000..cb5c6a2 --- /dev/null +++ b/datawrangler/io/AGENTS.md @@ -0,0 +1,38 @@ + + + +# io + +## Purpose +File and URL loading/saving with automatic format detection and transparent local caching of remote files. This is how `data-wrangler` ingests data from disk or the network before handing it to the zoo type handlers. + +## Key Files +| File | Description | +|-|-| +| `io.py` | Core I/O. `load(x, dtype=None, **kwargs)` loads local paths or remote URLs, auto-detecting format by extension (text, pandas-supported tabular formats, numpy `.npy/.npz`, images via matplotlib, pickled objects via `dill`). `save(x, obj, dtype=None, **kwargs)` writes bytes/text/pickle/numpy. Remote files are hashed (`blake2b`) and cached under `~/.datawrangler/data/` (`get_local_fname`), with `load_remote` fetching over `requests`. | +| `panda_handler.py` | `load_dataframe(x, extension=None, ...)` — dispatches to the correct `pandas.read_*` function (csv, excel, json, html, xml, hdf, feather, parquet, orc, sas, spss, sql, gbq, stata, pkl) based on file extension; passes through DataFrame objects unchanged. | +| `extension_handler.py` | `get_extension(fname)` — returns the lowercase file extension, or `'dw'` when none can be determined. | +| `__init__.py` | Re-exports `load`, `save`, `load_dataframe`. | + +## For AI Agents + +### Working In This Directory +- The cache directory is `~/.datawrangler/data/`; it is created on package import (in `core/configurator.py`). Cached filenames are content-hashed from the source URL/path. +- Known `FIXME`s in `io.py`: the Google-Drive confirm-token path is unimplemented (raises), and the load-after-save path can create a duplicated local copy. Preserve or fix intentionally; don't paper over. +- To support a new tabular format, add a branch to `load_dataframe` **and** to the extension list in `io.load`'s helper. To support a new binary/image format, extend `img_types` or the numpy branch in `io.load`. + +### Testing Requirements +- Covered by `tests/wrangler/test_io.py`, which loads real local files and remote URLs (from `tests/resources/`). Network access is required for the URL tests. + +### Common Patterns +- Extension-driven dispatch to library readers; content-hash caching of remote resources; `dill` for arbitrary object (de)serialization. + +## Dependencies + +### Internal +- `core.configurator` (`get_default_options`, cache path), used by `zoo` and `util` for loading inputs + +### External +- pandas (readers), requests (HTTP), dill (pickle), numpy, matplotlib/Pillow (images) + + diff --git a/datawrangler/io/__init__.py b/datawrangler/io/__init__.py index e3719a2..40b5b67 100644 --- a/datawrangler/io/__init__.py +++ b/datawrangler/io/__init__.py @@ -1,2 +1,6 @@ from .io import load, save from .panda_handler import load_dataframe + +__all__ = [ + 'load', 'save', 'load_dataframe' +] diff --git a/datawrangler/io/extension_handler.py b/datawrangler/io/extension_handler.py index 889f26c..09e116c 100644 --- a/datawrangler/io/extension_handler.py +++ b/datawrangler/io/extension_handler.py @@ -5,14 +5,22 @@ def get_extension(fname): """ Return the (lowercase) extension of a file, or return "dw" if the extension could not be determined. + Any URL query string (``?...``) or fragment (``#...``) is stripped before the extension is + extracted, so remote URLs such as ``https://.../data.npz?dl=1`` (Dropbox, Google Drive, etc.) + resolve to their true extension (``npz``) rather than ``npz?dl=1``. Without this, cached copies + of query-string URLs were saved under names like ``.npz?dl=1`` and could not be re-read + (``Unknown datatype: npz?dl=1``), causing repeated downloads. + Parameters ---------- - :param fname: the filename, represented as a string + :param fname: the filename or URL, represented as a string Returns ------- :return: The extension, represented as a lowercase string. """ + # Drop the URL query string / fragment before locating the extension. + fname = fname.split('?', 1)[0].split('#', 1)[0] _, f = os.path.split(fname) if '.' in f: return f[f.rfind('.') + 1:].lower() diff --git a/datawrangler/io/io.py b/datawrangler/io/io.py index 4c779e0..3d63215 100644 --- a/datawrangler/io/io.py +++ b/datawrangler/io/io.py @@ -1,10 +1,8 @@ import os import requests import dill -import re import numpy as np from hashlib import blake2b as hasher -from matplotlib import pyplot as plt from ..core.configurator import get_default_options from .panda_handler import load_dataframe @@ -48,9 +46,7 @@ def load_remote(url): token = get_confirm_token(response) if token: - raise NotImplementedError('This feature is poorly implemented. Try downloading and reading in the file locally.') - params['confirm'] = token # FIXME-- what's this supposed to be doing? - response = session.get(url, params=params, stream=True) + raise NotImplementedError('Confirm-token downloads are not supported; download the file locally instead.') if get_extension(url) in ['txt']: return response.text @@ -66,15 +62,18 @@ def load(x, dtype=None, **kwargs): ---------- :param x: a string containing a URL or file path :param dtype: Optional argument for specifying how the data should be loaded; can be one of: + - 'pickle': use the dill library to load in pickled objects and functions - 'numpy': treat the dataset as a .npy or .npz file - None (default): attempt to determine the filetype automatically based on the URL or file extension. The following filetypes are supported: - - txt files: treated as plain text - - any filetype supported by the Pandas library: - https://pandas.pydata.org/pandas-docs/stable/user_guide/io.html - - any image filetype supported by PIL; for a full list see: - https://pillow.readthedocs.io/en/stable/handbook/image-file-formats.html + + - txt files: treated as plain text + - any filetype supported by the Pandas library: + https://pandas.pydata.org/pandas-docs/stable/user_guide/io.html + - any image filetype supported by PIL; for a full list see: + https://pillow.readthedocs.io/en/stable/handbook/image-file-formats.html + :param kwargs: any additional keyword arguments are passed to whatever function is selected to load in the dataset. For example, when loading in a csv file (a Pandas-compatible format), passing the keyword argument index_col=0 will tell Pandas to interpret the first (0) column as the resulting DataFrame's index when loading the file's @@ -83,7 +82,7 @@ def load(x, dtype=None, **kwargs): Returns ------- :return: the retrieved data. Remote files will be cached (saved) locally to disk for faster loading if/when the - same address is used to load the file again at a later time. + same address is used to load the file again at a later time. """ # noinspection PyShadowingNames def helper(fname, dtype=None, **helper_kwargs): @@ -93,16 +92,10 @@ def helper(fname, dtype=None, **helper_kwargs): elif dtype == 'numpy': if 'allow_pickle' not in helper_kwargs.keys(): helper_kwargs['allow_pickle'] = True - data = np.load(fname, **helper_kwargs) - try: - if type(data) is dict: - if len(data.keys()) == 1: - return data[list(data.keys())[0]] - return data - except Exception: - if isinstance(data, np.lib.npyio.NpzFile): - data.close() - raise + # np.load returns an ndarray (.npy) or a lazy NpzFile (.npz). Callers that need a + # specific array out of a multi-array .npz index into the NpzFile and close it + # themselves (see zoo.text.get_corpus), so we return np.load's result unchanged. + return np.load(fname, **helper_kwargs) else: dtype = get_extension(fname) if dtype == 'txt': @@ -132,7 +125,11 @@ def helper(fname, dtype=None, **helper_kwargs): data = load_remote(x) else: return None - save(x, data, dtype=dtype) # FIXME: these last two lines result in a duplicated copy of each file... + # Cache the freshly downloaded copy to disk, then read it back through the normal + # extension-based dispatch. get_extension() strips URL query strings, so the cache + # filename (and this reload) resolve correctly even for URLs like ".../data.npz?dl=1"; + # a later load() of the same URL finds the cached file and skips the download entirely. + save(x, data, dtype=dtype) return load(x, dtype=dtype, **kwargs) @@ -145,12 +142,14 @@ def save(x, obj, dtype=None, **kwargs): :param x: the file's original path or URL (used to create a hash to define a new filename) :param obj: the data to store to disk :param dtype: optional argument specifying how to store the data; can be one of: + - 'pickle': use the dill library to pickle the object - 'numpy': save the objects as a compressed (.npz-formatted) numpy file - None (default): determine the filetype automatically; if x is passed in as bytes, write x directly to disk. If x is a string, treat x as text. + :param kwargs: any additional keyword arguments are passed to dill.dump (if dtype == 'pickle') or numpy.savez (if - dtype == 'numpy'). For any other datatype, additional keyword arguments are ignored. + dtype == 'numpy'). For any other datatype, additional keyword arguments are ignored. Returns ------- diff --git a/datawrangler/io/panda_handler.py b/datawrangler/io/panda_handler.py index 26f1edf..06b8fcd 100644 --- a/datawrangler/io/panda_handler.py +++ b/datawrangler/io/panda_handler.py @@ -12,12 +12,15 @@ def load_dataframe(x, extension=None, debug=False, **kwargs): Parameters ---------- :param x: a string (filename or URL) or DataFrame - :param extension: optional argument for specifying the filetype (e.g., 'csv', 'xls', etc.). If no extension is specified, + :param extension: optional argument for specifying the filetype (e.g., 'csv', 'xls', etc.). If no extension is + specified, by default the extension will be inferred automatically from the filename. The following data types are supported: https://pandas.pydata.org/pandas-docs/stable/user_guide/io.html - :param debug: internal flag used for debugging (prints a warning message if filetype cannot be inferred automatically); + :param debug: internal flag used for debugging (prints a warning message if filetype cannot be inferred + automatically); default: False. - :param kwargs: any additional keyword arguments are passed directly to the relevant Pandas function for reading in the + :param kwargs: any additional keyword arguments are passed directly to the relevant Pandas function for reading + in the inferred data type. Returns @@ -63,7 +66,7 @@ def load_dataframe(x, extension=None, debug=False, **kwargs): if debug: warnings.warn(f'cannot determine filetype: {x}') return None - elif all([d in type(x).__module__.lower() for d in ['pandas', 'frame']]): + elif isinstance(x, pd.DataFrame): # already a pandas DataFrame -> pass through (stable across pandas 2.x/3.0) return x else: return None diff --git a/datawrangler/util/AGENTS.md b/datawrangler/util/AGENTS.md new file mode 100644 index 0000000..57ee527 --- /dev/null +++ b/datawrangler/util/AGENTS.md @@ -0,0 +1,38 @@ + + + +# util + +## Purpose +Shared low-level utilities: duck-typing predicates used by the zoo detectors, and the lazy-import infrastructure that keeps `import datawrangler` fast by deferring heavy dependencies (torch, transformers, sklearn submodules, polars) until first use. + +## Key Files +| File | Description | +|-|-| +| `helpers.py` | Predicate/utility helpers: `btwn` (inclusive range test), `dataframe_like` (duck-types an object against ~50 DataFrame methods), `array_like` (array/DataFrame/list detection, optionally resolving strings as files/URLs), `depth` (max nesting depth of a list/array). | +| `lazy_imports.py` | Lazy-loading engine: `LazyModule`, `lazy_import`, `lazy_import_with_fallback` (custom ImportError message), `requires_import` (decorator asserting deps), plus pre-built importers `get_sklearn`, `get_numpy`, `get_pandas`, `get_polars`, `get_torch`, `get_transformers`, `get_sentence_transformers`, `get_datasets`, and sklearn-submodule importers. Importers cache their result after first call. | +| `__init__.py` | Re-exports the helpers and all `get_*` lazy importers. | + +## For AI Agents + +### Working In This Directory +- `array_like` / `dataframe_like` are **duck-typing** checks (attribute presence), not `isinstance` checks — this is deliberate so pandas-like and Polars-like objects both pass. Preserve that when editing. +- `array_like(x)` for a string will attempt to `load` it as a file/URL unless `force_literal=True`. Be mindful of the network/filesystem side-effect. +- Add heavy dependencies as new `get_*` lazy importers here rather than importing them at module top-level anywhere in the package — this is what keeps startup fast (see `benchmarks/import_time.py`). +- `helpers.py` uses a local lazy function (`_get_is_array`) to avoid a circular import with `zoo.array`. + +### Testing Requirements +- Covered by `tests/wrangler/test_util.py`. Test predicates against edge cases (empty, nested, scalar, string-as-path) and confirm lazy importers return the real modules. + +### Common Patterns +- Duck-typing over `isinstance`; cached lazy importers with optional install-hint fallback messages pointing to the `[hf]` extra. + +## Dependencies + +### Internal +- `io.load` (used by `array_like` to resolve string paths). Imported broadly by `zoo` and `decorate`. + +### External +- numpy, pandas (predicates); everything else is imported lazily on demand + + diff --git a/datawrangler/util/__init__.py b/datawrangler/util/__init__.py index f7d2c15..f3d708f 100644 --- a/datawrangler/util/__init__.py +++ b/datawrangler/util/__init__.py @@ -6,3 +6,10 @@ get_sklearn_decomposition, get_sklearn_manifold, get_sklearn_mixture, get_sklearn_feature_extraction_text, get_sklearn_impute ) + +__all__ = [ + 'btwn', 'dataframe_like', 'array_like', 'depth', 'lazy_import', 'lazy_import_with_fallback', 'requires_import', + 'get_sklearn', 'get_numpy', 'get_pandas', 'get_torch', 'get_transformers', 'get_sentence_transformers', + 'get_datasets', 'get_sklearn_decomposition', 'get_sklearn_manifold', 'get_sklearn_mixture', + 'get_sklearn_feature_extraction_text', 'get_sklearn_impute' +] diff --git a/datawrangler/util/helpers.py b/datawrangler/util/helpers.py index dbcfdc8..8108f7d 100644 --- a/datawrangler/util/helpers.py +++ b/datawrangler/util/helpers.py @@ -1,12 +1,10 @@ import numpy as np import pandas as pd -import six -import warnings -import os from ..io import load -from ..io.extension_handler import get_extension # Use lazy import to avoid circular dependency + + def _get_is_array(): from ..zoo.array import is_array return is_array @@ -54,8 +52,8 @@ def dataframe_like(x, debug=False): 'where', 'query', 'add', 'sub', 'mul', 'div', 'truediv', 'floordiv', 'mod', 'pow', 'dot', 'radd', 'rsub', 'rmul', 'rdiv', 'rtruediv', 'rfloordiv', 'rmod', 'rpow', 'lt', 'gt', 'le', 'ge', 'ne', 'eq', 'apply', 'groupby', 'rolling', 'expanding', 'abs', - 'filter', 'drop', 'drop_duplicates', 'backfill', 'bfill', 'ffill', 'fillna', 'interpolate', - 'pad', 'droplevel', 'pivot', 'pivot_table', 'squeeze', 'melt', 'join', 'merge'] + 'filter', 'drop', 'drop_duplicates', 'bfill', 'ffill', 'fillna', 'interpolate', + 'droplevel', 'pivot', 'pivot_table', 'squeeze', 'melt', 'join', 'merge'] for r in required_attributes: if not hasattr(x, r): if debug: diff --git a/datawrangler/util/lazy_imports.py b/datawrangler/util/lazy_imports.py index 1076f36..f2cebfd 100644 --- a/datawrangler/util/lazy_imports.py +++ b/datawrangler/util/lazy_imports.py @@ -6,28 +6,27 @@ """ import importlib -import sys from functools import wraps class LazyModule: """A placeholder for a module that hasn't been imported yet.""" - + def __init__(self, module_name): self._module_name = module_name self._module = None - + def _load(self): """Load the actual module.""" if self._module is None: self._module = importlib.import_module(self._module_name) return self._module - + def __getattr__(self, name): """Load module and get attribute when accessed.""" module = self._load() return getattr(module, name) - + def __dir__(self): """Load module and return directory.""" module = self._load() @@ -37,14 +36,14 @@ def __dir__(self): def lazy_import(module_name, attribute=None): """ Create a lazy import function. - + Parameters ---------- module_name : str The name of the module to import attribute : str, optional Specific attribute to import from the module - + Returns ------- function @@ -55,22 +54,22 @@ def _import(): if attribute: return getattr(module, attribute) return module - + # Cache the result after first import _import._cached = None - + def _cached_import(): if _import._cached is None: _import._cached = _import() return _import._cached - + return _cached_import def lazy_import_with_fallback(module_name, attribute=None, fallback_message=None): """ Create a lazy import function with error handling. - + Parameters ---------- module_name : str @@ -79,7 +78,7 @@ def lazy_import_with_fallback(module_name, attribute=None, fallback_message=None Specific attribute to import from the module fallback_message : str, optional Custom error message if import fails - + Returns ------- function @@ -96,27 +95,27 @@ def _import(): if fallback_message: raise ImportError(fallback_message) from e raise - + # Cache the result after first import _import._cached = None - + def _cached_import(): if _import._cached is None: _import._cached = _import() return _import._cached - + return _cached_import def requires_import(*modules): """ Decorator that ensures modules are available before function execution. - + Parameters ---------- *modules : str Module names that must be importable - + Returns ------- decorator @@ -165,4 +164,4 @@ def wrapper(*args, **kwargs): get_sklearn_manifold = lazy_import('sklearn.manifold') get_sklearn_mixture = lazy_import('sklearn.mixture') get_sklearn_feature_extraction_text = lazy_import('sklearn.feature_extraction.text') -get_sklearn_impute = lazy_import('sklearn.impute') \ No newline at end of file +get_sklearn_impute = lazy_import('sklearn.impute') diff --git a/datawrangler/zoo/AGENTS.md b/datawrangler/zoo/AGENTS.md new file mode 100644 index 0000000..94758bf --- /dev/null +++ b/datawrangler/zoo/AGENTS.md @@ -0,0 +1,42 @@ + + + +# zoo + +## Purpose +The heart of the package: the "zoo" of data-type handlers plus the `wrangle()` orchestrator. Each supported data type provides an `is_` detector and a `wrangle_` converter; `format.py` dispatches to them in priority order. This is where new data types are added. + +## Key Files +| File | Description | +|-|-| +| `format.py` | The dispatcher. Defines `wrangle(x, return_dtype=False, backend=None, **kwargs)`. Reads the priority list `format_checkers = ['dataframe','text','array','null']` from `config.ini`, then for each item calls the first matching `is_` and runs `wrangle_`. Handles per-type `*_kwargs`, model pre-fitting/reuse across a list of inputs, and list/nested-list inputs. | +| `dataframe.py` | `is_dataframe`, `is_multiindex_dataframe`, `wrangle_dataframe`. Detects pandas/Polars/modin DataFrames and dataframe-like objects; routes to the Polars handler or converts between backends per `backend`. | +| `array.py` | `is_array`, `is_number`, `wrangle_array`. Coerces numbers/arrays/sparse matrices/files into 2-D DataFrames (stacking >2-D arrays); builds pandas or Polars output based on `backend`. | +| `text.py` | **Active** text handler (735 lines, lazy imports). Public: `is_text`, `wrangle_text`, `get_corpus`, `apply_text_model`, `get_text_model`, `to_str_list`, `get_text`. Embeds text via sklearn vectorizers/decomposition and sentence-transformers / HuggingFace models; supports the simplified string/list `model` API. | +| `polars_dataframe.py` | Polars support: `is_polars_dataframe`, `is_polars_lazyframe`, `wrangle_polars_dataframe`, `create_polars_dataframe`, and `pandas_to_polars` / `polars_to_pandas` converters. | +| `null.py` | `is_null`, `wrangle_null`. Turns `None`/empty inputs into an empty pandas or Polars DataFrame. | +| `__init__.py` | Curates the public zoo namespace: `wrangle`, the `is_*`/`wrangle_*` pairs, and text helpers. | + +## For AI Agents + +### Working In This Directory +- **To add a data type**: implement `is_(obj)` and `wrangle_(obj, return_model=False, backend=None, **kwargs)`, export them in `__init__.py`, and add `` to `supported_formats.types` in `core/config.ini` at the right priority. **Order matters** — earlier checkers win, so put more specific types first. +- `wrangle_` functions share a contract: accept `return_model` (return `(df, model)` when True, where `model` is a `{'model', 'args', 'kwargs'}` dict reusable on new data) and `backend` (`'pandas'`/`'polars'`/`None`). +- `text.py` is the sole text handler (the former `text_lazy.py` / `text_original.py` duplicates were removed in v0.5.0). +- Circular-import guard: `array.py` imports `is_array` lazily elsewhere; keep new cross-module imports cycle-free. + +### Testing Requirements +- `tests/wrangler/test_zoo.py` holds the bulk of the suite (~21 tests), parameterized over both backends. Text tests download real sklearn corpora and sentence-transformers models. Add coverage for any new detector/converter across both backends. + +### Common Patterns +- Priority-based `is_`/`wrangle_` dispatch; model dicts (`{'model', 'args', 'kwargs'}`) for reproducible re-application; lazy imports for heavy NLP deps. + +## Dependencies + +### Internal +- `core` (defaults, `update_dict`, backend state), `io` (`load`, `load_dataframe`), `util` (`array_like`, `depth`, lazy importers) + +### External +- pandas, numpy, polars; scikit-learn, sentence-transformers, transformers, torch, datasets (text, lazily loaded / optional) + + diff --git a/datawrangler/zoo/__init__.py b/datawrangler/zoo/__init__.py index 1758fb1..a4edf04 100644 --- a/datawrangler/zoo/__init__.py +++ b/datawrangler/zoo/__init__.py @@ -4,3 +4,9 @@ from .null import is_null, wrangle_null from .text import is_text, wrangle_text, get_corpus, apply_text_model, get_text_model, to_str_list, get_text from ..util.helpers import dataframe_like, array_like + +__all__ = [ + 'wrangle', 'is_array', 'wrangle_array', 'is_dataframe', 'wrangle_dataframe', 'is_multiindex_dataframe', + 'is_null', 'wrangle_null', 'is_text', 'wrangle_text', 'get_corpus', 'apply_text_model', 'get_text_model', + 'to_str_list', 'get_text', 'dataframe_like', 'array_like' +] diff --git a/datawrangler/zoo/array.py b/datawrangler/zoo/array.py index a48a544..4312d37 100644 --- a/datawrangler/zoo/array.py +++ b/datawrangler/zoo/array.py @@ -4,7 +4,6 @@ import os from ..io import load from ..core.configurator import update_dict -from ..util.lazy_imports import get_polars from .polars_dataframe import create_polars_dataframe @@ -46,8 +45,8 @@ def is_array(x): try: if is_array(load(x)): return True - except: - if type(x) == list: + except Exception: + if type(x) is list: return all([is_array(i) for i in x]) elif is_number(x): return True @@ -67,11 +66,15 @@ def wrangle_array(data, return_model=False, backend=None, **kwargs): :param backend: str, optional The DataFrame backend to use ('pandas' or 'polars'). If None, uses the default backend (pandas) :param kwargs: a list of keyword arguments: + - 'model': a callable function or constructor, or a dictionary containing the following keys: + - 'model': a callable function or constructor - 'args': a list of arguments to pass to the function (in addition to data) - 'kwargs': a list of keyword arguments to pass to the function + default: pandas.DataFrame or polars.DataFrame (based on backend) + - all other keyword arguments are passed to the model (or constructor). These can be used to change how the DataFrame is created (e.g., passing columns=['one', 'two', 'three'] will change the column names of the resulting DataFrame). @@ -116,7 +119,7 @@ def stacker(x): default_model = pd.DataFrame else: default_model = pd.DataFrame - + model = kwargs.pop('model', default_model) if type(model) is dict: # noinspection PyArgumentList diff --git a/datawrangler/zoo/dataframe.py b/datawrangler/zoo/dataframe.py index 1e63fcd..7851828 100644 --- a/datawrangler/zoo/dataframe.py +++ b/datawrangler/zoo/dataframe.py @@ -2,8 +2,8 @@ from ..util import dataframe_like from ..io import load_dataframe -from .polars_dataframe import is_polars_dataframe, is_polars_lazyframe, wrangle_polars_dataframe, pandas_to_polars, polars_to_pandas -from ..util.lazy_imports import get_polars +from .polars_dataframe import (is_polars_dataframe, is_polars_lazyframe, wrangle_polars_dataframe, + pandas_to_polars, polars_to_pandas) def is_dataframe(x): @@ -17,16 +17,20 @@ def is_dataframe(x): Returns ------- :return: True if the object is a DataFrame (pandas or Polars) or points to a file that can be loaded as a DataFrame, - and False otherwise. + and False otherwise. """ - # Check for pandas DataFrames - if type(x).__module__ in ['pandas.core.frame', 'modin.pandas.dataframe']: + # Check for pandas DataFrames. isinstance is stable across pandas 2.x/3.0, whereas the reported + # __module__ was flattened from 'pandas.core.frame' to 'pandas' in pandas 3.0 (see issue #30). + if isinstance(x, pd.DataFrame): return True - + # modin DataFrames (optional dependency; match by module to avoid importing modin) + if type(x).__module__ == 'modin.pandas.dataframe': + return True + # Check for Polars DataFrames if is_polars_dataframe(x) or is_polars_lazyframe(x): return True - + else: if dataframe_like(x): return True @@ -35,7 +39,7 @@ def is_dataframe(x): try: data = load_dataframe(x) return data is not None - except: + except Exception: return False @@ -50,9 +54,12 @@ def is_multiindex_dataframe(x): Returns ------- :return: True if the object is a MultiIndex DataFrame (or points to a file that can be loaded as a - MultiIndex DataFrame), and False otherwise. + MultiIndex DataFrame), and False otherwise. """ - return is_dataframe(x) and ('indexes.multi' in type(x.index).__module__) + # Polars DataFrames/LazyFrames satisfy is_dataframe() but have no ``.index``; guard for it so + # this returns False (rather than raising AttributeError) on non-pandas backends. isinstance against + # pd.MultiIndex is stable across pandas 2.x/3.0 (unlike ``.__module__`` string matching -- see issue #30). + return is_dataframe(x) and hasattr(x, 'index') and isinstance(x.index, pd.MultiIndex) def wrangle_dataframe(data, return_model=False, backend=None, **kwargs): @@ -61,13 +68,14 @@ def wrangle_dataframe(data, return_model=False, backend=None, **kwargs): Parameters ---------- - :param data: a DataFrame (pandas or Polars), dataframe-like object, or a file path that points to a file that can be + :param data: a DataFrame (pandas or Polars), dataframe-like object, or a file path that points to a file that can be loaded as a DataFrame - :param return_model: if True, return a function for turning the ("messy") DataFrame into a "clean" DataFrame, along with - the cleaned DataFrame. Otherwise (if False), just return the cleaned DataFrame. Default: False + :param return_model: if True, return a function for turning the ("messy") DataFrame into a "clean" DataFrame, + along with the cleaned DataFrame. Otherwise (if False), just return the cleaned DataFrame. Default: False :param backend: str, optional The DataFrame backend to use ('pandas' or 'polars'). If None, preserves the input type - :param kwargs: passed to the DataFrame "wrangling" model (default: the constructor for pandas.DataFrame or polars.DataFrame) + :param kwargs: passed to the DataFrame "wrangling" model (default: the constructor for pandas.DataFrame or + polars.DataFrame) Returns ------- @@ -101,12 +109,12 @@ def wrangle_dataframe(data, return_model=False, backend=None, **kwargs): else: # Load as pandas DataFrame first data = load_dataframe(data, **load_kwargs) - + # Convert to Polars if requested if backend == 'polars': data = pandas_to_polars(data) return wrangle_polars_dataframe(data, return_model=return_model, **kwargs) - + # Handle pandas DataFrames model = kwargs.pop('model', None) if model is None: diff --git a/datawrangler/zoo/format.py b/datawrangler/zoo/format.py index 80f2858..10fdcbb 100644 --- a/datawrangler/zoo/format.py +++ b/datawrangler/zoo/format.py @@ -1,12 +1,12 @@ -import six -import numpy as np import pandas as pd -from .dataframe import is_dataframe, is_multiindex_dataframe, wrangle_dataframe -from .array import is_array, wrangle_array -from .text import is_text, wrangle_text -from .null import is_null, wrangle_null -from ..util import array_like, depth +# The is_/wrangle_ functions below are resolved dynamically via eval(f'is_{fc}')/eval(f'wrangle_{fc}') +# inside wrangle(), so they look unused to static analysis -- hence the noqa: F401. +from .dataframe import is_dataframe, wrangle_dataframe # noqa: F401 +from .array import is_array, wrangle_array # noqa: F401 +from .text import is_text, wrangle_text # noqa: F401 +from .null import is_null, wrangle_null # noqa: F401 +from ..util import depth from ..core import update_dict, get_default_options # the order matters: if earlier checks pass, later checks will not run. @@ -25,7 +25,7 @@ def wrangle(x, return_dtype=False, backend=None, **kwargs): ---------- :param x: data in any format. Supported datatypes: - Numpy Arrays, array-like objects, or paths to files that store array-like objects - - DataFrames (pandas or Polars), dataframe-like objects, or paths to files that store dataframe-like objects + - DataFrames (pandas or Polars), dataframe-like objects, or paths to files that store dataframe-like objects - Polars LazyFrames - Text strings, lists of strings, or paths to plain text files - Mixed lists or nested lists of the above types @@ -33,21 +33,26 @@ def wrangle(x, return_dtype=False, backend=None, **kwargs): :param backend: str, optional The DataFrame backend to use ('pandas' or 'polars'). If None, uses the default backend (pandas) :param kwargs: control how data are wrangled: + - array_kwargs: passed to wrangle_array function to control how arrays are handled - dataframe_kwargs: passed to wrangle_dataframe function to control how dataframes are handled - - text_kwargs: passed to wrangle_text function to control how text data are handled - Common text_kwargs options (simplified API): - - {'model': 'all-MiniLM-L6-v2'} for sentence-transformers - - {'model': 'CountVectorizer'} for sklearn text vectorization - - {'model': ['CountVectorizer', 'LatentDirichletAllocation']} for sklearn pipeline - Also supports full dict format for advanced configuration: - - {'model': {'model': 'all-MiniLM-L6-v2', 'args': [], 'kwargs': {}}} + - text_kwargs: passed to wrangle_text function to control how text data are handled. + Common text_kwargs options (simplified API): + + - {'model': 'all-MiniLM-L6-v2'} for sentence-transformers + - {'model': 'CountVectorizer'} for sklearn text vectorization + - {'model': ['CountVectorizer', 'LatentDirichletAllocation']} for sklearn pipeline + + Also supports full dict format for advanced configuration: + + - {'model': {'model': 'all-MiniLM-L6-v2', 'args': [], 'kwargs': {}}} + Any other keyword arguments are passed to all wrangle functions. Returns ------- :return: a DataFrame (pandas or Polars), or a list of DataFrames, containing the wrangled data - + Examples -------- >>> import datawrangler as dw @@ -97,7 +102,7 @@ def to_dataframe(y): break return wrangled, dtype - if ((not is_text(x)) and (type(x) == list)) or (is_text(x) and (type(x) == list) and (depth(x) > 1)): + if ((not is_text(x)) and (type(x) is list)) or (is_text(x) and (type(x) is list) and (depth(x) > 1)): dfs = [to_dataframe(i) for i in x] wrangled = [d[0] for d in dfs] dtypes = [d[1] for d in dfs] diff --git a/datawrangler/zoo/null.py b/datawrangler/zoo/null.py index a6226a0..3a868f7 100644 --- a/datawrangler/zoo/null.py +++ b/datawrangler/zoo/null.py @@ -21,7 +21,7 @@ def is_null(data): if np.iterable(data): return all([is_null(d) for d in data]) return (data is None) or (len(data) == 0) - except: + except Exception: return False @@ -38,9 +38,11 @@ def wrangle_null(data, return_model=False, backend=None, model=None): The DataFrame backend to use ('pandas' or 'polars'). If None, uses the default backend (pandas) :param model: a function or constructor that will generate an empty DataFrame. This can also be specified as a dictionary with the following fields: + - 'model': a function or constructor - 'args': a list of unnamed arguments to be passed to the given function or constructor - 'kwargs': a dictionary of named arguments to be passed to the given function or constructor + If None, defaults to pandas.DataFrame or polars.DataFrame based on backend. Returns @@ -64,7 +66,7 @@ def wrangle_null(data, return_model=False, backend=None, model=None): else: default_model = pd.DataFrame model = default_model - + if type(model) is not dict: model = {'model': model, 'args': [], 'kwargs': {}} diff --git a/datawrangler/zoo/polars_dataframe.py b/datawrangler/zoo/polars_dataframe.py index 128b236..24178f9 100644 --- a/datawrangler/zoo/polars_dataframe.py +++ b/datawrangler/zoo/polars_dataframe.py @@ -14,12 +14,12 @@ def is_polars_dataframe(x): """ Determine if an object is a Polars DataFrame. - + Parameters ---------- x : object The object to check - + Returns ------- bool @@ -35,12 +35,12 @@ def is_polars_dataframe(x): def is_polars_lazyframe(x): """ Determine if an object is a Polars LazyFrame. - + Parameters ---------- x : object The object to check - + Returns ------- bool @@ -56,59 +56,57 @@ def is_polars_lazyframe(x): def polars_to_pandas(df): """ Convert a Polars DataFrame to a pandas DataFrame. - + Parameters ---------- df : polars.DataFrame or polars.LazyFrame The Polars DataFrame to convert - + Returns ------- pandas.DataFrame The converted pandas DataFrame """ - pl = get_polars() - if is_polars_lazyframe(df): # Collect LazyFrame to DataFrame first df = df.collect() - + if not is_polars_dataframe(df): raise TypeError(f"Expected Polars DataFrame, got {type(df)}") - + return df.to_pandas() def pandas_to_polars(df): """ Convert a pandas DataFrame to a Polars DataFrame. - + Parameters ---------- df : pandas.DataFrame The pandas DataFrame to convert - + Returns ------- polars.DataFrame The converted Polars DataFrame """ import pandas as pd - + if not isinstance(df, pd.DataFrame): raise TypeError(f"Expected pandas DataFrame, got {type(df)}") - + pl = get_polars() return pl.from_pandas(df) def wrangle_polars_dataframe(data, return_model=False, **kwargs): - """ + r""" Wrangle a Polars DataFrame. - + This function accepts Polars DataFrames and LazyFrames and applies any specified transformations while preserving the Polars format. - + Parameters ---------- data : polars.DataFrame or polars.LazyFrame @@ -116,9 +114,9 @@ def wrangle_polars_dataframe(data, return_model=False, **kwargs): return_model : bool, optional If True, return a function for transforming DataFrames along with the wrangled DataFrame. Default: False - **kwargs : dict + \*\*kwargs : dict Additional keyword arguments passed to the wrangling model - + Returns ------- polars.DataFrame or tuple @@ -126,25 +124,25 @@ def wrangle_polars_dataframe(data, return_model=False, **kwargs): of (DataFrame, model) if return_model is True """ pl = get_polars() - + # Handle LazyFrames by collecting them if is_polars_lazyframe(data): data = data.collect() - + if not is_polars_dataframe(data): raise TypeError(f"Expected Polars DataFrame, got {type(data)}") - + # Extract model from kwargs or use default model = kwargs.pop('model', None) if model is None: model = {'model': pl.DataFrame, 'args': [], 'kwargs': kwargs} elif not isinstance(model, dict): model = {'model': model, 'args': [], 'kwargs': kwargs} - + # Apply the model (for now, just return the DataFrame) # In the future, this could apply Polars-specific transformations wrangled = data - + if return_model: return wrangled, model return wrangled @@ -153,21 +151,21 @@ def wrangle_polars_dataframe(data, return_model=False, **kwargs): def create_polars_dataframe(data, columns=None): """ Create a Polars DataFrame from various data types. - + Parameters ---------- data : array-like, dict, or scalar The data to convert to a Polars DataFrame columns : list of str, optional Column names for the DataFrame - + Returns ------- polars.DataFrame The created Polars DataFrame """ pl = get_polars() - + # Handle different input types if isinstance(data, dict): return pl.DataFrame(data) @@ -175,7 +173,7 @@ def create_polars_dataframe(data, columns=None): # NumPy array or similar import numpy as np arr = np.asarray(data) - + if arr.ndim == 1: # 1D array - create single column col_name = columns[0] if columns else "0" @@ -189,4 +187,4 @@ def create_polars_dataframe(data, columns=None): raise ValueError(f"Cannot create DataFrame from {arr.ndim}D array") else: # Try to create directly - return pl.DataFrame(data) \ No newline at end of file + return pl.DataFrame(data) diff --git a/datawrangler/zoo/text.py b/datawrangler/zoo/text.py index 36e4a0b..ecb3308 100644 --- a/datawrangler/zoo/text.py +++ b/datawrangler/zoo/text.py @@ -57,14 +57,12 @@ torch = None list_datasets = None -from .array import is_array, wrangle_array -from .dataframe import is_dataframe -from .null import is_null -from .polars_dataframe import create_polars_dataframe +from .array import is_array, wrangle_array # noqa: E402 +from .dataframe import is_dataframe # noqa: E402 +from .null import is_null # noqa: E402 -from ..core.configurator import get_default_options, apply_defaults, update_dict -from ..io import load -from ..io.io import get_extension +from ..core.configurator import get_default_options, apply_defaults, update_dict # noqa: E402 +from ..io import load # noqa: E402 defaults = get_default_options() preloaded_corpora = {} @@ -73,22 +71,22 @@ def normalize_text_model(model): """ Convert string or partial dict to full model specification. - + This function enables simplified text model API by accepting: - String model names: 'all-MiniLM-L6-v2', 'CountVectorizer', etc. - Partial dicts: {'model': 'all-MiniLM-L6-v2'} - Full dicts: {'model': 'all-MiniLM-L6-v2', 'args': [], 'kwargs': {}} - + Normalizes both scikit-learn and HuggingFace models to consistent dict format. - + Parameters ---------- :param model: Model specification as string, partial dict, or full dict - + Returns ------- :return: Normalized dict with 'model', 'args', and 'kwargs' keys - + Examples -------- >>> from datawrangler.zoo.text import normalize_text_model @@ -128,12 +126,12 @@ def is_sklearn_model(x): def is_sklearn_model_name(model_name): """ Check if a string represents a scikit-learn model name from supported modules. - + Supported sklearn modules: decomposition, feature_extraction.text, manifold """ if not isinstance(model_name, str): return False - + # Check against known sklearn modules try: # Check decomposition module @@ -142,7 +140,7 @@ def is_sklearn_model_name(model_name): return True except (ImportError, AttributeError): pass - + try: # Check feature_extraction.text module sklearn_text = _get_sklearn_text() @@ -150,7 +148,7 @@ def is_sklearn_model_name(model_name): return True except (ImportError, AttributeError): pass - + try: # Check manifold module sklearn_manifold = lazy_import_with_fallback('sklearn.manifold')() @@ -158,7 +156,7 @@ def is_sklearn_model_name(model_name): return True except (ImportError, AttributeError): pass - + return False @@ -183,14 +181,14 @@ def is_hugging_face_model(x): # If sentence-transformers not available, check by class name string if hasattr(x, '__class__') and 'SentenceTransformer' in str(x.__class__): return True - + # If it's a string, check if it's NOT a sklearn model if isinstance(x, str): if is_sklearn_model_name(x): return False # If not sklearn, assume it's a HuggingFace model (sentence-transformers or other) return True - + # Check for encode method (sentence-transformers interface) but not strings return hasattr(x, 'encode') and not isinstance(x, str) @@ -213,7 +211,7 @@ def robust_is_sklearn_model(x): # Handle normalized dict format if isinstance(x, dict) and 'model' in x: x = x['model'] - + x = get_text_model(x) return is_sklearn_model(x) @@ -223,7 +221,7 @@ def robust_is_hugging_face_model(x): Wrapper for is_hugging_face_model that also supports strings-- e.g., the string 'all-MiniLM-L6-v2' will be a valid hugging-face model when checked with this function, because it's a sentence-transformers model name. Also supports normalized dict format: {'model': 'all-MiniLM-L6-v2', 'args': [], 'kwargs': {}}. - + Parameters ---------- :param x: a to-be-tested model object, a string, or a normalized dict @@ -235,14 +233,14 @@ def robust_is_hugging_face_model(x): # Handle normalized dict format if isinstance(x, dict) and 'model' in x: x = x['model'] - + x = get_text_model(x) return is_hugging_face_model(x) def get_text_model(x): """ - Given a valid scikit-learn or sentence-transformers model, or a string matching the name of a valid model, + Given a valid scikit-learn or sentence-transformers model, or a string matching the name of a valid model, return a callable function or class constructor for the given model. Parameters @@ -255,9 +253,9 @@ def get_text_model(x): Returns ------- - :return: A valid scikit-learn or sentence-transformers model (or None if no model matching the given + :return: A valid scikit-learn or sentence-transformers model (or None if no model matching the given description can be found) - + Examples -------- >>> from datawrangler.zoo.text import get_text_model @@ -291,22 +289,22 @@ def model_lookup(model_name, parent): except AttributeError: return None except ImportError: - raise ModuleNotFoundError('sklearn is required for text processing models. Install with: pip install scikit-learn') - + raise ModuleNotFoundError('sklearn is required for text processing models. ' + 'Install with: pip install scikit-learn') # Check sklearn models first (before sentence-transformers) for p in ['text', 'decomposition', 'manifold']: m = model_lookup(x, p) if m is not None: return m - + # Check for sentence-transformers models if x == 'SentenceTransformer': try: return _get_SentenceTransformer() except ImportError: return None - + # If it's a string and not found in sklearn modules, assume it's a sentence-transformers model if isinstance(x, str): try: @@ -316,18 +314,24 @@ def model_lookup(model_name, parent): return None -def get_corpus(dataset_name='wikipedia', config_name='20200501.en'): +def get_corpus(dataset_name='wikimedia/wikipedia', config_name='20231101.en'): """ - Download (and return) a text corpus. By default, a 2020 snapshot of all English Wikipedia articles is returned. + Download (and return) a text corpus. By default, a 2023 snapshot of all English Wikipedia articles is returned. + + Hugging-Face corpora must be referenced by their full ``namespace/name`` id (e.g. ``wikimedia/wikipedia``, + ``cam-cst/cbt``); bare legacy names (e.g. ``wikipedia``, ``cbt``) are no longer accepted by ``datasets`` >= 4. [Parameters] ------------ :param dataset_name: a string containing the corpus name. Can be one of the following: + - Corpora built into data-wrangler: + - 'minipedia': a curated and cleaned up subset of Wikipedia containing articles on a wide variety of topics - 'neurips': a collection of NeurIPS articles - 'sotus': transcripts of state of the union addresses from US Presidents from 1989 -- 2018 - 'khan': transcripts of (most) Khan Academy YouTube videos + - Any hugging-face corpus; for a full list see https://huggingface.co/datasets Note that downloading hugging-face corpora also requires specifying a config_name :param config_name: configuration name or description for hugging-face corpora. This argument is ignored if dataset @@ -390,7 +394,8 @@ def get_formatter(s): raise RuntimeError(f'Configuration for {dataset_name} corpus not found: {config_name}. ' f'(Cannot list available configurations - datasets not installed)') except NameError: - raise ModuleNotFoundError('Hugging-face libraries have not been installed. To use hugging-face corpora, please run "pip install --upgrade pydata-wrangler[hf]" to fix.') + raise ModuleNotFoundError('Hugging-face libraries have not been installed. To use hugging-face corpora, ' + 'please run "pip install --upgrade pydata-wrangler[hf]" to fix.') corpus = [] content_keys = ['text', 'content'] @@ -413,38 +418,44 @@ def apply_text_model(x, text, *args, mode='fit_transform', return_model=False, * Parameters ---------- :param x: the model to apply. Supported models include: + - Scikit-learn models. The recommended pipeline is to specify a feature extraction model (for turning text into a number-of-documents by number-of-features matrix), and then to apply a matrix decomposition or embedding model (for turning the features matrix into text embeddings). When models are passed as a list, each model is applied in succession to the output of the previous model. The pipeline is first fit to the provided corpus, and then applied to the given text. Default: ['CountVectorizer', 'LatentDirichletAllocation'] + - All scikit-learn text feature extraction models are supported; for a full list see - https://scikit-learn.org/stable/modules/classes.html#module-sklearn.feature_extraction.text - These may be passed either as callable modules (e.g., sklearn.feature_extraction.text.CountVectorizer) or - as strings (e.g., 'CountVectorizer'). Default options for each model are defined in config.ini. + https://scikit-learn.org/stable/modules/classes.html#module-sklearn.feature_extraction.text + These may be passed either as callable modules (e.g., sklearn.feature_extraction.text.CountVectorizer) or + as strings (e.g., 'CountVectorizer'). Default options for each model are defined in config.ini. - All scikit-learn matrix decomposition models are supported; for a full list see - https://scikit-learn.org/stable/modules/classes.html#module-sklearn.decomposition - These may be passed either as callable modules (e.g., sklearn.decomposition.NMF) or as strings (e.g., - 'NMF'). Default options for each model are defined in config.ini. + https://scikit-learn.org/stable/modules/classes.html#module-sklearn.decomposition + These may be passed either as callable modules (e.g., sklearn.decomposition.NMF) or as strings (e.g., + 'NMF'). Default options for each model are defined in config.ini. + - Hugging-face models. These take raw text as input and produce text embeddings as output. Models can be - specified using the simplified API (recommended) or full dict format: - - Simplified API (NEW): - - As a string: 'all-MiniLM-L6-v2' - - As a partial dict: {'model': 'all-MiniLM-L6-v2'} - - Popular models include: - - 'all-MiniLM-L6-v2': Fast, good for general sentence similarity - - 'all-mpnet-base-v2': High quality sentence embeddings - - 'paraphrase-MiniLM-L6-v2': Good for paraphrase detection - For a full list see: https://www.sbert.net/docs/pretrained_models.html - - Full dict format (backward compatible): - {'model': 'all-mpnet-base-v2', 'args': [], 'kwargs': {}} - or using the SentenceTransformer class: - {'model': 'SentenceTransformer', 'args': ['all-MiniLM-L6-v2'], 'kwargs': {}} - The 'kwargs' dictionary may be further subdivided; if an 'embedding_kwargs' key is included in 'kwargs', - its values will be treated as keyword arguments to be applied to the embedding model when it is initialized. + specified using the simplified API (recommended) or full dict format: + + Simplified API (NEW): + + - As a string: 'all-MiniLM-L6-v2' + - As a partial dict: {'model': 'all-MiniLM-L6-v2'} + + Popular models include: + + - 'all-MiniLM-L6-v2': Fast, good for general sentence similarity + - 'all-mpnet-base-v2': High quality sentence embeddings + - 'paraphrase-MiniLM-L6-v2': Good for paraphrase detection + + For a full list see: https://www.sbert.net/docs/pretrained_models.html + + Full dict format (backward compatible): + {'model': 'all-mpnet-base-v2', 'args': [], 'kwargs': {}} + or using the SentenceTransformer class: + {'model': 'SentenceTransformer', 'args': ['all-MiniLM-L6-v2'], 'kwargs': {}} + The 'kwargs' dictionary may be further subdivided; if an 'embedding_kwargs' key is included in 'kwargs', + its values will be treated as keyword arguments to be applied to the embedding model when it is initialized. :param text: a string (a single word, sentence, or document), list of strings (a list of words, sentences, or documents), or a nested list of strings (a list of listed words, sentences, or documents). Strings and (shallow) lists of strings result in a single embedding matrix; nested lists produce a list of embedding matrices (one @@ -481,7 +492,7 @@ def apply_text_model(x, text, *args, mode='fit_transform', return_model=False, * return text elif type(x) is dict: assert all([k in x.keys() for k in ['model']]), ValueError(f'invalid model: {x}') - + # Normalize the model dict to ensure 'args' and 'kwargs' keys exist x = normalize_text_model(x) @@ -509,11 +520,12 @@ def apply_text_model(x, text, *args, mode='fit_transform', return_model=False, * return transformed_text elif is_hugging_face_model(model): warnings.simplefilter('ignore') - + try: _get_SentenceTransformer() except ImportError: - raise ModuleNotFoundError('Hugging-face libraries have not been installed. Please run "pip install --upgrade pydata-wrangler[hf]" to fix.') + raise ModuleNotFoundError('Hugging-face libraries have not been installed. ' + 'Please run "pip install --upgrade pydata-wrangler[hf]" to fix.') if mode == 'fit': # do nothing-- just return the un-transformed text and original model if return_model: @@ -521,7 +533,7 @@ def apply_text_model(x, text, *args, mode='fit_transform', return_model=False, * return text embedding_kwargs = kwargs.pop('embedding_kwargs', {}) - + # Handle different model specifications for sentence-transformers SentenceTransformer = _get_SentenceTransformer() if isinstance(model, str): @@ -545,7 +557,7 @@ def apply_text_model(x, text, *args, mode='fit_transform', return_model=False, * # Generate embeddings embedded_text = model_instance.encode(texts, **kwargs) - + # Convert to numpy array if not already if not isinstance(embedded_text, np.ndarray): embedded_text = np.array(embedded_text) @@ -561,7 +573,7 @@ def apply_text_model(x, text, *args, mode='fit_transform', return_model=False, * else: return embedded_text else: # unknown model - raise RuntimeError('Cannot apply text model: {model}') + raise RuntimeError(f'Cannot apply text model: {model}') def get_text(x, force_literal=False): @@ -580,9 +592,9 @@ def get_text(x, force_literal=False): ------- :return: The text as a string or (potentially nested) list of strings """ - if type(x) == list: + if type(x) is list: return [get_text(t) for t in x] - if (type(x) in six.string_types) or (type(x) == str): + if (type(x) in six.string_types) or (type(x) is str): if os.path.exists(x): if not force_literal: return get_text(load(x), force_literal=True) @@ -603,7 +615,7 @@ def is_text(x): :return: True if the object is (or points to) text and False otherwise. """ - if type(x) == list: + if type(x) is list: return all([is_text(i) for i in x]) return get_text(x) is not None @@ -623,13 +635,13 @@ def to_str_list(x, encoding='utf-8'): :return: a string or (possibly nested) list of strings """ def to_string(s): - if type(s) == str: + if type(s) is str: return s elif is_null(s): return '' elif type(s) in [bytes, np.bytes_]: return s.decode(encoding) - elif is_array(s) or is_dataframe(s) or (type(s) == list): + elif is_array(s) or is_dataframe(s) or (type(s) is list): if len(s) == 1: return to_string(s[0]) else: @@ -637,12 +649,12 @@ def to_string(s): else: return str(s) - if is_array(x) or (type(x) == list): + if is_array(x) or (type(x) is list): return [to_string(s) for s in x] elif is_text(x): return [x] else: - raise Exception('Unsupported data type: {type(x)}') + raise Exception(f'Unsupported data type: {type(x)}') # noinspection PyShadowingNames @@ -660,34 +672,41 @@ def wrangle_text(text, return_model=False, backend=None, **kwargs): The DataFrame backend to use ('pandas' or 'polars'). If None, uses the default backend (pandas) :param kwargs: Other (optional) keyword arguments may be passed into the function to control the wrangling process: + - 'corpus': any built-in or hugging-face corpus (see get_corpus for more details); this argument is passed to the get_corpus function as the "dataset_name" keyword argument + - the 'config' argument may be used to select a specific variant of the corpus (passed to get_corpus as the "config_name" keyword argument). + - 'model': any scikit-learn-compatible or hugging-face-compatible model (see apply_text_model for more details) Simplified API examples: - - 'all-MiniLM-L6-v2' (string format for sentence-transformers) - - 'CountVectorizer' (string format for sklearn model) - - ['CountVectorizer', 'LatentDirichletAllocation'] (list of strings for sklearn pipeline) - - {'model': 'all-MiniLM-L6-v2'} (partial dict format) + + - 'all-MiniLM-L6-v2' (string format for sentence-transformers) + - 'CountVectorizer' (string format for sklearn model) + - ['CountVectorizer', 'LatentDirichletAllocation'] (list of strings for sklearn pipeline) + - {'model': 'all-MiniLM-L6-v2'} (partial dict format) + Full dict format (backward compatible): - - {'model': 'all-MiniLM-L6-v2', 'args': [], 'kwargs': {}} + + - {'model': 'all-MiniLM-L6-v2', 'args': [], 'kwargs': {}} + - 'array_kwargs': a dictionary of keyword arguments that may be passed to wrangle_array to control how the final DataFrame is structured (see wrangle_array for details). Returns ------- - :return: a DataFrame (pandas or Polars based on backend) or list of DataFrames containing the embedded text. If - return_model is True a tuple, whose first element contains the embedded text and second element contains the + :return: a DataFrame (pandas or Polars based on backend) or list of DataFrames containing the embedded text. If + return_model is True a tuple, whose first element contains the embedded text and second element contains the fitted models, is returned instead. Examples -------- >>> import datawrangler as dw >>> # Create pandas DataFrame with sentence embeddings - >>> df_pandas = dw.wrangle(["Hello world", "How are you?"], + >>> df_pandas = dw.wrangle(["Hello world", "How are you?"], ... text_kwargs={'model': 'all-MiniLM-L6-v2'}) - >>> # Create Polars DataFrame with sentence embeddings + >>> # Create Polars DataFrame with sentence embeddings >>> df_polars = dw.wrangle(["Hello world", "How are you?"], ... text_kwargs={'model': 'all-MiniLM-L6-v2'}, ... backend='polars') @@ -706,7 +725,7 @@ def wrangle_text(text, return_model=False, backend=None, **kwargs): if type(model) is not list: model = [model] - + # Normalize each model in the list to support simplified API model = [normalize_text_model(m) if isinstance(m, (str, dict)) else m for m in model] diff --git a/datawrangler/zoo/text_lazy.py b/datawrangler/zoo/text_lazy.py deleted file mode 100644 index bff8d3e..0000000 --- a/datawrangler/zoo/text_lazy.py +++ /dev/null @@ -1,79 +0,0 @@ -import six -import os -import warnings -import numpy as np - -from .array import is_array, wrangle_array -from .dataframe import is_dataframe -from .null import is_null - -from ..core.configurator import get_default_options, apply_defaults, update_dict -from ..io import load -from ..io.io import get_extension -from ..util.lazy_imports import ( - lazy_import_with_fallback, - get_sklearn_feature_extraction_text, - get_sklearn_decomposition, - get_sentence_transformers, - get_transformers, - get_torch, - get_datasets -) - -# Lazy imports for sklearn modules -_get_sklearn_text = lazy_import_with_fallback('sklearn.feature_extraction', 'text') -_get_sklearn_decomposition = lazy_import_with_fallback('sklearn', 'decomposition') - -# Lazy imports for HuggingFace modules -_get_SentenceTransformer = lazy_import_with_fallback( - 'sentence_transformers', 'SentenceTransformer', - fallback_message="sentence-transformers not installed. Install with: pip install 'pydata-wrangler[hf]'" -) - -_get_AutoTokenizer = lazy_import_with_fallback( - 'transformers', 'AutoTokenizer', - fallback_message="transformers not installed. Install with: pip install 'pydata-wrangler[hf]'" -) - -_get_AutoModel = lazy_import_with_fallback( - 'transformers', 'AutoModel', - fallback_message="transformers not installed. Install with: pip install 'pydata-wrangler[hf]'" -) - -_get_torch = lazy_import_with_fallback( - 'torch', - fallback_message="PyTorch not installed. Install with: pip install torch" -) - -_get_load_dataset = lazy_import_with_fallback( - 'datasets', 'load_dataset', - fallback_message="datasets not installed. Install with: pip install 'pydata-wrangler[hf]'" -) - -_get_dataset_config_names = lazy_import_with_fallback( - 'datasets', 'get_dataset_config_names', - fallback_message="datasets not installed. Install with: pip install 'pydata-wrangler[hf]'" -) - -_get_list_datasets = lazy_import_with_fallback( - 'huggingface_hub', 'list_datasets', - fallback_message=None # Optional dependency -) - -# Global variables -defaults = get_default_options() -preloaded_corpora = {} - -# Cache for checking if modules are available without importing -_module_availability_cache = {} - -def _is_module_available(module_name): - """Check if a module is available without importing it.""" - if module_name not in _module_availability_cache: - try: - import importlib.util - spec = importlib.util.find_spec(module_name) - _module_availability_cache[module_name] = spec is not None - except (ImportError, ValueError): - _module_availability_cache[module_name] = False - return _module_availability_cache[module_name] \ No newline at end of file diff --git a/datawrangler/zoo/text_original.py b/datawrangler/zoo/text_original.py deleted file mode 100644 index 5e642a0..0000000 --- a/datawrangler/zoo/text_original.py +++ /dev/null @@ -1,539 +0,0 @@ -import six -import os -import warnings -import numpy as np -from sklearn.feature_extraction import text -from sklearn import decomposition - -try: - from sentence_transformers import SentenceTransformer -except ModuleNotFoundError: # ignore missing sentence-transformers module for now... - SentenceTransformer = None - -try: - from transformers import AutoTokenizer, AutoModel - import torch -except ModuleNotFoundError: # ignore missing transformers module for now... - AutoTokenizer = None - AutoModel = None - torch = None - -try: - from datasets import load_dataset, get_dataset_config_names - # list_datasets was removed in datasets 2.0+, replace with Hub API if needed - try: - from huggingface_hub import list_datasets - except ImportError: - list_datasets = None -except ModuleNotFoundError: # this will be triggered if hugging-face libraries aren't installed - list_datasets = None - -from .array import is_array, wrangle_array -from .dataframe import is_dataframe -from .null import is_null - -from ..core.configurator import get_default_options, apply_defaults, update_dict -from ..io import load -from ..io.io import get_extension - -defaults = get_default_options() -preloaded_corpora = {} - - -def is_sklearn_model(x): - """ - Determine whether an object seems to be a valid scikit-learn model - - Parameters - ---------- - :param x: the object to test - - Returns - ------- - :return: True if x contains "transform", "fit", and "fit_transform" methods and False otherwise. - """ - return hasattr(x, 'transform') and hasattr(x, 'fit') and hasattr(x, 'fit_transform') - - -def is_hugging_face_model(x): - """ - Determine whether an object seems to be a valid hugging-face model (sentence-transformers) - - Parameters - ---------- - :param x: the object to test - - Returns - ------- - :return: True if x is a sentence-transformers model or model name, and False otherwise. - """ - # Check for SentenceTransformer class or instance - if x == SentenceTransformer or (hasattr(x, '__class__') and 'SentenceTransformer' in str(x.__class__)): - return True - - # Check for sentence-transformers model names (common ones) - if isinstance(x, str) and any(name in x for name in ['all-MiniLM', 'all-mpnet', 'all-distilroberta', 'paraphrase-', 'sentence-t5']): - return True - - # Check for encode method (sentence-transformers interface) but not strings - return hasattr(x, 'encode') and not isinstance(x, str) - - -def robust_is_sklearn_model(x): - """ - Wrapper for is_sklearn_model that also supports strings-- e.g., the string 'SparsePCA' will be a valid scikit-learn - model when checked with this function, because 'SparsePCA' is defined in the sklearn.decomposition module. - - Parameters - ---------- - :param x: a to-be-tested model object or a string - - Returns - ------- - :return: True if x (or the scikit-learn module x evaluates to) contains "transform", "fit", and "fit_transform" - methods and False otherwise. - """ - x = get_text_model(x) - return is_sklearn_model(x) - - -def robust_is_hugging_face_model(x): - """ - Wrapper for is_hugging_face_model that also supports strings-- e.g., the string 'all-MiniLM-L6-v2' will be a valid - hugging-face model when checked with this function, because it's a sentence-transformers model name. - - Parameters - ---------- - :param x: a to-be-tested model object or a string - - Returns - ------- - :return: True if x (or the sentence-transformers model x evaluates to) is a valid model and False otherwise. - """ - x = get_text_model(x) - return is_hugging_face_model(x) - - -def get_text_model(x): - """ - Given a valid scikit-learn or sentence-transformers model, or a string matching the name of a valid model, - return a callable function or class constructor for the given model. - - Parameters - ---------- - :param x: an object to turn into a valid scikit-learn or sentence-transformers model. Can be: - - An already-valid model instance - - A string matching sklearn model names (e.g., 'LatentDirichletAllocation', 'CountVectorizer') - - A string matching sentence-transformers model names (e.g., 'all-MiniLM-L6-v2', 'all-mpnet-base-v2') - - Returns - ------- - :return: A valid scikit-learn or sentence-transformers model (or None if no model matching the given - description can be found) - - Examples - -------- - >>> from datawrangler.zoo.text_original import get_text_model - >>> get_text_model('LatentDirichletAllocation') # sklearn model - >>> get_text_model('all-MiniLM-L6-v2') # sentence-transformers model - """ - if is_sklearn_model(x) or is_hugging_face_model(x): - return x # already a valid model - - if type(x) is dict: - if hasattr(x, 'model'): - return get_text_model(x['model']) - else: - return None - - # noinspection PyShadowingNames - def model_lookup(model_name, parent): - try: - return eval(f'{parent}.{model_name}') - except AttributeError: - return None - except NameError: - raise ModuleNotFoundError('Hugging-face libraries have not been installed. To use hugging-face models, please run "pip install --upgrade pydata-wrangler[hf]" to fix.') - - - # Check sklearn models first (before sentence-transformers) - for p in ['text', 'decomposition']: - m = model_lookup(x, p) - if m is not None: - return m - - # Check for sentence-transformers models - if x == 'SentenceTransformer' and SentenceTransformer is not None: - return SentenceTransformer - - # If it's a string and not found in sklearn modules, assume it's a sentence-transformers model - if isinstance(x, str) and SentenceTransformer is not None: - return SentenceTransformer - return None - - -def get_corpus(dataset_name='wikipedia', config_name='20200501.en'): - """ - Download (and return) a text corpus. By default, a 2020 snapshot of all English Wikipedia articles is returned. - - [Parameters] - ------------ - :param dataset_name: a string containing the corpus name. Can be one of the following: - - Corpora built into data-wrangler: - - 'minipedia': a curated and cleaned up subset of Wikipedia containing articles on a wide variety of topics - - 'neurips': a collection of NeurIPS articles - - 'sotus': transcripts of state of the union addresses from US Presidents from 1989 -- 2018 - - 'khan': transcripts of (most) Khan Academy YouTube videos - - Any hugging-face corpus; for a full list see https://huggingface.co/datasets - Note that downloading hugging-face corpora also requires specifying a config_name - :param config_name: configuration name or description for hugging-face corpora. This argument is ignored if dataset - name is set to one of the data-wrangler corpora described above. - - Returns - ------- - :return: A list of number-of-documents strings, where each string contains the text of one document in the corpus. - """ - - key = f'{dataset_name}[{config_name}]' - if key in preloaded_corpora.keys(): - return preloaded_corpora[key] - - def get_formatter(s): - return s[s.find('_'):(s.rfind('_') + 1)] - - # built-in corpora - corpora = { - 'minipedia': 'https://www.dropbox.com/s/eal65nd5a193pmk/minipedia.npz?dl=1', - 'neurips': 'https://www.dropbox.com/s/i32dycxr0qa90wx/neurips.npz?dl=1', - 'sotus': 'https://www.dropbox.com/s/e2qfw8tkmxp6bad/sotus.npz?dl=1', - 'khan': 'https://www.dropbox.com/s/ieztnyhao2ejo48/khan.npz?dl=1'} - - if dataset_name in corpora.keys(): - print(f'loading corpus: {dataset_name}', end='') - data = load(corpora[dataset_name], dtype='numpy') - try: - corpus = data['corpus'] - print('...done!', end='') - preloaded_corpora[key] = corpus - return corpus - finally: - # ensure NpzFile is closed - data.close() - print('') - - # Hugging-Face Corpus - try: - data = load_dataset(dataset_name, config_name) - except FileNotFoundError: - available_msg = "" - if list_datasets is not None: - try: - available_corpora = list_datasets() - available_msg = f" Available corpora: {', '.join(available_corpora)}" - except Exception: - available_msg = " (Unable to list available corpora)" - raise RuntimeError(f'Corpus not found: {dataset_name}.{available_msg}') - except ValueError: - raise RuntimeError(f'Configuration for {dataset_name} corpus not found: {config_name}. ' - f'Available configurations: {", ".join(get_dataset_config_names(dataset_name))}') - except NameError: - raise ModuleNotFoundError('Hugging-face libraries have not been installed. To use hugging-face corpora, please run "pip install --upgrade pydata-wrangler[hf]" to fix.') - - corpus = [] - content_keys = ['text', 'content'] - - for k in data.keys(): - for c in content_keys: - if c in data[k].data.column_names: - for document in data[k].data[c]: - corpus.append(' '.join([w if '_' not in w else w.replace(get_formatter(w), ' ') - for w in str(document).split()])) - return corpus - - -# noinspection PyShadowingNames -def apply_text_model(x, text, *args, mode='fit_transform', return_model=False, **kwargs): - """ - Apply a scikit-learn or hugging-face text embedding model to one or more text datasets. Scikit-learn models are - trained on the specified corpus and then applied to all datasets. All Hugging-Face models are pre-trained. - - Parameters - ---------- - :param x: the model to apply. Supported models include: - - Scikit-learn models. The recommended pipeline is to specify a feature extraction model (for turning text into - a number-of-documents by number-of-features matrix), and then to apply a matrix decomposition or embedding model - (for turning the features matrix into text embeddings). When models are passed as a list, each model is applied - in succession to the output of the previous model. The pipeline is first fit to the provided corpus, and then - applied to the given text. Default: ['CountVectorizer', 'LatentDirichletAllocation'] - - All scikit-learn text feature extraction models are supported; for a full list see - https://scikit-learn.org/stable/modules/classes.html#module-sklearn.feature_extraction.text - These may be passed either as callable modules (e.g., sklearn.feature_extraction.text.CountVectorizer) or - as strings (e.g., 'CountVectorizer'). Default options for each model are defined in config.ini. - - All scikit-learn matrix decomposition models are supported; for a full list see - https://scikit-learn.org/stable/modules/classes.html#module-sklearn.decomposition - These may be passed either as callable modules (e.g., sklearn.decomposition.NMF) or as strings (e.g., - 'NMF'). Default options for each model are defined in config.ini. - - Hugging-face models. These take raw text as input and produce text embeddings as output. Models are - specified using sentence-transformers: - - 'model': the name of a sentence-transformers model or 'SentenceTransformer'. Popular models include: - - 'all-MiniLM-L6-v2': Fast, good for general sentence similarity - - 'all-mpnet-base-v2': High quality sentence embeddings - - 'paraphrase-MiniLM-L6-v2': Good for paraphrase detection - For a full list see: https://www.sbert.net/docs/pretrained_models.html - - 'args': a list of arguments to pass to the model (typically the model name if using 'SentenceTransformer') - - 'kwargs': a dictionary of keyword arguments to pass to the model initialization - for example, to embed text using a high-quality model, use: - {'model': 'all-mpnet-base-v2', 'args': [], 'kwargs': {}} - or using the SentenceTransformer class: - {'model': 'SentenceTransformer', 'args': ['all-MiniLM-L6-v2'], 'kwargs': {}} - The 'kwargs' dictionary may be further subdivided; if an 'embedding_kwargs' key is included in 'kwargs', - its values will be treated as keyword arguments to be applied to the embedding model when it is initialized. - :param text: a string (a single word, sentence, or document), list of strings (a list of words, sentences, or - documents), or a nested list of strings (a list of listed words, sentences, or documents). Strings and (shallow) - lists of strings result in a single embedding matrix; nested lists produce a list of embedding matrices (one - per lowest-level list) - :param args: a list of unnamed arguments to pass to *every* text embedding model or pipeline step. Default: []. - :param mode: one of: 'fit' (fit the model), 'transform' (apply an already-fitted model), or 'fit_transform' (fit - a model and then apply it to the same text). The 'fit' mode is only supported for scikit-learn (and scikit-learn- - compatible) models. - :param return_model: if True, return both the embedded text and a trained model that may be applied to new text. If - False, return only the text embeddings. Default: False. - :param kwargs: keyword arguments are passed to the embedding model; these are equivalent to specifying the - embedding model as a dictionary. When a keyword argument appears in both model['kwargs'] and kwargs, the kwargs - value is used preferentially. - - Returns - ------- - :return: The text embeddings (if return_model is False) or a tuple whose first element is the text embeddings and - whose second element is a fitted model that may be applied to new text (if return_model is True). - """ - if type(x) is list: - models = [] - for i, v in enumerate(x): - if (i < len(x) - 1) and ('transform' not in mode): - temp_mode = 'fit_transform' - else: - temp_mode = mode - - text, m = apply_text_model(v, text, *args, mode=temp_mode, return_model=True, **kwargs) - models.append(m) - - if return_model: - return text, models - else: - return text - elif type(x) is dict: - assert all([k in x.keys() for k in ['model', 'args', 'kwargs']]), ValueError(f'invalid model: {x}') - return apply_text_model(x['model'], text, *[*x['args'], *args], mode=mode, return_model=return_model, - **update_dict(x['kwargs'], kwargs)) - - model = get_text_model(x) - if model is None: - raise RuntimeError(f'unsupported text processing module: {x}') - - # noinspection DuplicatedCode - if is_sklearn_model(model): - assert mode in ['fit', 'transform', 'fit_transform'] - - if callable(model): - model = apply_defaults(model)(*args, **kwargs) - - m = getattr(model, mode) - transformed_text = m(text) - if return_model: - return transformed_text, {'model': model, 'args': args, 'kwargs': kwargs} - return transformed_text - elif is_hugging_face_model(model): - warnings.simplefilter('ignore') - - if SentenceTransformer is None: - raise ModuleNotFoundError('Hugging-face libraries have not been installed. Please run "pip install --upgrade pydata-wrangler[hf]" to fix.') - - if mode == 'fit': # do nothing-- just return the un-transformed text and original model - if return_model: - return text, {'model': model, 'args': args, 'kwargs': kwargs} - return text - - embedding_kwargs = kwargs.pop('embedding_kwargs', {}) - - # Handle different model specifications for sentence-transformers - if isinstance(model, str): - # Model name string (e.g., 'all-MiniLM-L6-v2') - model_instance = SentenceTransformer(model, **embedding_kwargs) - elif model == SentenceTransformer: - # SentenceTransformer class with args - if args: - model_instance = SentenceTransformer(args[0], **embedding_kwargs) - else: - model_instance = SentenceTransformer('all-MiniLM-L6-v2', **embedding_kwargs) - else: - # Already instantiated model - model_instance = model - - # Convert text to list if it's a single string - if isinstance(text, str): - texts = [text] - else: - texts = text - - # Generate embeddings - embedded_text = model_instance.encode(texts, **kwargs) - - # Convert to numpy array if not already - if not isinstance(embedded_text, np.ndarray): - embedded_text = np.array(embedded_text) - - # If input was a single string, return single embedding - if isinstance(text, str): - embedded_text = embedded_text[0] - - if return_model: - return embedded_text, {'model': model_instance, 'args': args, - 'kwargs': {'embedding_kwargs': embedding_kwargs, - **kwargs}} - else: - return embedded_text - else: # unknown model - raise RuntimeError('Cannot apply text model: {model}') - - -def get_text(x, force_literal=False): - """ - Parse, load, or download one or more documents. - - Parameters - ---------- - :param x: A string or list of strings. Each string can be either the text of a document, a file path, or a URL. If - a file path or URL is provided, the contents are loaded in, treated as text, and returned. If a list of strings - is provided, the get_text function is applied to each element of the list. - :param force_literal: If True, interpret strings literally (rather than checking to see if the strings point to a - local or remote file). Default: False. - - Returns - ------- - :return: The text as a string or (potentially nested) list of strings - """ - if type(x) == list: - return [get_text(t) for t in x] - if (type(x) in six.string_types) or (type(x) == str): - if os.path.exists(x): - if not force_literal: - return get_text(load(x), force_literal=True) - return x - return None - - -def is_text(x): - """ - Test whether an object contains (or points to) text. - - Parameters - ---------- - :param x: the object to test - - Returns - ------- - :return: True if the object is (or points to) text and False otherwise. - """ - - if type(x) == list: - return all([is_text(i) for i in x]) - return get_text(x) is not None - - -def to_str_list(x, encoding='utf-8'): - """ - Internal helper function used to wrangle text data. Handles binary strings, nested lists of strings, and arrays - or dataframes containing text. - - Parameters - ---------- - :param x: the text-containing object to be wrangled. - :param encoding: for objects of type bytes, specify the encoding. Default: 'utf-8'. - - Returns - ------- - :return: a string or (possibly nested) list of strings - """ - def to_string(s): - if type(s) == str: - return s - elif is_null(s): - return '' - elif type(s) in [bytes, np.bytes_]: - return s.decode(encoding) - elif is_array(s) or is_dataframe(s) or (type(s) == list): - if len(s) == 1: - return to_string(s[0]) - else: - return to_str_list(s, encoding=encoding) - else: - return str(s) - - if is_array(x) or (type(x) == list): - return [to_string(s) for s in x] - elif is_text(x): - return [x] - else: - raise Exception('Unsupported data type: {type(x)}') - - -# noinspection PyShadowingNames -def wrangle_text(text, return_model=False, **kwargs): - """ - Turn text into DataFrames - - Parameters - ---------- - :param text: A string or (nested) list of strings. Each string can contain either the to-be-wrangled text, a file - path, or a URL. - :param return_model: if True, return a fitted model that may be applied to new text data, along with the wrangled - text. Default: False. - :param kwargs: Other (optional) keyword arguments may be passed into the function to control the wrangling - process: - - 'corpus': any built-in or hugging-face corpus (see get_corpus for more details); this argument is passed to the - get_corpus function as the "dataset_name" keyword argument - - the 'config' argument may be used to select a specific variant of the corpus (passed to get_corpus as the - "config_name" keyword argument). - - 'model': any scikit-learn-compatible or hugging-face-compatible model (see apply_text_model for more details) - - 'array_kwargs': a dictionary of keyword arguments that may be passed to wrangle_array to control how the final - DataFrame is structured (see wrangle_array for details). - - Returns - ------- - :return: a DataFrame (or list of DataFrames) containing the embedded text. If return_model is True a tuple, whose - first element contains the embedded text and second element contains the fitted models, is returned instead. - """ - text = get_text(text) - if type(text) is not list: - text = [text] - - model = kwargs.pop('model', eval(defaults['text']['model'])) - corpus = kwargs.pop('corpus', None) - config = kwargs.pop('config', None) - array_kwargs = kwargs.pop('array_kwargs', {}) - - if type(model) is not list: - model = [model] - - if any(robust_is_sklearn_model(m) for m in model): - if corpus is not None: - if not ((type(corpus) is list) and is_text(corpus)): - corpus = get_corpus(dataset_name=corpus, config_name=config) - else: - corpus = get_corpus(dataset_name=eval(defaults['text']['corpus']), - config_name=eval(defaults['text']['corpus_config'])) - - # train model on corpus - _, model = apply_text_model(model, corpus, mode='fit', return_model=True, **kwargs) - - # apply model to text - embedded_text = apply_text_model(model, text, mode='transform', return_model=False, **kwargs) - - # turn array into dataframe - df = wrangle_array(embedded_text, **array_kwargs) - - if return_model: - return df, model - else: - return df diff --git a/docs/AGENTS.md b/docs/AGENTS.md new file mode 100644 index 0000000..11dc10f --- /dev/null +++ b/docs/AGENTS.md @@ -0,0 +1,52 @@ + + + +# docs + +## Purpose +Sphinx documentation source for the project, published to ReadTheDocs (https://data-wrangler.readthedocs.io). Contains the reStructuredText pages, autodoc module stubs, a set of executable Jupyter tutorials, and static assets. + +## Key Files +| File | Description | +|-|-| +| `conf.py` | Sphinx configuration (extensions, theme, autodoc settings) | +| `index.rst` | Documentation home page / table of contents | +| `api.rst`, `modules.rst`, `datawrangler*.rst` | Auto-generated API reference stubs (one per subpackage/module) | +| `installation.rst` | Install instructions | +| `migration_guide.rst` | Guidance for upgrading across versions (e.g. Polars backend) | +| `tutorials.rst` | Index page linking the notebook tutorials | +| `readme.rst`, `history.rst`, `authors.rst`, `contributing.rst` | Includes of the top-level RST docs | +| `requirements.txt` | Doc-build dependencies | +| `Makefile`, `make.bat` | Sphinx build entry points | +| `build.log` | Last build log (generated artifact) | + +## Subdirectories +| Directory | Purpose | +|-|-| +| `tutorials/` | Executable Jupyter notebooks + `tutorial_helpers.py` (see `tutorials/AGENTS.md`) | +| `_static/` | Static assets for the HTML theme (currently empty) | +| `images/` | Logo/icon PNGs (`wrangler_logo.png`, `wrangler_icon.png`) | +| `_build/` | Generated HTML output — do not edit by hand | + +## For AI Agents + +### Working In This Directory +- Build docs with `make docs` from the repo root (runs Sphinx and opens the result). Per repo `CLAUDE.md`, a successful docs build is part of the pre-push checklist. +- The `datawrangler*.rst` files are API stubs consumed by autodoc; when you add/rename a public module or function, update the corresponding stub and the tutorial/prose that references it. +- Verify any web addresses you add — links must be manually checked (repo `CLAUDE.md`). + +### Testing Requirements +- A clean Sphinx build (no warnings treated as errors where configured) is the bar. Notebooks under `tutorials/` should execute end-to-end. + +### Common Patterns +- Prose docs are reStructuredText; runnable examples are Jupyter notebooks that import `datawrangler as dw`. + +## Dependencies + +### Internal +- Documents the `datawrangler` package API + +### External +- Sphinx (+ theme/extensions listed in `requirements.txt`), Jupyter/nbsphinx for tutorials + + diff --git a/docs/conf.py b/docs/conf.py index e8fe93d..9277e3d 100755 --- a/docs/conf.py +++ b/docs/conf.py @@ -91,7 +91,9 @@ # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. # This patterns also effect to html_static_path and html_extra_path -exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store'] +# modules.rst is an auto-generated sphinx-apidoc artifact that duplicates the curated api.rst +# and is not referenced by any toctree; exclude it to avoid an "isn't included in any toctree" warning. +exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store', 'modules.rst'] # The name of the Pygments (syntax highlighting) style to use. pygments_style = 'sphinx' diff --git a/docs/datawrangler.core.rst b/docs/datawrangler.core.rst index a1355cb..9ebacbc 100644 --- a/docs/datawrangler.core.rst +++ b/docs/datawrangler.core.rst @@ -8,3 +8,9 @@ .. autofunction:: apply_defaults .. autofunction:: update_dict + +.. autofunction:: set_dataframe_backend + +.. autofunction:: get_dataframe_backend + +.. autofunction:: reset_dataframe_backend diff --git a/docs/datawrangler.zoo.polars_dataframe.rst b/docs/datawrangler.zoo.polars_dataframe.rst new file mode 100644 index 0000000..48d78aa --- /dev/null +++ b/docs/datawrangler.zoo.polars_dataframe.rst @@ -0,0 +1,16 @@ +datawrangler.zoo.polars_dataframe +================================= + +.. currentmodule:: datawrangler.zoo.polars_dataframe + +.. autofunction:: is_polars_dataframe + +.. autofunction:: is_polars_lazyframe + +.. autofunction:: wrangle_polars_dataframe + +.. autofunction:: create_polars_dataframe + +.. autofunction:: pandas_to_polars + +.. autofunction:: polars_to_pandas diff --git a/docs/datawrangler.zoo.rst b/docs/datawrangler.zoo.rst index 2cfa6d9..96f6356 100644 --- a/docs/datawrangler.zoo.rst +++ b/docs/datawrangler.zoo.rst @@ -8,4 +8,5 @@ datawrangler.zoo.dataframe datawrangler.zoo.text datawrangler.zoo.null + datawrangler.zoo.polars_dataframe diff --git a/docs/datawrangler.zoo.text.rst b/docs/datawrangler.zoo.text.rst index 37e7a43..9187ac3 100644 --- a/docs/datawrangler.zoo.text.rst +++ b/docs/datawrangler.zoo.text.rst @@ -13,6 +13,6 @@ datawrangler.zoo.text .. autofunction:: apply_text_model -.. autofunction:: text.to_str_list +.. autofunction:: to_str_list -.. autofunction:: text.get_text +.. autofunction:: get_text diff --git a/docs/images/demo.gif b/docs/images/demo.gif new file mode 100644 index 0000000..08f5e6c Binary files /dev/null and b/docs/images/demo.gif differ diff --git a/docs/installation.rst b/docs/installation.rst index 9b5dd26..c261090 100644 --- a/docs/installation.rst +++ b/docs/installation.rst @@ -7,8 +7,9 @@ Installation Requirements ------------ -- **Python 3.9+** (v0.3.0+ requires modern Python versions) +- **Python 3.9+** - NumPy 2.0+ and pandas 2.0+ compatible +- Polars 0.20+ (installed automatically; enables the high-performance ``backend='polars'`` option) - Optional: HuggingFace transformers for advanced text processing Stable release diff --git a/docs/migration_guide.rst b/docs/migration_guide.rst index d355f94..6b5ffa0 100644 --- a/docs/migration_guide.rst +++ b/docs/migration_guide.rst @@ -4,6 +4,17 @@ Migration Guide: v0.2 → v0.3 This guide helps you migrate from data-wrangler v0.2.x to v0.3.0, which includes significant modernization and breaking changes. +.. note:: + + This guide covers the v0.2.x → v0.3.0 migration. Later releases are **backward compatible** and + require no code changes: + + - **v0.4.0** added the optional high-performance Polars backend + (``dw.wrangle(..., backend='polars')``) and a simplified text-model API + (e.g. ``text_kwargs={'model': 'all-MiniLM-L6-v2'}``). + - **v0.5.0** fixed remote-file caching for URLs with query strings (e.g. Dropbox ``?dl=1`` + links); no API changes. + .. contents:: Table of Contents :local: :depth: 2 diff --git a/docs/requirements.txt b/docs/requirements.txt index a08e375..42b8b32 100644 --- a/docs/requirements.txt +++ b/docs/requirements.txt @@ -32,4 +32,5 @@ nbconvert nbformat jupyter-client jupyter-core -jupyterlab-pygments \ No newline at end of file +jupyterlab-pygments +ipython \ No newline at end of file diff --git a/docs/tutorials/AGENTS.md b/docs/tutorials/AGENTS.md new file mode 100644 index 0000000..c662852 --- /dev/null +++ b/docs/tutorials/AGENTS.md @@ -0,0 +1,43 @@ + + + +# tutorials + +## Purpose +Executable Jupyter notebooks that teach `data-wrangler` feature-by-feature, rendered into the Sphinx docs site. They double as living examples and as an informal integration check (they must run end-to-end). + +## Key Files +| File | Description | +|-|-| +| `wrangling_basics.ipynb` | Core `dw.wrangle` usage across data types | +| `core.ipynb` | Configuration and defaults (`config.ini`, backend selection) | +| `io.ipynb` | Loading/saving files and URLs | +| `util.ipynb` | Helper predicates and utilities | +| `decorators1.ipynb`, `decorators2.ipynb` | The `@funnel` decorator family, in two parts | +| `interpolation_and_imputation.ipynb` | Missing-value handling via the `interpolate` decorator | +| `polars_performance.ipynb`, `polars_advanced.ipynb`, `polars_benchmarks.ipynb` | The Polars backend: usage, advanced patterns, and speed comparisons | +| `real_world_examples.ipynb` | End-to-end applied walkthroughs | +| `tutorial_helpers.py` | Shared helper functions imported by the notebooks | + +## For AI Agents + +### Working In This Directory +- Notebooks `import datawrangler as dw` and must execute cleanly against the current source. When you change public API, update the affected notebooks (repo `CLAUDE.md`: update docs/examples alongside code). +- Keep shared logic in `tutorial_helpers.py` rather than duplicating it across notebooks. +- Notebooks may download models/corpora and hit the network; expect longer run times for the text and Polars-benchmark tutorials. + +### Testing Requirements +- Correctness = every notebook runs top-to-bottom without errors and renders in the Sphinx build (`make docs`). + +### Common Patterns +- One concept per notebook; prose + runnable cells; a shared `tutorial_helpers` module. + +## Dependencies + +### Internal +- `datawrangler`; linked from `docs/tutorials.rst` + +### External +- Jupyter, pandas, polars, numpy; sklearn / sentence-transformers for the text examples + + diff --git a/docs/tutorials/core.ipynb b/docs/tutorials/core.ipynb index 593a6e9..c2c0060 100644 --- a/docs/tutorials/core.ipynb +++ b/docs/tutorials/core.ipynb @@ -2,80 +2,407 @@ "cells": [ { "cell_type": "markdown", - "source": "# Data Wrangler Core Configuration\n\nThis tutorial covers the core configuration system in data-wrangler, including how to customize default settings, work with configuration files, and apply custom defaults to functions.\n\n## Overview\n\nThe `datawrangler.core` module provides a flexible configuration system that allows you to:\n\n- Set default parameters for text processing models\n- Customize data processing behavior\n- Apply consistent settings across your project\n- Override defaults on a per-function basis\n\nLet's explore how to use these features effectively.", - "metadata": {} + "metadata": {}, + "source": [ + "# Data Wrangler Core Configuration\n", + "\n", + "This tutorial covers the core configuration system in data-wrangler, including how to customize default settings, work with configuration files, and apply custom defaults to functions.\n", + "\n", + "## Overview\n", + "\n", + "The `datawrangler.core` module provides a flexible configuration system that allows you to:\n", + "\n", + "- Set default parameters for text processing models\n", + "- Customize data processing behavior\n", + "- Apply consistent settings across your project\n", + "- Override defaults on a per-function basis\n", + "\n", + "Let's explore how to use these features effectively." + ] }, { "cell_type": "code", - "source": "import datawrangler as dw\nfrom datawrangler.core import get_default_options, apply_defaults, update_dict\nimport pandas as pd\nimport numpy as np", - "metadata": {}, + "execution_count": 1, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-03T20:51:37.916521Z", + "iopub.status.busy": "2026-07-03T20:51:37.916430Z", + "iopub.status.idle": "2026-07-03T20:51:38.251580Z", + "shell.execute_reply": "2026-07-03T20:51:38.250915Z" + } + }, "outputs": [], - "execution_count": null + "source": [ + "import datawrangler as dw\n", + "from datawrangler.core import get_default_options, apply_defaults, update_dict\n", + "import pandas as pd\n", + "import numpy as np" + ] }, { "cell_type": "markdown", - "source": "## Getting Default Configuration\n\nThe configuration system is built around a `config.ini` file that defines default parameters for all supported models and data types. Let's examine the current defaults:", - "metadata": {} + "metadata": {}, + "source": [ + "## Getting Default Configuration\n", + "\n", + "The configuration system is built around a `config.ini` file that defines default parameters for all supported models and data types. Let's examine the current defaults:" + ] }, { "cell_type": "code", - "source": "# Get all default configuration options\ndefaults = get_default_options()\n\n# Display the main configuration sections\nprint(\"Available configuration sections:\")\nfor section in defaults.keys():\n print(f\"- {section}\")\n\nprint(f\"\\nSupported data types: {defaults['supported_formats']['types']}\")\nprint(f\"Default text model: {defaults['text']['model']}\")\nprint(f\"Default text corpus: {defaults['text']['corpus']}\")", + "execution_count": 2, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-03T20:51:38.253420Z", + "iopub.status.busy": "2026-07-03T20:51:38.253257Z", + "iopub.status.idle": "2026-07-03T20:51:38.256828Z", + "shell.execute_reply": "2026-07-03T20:51:38.256378Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Available configuration sections:\n", + "- DEFAULT\n", + "- supported_formats\n", + "- backend\n", + "- text\n", + "- CountVectorizer\n", + "- HashingVectorizer\n", + "- TfidfTransformer\n", + "- TfidfVectorizer\n", + "- DictionaryLearning\n", + "- FactorAnalysis\n", + "- FastICA\n", + "- IncrementalPCA\n", + "- KernelPCA\n", + "- LatentDirichletAllocation\n", + "- MiniBatchDictionaryLearning\n", + "- MiniBatchSparsePCA\n", + "- NMF\n", + "- PCA\n", + "- SparsePCA\n", + "- TruncatedSVD\n", + "- SentenceTransformer\n", + "- all-MiniLM-L6-v2\n", + "- all-mpnet-base-v2\n", + "- paraphrase-MiniLM-L6-v2\n", + "- all-distilroberta-v1\n", + "- impute\n", + "- SimpleImputer\n", + "- IterativeImputer\n", + "- KNNImputer\n", + "- interpolate\n", + "- data\n", + "\n", + "Supported data types: ['dataframe', 'text', 'array', 'null']\n", + "Default text model: ['CountVectorizer', 'LatentDirichletAllocation']\n", + "Default text corpus: 'minipedia'\n" + ] + } + ], + "source": [ + "# Get all default configuration options\n", + "defaults = get_default_options()\n", + "\n", + "# Display the main configuration sections\n", + "print(\"Available configuration sections:\")\n", + "for section in defaults.keys():\n", + " print(f\"- {section}\")\n", + "\n", + "print(f\"\\nSupported data types: {defaults['supported_formats']['types']}\")\n", + "print(f\"Default text model: {defaults['text']['model']}\")\n", + "print(f\"Default text corpus: {defaults['text']['corpus']}\")" + ] + }, + { + "cell_type": "markdown", "metadata": {}, - "outputs": [], - "execution_count": null + "source": [ + "## Model-Specific Configuration\n", + "\n", + "Each model has its own section in the configuration with optimized default parameters. Let's examine some key model configurations:" + ] }, { "cell_type": "markdown", - "source": "## Model-Specific Configuration\n\nEach model has its own section in the configuration with optimized default parameters. Let's examine some key model configurations:", - "metadata": {} + "metadata": {}, + "source": [ + "## DataFrame Backend Configuration\n", + "\n", + "With the introduction of Polars support, data-wrangler now supports configuring the DataFrame backend globally:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-03T20:51:38.278391Z", + "iopub.status.busy": "2026-07-03T20:51:38.278242Z", + "iopub.status.idle": "2026-07-03T20:51:38.281236Z", + "shell.execute_reply": "2026-07-03T20:51:38.280628Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CountVectorizer default settings:\n", + " stop_words: 'english'\n", + " lowercase: True\n", + " max_df: 0.25\n", + " min_df: 0.1\n", + " strip_accents: 'unicode'\n", + "\n", + "LatentDirichletAllocation default settings:\n", + " n_components: 50\n", + " learning_method: 'online'\n", + "\n", + "SentenceTransformer default settings:\n", + " __model: 'all-MiniLM-L6-v2'\n" + ] + } + ], + "source": [ + "# Examine sklearn model defaults\n", + "print(\"CountVectorizer default settings:\")\n", + "for key, value in defaults['CountVectorizer'].items():\n", + " print(f\" {key}: {value}\")\n", + "\n", + "print(\"\\nLatentDirichletAllocation default settings:\")\n", + "for key, value in defaults['LatentDirichletAllocation'].items():\n", + " print(f\" {key}: {value}\")\n", + "\n", + "print(\"\\nSentenceTransformer default settings:\")\n", + "for key, value in defaults['SentenceTransformer'].items():\n", + " print(f\" {key}: {value}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-03T20:51:38.282729Z", + "iopub.status.busy": "2026-07-03T20:51:38.282625Z", + "iopub.status.idle": "2026-07-03T20:51:38.344406Z", + "shell.execute_reply": "2026-07-03T20:51:38.343758Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Current DataFrame backend: pandas\n", + "Pandas result type: \n", + "Polars result type: \n", + "\n", + "📝 Setting global backend to Polars...\n", + "New global backend: polars\n", + "Global setting result type: \n", + "\n", + "🔄 Reset to pandas: pandas\n" + ] + } + ], + "source": [ + "# Import backend configuration functions\n", + "from datawrangler.core.configurator import set_dataframe_backend, get_dataframe_backend\n", + "\n", + "# Check current backend\n", + "print(f\"Current DataFrame backend: {get_dataframe_backend()}\")\n", + "\n", + "# Create sample data\n", + "sample_data = np.random.rand(100, 5)\n", + "\n", + "# Test with pandas backend (default)\n", + "pandas_result = dw.wrangle(sample_data, backend='pandas')\n", + "print(f\"Pandas result type: {type(pandas_result)}\")\n", + "\n", + "# Test with Polars backend\n", + "polars_result = dw.wrangle(sample_data, backend='polars')\n", + "print(f\"Polars result type: {type(polars_result)}\")\n", + "\n", + "# Set global backend preference\n", + "print(\"\\n📝 Setting global backend to Polars...\")\n", + "set_dataframe_backend('polars')\n", + "print(f\"New global backend: {get_dataframe_backend()}\")\n", + "\n", + "# Now operations use Polars by default\n", + "global_result = dw.wrangle(sample_data) # No backend parameter needed\n", + "print(f\"Global setting result type: {type(global_result)}\")\n", + "\n", + "# Reset to pandas for rest of tutorial\n", + "set_dataframe_backend('pandas')\n", + "print(f\"\\n🔄 Reset to pandas: {get_dataframe_backend()}\")" + ] }, { "cell_type": "markdown", - "source": "## DataFrame Backend Configuration\n\nWith the introduction of Polars support, data-wrangler now supports configuring the DataFrame backend globally:", - "metadata": {} + "metadata": {}, + "source": [ + "## How `config.ini` is structured\n", + "\n", + "`get_default_options()` parses `datawrangler/core/config.ini`, which is organized into named sections. Some\n", + "sections configure data types and backends (`[supported_formats]`, `[backend]`, `[text]`); the rest give the\n", + "default keyword arguments for a specific model or function, one section per name (`[CountVectorizer]`,\n", + "`[LatentDirichletAllocation]`, `[interpolate]`, and so on). Values are stored as strings and evaluated when\n", + "used, so you can write things like `stop_words = 'english'` or `n_components = 50`." + ] }, { "cell_type": "code", - "source": "# Examine sklearn model defaults\nprint(\"CountVectorizer default settings:\")\nfor key, value in defaults['CountVectorizer'].items():\n print(f\" {key}: {value}\")\n\nprint(\"\\nLatentDirichletAllocation default settings:\")\nfor key, value in defaults['LatentDirichletAllocation'].items():\n print(f\" {key}: {value}\")\n\nprint(\"\\nSentenceTransformer default settings:\")\nfor key, value in defaults['SentenceTransformer'].items():\n print(f\" {key}: {value}\")", + "execution_count": 5, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-03T20:51:38.346287Z", + "iopub.status.busy": "2026-07-03T20:51:38.346125Z", + "iopub.status.idle": "2026-07-03T20:51:38.348623Z", + "shell.execute_reply": "2026-07-03T20:51:38.348123Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Default text pipeline: ['CountVectorizer', 'LatentDirichletAllocation']\n", + "Default corpus: 'minipedia'\n", + "Default interpolate: {'method': \"'linear'\", 'limit_direction': \"'both'\"}\n", + "Default impute model: 'IterativeImputer'\n" + ] + } + ], + "source": [ + "# The [text] section defines the default model, corpus, and per-model settings\n", + "print('Default text pipeline:', defaults['text']['model'])\n", + "print('Default corpus: ', defaults['text']['corpus'])\n", + "print('Default interpolate: ', dict(defaults['interpolate']))\n", + "print('Default impute model: ', defaults['impute']['model'])" + ] + }, + { + "cell_type": "markdown", "metadata": {}, - "outputs": [], - "execution_count": null + "source": [ + "## Customizing the defaults\n", + "\n", + "`get_default_options()` returns an ordinary (mutable) config object, so you can adjust settings at runtime\n", + "without editing the file on disk. Changing a value here changes the defaults that downstream functions pick\n", + "up via `apply_defaults`." + ] }, { "cell_type": "code", - "source": "# Import backend configuration functions\nfrom datawrangler.core.configurator import set_dataframe_backend, get_dataframe_backend\n\n# Check current backend\nprint(f\"Current DataFrame backend: {get_dataframe_backend()}\")\n\n# Create sample data\nsample_data = np.random.rand(100, 5)\n\n# Test with pandas backend (default)\npandas_result = dw.wrangle(sample_data, backend='pandas')\nprint(f\"Pandas result type: {type(pandas_result)}\")\n\n# Test with Polars backend\npolars_result = dw.wrangle(sample_data, backend='polars')\nprint(f\"Polars result type: {type(polars_result)}\")\n\n# Set global backend preference\nprint(\"\\n\ud83d\udcdd Setting global backend to Polars...\")\nset_dataframe_backend('polars')\nprint(f\"New global backend: {get_dataframe_backend()}\")\n\n# Now operations use Polars by default\nglobal_result = dw.wrangle(sample_data) # No backend parameter needed\nprint(f\"Global setting result type: {type(global_result)}\")\n\n# Reset to pandas for rest of tutorial\nset_dataframe_backend('pandas')\nprint(f\"\\n\ud83d\udd04 Reset to pandas: {get_dataframe_backend()}\")", + "execution_count": 6, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-03T20:51:38.349841Z", + "iopub.status.busy": "2026-07-03T20:51:38.349720Z", + "iopub.status.idle": "2026-07-03T20:51:38.353172Z", + "shell.execute_reply": "2026-07-03T20:51:38.352727Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Customized LDA topics: 10\n", + "Customized default corpus: 'sotus'\n" + ] + } + ], + "source": [ + "# Make a customized copy of the defaults\n", + "custom = get_default_options()\n", + "custom['LatentDirichletAllocation']['n_components'] = '10' # 10 topics instead of 50\n", + "print(f\"Customized LDA topics: {custom['LatentDirichletAllocation']['n_components']}\")\n", + "\n", + "# Point the default text corpus somewhere else\n", + "custom['text']['corpus'] = \"'sotus'\"\n", + "print(f\"Customized default corpus: {custom['text']['corpus']}\")" + ] + }, + { + "cell_type": "markdown", "metadata": {}, - "outputs": [], - "execution_count": null + "source": [ + "## Applying defaults with `apply_defaults`\n", + "\n", + "`apply_defaults` wraps a function so that any argument the caller omits is filled in from the configuration.\n", + "It matches the function's name against a section in the defaults, so a function called `scale` picks up the\n", + "values from a `[scale]` section. This is how data-wrangler injects per-model settings automatically." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-03T20:51:38.354639Z", + "iopub.status.busy": "2026-07-03T20:51:38.354541Z", + "iopub.status.idle": "2026-07-03T20:51:38.358013Z", + "shell.execute_reply": "2026-07-03T20:51:38.357470Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Without defaults (factor=1.0): [1.0, 2.0, 3.0]\n", + "With apply_defaults (factor=3.0): [3.0, 6.0, 9.0]\n", + "Explicit argument still wins: [10.0, 20.0, 30.0]\n" + ] + } + ], + "source": [ + "def scale(data, factor=1.0):\n", + " \"\"\"Multiply every value by `factor`.\"\"\"\n", + " return [d * factor for d in data]\n", + "\n", + "# Supply defaults for `scale` via a matching section (values are strings, as in config.ini)\n", + "scale_with_defaults = apply_defaults(scale, defaults={'scale': {'factor': '3.0'}})\n", + "\n", + "print('Without defaults (factor=1.0):', scale([1, 2, 3]))\n", + "print('With apply_defaults (factor=3.0):', scale_with_defaults([1, 2, 3]))\n", + "print('Explicit argument still wins:', scale_with_defaults([1, 2, 3], factor=10.0))" + ] } ], "metadata": { "language_info": { "codemirror_mode": { "name": "ipython", - "version": 2 + "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.6" + "pygments_lexer": "ipython3", + "version": "3.10.12" }, "pycharm": { "stem_cell": { "cell_type": "raw", + "metadata": { + "collapsed": false + }, "source": [ "\n", "\n", "\n" - ], - "metadata": { - "collapsed": false - } + ] } } }, "nbformat": 4, "nbformat_minor": 0 -} \ No newline at end of file +} diff --git a/docs/tutorials/decorators1.ipynb b/docs/tutorials/decorators1.ipynb index 4f69ec4..3ff5c0c 100644 --- a/docs/tutorials/decorators1.ipynb +++ b/docs/tutorials/decorators1.ipynb @@ -7,61 +7,315 @@ "collapsed": true }, "outputs": [], - "source": [ - "" - ] + "source": [] }, { "cell_type": "markdown", - "source": "# Data Wrangler Decorators Part 1: The @funnel Decorator\n\nThis tutorial introduces the powerful `@funnel` decorator, which automatically converts function inputs to pandas DataFrames. This allows you to write functions that work seamlessly with any data type that data-wrangler supports.\n\n## The @funnel Decorator\n\nThe `@funnel` decorator is the cornerstone of data-wrangler's function integration system. It automatically wrangles function arguments into DataFrames, allowing your functions to work with:\n\n- Raw arrays, lists, and nested data structures\n- Text data (automatically embedded using NLP models)\n- Files and URLs\n- Mixed data types\n- Any other data type supported by data-wrangler\n\nLet's see how this works in practice.", - "metadata": {} + "metadata": {}, + "source": [ + "# Data Wrangler Decorators Part 1: The @funnel Decorator\n", + "\n", + "This tutorial introduces the powerful `@funnel` decorator, which automatically converts function inputs to pandas DataFrames. This allows you to write functions that work seamlessly with any data type that data-wrangler supports.\n", + "\n", + "## The @funnel Decorator\n", + "\n", + "The `@funnel` decorator is the cornerstone of data-wrangler's function integration system. It automatically wrangles function arguments into DataFrames, allowing your functions to work with:\n", + "\n", + "- Raw arrays, lists, and nested data structures\n", + "- Text data (automatically embedded using NLP models)\n", + "- Files and URLs\n", + "- Mixed data types\n", + "- Any other data type supported by data-wrangler\n", + "\n", + "Let's see how this works in practice." + ] }, { "cell_type": "code", - "source": "import datawrangler as dw\nimport pandas as pd\nimport numpy as np\nfrom datawrangler import funnel\nimport matplotlib.pyplot as plt", - "metadata": {}, + "execution_count": 1, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-03T20:53:39.281098Z", + "iopub.status.busy": "2026-07-03T20:53:39.281015Z", + "iopub.status.idle": "2026-07-03T20:53:39.799738Z", + "shell.execute_reply": "2026-07-03T20:53:39.799091Z" + } + }, "outputs": [], - "execution_count": null + "source": [ + "import datawrangler as dw\n", + "import pandas as pd\n", + "import numpy as np\n", + "from datawrangler import funnel\n", + "import matplotlib.pyplot as plt" + ] }, { "cell_type": "markdown", - "source": "## Basic Example: Numerical Analysis Function\n\nLet's start with a simple function that computes basic statistics. Without @funnel, this would only work with DataFrames:", - "metadata": {} + "metadata": {}, + "source": [ + "## Basic Example: Numerical Analysis Function\n", + "\n", + "Let's start with a simple function that computes basic statistics. Without @funnel, this would only work with DataFrames:" + ] }, { "cell_type": "code", - "source": "# Define a function that works on DataFrames\n@funnel\ndef compute_stats(data):\n \\\"\\\"\\\"Compute basic statistics for numerical data\\\"\\\"\\\"\n return {\n 'mean': data.mean().mean(),\n 'std': data.std().mean(), \n 'shape': data.shape,\n 'columns': list(data.columns)\n }\n\n# Test with different data types\nprint(\"=== Testing with different data types ===\")\n\n# 1. Raw numpy array\narray_data = np.random.randn(10, 5)\nprint(\"\\\\n1. NumPy Array:\")\nprint(f\"Input shape: {array_data.shape}\")\nstats = compute_stats(array_data)\nprint(f\"Result: {stats}\")\n\n# 2. Python list\nlist_data = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\nprint(\"\\\\n2. Python List:\")\nprint(f\"Input: {list_data}\")\nstats = compute_stats(list_data)\nprint(f\"Result: {stats}\")\n\n# 3. Already a DataFrame\ndf_data = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})\nprint(\"\\\\n3. Pandas DataFrame:\")\nprint(f\"Input shape: {df_data.shape}\")\nstats = compute_stats(df_data)\nprint(f\"Result: {stats}\")", - "metadata": {}, - "outputs": [], - "execution_count": null + "execution_count": 2, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-03T20:53:39.801600Z", + "iopub.status.busy": "2026-07-03T20:53:39.801445Z", + "iopub.status.idle": "2026-07-03T20:53:39.854153Z", + "shell.execute_reply": "2026-07-03T20:53:39.853708Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== Testing with different data types ===\n", + "\\n1. NumPy Array:\n", + "Input shape: (10, 5)\n", + "Result: {'mean': np.float64(-0.16432272636920753), 'std': np.float64(1.0205481350367525), 'shape': (10, 5), 'columns': [0, 1, 2, 3, 4]}\n", + "\\n2. 2D NumPy array:\n", + "Input: [[1 2 3]\n", + " [4 5 6]\n", + " [7 8 9]]\n", + "Result: {'mean': np.float64(5.0), 'std': np.float64(3.0), 'shape': (3, 3), 'columns': [0, 1, 2]}\n", + "\\n3. Pandas DataFrame:\n", + "Input shape: (3, 2)\n", + "Result: {'mean': np.float64(3.5), 'std': np.float64(1.0), 'shape': (3, 2), 'columns': ['A', 'B']}\n" + ] + } + ], + "source": [ + "# Define a function that works on DataFrames\n", + "@funnel\n", + "def compute_stats(data):\n", + " \"\"\"Compute basic statistics for numerical data\"\"\"\n", + " return {\n", + " 'mean': data.mean().mean(),\n", + " 'std': data.std().mean(), \n", + " 'shape': data.shape,\n", + " 'columns': list(data.columns)\n", + " }\n", + "\n", + "# Test with different data types\n", + "print(\"=== Testing with different data types ===\")\n", + "\n", + "# 1. Raw numpy array\n", + "array_data = np.random.randn(10, 5)\n", + "print(\"\\\\n1. NumPy Array:\")\n", + "print(f\"Input shape: {array_data.shape}\")\n", + "stats = compute_stats(array_data)\n", + "print(f\"Result: {stats}\")\n", + "\n", + "# 2. 2D NumPy array (built from a nested Python list)\n", + "list_data = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])\n", + "print(\"\\\\n2. 2D NumPy array:\")\n", + "print(f\"Input: {list_data}\")\n", + "stats = compute_stats(list_data)\n", + "print(f\"Result: {stats}\")\n", + "\n", + "# 3. Already a DataFrame\n", + "df_data = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})\n", + "print(\"\\\\n3. Pandas DataFrame:\")\n", + "print(f\"Input shape: {df_data.shape}\")\n", + "stats = compute_stats(df_data)\n", + "print(f\"Result: {stats}\")" + ] }, { "cell_type": "markdown", - "source": "## Text Processing with @funnel\n\nOne of the most powerful features is how @funnel handles text data automatically. Let's create a function that analyzes text sentiment and see how it works with different text inputs:", - "metadata": {} + "metadata": {}, + "source": [ + "## Text Processing with @funnel\n", + "\n", + "One of the most powerful features is how @funnel handles text data automatically. Let's create a function that analyzes text sentiment and see how it works with different text inputs:" + ] }, { "cell_type": "code", - "source": "@funnel\ndef analyze_text_dimensions(text_data, text_kwargs={'model': 'all-MiniLM-L6-v2'}):\n \\\"\\\"\\\"Analyze the dimensionality and characteristics of text embeddings\\\"\\\"\\\"\n print(f\"Received DataFrame with shape: {text_data.shape}\")\n print(f\"Data type: {type(text_data)}\")\n print(f\"Columns: {list(text_data.columns)}\")\n \n # Basic statistics about the embeddings\n stats = {\n 'embedding_dimensions': text_data.shape[1],\n 'num_texts': text_data.shape[0],\n 'mean_embedding_magnitude': np.sqrt((text_data ** 2).sum(axis=1)).mean(),\n 'embedding_std': text_data.std().mean()\n }\n \n return stats\n\n# Test with different text inputs\nprint(\"=== Testing text processing with @funnel ===\")\n\n# 1. Single text string\nsingle_text = \"This is a sample sentence for analysis.\"\nprint(\"\\\\n1. Single text string:\")\nprint(f\"Input: '{single_text}'\")\nresult = analyze_text_dimensions(single_text)\nprint(f\"Result: {result}\")\n\n# 2. List of texts\ntext_list = [\n \"Data science is fascinating.\",\n \"Machine learning transforms industries.\", \n \"Natural language processing enables AI communication.\",\n \"Data wrangling simplifies preprocessing.\"\n]\nprint(\"\\\\n2. List of texts:\")\nprint(f\"Input: {len(text_list)} texts\")\nresult = analyze_text_dimensions(text_list)\nprint(f\"Result: {result}\")", + "execution_count": 3, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-03T20:53:39.874216Z", + "iopub.status.busy": "2026-07-03T20:53:39.874100Z", + "iopub.status.idle": "2026-07-03T20:54:25.787219Z", + "shell.execute_reply": "2026-07-03T20:54:25.786488Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== Testing text processing with @funnel ===\n", + "\\n1. Single text string:\n", + "Input: 'This is a sample sentence for analysis.'\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/jmanning/.pyenv/versions/3.10.12/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loading corpus: minipedia" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "...done!" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Received DataFrame with shape: (1, 50)\n", + "Data type: \n", + "Columns: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49]\n", + "Result: {'embedding_dimensions': 50, 'num_texts': 1, 'mean_embedding_magnitude': np.float64(0.5147815070493398), 'embedding_std': nan}\n", + "\\n2. List of texts:\n", + "Input: 4 texts\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Received DataFrame with shape: (4, 50)\n", + "Data type: \n", + "Columns: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49]\n", + "Result: {'embedding_dimensions': 50, 'num_texts': 4, 'mean_embedding_magnitude': np.float64(0.5669376195429721), 'embedding_std': np.float64(0.018058002593314436)}\n" + ] + } + ], + "source": [ + "@funnel\n", + "def analyze_text_dimensions(text_data, text_kwargs={'model': 'all-MiniLM-L6-v2'}):\n", + " \"\"\"Analyze the dimensionality and characteristics of text embeddings\"\"\"\n", + " print(f\"Received DataFrame with shape: {text_data.shape}\")\n", + " print(f\"Data type: {type(text_data)}\")\n", + " print(f\"Columns: {list(text_data.columns)}\")\n", + " \n", + " # Basic statistics about the embeddings\n", + " stats = {\n", + " 'embedding_dimensions': text_data.shape[1],\n", + " 'num_texts': text_data.shape[0],\n", + " 'mean_embedding_magnitude': np.sqrt((text_data ** 2).sum(axis=1)).mean(),\n", + " 'embedding_std': text_data.std().mean()\n", + " }\n", + " \n", + " return stats\n", + "\n", + "# Test with different text inputs\n", + "print(\"=== Testing text processing with @funnel ===\")\n", + "\n", + "# 1. Single text string\n", + "single_text = \"This is a sample sentence for analysis.\"\n", + "print(\"\\\\n1. Single text string:\")\n", + "print(f\"Input: '{single_text}'\")\n", + "result = analyze_text_dimensions(single_text)\n", + "print(f\"Result: {result}\")\n", + "\n", + "# 2. List of texts\n", + "text_list = [\n", + " \"Data science is fascinating.\",\n", + " \"Machine learning transforms industries.\", \n", + " \"Natural language processing enables AI communication.\",\n", + " \"Data wrangling simplifies preprocessing.\"\n", + "]\n", + "print(\"\\\\n2. List of texts:\")\n", + "print(f\"Input: {len(text_list)} texts\")\n", + "result = analyze_text_dimensions(text_list)\n", + "print(f\"Result: {result}\")" + ] + }, + { + "cell_type": "markdown", "metadata": {}, - "outputs": [], - "execution_count": null + "source": [ + "## The `list_generalizer` Decorator\n", + "\n", + "`@funnel` converts inputs to DataFrames. A lower-level building block, `@list_generalizer`, does something\n", + "complementary: it lets a function that operates on a **single** object automatically accept a **list** of\n", + "objects, applying itself to each element and returning a list of results. `data-wrangler` uses it\n", + "internally so that every wrangling function transparently supports lists of inputs." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-03T20:54:25.788999Z", + "iopub.status.busy": "2026-07-03T20:54:25.788801Z", + "iopub.status.idle": "2026-07-03T20:54:25.792467Z", + "shell.execute_reply": "2026-07-03T20:54:25.791686Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Single object:\n", + "{'shape': (10,), 'mean': 4.5}\n", + "\n", + "List of objects:\n", + "{'shape': (10,), 'mean': 4.5}\n", + "{'shape': (3, 3), 'mean': 1.0}\n", + "{'shape': (3,), 'mean': 5.0}\n" + ] + } + ], + "source": [ + "from datawrangler.decorate import list_generalizer\n", + "\n", + "@list_generalizer\n", + "def describe(x):\n", + " \"\"\"Summarize a single array-like object.\"\"\"\n", + " arr = np.asarray(x)\n", + " return {'shape': arr.shape, 'mean': float(arr.mean())}\n", + "\n", + "# A single object -> a single result\n", + "print('Single object:')\n", + "print(describe(np.arange(10)))\n", + "\n", + "# A list of objects -> a list of results (no manual loop required)\n", + "print()\n", + "print('List of objects:')\n", + "for result in describe([np.arange(10), np.ones((3, 3)), [5, 5, 5]]):\n", + " print(result)" + ] } ], "metadata": { "language_info": { "codemirror_mode": { "name": "ipython", - "version": 2 + "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.6" + "pygments_lexer": "ipython3", + "version": "3.10.12" } }, "nbformat": 4, "nbformat_minor": 0 -} \ No newline at end of file +} diff --git a/docs/tutorials/decorators2.ipynb b/docs/tutorials/decorators2.ipynb index d8d4ce1..4fc66e2 100644 --- a/docs/tutorials/decorators2.ipynb +++ b/docs/tutorials/decorators2.ipynb @@ -7,56 +7,323 @@ "collapsed": true }, "outputs": [], - "source": [ - "" - ] + "source": [] }, { "cell_type": "markdown", - "source": "# Data Wrangler Decorators Part 2: Advanced Decorators\n\nThis tutorial covers advanced decorator functionality in data-wrangler, including interpolation, stacking/unstacking operations, and building complex data processing pipelines.\n\n## Advanced Decorators Overview\n\nBeyond the basic `@funnel` decorator, data-wrangler provides specialized decorators for:\n\n- **`@interpolate`**: Automatic handling of missing data\n- **`@apply_stacked`**: Operations on stacked (melted) data\n- **`@apply_unstacked`**: Operations on unstacked (pivoted) data \n- **Custom decorator combinations**: Chaining decorators for complex workflows\n\nThese decorators enable sophisticated data preprocessing pipelines with minimal code.", - "metadata": {} + "metadata": {}, + "source": [ + "# Data Wrangler Decorators Part 2: Advanced Decorators\n", + "\n", + "This tutorial covers advanced decorator functionality in data-wrangler, including interpolation, stacking/unstacking operations, and building complex data processing pipelines.\n", + "\n", + "## Advanced Decorators Overview\n", + "\n", + "Beyond the basic `@funnel` decorator, data-wrangler provides specialized decorators for:\n", + "\n", + "- **`@interpolate`**: Automatic handling of missing data\n", + "- **`@apply_stacked`**: Operations on stacked (melted) data\n", + "- **`@apply_unstacked`**: Operations on unstacked (pivoted) data \n", + "- **Custom decorator combinations**: Chaining decorators for complex workflows\n", + "\n", + "These decorators enable sophisticated data preprocessing pipelines with minimal code." + ] }, { "cell_type": "code", - "source": "import datawrangler as dw\nimport pandas as pd\nimport numpy as np\nfrom datawrangler.decorate import funnel, interpolate, apply_stacked, apply_unstacked\nimport matplotlib.pyplot as plt", - "metadata": {}, + "execution_count": 1, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-03T20:51:27.609227Z", + "iopub.status.busy": "2026-07-03T20:51:27.609136Z", + "iopub.status.idle": "2026-07-03T20:51:28.191272Z", + "shell.execute_reply": "2026-07-03T20:51:28.190633Z" + } + }, "outputs": [], - "execution_count": null + "source": [ + "import datawrangler as dw\n", + "import pandas as pd\n", + "import numpy as np\n", + "from datawrangler.decorate import funnel, interpolate, apply_stacked, apply_unstacked\n", + "import matplotlib.pyplot as plt" + ] }, { "cell_type": "markdown", - "source": "## The @interpolate Decorator\n\nThe `@interpolate` decorator automatically handles missing data by applying interpolation methods before passing data to your function. This is particularly useful for time series analysis and data cleaning pipelines.", - "metadata": {} + "metadata": {}, + "source": [ + "## The @interpolate Decorator\n", + "\n", + "The `@interpolate` decorator automatically handles missing data by applying interpolation methods before passing data to your function. This is particularly useful for time series analysis and data cleaning pipelines." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-03T20:51:28.193226Z", + "iopub.status.busy": "2026-07-03T20:51:28.193049Z", + "iopub.status.idle": "2026-07-03T20:51:28.199961Z", + "shell.execute_reply": "2026-07-03T20:51:28.199513Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Original data with missing values:\n", + " date value category\n", + "0 2024-01-01 0.496714 A\n", + "1 2024-01-02 0.358450 A\n", + "2 2024-01-03 1.006138 A\n", + "3 2024-01-04 2.529168 A\n", + "4 2024-01-05 2.295015 A\n", + "5 2024-01-06 NaN A\n", + "6 2024-01-07 NaN A\n", + "7 2024-01-08 NaN A\n", + "8 2024-01-09 3.938051 A\n", + "9 2024-01-10 4.480611 A\n", + "10 2024-01-11 4.017193 B\n", + "11 2024-01-12 3.551464 B\n", + "12 2024-01-13 3.793426 B\n", + "13 2024-01-14 1.880146 B\n", + "14 2024-01-15 0.155228 B\n", + "15 2024-01-16 NaN B\n", + "16 2024-01-17 -1.419891 B\n", + "17 2024-01-18 -1.105643 B\n", + "18 2024-01-19 -2.013668 B\n", + "19 2024-01-20 -3.425971 B\n", + "\n", + "Missing values: 4\n" + ] + } + ], + "source": [ + "# Create sample data with missing values\n", + "np.random.seed(42)\n", + "dates = pd.date_range('2024-01-01', periods=20, freq='D')\n", + "values = np.random.randn(20).cumsum()\n", + "# Introduce some missing values\n", + "values[5:8] = np.nan\n", + "values[15] = np.nan\n", + "\n", + "# Create DataFrame with missing data\n", + "timeseries_data = pd.DataFrame({\n", + " 'date': dates,\n", + " 'value': values,\n", + " 'category': ['A'] * 10 + ['B'] * 10\n", + "})\n", + "\n", + "print(\"Original data with missing values:\")\n", + "print(timeseries_data)\n", + "print(f\"\\nMissing values: {timeseries_data['value'].isna().sum()}\")" + ] }, { "cell_type": "code", - "source": "# Create sample data with missing values\nnp.random.seed(42)\ndates = pd.date_range('2024-01-01', periods=20, freq='D')\nvalues = np.random.randn(20).cumsum()\n# Introduce some missing values\nvalues[5:8] = np.nan\nvalues[15] = np.nan\n\n# Create DataFrame with missing data\ntimeseries_data = pd.DataFrame({\n 'date': dates,\n 'value': values,\n 'category': ['A'] * 10 + ['B'] * 10\n})\n\nprint(\"Original data with missing values:\")\nprint(timeseries_data)\nprint(f\"\\nMissing values: {timeseries_data['value'].isna().sum()}\")", + "execution_count": 3, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-03T20:51:28.220066Z", + "iopub.status.busy": "2026-07-03T20:51:28.219928Z", + "iopub.status.idle": "2026-07-03T20:51:28.282008Z", + "shell.execute_reply": "2026-07-03T20:51:28.281260Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Rolling statistics computed on interpolated data:\n", + " rolling_mean rolling_std rolling_min rolling_max\n", + "0 NaN NaN NaN NaN\n", + "1 NaN NaN NaN NaN\n", + "2 NaN NaN NaN NaN\n", + "3 NaN NaN NaN NaN\n", + "4 1.337097 1.013924 0.358450 2.529168\n", + "5 1.778909 1.037209 0.358450 2.705774\n", + "6 2.330526 0.798959 1.006138 3.116533\n", + "7 2.834756 0.489986 2.295015 3.527292\n", + "8 3.116533 0.649467 2.295015 3.938051\n", + "9 3.553652 0.692402 2.705774 4.480611\n", + "\n", + "Missing values after interpolation: 16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/jmanning/data-wrangler/datawrangler/decorate/decorate.py:340: FutureWarning: DataFrame.interpolate with object dtype is deprecated and will raise in a future version. Call obj.infer_objects(copy=False) before interpolating instead.\n", + " data = data.interpolate(**kwargs)\n" + ] + } + ], + "source": [ + "# Define a function that computes rolling statistics\n", + "@funnel\n", + "@interpolate\n", + "def compute_rolling_stats(data, window=5):\n", + " \"\"\"Compute rolling statistics on clean data\"\"\"\n", + " if 'value' not in data.columns:\n", + " return pd.DataFrame()\n", + " \n", + " result = pd.DataFrame({\n", + " 'rolling_mean': data['value'].rolling(window=window).mean(),\n", + " 'rolling_std': data['value'].rolling(window=window).std(),\n", + " 'rolling_min': data['value'].rolling(window=window).min(),\n", + " 'rolling_max': data['value'].rolling(window=window).max()\n", + " })\n", + " \n", + " return result\n", + "\n", + "# Apply to data with missing values - interpolation happens automatically\n", + "rolling_stats = compute_rolling_stats(timeseries_data, interp_kwargs={'method': 'linear'})\n", + "\n", + "print(\"Rolling statistics computed on interpolated data:\")\n", + "print(rolling_stats.head(10))\n", + "\n", + "# Verify no missing values in the processed data\n", + "print(f\"\\nMissing values after interpolation: {rolling_stats.isna().sum().sum()}\")" + ] + }, + { + "cell_type": "markdown", "metadata": {}, - "outputs": [], - "execution_count": null + "source": [ + "## Stacking and unstacking\n", + "\n", + "Many datasets are naturally a *collection* of DataFrames -- one per subject, session, file, or trial -- that\n", + "all share the same columns. `dw.stack` concatenates such a list into a single DataFrame with a\n", + "**hierarchical (MultiIndex)** row index that remembers which rows came from which original DataFrame.\n", + "`dw.unstack` is the exact inverse, splitting a stacked DataFrame back into the original list.\n", + "\n", + "**Why is this useful?** Stacking lets you run one vectorized operation over *all* the data at once (fitting a\n", + "model, normalizing, computing statistics) instead of looping, while unstacking recovers the per-DataFrame\n", + "structure so downstream code still sees the individual pieces." + ] }, { "cell_type": "code", - "source": "# Define a function that computes rolling statistics\n@funnel\n@interpolate(method='linear')\ndef compute_rolling_stats(data, window=5):\n \\\"\\\"\\\"Compute rolling statistics on clean data\\\"\\\"\\\"\n if 'value' not in data.columns:\n return pd.DataFrame()\n \n result = pd.DataFrame({\n 'rolling_mean': data['value'].rolling(window=window).mean(),\n 'rolling_std': data['value'].rolling(window=window).std(),\n 'rolling_min': data['value'].rolling(window=window).min(),\n 'rolling_max': data['value'].rolling(window=window).max()\n })\n \n return result\n\n# Apply to data with missing values - interpolation happens automatically\nrolling_stats = compute_rolling_stats(timeseries_data)\n\nprint(\"Rolling statistics computed on interpolated data:\")\nprint(rolling_stats.head(10))\n\n# Verify no missing values in the processed data\nprint(f\"\\nMissing values after interpolation: {rolling_stats.isna().sum().sum()}\")", + "execution_count": 4, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-03T20:51:28.283505Z", + "iopub.status.busy": "2026-07-03T20:51:28.283388Z", + "iopub.status.idle": "2026-07-03T20:51:28.289640Z", + "shell.execute_reply": "2026-07-03T20:51:28.288966Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Stacked shape: (12, 2) with a 2-level index\n", + " x y\n", + "ID \n", + "0 0 0.456070 0.785176\n", + " 1 0.199674 0.514234\n", + " 2 0.592415 0.046450\n", + " 3 0.607545 0.170524\n", + "1 0 0.065052 0.948886\n", + " 1 0.965632 0.808397\n", + "\n", + "Unstacked back into 3 DataFrames of shape (4, 2)\n" + ] + } + ], + "source": [ + "from datawrangler import stack, unstack\n", + "\n", + "# Three DataFrames that share the same columns (e.g. one per experiment subject)\n", + "subjects = [pd.DataFrame(np.random.rand(4, 2), columns=['x', 'y']) for _ in range(3)]\n", + "\n", + "stacked = stack(subjects)\n", + "print(f'Stacked shape: {stacked.shape} with a {stacked.index.nlevels}-level index')\n", + "print(stacked.head(6))\n", + "\n", + "restored = unstack(stacked)\n", + "print(f'\\nUnstacked back into {len(restored)} DataFrames of shape {restored[0].shape}')" + ] + }, + { + "cell_type": "markdown", "metadata": {}, - "outputs": [], - "execution_count": null + "source": [ + "### `@apply_stacked` and `@apply_unstacked`\n", + "\n", + "These decorators wire stacking/unstacking into a function automatically:\n", + "\n", + "- **`@apply_stacked`**: stacks a list of DataFrames, runs your function once on the combined data, then\n", + " unstacks the result. Use it for operations that should treat all the data *together* (e.g. a global mean).\n", + "- **`@apply_unstacked`**: the opposite -- given a stacked DataFrame, it splits the data, applies your function\n", + " to *each* piece independently, then re-stacks. Use it for per-group operations." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-03T20:51:28.291509Z", + "iopub.status.busy": "2026-07-03T20:51:28.291368Z", + "iopub.status.idle": "2026-07-03T20:51:28.299420Z", + "shell.execute_reply": "2026-07-03T20:51:28.298960Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "@apply_stacked returned 3 DataFrames; pooled mean is now ~0: 3.70e-17\n", + "@apply_unstacked returned a DataFrame of shape (12, 2)\n" + ] + } + ], + "source": [ + "from datawrangler.decorate import apply_stacked, apply_unstacked\n", + "\n", + "@apply_stacked\n", + "def demean_globally(df):\n", + " \"\"\"Subtract the grand mean computed across ALL subjects at once.\"\"\"\n", + " return df - df.mean()\n", + "\n", + "@apply_unstacked\n", + "def zscore_each(df):\n", + " \"\"\"Standardize each subject independently.\"\"\"\n", + " return (df - df.mean()) / df.std()\n", + "\n", + "# apply_stacked takes the list, works on the pooled data, and returns a list\n", + "pooled = demean_globally(subjects)\n", + "print(f'@apply_stacked returned {len(pooled)} DataFrames; pooled mean is now ~0: '\n", + " f'{stack(pooled).mean().abs().max():.2e}')\n", + "\n", + "# apply_unstacked takes the stacked frame, works per-subject, and returns a stacked frame\n", + "standardized = zscore_each(stacked)\n", + "print(f'@apply_unstacked returned a {type(standardized).__name__} of shape {standardized.shape}')" + ] } ], "metadata": { "language_info": { "codemirror_mode": { "name": "ipython", - "version": 2 + "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.6" + "pygments_lexer": "ipython3", + "version": "3.10.12" } }, "nbformat": 4, "nbformat_minor": 0 -} \ No newline at end of file +} diff --git a/docs/tutorials/interpolation_and_imputation.ipynb b/docs/tutorials/interpolation_and_imputation.ipynb index 9bdaf95..06e971e 100644 --- a/docs/tutorials/interpolation_and_imputation.ipynb +++ b/docs/tutorials/interpolation_and_imputation.ipynb @@ -7,37 +7,532 @@ "collapsed": true }, "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Data Interpolation and Imputation\n", + "\n", + "This tutorial demonstrates data-wrangler's capabilities for handling missing data through interpolation and imputation techniques. These are essential for cleaning real-world datasets.\n", + "\n", + "## Overview\n", + "\n", + "Data-wrangler provides several approaches for handling missing data:\n", + "\n", + "- **Interpolation**: Fill missing values using mathematical interpolation methods\n", + "- **Model-based imputation**: Use machine learning models to predict missing values \n", + "- **Statistical imputation**: Fill with statistical measures (mean, median, mode)\n", + "- **Custom imputation**: Define your own missing data handling strategies\n", + "\n", + "Let's explore these techniques with practical examples." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-03T20:51:29.958318Z", + "iopub.status.busy": "2026-07-03T20:51:29.958208Z", + "iopub.status.idle": "2026-07-03T20:51:30.528152Z", + "shell.execute_reply": "2026-07-03T20:51:30.527704Z" + } + }, + "outputs": [], + "source": [ + "import datawrangler as dw\n", + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from datawrangler.decorate import funnel, interpolate" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Interpolation with `@interpolate`\n", + "\n", + "The `@interpolate` decorator cleans missing values (`NaN`) out of the data *before* your function runs. You\n", + "control it at **call time** with the `interp_kwargs` keyword. Passing `interp_kwargs={'method': 'linear'}`\n", + "fills gaps by linear interpolation (any method supported by `pandas.DataFrame.interpolate` works)." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-03T20:51:30.530039Z", + "iopub.status.busy": "2026-07-03T20:51:30.529876Z", + "iopub.status.idle": "2026-07-03T20:51:30.538402Z", + "shell.execute_reply": "2026-07-03T20:51:30.537997Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Missing values before cleaning: 6\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
abc
00.0000001.0000000.176405
10.5195840.8544190.559600
20.8878850.4600650.985759
3NaN-0.0682421.221758
4NaN-0.5766801.003726
5NaN-0.9172110.300673
6-0.136167-0.990686-0.041158
7-0.631088-0.775711-0.646224
\n", + "
" + ], + "text/plain": [ + " a b c\n", + "0 0.000000 1.000000 0.176405\n", + "1 0.519584 0.854419 0.559600\n", + "2 0.887885 0.460065 0.985759\n", + "3 NaN -0.068242 1.221758\n", + "4 NaN -0.576680 1.003726\n", + "5 NaN -0.917211 0.300673\n", + "6 -0.136167 -0.990686 -0.041158\n", + "7 -0.631088 -0.775711 -0.646224" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Build a small signal and knock some values out\n", + "np.random.seed(0)\n", + "x = np.linspace(0, 4 * np.pi, 24)\n", + "signal = np.sin(x)\n", + "\n", + "data = pd.DataFrame({'a': signal, 'b': np.cos(x), 'c': signal + np.random.randn(24) * 0.1})\n", + "data.loc[[3, 4, 5], 'a'] = np.nan\n", + "data.loc[[10, 11], 'b'] = np.nan\n", + "data.loc[[17], 'c'] = np.nan\n", + "print(f'Missing values before cleaning: {int(data.isna().sum().sum())}')\n", + "data.head(8)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-03T20:51:30.557641Z", + "iopub.status.busy": "2026-07-03T20:51:30.557531Z", + "iopub.status.idle": "2026-07-03T20:51:30.613132Z", + "shell.execute_reply": "2026-07-03T20:51:30.612653Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Missing values after linear interpolation: 0\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
abc
00.0000001.0000000.176405
10.5195840.8544190.559600
20.8878850.4600650.985759
30.631872-0.0682421.221758
40.375859-0.5766801.003726
50.119846-0.9172110.300673
6-0.136167-0.990686-0.041158
7-0.631088-0.775711-0.646224
\n", + "
" + ], + "text/plain": [ + " a b c\n", + "0 0.000000 1.000000 0.176405\n", + "1 0.519584 0.854419 0.559600\n", + "2 0.887885 0.460065 0.985759\n", + "3 0.631872 -0.068242 1.221758\n", + "4 0.375859 -0.576680 1.003726\n", + "5 0.119846 -0.917211 0.300673\n", + "6 -0.136167 -0.990686 -0.041158\n", + "7 -0.631088 -0.775711 -0.646224" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "" + "from datawrangler.decorate import interpolate\n", + "\n", + "@interpolate\n", + "def clean(df):\n", + " \"\"\"Return the data unchanged; @interpolate fills the gaps before we ever see it.\"\"\"\n", + " return df\n", + "\n", + "# Linear interpolation\n", + "interpolated = clean(data, interp_kwargs={'method': 'linear'})\n", + "print(f'Missing values after linear interpolation: {int(interpolated.isna().sum().sum())}')\n", + "interpolated.head(8)" ] }, { "cell_type": "markdown", - "source": "# Data Interpolation and Imputation\n\nThis tutorial demonstrates data-wrangler's capabilities for handling missing data through interpolation and imputation techniques. These are essential for cleaning real-world datasets.\n\n## Overview\n\nData-wrangler provides several approaches for handling missing data:\n\n- **Interpolation**: Fill missing values using mathematical interpolation methods\n- **Model-based imputation**: Use machine learning models to predict missing values \n- **Statistical imputation**: Fill with statistical measures (mean, median, mode)\n- **Custom imputation**: Define your own missing data handling strategies\n\nLet's explore these techniques with practical examples.", - "metadata": {} + "metadata": {}, + "source": [ + "## Model-based imputation\n", + "\n", + "Instead of interpolating along each column, you can **impute** missing entries with a scikit-learn model that\n", + "learns from the relationships *between* columns. Pass an `impute_kwargs` dictionary (nested inside\n", + "`interp_kwargs`) naming the model, e.g. `IterativeImputer`, `KNNImputer`, or `SimpleImputer`." + ] }, { "cell_type": "code", - "source": "import datawrangler as dw\nimport pandas as pd\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom datawrangler.decorate import funnel, interpolate", + "execution_count": 4, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-03T20:51:30.614509Z", + "iopub.status.busy": "2026-07-03T20:51:30.614415Z", + "iopub.status.idle": "2026-07-03T20:51:32.159145Z", + "shell.execute_reply": "2026-07-03T20:51:32.158667Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Missing values after IterativeImputer: 0\n", + "Missing values after SimpleImputer: 0\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
abc
00.0000001.0000000.176405
10.5195840.8544190.559600
20.8878850.4600650.985759
31.102661-0.0682421.221758
40.899463-0.5766801.003726
50.243019-0.9172110.300673
6-0.136167-0.990686-0.041158
7-0.631088-0.775711-0.646224
\n", + "
" + ], + "text/plain": [ + " a b c\n", + "0 0.000000 1.000000 0.176405\n", + "1 0.519584 0.854419 0.559600\n", + "2 0.887885 0.460065 0.985759\n", + "3 1.102661 -0.068242 1.221758\n", + "4 0.899463 -0.576680 1.003726\n", + "5 0.243019 -0.917211 0.300673\n", + "6 -0.136167 -0.990686 -0.041158\n", + "7 -0.631088 -0.775711 -0.646224" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Iterative imputation: model each column from the others\n", + "iterative = clean(data, interp_kwargs={'impute_kwargs': {'model': 'IterativeImputer'}})\n", + "print(f'Missing values after IterativeImputer: {int(iterative.isna().sum().sum())}')\n", + "\n", + "# Simple imputation: fill each column with its mean (see config.ini for the default strategy)\n", + "simple = clean(data, interp_kwargs={'impute_kwargs': {'model': 'SimpleImputer'}})\n", + "print(f'Missing values after SimpleImputer: {int(simple.isna().sum().sum())}')\n", + "iterative.head(8)" + ] + }, + { + "cell_type": "markdown", "metadata": {}, - "outputs": [], - "execution_count": null + "source": [ + "## Comparing the approaches\n", + "\n", + "Interpolation uses each column's own trend, while imputation models relationships across columns. Plotting\n", + "the filled values for column `a` shows how the strategies differ where the data were missing (rows 3-5)." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-03T20:51:32.160761Z", + "iopub.status.busy": "2026-07-03T20:51:32.160620Z", + "iopub.status.idle": "2026-07-03T20:51:32.293931Z", + "shell.execute_reply": "2026-07-03T20:51:32.293484Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Values filled in for the missing rows of column \"a\":\n", + " linear interpolation IterativeImputer SimpleImputer\n", + "3 0.631872 1.102661 -0.105383\n", + "4 0.375859 0.899463 -0.105383\n", + "5 0.119846 0.243019 -0.105383\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "missing_rows = [3, 4, 5]\n", + "comparison = pd.DataFrame({\n", + " 'linear interpolation': interpolated['a'],\n", + " 'IterativeImputer': iterative['a'],\n", + " 'SimpleImputer': simple['a'],\n", + "})\n", + "print('Values filled in for the missing rows of column \"a\":')\n", + "print(comparison.loc[missing_rows])\n", + "\n", + "ax = comparison.plot(marker='o', figsize=(9, 4), title='Filled values for column \"a\"')\n", + "ax.axvspan(missing_rows[0], missing_rows[-1], alpha=0.15, color='gray')\n", + "ax.set_xlabel('row')\n", + "ax.set_ylabel('value')\n", + "plt.tight_layout()\n", + "plt.show()" + ] } ], "metadata": { "language_info": { "codemirror_mode": { "name": "ipython", - "version": 2 + "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.6" + "pygments_lexer": "ipython3", + "version": "3.10.12" } }, "nbformat": 4, "nbformat_minor": 0 -} \ No newline at end of file +} diff --git a/docs/tutorials/io.ipynb b/docs/tutorials/io.ipynb index 03bae7d..9f2d22e 100644 --- a/docs/tutorials/io.ipynb +++ b/docs/tutorials/io.ipynb @@ -7,49 +7,432 @@ "collapsed": true }, "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, "source": [ - "" + "# Data Wrangler I/O Operations\n", + "\n", + "This tutorial covers the I/O capabilities of data-wrangler, including loading and saving data from various sources and formats.\n", + "\n", + "## Overview\n", + "\n", + "The `datawrangler.io` module provides seamless loading and saving of data from:\n", + "\n", + "- **Local files**: CSV, JSON, text files, images, and more\n", + "- **URLs**: Load data directly from web sources\n", + "- **Multiple formats**: Automatic format detection based on file extensions\n", + "- **Mixed sources**: Handle lists of files/URLs with different formats\n", + "\n", + "Let's explore these capabilities with practical examples." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-03T20:51:34.052475Z", + "iopub.status.busy": "2026-07-03T20:51:34.052371Z", + "iopub.status.idle": "2026-07-03T20:51:34.362581Z", + "shell.execute_reply": "2026-07-03T20:51:34.362010Z" + } + }, + "outputs": [], + "source": [ + "import datawrangler as dw\n", + "from datawrangler.io import load, save\n", + "import pandas as pd\n", + "import numpy as np\n", + "import os\n", + "from pathlib import Path" ] }, { "cell_type": "markdown", - "source": "# Data Wrangler I/O Operations\n\nThis tutorial covers the I/O capabilities of data-wrangler, including loading and saving data from various sources and formats.\n\n## Overview\n\nThe `datawrangler.io` module provides seamless loading and saving of data from:\n\n- **Local files**: CSV, JSON, text files, images, and more\n- **URLs**: Load data directly from web sources\n- **Multiple formats**: Automatic format detection based on file extensions\n- **Mixed sources**: Handle lists of files/URLs with different formats\n\nLet's explore these capabilities with practical examples.", - "metadata": {} + "metadata": {}, + "source": [ + "## Loading Different File Formats\n", + "\n", + "Data-wrangler automatically detects file formats and loads them appropriately. Let's demonstrate with different file types:" + ] }, { "cell_type": "code", - "source": "import datawrangler as dw\nfrom datawrangler.io import load, save\nimport pandas as pd\nimport numpy as np\nimport os\nfrom pathlib import Path", + "execution_count": 2, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-03T20:51:34.364425Z", + "iopub.status.busy": "2026-07-03T20:51:34.364256Z", + "iopub.status.idle": "2026-07-03T20:51:34.371007Z", + "shell.execute_reply": "2026-07-03T20:51:34.370589Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Working in temporary directory: /var/folders/tp/qtzc39jx5w556wl5w3dj21wr0000gn/T/tmplgesr916\n", + "Created files:\n", + "- CSV: /var/folders/tp/qtzc39jx5w556wl5w3dj21wr0000gn/T/tmplgesr916/products.csv\n", + "- Text: /var/folders/tp/qtzc39jx5w556wl5w3dj21wr0000gn/T/tmplgesr916/sample_text.txt\n", + "- JSON: /var/folders/tp/qtzc39jx5w556wl5w3dj21wr0000gn/T/tmplgesr916/users.json\n" + ] + } + ], + "source": [ + "# Create sample data files for demonstration\n", + "import tempfile\n", + "\n", + "# Create a temporary directory for our examples\n", + "temp_dir = tempfile.mkdtemp()\n", + "print(f\"Working in temporary directory: {temp_dir}\")\n", + "\n", + "# Create sample CSV file\n", + "csv_data = pd.DataFrame({\n", + " 'product': ['laptop', 'mouse', 'keyboard', 'monitor'],\n", + " 'price': [999.99, 25.50, 75.00, 300.00],\n", + " 'category': ['electronics', 'accessories', 'accessories', 'electronics']\n", + "})\n", + "\n", + "csv_file = os.path.join(temp_dir, 'products.csv')\n", + "csv_data.to_csv(csv_file, index=False)\n", + "\n", + "# Create sample text file\n", + "text_content = \"\"\"Data science is transforming industries worldwide.\n", + "Machine learning enables computers to learn from data.\n", + "Natural language processing helps computers understand human language.\n", + "Data visualization makes complex data insights accessible.\"\"\"\n", + "\n", + "text_file = os.path.join(temp_dir, 'sample_text.txt')\n", + "with open(text_file, 'w') as f:\n", + " f.write(text_content)\n", + "\n", + "# Create sample JSON file\n", + "json_data = {\n", + " 'users': [\n", + " {'name': 'Alice', 'age': 30, 'city': 'New York'},\n", + " {'name': 'Bob', 'age': 25, 'city': 'San Francisco'},\n", + " {'name': 'Charlie', 'age': 35, 'city': 'Chicago'}\n", + " ]\n", + "}\n", + "\n", + "json_file = os.path.join(temp_dir, 'users.json')\n", + "import json\n", + "with open(json_file, 'w') as f:\n", + " json.dump(json_data, f)\n", + "\n", + "print(f\"Created files:\")\n", + "print(f\"- CSV: {csv_file}\")\n", + "print(f\"- Text: {text_file}\")\n", + "print(f\"- JSON: {json_file}\")" + ] + }, + { + "cell_type": "markdown", "metadata": {}, - "outputs": [], - "execution_count": null + "source": [ + "## Loading local files\n", + "\n", + "With the files created above, `load` detects each format from its extension and returns the natural Python\n", + "object: CSV becomes a DataFrame, `.txt` becomes a string, and JSON becomes a DataFrame." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-03T20:51:34.390288Z", + "iopub.status.busy": "2026-07-03T20:51:34.390163Z", + "iopub.status.idle": "2026-07-03T20:51:34.398767Z", + "shell.execute_reply": "2026-07-03T20:51:34.398351Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CSV -> DataFrame of shape (4, 3)\n", + "Text -> str (235 characters)\n", + "JSON -> DataFrame of shape (3, 1)\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
productpricecategory
0laptop999.99electronics
1mouse25.50accessories
2keyboard75.00accessories
3monitor300.00electronics
\n", + "
" + ], + "text/plain": [ + " product price category\n", + "0 laptop 999.99 electronics\n", + "1 mouse 25.50 accessories\n", + "2 keyboard 75.00 accessories\n", + "3 monitor 300.00 electronics" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "loaded_csv = load(csv_file) # -> pandas DataFrame\n", + "loaded_text = load(text_file) # -> str\n", + "loaded_json = load(json_file) # -> pandas DataFrame\n", + "\n", + "print(f'CSV -> {type(loaded_csv).__name__} of shape {loaded_csv.shape}')\n", + "print(f'Text -> {type(loaded_text).__name__} ({len(loaded_text)} characters)')\n", + "print(f'JSON -> {type(loaded_json).__name__} of shape {loaded_json.shape}')\n", + "loaded_csv" + ] }, { "cell_type": "markdown", - "source": "## Loading Different File Formats\n\nData-wrangler automatically detects file formats and loads them appropriately. Let's demonstrate with different file types:", - "metadata": {} + "metadata": {}, + "source": [ + "## Loading remote files\n", + "\n", + "`load` accepts URLs as well as local paths. Remote files are downloaded on first use and **cached** to disk,\n", + "so loading the same URL again is fast and works offline." + ] }, { "cell_type": "code", - "source": "# Create sample data files for demonstration\nimport tempfile\n\n# Create a temporary directory for our examples\ntemp_dir = tempfile.mkdtemp()\nprint(f\\\"Working in temporary directory: {temp_dir}\\\"\n\n# Create sample CSV file\ncsv_data = pd.DataFrame({\n 'product': ['laptop', 'mouse', 'keyboard', 'monitor'],\n 'price': [999.99, 25.50, 75.00, 300.00],\n 'category': ['electronics', 'accessories', 'accessories', 'electronics']\n})\n\ncsv_file = os.path.join(temp_dir, 'products.csv')\ncsv_data.to_csv(csv_file, index=False)\n\n# Create sample text file\ntext_content = \\\"\\\"\\\"Data science is transforming industries worldwide.\nMachine learning enables computers to learn from data.\nNatural language processing helps computers understand human language.\nData visualization makes complex data insights accessible.\\\"\\\"\\\"\n\ntext_file = os.path.join(temp_dir, 'sample_text.txt')\nwith open(text_file, 'w') as f:\n f.write(text_content)\n\n# Create sample JSON file\njson_data = {\n 'users': [\n {'name': 'Alice', 'age': 30, 'city': 'New York'},\n {'name': 'Bob', 'age': 25, 'city': 'San Francisco'},\n {'name': 'Charlie', 'age': 35, 'city': 'Chicago'}\n ]\n}\n\njson_file = os.path.join(temp_dir, 'users.json')\nimport json\nwith open(json_file, 'w') as f:\n json.dump(json_data, f)\n\nprint(f\\\"Created files:\\\"\nprint(f\\\"- CSV: {csv_file}\\\"\nprint(f\\\"- Text: {text_file}\\\"\nprint(f\\\"- JSON: {json_file}\\\")", + "execution_count": 4, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-03T20:51:34.399935Z", + "iopub.status.busy": "2026-07-03T20:51:34.399847Z", + "iopub.status.idle": "2026-07-03T20:51:34.404489Z", + "shell.execute_reply": "2026-07-03T20:51:34.404094Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loaded a DataFrame of shape (7, 5) from the web\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
FirstDimSecondDimThirdDimFourthDimFifthDim
ByTwos
012345
2246810
43691215
548121620
6510152025
\n", + "
" + ], + "text/plain": [ + " FirstDim SecondDim ThirdDim FourthDim FifthDim\n", + "ByTwos \n", + "0 1 2 3 4 5\n", + "2 2 4 6 8 10\n", + "4 3 6 9 12 15\n", + "5 4 8 12 16 20\n", + "6 5 10 15 20 25" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "url = 'https://raw.githubusercontent.com/ContextLab/data-wrangler/main/tests/resources/testdata.csv'\n", + "remote_df = load(url, index_col=0)\n", + "print(f'Loaded a {type(remote_df).__name__} of shape {remote_df.shape} from the web')\n", + "remote_df.head()" + ] + }, + { + "cell_type": "markdown", "metadata": {}, - "outputs": [], - "execution_count": null + "source": [ + "## Saving data\n", + "\n", + "`save(key, obj)` writes data to disk. Strings are written as text and bytes are written directly; NumPy\n", + "arrays use `dtype='numpy'` and arbitrary Python objects use `dtype='pickle'`. `save` stores the data at a\n", + "cache location derived from the `key`; `get_local_fname` tells you where that is so you can read it back." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-03T20:51:34.405603Z", + "iopub.status.busy": "2026-07-03T20:51:34.405509Z", + "iopub.status.idle": "2026-07-03T20:51:34.409389Z", + "shell.execute_reply": "2026-07-03T20:51:34.408980Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Reloaded text: data-wrangler makes preprocessing easy.\n", + "Reloaded array of shape (3, 4)\n" + ] + } + ], + "source": [ + "from datawrangler.io.io import get_local_fname\n", + "\n", + "# Save a text note\n", + "save('analysis_notes.txt', 'data-wrangler makes preprocessing easy.')\n", + "print('Reloaded text:', load(get_local_fname('analysis_notes.txt')))\n", + "\n", + "# Save a NumPy array\n", + "save('demo_array.npz', np.arange(12).reshape(3, 4), dtype='numpy')\n", + "restored = load(get_local_fname('demo_array.npz'))['arr_0']\n", + "print(f'Reloaded array of shape {restored.shape}')" + ] } ], "metadata": { "language_info": { "codemirror_mode": { "name": "ipython", - "version": 2 + "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.6" + "pygments_lexer": "ipython3", + "version": "3.10.12" } }, "nbformat": 4, "nbformat_minor": 0 -} \ No newline at end of file +} diff --git a/docs/tutorials/util.ipynb b/docs/tutorials/util.ipynb index c77f0a5..3607f64 100644 --- a/docs/tutorials/util.ipynb +++ b/docs/tutorials/util.ipynb @@ -7,49 +7,287 @@ "collapsed": true }, "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, "source": [ - "" + "# Data Wrangler Utilities\n", + "\n", + "This tutorial covers the utility functions in `datawrangler.util` that help with data type detection, validation, and manipulation. These utilities are the building blocks that power data-wrangler's automatic data type detection.\n", + "\n", + "## Overview\n", + "\n", + "The `datawrangler.util` module provides essential helper functions:\n", + "\n", + "- **`dataframe_like()`**: Check if an object behaves like a DataFrame\n", + "- **`array_like()`**: Detect array-like objects\n", + "- **`depth()`**: Determine nesting depth of data structures\n", + "- **`btwn()`**: Check if values fall within a range\n", + "\n", + "These utilities are particularly useful when building custom data processing pipelines or extending data-wrangler's functionality." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-03T20:51:35.896840Z", + "iopub.status.busy": "2026-07-03T20:51:35.896749Z", + "iopub.status.idle": "2026-07-03T20:51:36.246303Z", + "shell.execute_reply": "2026-07-03T20:51:36.245365Z" + } + }, + "outputs": [], + "source": [ + "import datawrangler as dw\n", + "from datawrangler.util import dataframe_like, array_like, depth, btwn\n", + "import pandas as pd\n", + "import numpy as np\n", + "import os\n" ] }, { "cell_type": "markdown", - "source": "# Data Wrangler Utilities\n\nThis tutorial covers the utility functions in `datawrangler.util` that help with data type detection, validation, and manipulation. These utilities are the building blocks that power data-wrangler's automatic data type detection.\n\n## Overview\n\nThe `datawrangler.util` module provides essential helper functions:\n\n- **`dataframe_like()`**: Check if an object behaves like a DataFrame\n- **`array_like()`**: Detect array-like objects\n- **`depth()`**: Determine nesting depth of data structures\n- **`btwn()`**: Check if values fall within a range\n\nThese utilities are particularly useful when building custom data processing pipelines or extending data-wrangler's functionality.", - "metadata": {} + "metadata": {}, + "source": [ + "## Data Type Detection\n", + "\n", + "Understanding how data-wrangler detects different data types is crucial for building robust data processing pipelines. Let's explore the detection utilities:" + ] }, { "cell_type": "code", - "source": "import datawrangler as dw\nfrom datawrangler.util import dataframe_like, array_like, depth, btwn\nimport pandas as pd\nimport numpy as np", - "metadata": {}, - "outputs": [], - "execution_count": null + "execution_count": 2, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-03T20:51:36.248799Z", + "iopub.status.busy": "2026-07-03T20:51:36.248520Z", + "iopub.status.idle": "2026-07-03T20:51:36.253594Z", + "shell.execute_reply": "2026-07-03T20:51:36.252984Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== Data Type Detection Results ===\n", + "Object Type DataFrame-like Array-like Depth \n", + "------------------------------------------------------------\n", + "pandas DataFrame True True 1 \n", + "Dictionary False False 0 \n", + "NumPy Array False True 2 \n", + "Nested List False True 2 \n", + "Simple List False True 1 \n", + "String False False 0 \n", + "Number False True 0 \n" + ] + } + ], + "source": [ + "# Test different data types with detection utilities\n", + "test_objects = [\n", + " pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]}), # True DataFrame\n", + " {'A': [1, 2, 3], 'B': [4, 5, 6]}, # Dict (not DataFrame-like)\n", + " np.array([[1, 2, 3], [4, 5, 6]]), # NumPy array\n", + " [[1, 2, 3], [4, 5, 6]], # Nested list\n", + " [1, 2, 3, 4, 5], # Simple list\n", + " \"Hello World\", # String\n", + " 42 # Number\n", + "]\n", + "\n", + "object_names = [\n", + " \"pandas DataFrame\",\n", + " \"Dictionary\", \n", + " \"NumPy Array\",\n", + " \"Nested List\",\n", + " \"Simple List\",\n", + " \"String\",\n", + " \"Number\"\n", + "]\n", + "\n", + "print(\"=== Data Type Detection Results ===\")\n", + "print(f\"{'Object Type':<20} {'DataFrame-like':<15} {'Array-like':<12} {'Depth':<8}\")\n", + "print(\"-\" * 60)\n", + "\n", + "for obj, name in zip(test_objects, object_names):\n", + " is_df_like = dataframe_like(obj)\n", + " is_array_like = array_like(obj)\n", + " obj_depth = depth(obj)\n", + " \n", + " print(f\"{name:<20} {str(is_df_like):<15} {str(is_array_like):<12} {obj_depth:<8}\")" + ] }, { "cell_type": "markdown", - "source": "## Data Type Detection\n\nUnderstanding how data-wrangler detects different data types is crucial for building robust data processing pipelines. Let's explore the detection utilities:", - "metadata": {} + "metadata": {}, + "source": [ + "## Range checking with `btwn`\n", + "\n", + "`btwn(x, a, b)` tests whether values fall within the inclusive range `[a, b]`. For an array it returns a\n", + "single boolean that is `True` only when *every* element is in range -- handy for validating that data lie in\n", + "an expected interval." + ] }, { "cell_type": "code", - "source": "# Test different data types with detection utilities\ntest_objects = [\n pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]}), # True DataFrame\n {'A': [1, 2, 3], 'B': [4, 5, 6]}, # Dict (not DataFrame-like)\n np.array([[1, 2, 3], [4, 5, 6]]), # NumPy array\n [[1, 2, 3], [4, 5, 6]], # Nested list\n [1, 2, 3, 4, 5], # Simple list\n \\\"Hello World\\\", # String\n 42 # Number\n]\n\nobject_names = [\n \\\"pandas DataFrame\\\",\n \\\"Dictionary\\\", \n \\\"NumPy Array\\\",\n \\\"Nested List\\\",\n \\\"Simple List\\\",\n \\\"String\\\",\n \\\"Number\\\"\n]\n\nprint(\\\"=== Data Type Detection Results ===\\\")\nprint(f\\\"{'Object Type':<20} {'DataFrame-like':<15} {'Array-like':<12} {'Depth':<8}\\\")\nprint(\\\"-\\\" * 60)\n\nfor obj, name in zip(test_objects, object_names):\n is_df_like = dataframe_like(obj)\n is_array_like = array_like(obj)\n obj_depth = depth(obj)\n \n print(f\\\"{name:<20} {str(is_df_like):<15} {str(is_array_like):<12} {obj_depth:<8}\\\")", + "execution_count": 3, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-03T20:51:36.274299Z", + "iopub.status.busy": "2026-07-03T20:51:36.274156Z", + "iopub.status.idle": "2026-07-03T20:51:36.277282Z", + "shell.execute_reply": "2026-07-03T20:51:36.276867Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "All of [0.2 0.5 0.9] in [0, 1]? True\n", + "All of [0.2 0.5 0.9] in [0, 0.6]? False\n", + "Scalar 5 in [1, 10]? True\n", + "Element-wise in [0, 0.6]: [np.True_, np.True_, np.False_]\n" + ] + } + ], + "source": [ + "values = np.array([0.2, 0.5, 0.9])\n", + "print(f'All of {values} in [0, 1]? {btwn(values, 0, 1)}')\n", + "print(f'All of {values} in [0, 0.6]? {btwn(values, 0, 0.6)}')\n", + "print(f'Scalar 5 in [1, 10]? {btwn(5, 1, 10)}')\n", + "\n", + "# Element-wise membership is easy to build on top of the same idea\n", + "elementwise = [btwn(v, 0, 0.6) for v in values]\n", + "print(f'Element-wise in [0, 0.6]: {elementwise}')" + ] + }, + { + "cell_type": "markdown", "metadata": {}, - "outputs": [], - "execution_count": null + "source": [ + "## Reading tabular files with `load_dataframe`\n", + "\n", + "`load_dataframe` powers data-wrangler's file loading: it inspects a file's extension and dispatches to the\n", + "matching pandas reader, so the *same* call handles CSV, JSON, Excel, Parquet, and more with no extra\n", + "configuration." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-03T20:51:36.278854Z", + "iopub.status.busy": "2026-07-03T20:51:36.278747Z", + "iopub.status.idle": "2026-07-03T20:51:36.289753Z", + "shell.execute_reply": "2026-07-03T20:51:36.289241Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "From CSV : DataFrame of shape (3, 2)\n", + "From JSON: DataFrame of shape (3, 2)\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
citypopulation_m
0NYC8.5
1SF0.9
2Chicago2.7
\n", + "
" + ], + "text/plain": [ + " city population_m\n", + "0 NYC 8.5\n", + "1 SF 0.9\n", + "2 Chicago 2.7" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import tempfile\n", + "from datawrangler.io import load_dataframe\n", + "\n", + "sample = pd.DataFrame({'city': ['NYC', 'SF', 'Chicago'], 'population_m': [8.5, 0.9, 2.7]})\n", + "tmp = tempfile.mkdtemp()\n", + "\n", + "csv_path = os.path.join(tmp, 'cities.csv')\n", + "json_path = os.path.join(tmp, 'cities.json')\n", + "sample.to_csv(csv_path, index=False)\n", + "sample.to_json(json_path)\n", + "\n", + "from_csv = load_dataframe(csv_path) # extension '.csv' -> pandas.read_csv\n", + "from_json = load_dataframe(json_path) # extension '.json' -> pandas.read_json\n", + "print(f'From CSV : {type(from_csv).__name__} of shape {from_csv.shape}')\n", + "print(f'From JSON: {type(from_json).__name__} of shape {from_json.shape}')\n", + "from_csv" + ] } ], "metadata": { "language_info": { "codemirror_mode": { "name": "ipython", - "version": 2 + "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.6" + "pygments_lexer": "ipython3", + "version": "3.10.12" } }, "nbformat": 4, "nbformat_minor": 0 -} \ No newline at end of file +} diff --git a/docs/tutorials/wrangling_basics.ipynb b/docs/tutorials/wrangling_basics.ipynb index 1f4f5fc..2b7177e 100644 --- a/docs/tutorials/wrangling_basics.ipynb +++ b/docs/tutorials/wrangling_basics.ipynb @@ -14,6 +14,12 @@ "execution_count": 1, "metadata": { "collapsed": false, + "execution": { + "iopub.execute_input": "2026-07-03T20:51:40.052575Z", + "iopub.status.busy": "2026-07-03T20:51:40.052479Z", + "iopub.status.idle": "2026-07-03T20:51:40.594560Z", + "shell.execute_reply": "2026-07-03T20:51:40.593998Z" + }, "pycharm": { "name": "#%%\n" } @@ -45,6 +51,12 @@ "execution_count": 2, "metadata": { "collapsed": false, + "execution": { + "iopub.execute_input": "2026-07-03T20:51:40.596562Z", + "iopub.status.busy": "2026-07-03T20:51:40.596356Z", + "iopub.status.idle": "2026-07-03T20:51:40.611328Z", + "shell.execute_reply": "2026-07-03T20:51:40.610930Z" + }, "pycharm": { "name": "#%%\n" } @@ -74,6 +86,12 @@ "execution_count": 3, "metadata": { "collapsed": false, + "execution": { + "iopub.execute_input": "2026-07-03T20:51:40.612561Z", + "iopub.status.busy": "2026-07-03T20:51:40.612476Z", + "iopub.status.idle": "2026-07-03T20:51:40.617824Z", + "shell.execute_reply": "2026-07-03T20:51:40.617278Z" + }, "pycharm": { "name": "#%%\n" } @@ -214,6 +232,12 @@ "execution_count": 4, "metadata": { "collapsed": false, + "execution": { + "iopub.execute_input": "2026-07-03T20:51:40.636456Z", + "iopub.status.busy": "2026-07-03T20:51:40.636350Z", + "iopub.status.idle": "2026-07-03T20:51:40.638818Z", + "shell.execute_reply": "2026-07-03T20:51:40.638334Z" + }, "pycharm": { "name": "#%%\n" } @@ -257,6 +281,12 @@ "execution_count": 5, "metadata": { "collapsed": false, + "execution": { + "iopub.execute_input": "2026-07-03T20:51:40.639945Z", + "iopub.status.busy": "2026-07-03T20:51:40.639839Z", + "iopub.status.idle": "2026-07-03T20:51:40.812825Z", + "shell.execute_reply": "2026-07-03T20:51:40.812303Z" + }, "pycharm": { "name": "#%%\n" } @@ -265,7 +295,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 5, @@ -274,14 +304,12 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAVgAAAD8CAYAAAAylrwMAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOz9W6wtSZrfh/2+iMhca59z6tS9unt6mnMhhyORHJKiKFIETUMwLciSDdMPNiHbsEmZwLxIggwYsGg/+0F+scwnAQPJhmQIoATZAAWBvsiUCMiQRImc0ZDiXJrDmb5U171Onevea2VGxOeH74vMXLlzrX26m9M+Y1QUTu2918qMjIiM+L7/dxdV5cv2Zfuyfdm+bP/gW/j/9QC+bF+2L9uX7f9f25cE9sv2Zfuyfdl+m9qXBPbL9mX7sn3ZfpvalwT2y/Zl+7J92X6b2pcE9sv2Zfuyfdl+m9qXBPbL9mX7sn3Zfpvaj5zAish/R0R+XUR+Q0T+4o/6+V+2L9uX7cv2o2ryo/SDFZEIfBP4J4H3gf8S+B+r6q/8yAbxZfuyfdm+bD+i9qNGsH8M+A1V/U1VHYC/DPyZH/EYvmxfti/bl+1H0tKP+HlfB767+Pt94I8vLxCRnwd+HuDevXv/6O/+PT9z0kHD27L4/a4mq3t/0PYPqp+TTuT0Y9FF/7Jxseric9kYzOKDzUX6/mfxg8z7+3k/5+4QZPHJ+rvzY/r+n/1l+7Ktm+0w8SM3fSrbV/+dv/3Ln6nqu+vPf9QE9s6mqr8A/ALAz/2hP6x/5f/+/0ZEuKTKuKjmULX7ARCjTwKC2sJtLdhqRVXVF9aObvtavAOV5fOXR1+n31DQ1ofq6rGCYoTztkghZ+eo0/9OL/dRIu3eWqedIdLIz2IE04RmAv4ymqM1kROgolRVavV31rqU00dNfSx2rLR/IsZppvErquor2mbXOpN52DKv03x9e98yE17/rqpOvy+botQ6v72T7cDp53ryTV2tir8BYX4XKKqLBZa5/yAyvYOqFa06za3N2y4RZz6LgSmUqtT2x8b725rP6dtb7W8ffBCIIkiw3VlrpdR6sv9O9rMIITDN/fRRMv+q6uvBrY3R9g7M7669a1ms2Xw25xUXEUIIhCCr++f9IWHeEUEgxkjfdXQxEASE4Ot8u8lEE+Zvf+rH3/v2xqU/cgL7PeAbi79/3D+70GRxaJgIiL8VigqH4cj1wf4djgO1VFQE1DZCVaX4Ia1aybnY5qVSFi/WCIO99BgiUaAolFIIwV4a2AartaLVvitaKEVRqr0UMUJea6FWOxrtuaWU6eCr1sX+FroU6WMgSEBRSlGKFh+3zTv4Sy212Dz8RctMSabNIxhxLbUQUGKKpNgRQqACuRRKyYgforYhbX6AP1t9rdXptIRACMEOnBOp4L8fhxtevDhwGAZyKVStMzFQJ0rOYGytbLxBrM8gkGKgiwkRGIsyjiO1FKofxupz0qoECRPTCM44x6JOAOw/EaELgRgDtdpcqiqlVEopfq+9sxjE3lUpto90ItP+XoyIioivUzHiHoRAQH0tVOu0r/oUJjReq5KrrWsMgmq1PaeQUvLP1PaXGhFLIdh4qiJB6LsICKUoEvyMVLXr295U2wtB2pobYWrv146QzS2GaPc2JuX7MaCEGCmlkmKkTxHF9ryIkKtSa4Gq09lo2znF6AxjZkSNAMbgTL+tiSq1FEQCQcTn2Wiur2dVYozt5PjYZ0BQ/SG2L8UYgkAI0T4TP29NKlJAlC5GupTY7fbcf/0t3nrna3ztK1/jx77yNR7cv0c3zSOcwWKnhHbdftQE9r8EfkZEfgojrP8s8D+5fEvj1I3I2qbMeeDRk8d8+t1v8r3v/AZfPHrEs+trroeMAFGUKEIFRj8o7XArFSp0KUyEq6DknKkFuhTpon1+zHYQQhRiDAjBiKQaRmybtPoGt81qI5bFYYkhUrVtfmXXJdtIjkhqraQY6KOQa3VdQQLnorkWglb6FMi1UjXy4jDQpWQHp20ulJQErULR4tw8cr+LqGauDwe6vieGSNHAUIzpRJQuBaJDtAKkFNFaCWIEqJTCvT5y1SduhsxYhdI2fq10caDojuO1Iii93xNTIpdsBDQGarED3hiJ1kKIgRg7Y3wBQizEEBCN6FDtEFU7hKogMVBrNYKaR0K0Q5QksqvOBGKcGBqDPV/9uVXtPYzjSIyRGNOMDAVqqFSUrutQ6nTAG3FPsUNrmZgAWuli8PdthKmqEmIiSEVUybkg0dZMRCg5E5JQayGlHtWREAwpVhVUGyEO9r6qMdY+GXGpaoRKJExIvVYlhOj70QgIWqlaJgJaio1rzJkUhBSFIRsxSjGSS0FrJQYoNaMSCAGCjsQU/NkGAHCkF1OaGO04jkbYa3bpMUxnwhi50cVSZskqhGiQQOyaGCK5CEqhT5ExF47Dkd2uI6CMYyFGI561FgDGcQQRYowGLhRUbA37FMh5JCY7d7XWSbKpo5DzNc+uH/Pi02/x3V+LvPPee/zcz/1JvvJjv4urvkekGJGVJeC7TFzhR0xgVTWLyL8A/D+BCPyfVPXv3nGPoVAq1y+e89lnn/Lo0+/y2Ye/RXn+GVoKz0c4Zjts+yR0URCqbVIJpCgEreQ8TmipFDuEu12HiDAMR0qMoIGQAikG28w76GNAEVKMKMJwVGIMGGEtaBFCUHJWUhfIORNiAoSuS5RckCBAYMx5QqEhCDlnUkooMI6ZkBJ7gb7ryGNFycSYOOZCSokkGLcPkf2+R1BElaEYUowxTqhB6KhV2V/t0arkEun2kZytzxiEfXTiHoRiVJqaM1oKSkKlksto8w2J6yI8ez4aqo+RKIEhC1oDqXQcxwMiQooJcRgSKfS9ETBCoIgh+v2uQ1U5Hkyd0QVBg1Bq4VgCdajs+0BMOPotdMkIDdjZjCi7PnEcR2JMpKAcciGGRJ96sqMdo4GFGAOBCmrEsdt1LhkZYxpLJYoh6UKhk2gETzK1DiQxVUDJR0O7pRA0IKKIQgyBXDNSK32MCKMx8KomRYRAFEPbgxpTDyHQBSOOXTIGcswDKTCh4VqccKqpL2oZjXATiMFRqSqUihYAdQZZ7PyUzIN9T86ZXZ8YSyGjRAl0DgxzHkAiu65nGDK1GMqXaOMoqoRq5yiESAQnVgol03Ud4/EAqvR9xyFnqooBgCZuVyVIhJCouVLySEwRUUPmOWdyrmhKlOLPLSM1jwQKFMjVAMXxMKJA3yWTfIKh04BSSqbve47DiFalEmy844hSqcX2SMXeWRBBQiUANSc++d53+cXr/xc/94f/BF/7Xb+Xe/srYjR434hqUz1eIrE/ch2sqv5V4K++3MWQS+b65gXf+63/mm//+i/zxaNPGWpFxdBJlzpKzmjJRGkcuppKoJponWJkLCOjE7p93xOkgFbysdD0n7Vm0ICOgpZAdf1OrplalWNVlODIU1AqIQRSjKb/UiUXGxt2JeOxoATKWB3xVmKQSZVALYja9X0XQZVSCsdaqVrpuh1jsTnFoAyqaFFUR6pWUhKqinNyJpG9Hf4udYbSQqCLARxhI8YwjuNgKFQCqUuMYwGFGIVxOGCagkxXDQ0XFUNNRGJUSjmiuBjlojaq5HGkT0oQJQUl57HpdgzJKtScDYVEU1GU8QgiM7IKgXE8knMlRSEBeRgpCBITEetftDoRKtwMBYJQcuGmDEiIpBChjAgBagFHtjEElNHXI5Cr6Q5j6ChaoGZyNtGdakxHYufosxCQSawt40joE6gjv1IoOquMqroaomYAQgwElBQjhEDOhVorw3AkxuTibIDgOuhaCTGxSzb2WjMSbb/UklE1dC8oxZF+GTMpulQC5ApFhXw0whQVaqkcq0zqsTEXqo6mDkLZdY4QixpBrEJVU3XVYkiwSx0SoJSBUpQUAhWl7zrbT1hfplISQ8hZXYSHmkdS35HHDKiDG1PfdDGhpQLG+EquSLAzDZVScVWfEESIITLmgZQStTa1WiVgjLuqUEo1ScHVjUMudCkQamVUBUaCCF989hG/8ot/nadPv+AbP/1zvPHGG3QpEZuKSE11sKHuntorZ+Q6bUoZjzz54O/x3V/5T/ns6UimgwA31y8IVKSMgJJrNV1nhVxcTMaIrEQxbq7V0KKLFDFGhmEw4qRKjB2IUHOm1kx1ParGyfxietYAUOlCsN+1MgzDJLIchxGN4oS3+FQM9YaQEDdFNB3qMA6mJ+w61NUNpWZSigzHA6UaGil+Xa2GWCTA8ZjZdYZGQyccjoPpzFIiiHA83NiGFXyeQpDIOI6Mw0BMkSgRiYlaMHEzQCmQ+o5xPJquUYTqm1xdTzfkjKCEYAT75mAIKAah7wIoLoqLi9eGGlMQ169VxjHTx0iplcM4ECSSEohWR8nJ9Zp2f4xCksBYC4fjkV1nCDOIIayq0AUjfKURNTVCnnPFXLEDfSeuiwyUkql1NESOEXwaYSyFUY2Qd84MyJWrPpmYnE2Pvd/35FInFYb9LqRoEo2IoCKklCjFdNydi765VPI4mg42RVMz1UDOtjdjjPR9QhWGYXAdtqklBNNZopUQBa2FFE2fn7Otb7MftHGYFNf07cbwSi6k1E3orKlGaqmT7jgEUxtFIsdhYL/rKLUyDpmUeutPK2OuHIdC1yfUx9Z1O47HERElRpnsHEGgihgwwYyAKQg5m/pgGE1tkksFJ44ShBhs35Va2KVEzpUqgc5Vg3kc6VKi66IZUoClidJUBPaetSq1ZkKKaDkV/z/94guuf/Vv8vlnH/MP/4F/lK997ScI3W5htH21dLDfd8t54Hvf/iYfPsmG4qKSx4EUCtUXtRnG7eC7MavYxIPrTCImCpScXRflhzwkYuqQOpBcx9aMvCkmNMTJOCAGcyeOlbMr5n0DxxgpOZteNMiEFE03hROI3glPsZfrFkzT0ZueDlVD446GmpU1BiGaSZdhKGT/XKuhZHVj1W7fcxwLx1LogtiGdl2xBIGKMxrTDWodOB4zXdoZISqKxI7U7Sh5hOi6YHXOHyIlV0qpdMn0feNoaNkOQ/H1GSd9YAyFzvV7xd+Num68UBiziZiCkCKTDrFWNTTiG7kZhQToOtu+Vf1Aoux3yRlJMD1dkxaCIFIZSyZoIAV7l7gudKzKTgJZj9Q80vU9El10nIwpM9LsOiEPhkZ3u7Zu2XSYbY+B743OEHOMDKOphGzv2ByjgMZAjDIZHGtQRKMxpGR9ImLqkMGMfkXNIBiiMbPkm6X6nhhzNkSJMaf9vnedvxmkTICy3WxrqYRgjKcUnYxDpZqU0Pc2j1IKyT0FVANXeyM4VTH1SgyUrJSxTDrRccx0na+fo81xHOlTpEuBXBQNYcFsjBHmXKnFbC/VDqzZCGolSKALnSF3yUiAYchIiCb+u1pGJDjqV1LXgVRKMakul2I6+VoJIdJJpFZTa9RSKLlwvDnw6Yff4SqMvPXmO6TUoRpmKfRCe6UJrALDzTM+ffQZuYxQshErN2drEAbn0NUPSzuIMSZXIRiEN8lR3NBhEGw2eoEEe6Gmu/J7u+iWfyOQpRoVb9bJsYymlwG3cOJE3azRqDPPZmEtxcUZ8yiQIC7KKDF0hjYEYrQDOI6FmKIb4tySKcH1b0oXhCKBsVRCrY46jDubxdyNQpheMLleq98lajEPimHM5Krc25m+MGczgJQqHA5HgppRCNwwU0zt0e8SqEwWarPsymR5NzUNpt9DCcnERTNgN4ORusEJNwYZIbN32RCreSvkbMTL1Eam3lGF0PVmxOh70yWnzpiUwNWuI7oBcCyVlCLH40guCinQ9zsE0yniFn1DehXGQkjR1Se+T9zrwHT22fTauSDM+7ChpOgM1azPbd/Z3ooxEbtqukY163aMwSSraHrBquJ6flwlFXxdC30X0NRxGIq9Y4yhaYCYAnnIDKOJ4F3XmUjs5yElX8+xTF4TdrMZO0tuBlxFQnKmFyaD25jdiBwjw2Ek9mnyPFBkMgCnzt7VMBqi7dK811Xd0IUxvhgTpY7kcaRWZbfb2ztRnc6VaqA6mm3rJSFQc+U4OvFE6VJiGEZCSpMHRIzBjHBOI0w9YJ4YMSZS6kxKK+Z5ImJnx6RJk05zUT7/9GOG559z78HrCyL1OxnBqvLksw949OQ5lJEuBYaxTO4xxrBNzWzGHZNtm0uGuFg8ZtfJ4px6iVCNJFFypbrLS2tNvGrPjcldgrSJUcmNEG7sArc2mwuNHfjkYwmTe1eQYGKzJGqtZtAqmVxGOjeOSTCUVVXZdYZwx1woAVIznmEHajyOpGQIWhGujyNXu2juQTFSEbPQq1DKwPFYzCpdDOF1KRrB00IimC5MzCAjQSa9VYzGXLreGRTNy8BcicxHTKY+u87WsEsdtWSQCGLGyDrpIjvTT7qYPw7jJBHYvg1mbcZQERiKjqGb9N6mn4yGnEphGLMbPtTc8DQQYnMFEn8XynHIKOZK1qUe0coxZyR2VMS5o6Jh4fvoBpHibkV9Hx2NF0fXMqHOEDokRDNQRSNSZuhSMyRO1uzgc4rO/NXVKJXsRLxLEXX9dXMbTCkQxbwAQrA9ejgekRBN+onRVR04F7Q5DMfZsKoCw3FwKS2YMU7MlpCSUnLFfGyguCcIapJQ6qL5C0dDgqVW140amKlA3yeGPAJi+tMmcWLnJJdKriOlmI1iv+uIASTZupVqNgHEdeGqVGRaNyQQk2CaUSVnBxqqE0OKvi+qSyFaTDLM1e0i42iGRjdcI8phVA7Dkd7BVoyJQx65+eJ9Xn/vp146BvaVz6alT7/DNx4Gdl0kF+dgrswPMFlaYzTdVZc6+q43uN/tyBU7LGCo11UI4pzseDhwOAzmwhFBNXt/aUJnCn54cRXO7KOYS3F1AISQqH54a1VibPwrOnJrDIFpo/WdGUYC0MXO9a82vr7vJvccAFET1TLK9TEDkSCRfrfzZ5l1uguuxAhxQlaKIZQQOrrUE2Jgt9ux23WkKKYKUEwlknr63Y6QIsEPKSKmo3TRrXF4iYFKsM0v7nlalHE0lN51ncGVENl1pjsTqfS9uf5UR6x2kI0wpdTE1cDQ3KjcnzGERC2KCpPYJ8GIVy2FnCt9FyepxkClqRBKhZgSKZnoXTBpwXSxlcMwUor6HuoAcQaproJwQ6JEqousxnScmTvhaO+/qX2qewtoheOQGcfB9nAMTlwN5UIkZ3P/a4aqms13M5dKzsqYzTsmFxdhq5KLEcRaDMH1XaSouKE3I1RCqC5tGVEyCUHJw0iK0RiBb/ZSIEh0BlA4DgUVd1MUMSmhKEicpJpaCrsuTaAmZ/f+qcXUdBKdWeTJB7a6R0HNhRQDKQXGPDp4MhVEF4WGnXadeQTFZEzOxH81tz9VZ/KVMQ+MeZhc2JoKKyBIaethuD91iRCFWjNjKYxFGcZCCLDvDf2rWcoYsvL08efu+3zJtDW3VxvBAqEMvCnP+Dj0aFFiMiIVQzA9jRjczxNyxdGjIYogkZgCNQTGMbv43DaGuRo1I8qY1fwRCRCErBmyGXZiN4trgHHUzrk1Quh7hlxm1w0xv9jsxgND0oY4NQh93xt6qm28yq7vXbw14k8zTFVF3dVJEY5jQYO5kTUH7zEXR9uRUiJCRCWakWVsjuW+4RRE7FDF2JlOeBhAzRujqqJuCMk5T2JxcWJW1ay7WZu4VVGa9bzOzt3RAhpqqZMur+kgD8dMTB0EIYq75xQXW10EjyHQpYT57Mvk1tb3ZlxJXZot2V00yz+COgFqTvbDMLqInEmpucgF0ELJlf3+HqDs98a2xZmR9eU+mlJpkVO1zigpe6CGqpgu1N9dKYVxzEh142oww6IsdO6lGkKlFgIQghHNWmUan1np04RczY1LuTlk+i7SRZMwmg48uiOzGXI9YGUsE6NQnZmKqaSEMdcpwEOagc89XqDpgKvZMfzshBgndylRU0U00XsKsIkWtBHcLzXGSHC1GzS1mrl0qVbE/bgVYczm5dFi45JLU11IJJqHkAf71ErNtnaKuV7iQTxGD+ZzEt2DZCymntJS3GBskq75Qrv3UM7mXhiSS2zw+PkNOQ+k1L0U/XrlCewnh8RvvbjiehjMedt1YvYqbHFnbjKLQVWVQHRluZDLcdJJVTXkFMUMQKaaMf2Z6aeyc39ht9sZOlJ1fVaeFOI5V0RBUiCXTC3uqxoDtWbXq+FoysTEnAt1MJHPWrGNJVC0Tq5MtSpSZmNEjJ15SbgRYLffTUYfu8h0zWM2ZlE0o6p0wXxvVQ0hGPKCoK7O6HtACKVSxmJqj2Ki7OFwNKIUxAi6KkFtnWpDIK53HAYzGkjz9Q0Bzc1abMQhxeC6swROTDVbIEIIMomxRw8KkGBO+CE0/a86UTPGZE7vhS4l8mheF5MTeWiE1NUpVYmpB4zY16r0KSKkhcTggQlOVEdRjsPRDreIMzTXCWLrjKojbmHIA4LthS5FVM14c7XbG6GreKSWMSvzBnGjZhcpxdQmhtgTSKXfhXlOgrlkSZh0nC2kV8Qc/Es1QBFDcpE9sQz4jB6QMZZM7KIZiqt5IKB4tJxFBop4lKA0PbwRS2MUga5LHD3YJaYwIcMYOyRU1xiZv2uXTA9uthDb17l4OLADA8HcrwzDuGeBAlKpQ5lAVbMxiHmtOqhRCGky7iW3hQgKwWwDhswNoFUwrwstpuoohT7ZSklMtMitxhgUJUjh8dPHjIdrdvt7LMPRz7VXmsAqyvVQuT5mArOBIQbxg1yoar5xFtEkE7qQGhiHTDVXYhO/gyOa0YlP07kg5GyHJ/t3UYTYd5PeronYMQX6YG4hqLl4GJFnIq4iFokCuPhRDOEYJKXRElP6FyOcjmi6MIcjZg8uaD6bzTp/72rv99jctLk0BTOUGCESQlQKmRCFPGZqDe4nOBJSR+pN8T8WU2cEPBotJYahEFKPYs7vQ2l6UqFoRbGxHw6F1AXzKXWDYefWZq3mHqUuJoIhnJKz6UzFUHoUYz7gak9Jdq8IkpK56IAhq+k5Jp2k3rwyTEXiB0881BSP7sEJkUCgUMqshzWCbb7J4+jGmopHAOFoyC3vpbl2QRlHZ8w27hAswAXMNmAuUUbQVKvpIcWYW2kGphjZ7xLH44EQOpA8MamSR3Z9hGihCma8NOtQycVE61odmdVZdSaQR2dQLqVFZ+wxedBEwRBplxxNK2OFPggpCDeDIerkQQ/BUSsEJ3jGbBKJLplNQwAkMBYLCDHRXakFjmNm54ZV1dl1re97JEHJmVILpRq5SinZuZXAzc3BordC8LPkXiRiLneu9EBSMFdJmQ2KBEFLBC2Tl4Q6M8V9i0s25J9rJudM1yX6JORqtCWKMI7Z+tPA8XBguH4Eb7xtBu/wO5jAGoducf91cnVpYmQpJnLGYF4AFlcurnC3a1MyEbm4z2BL4BCToY9czVigrs9rYXfms+ouXjEyHkcjWqJoMmIRJJApk7UzhjgZgpqfXa15YZVsOj3jpg2VGIc0htKsmKWsiKv7MDbxL3WJiPlRgjnlhxhREUKok25Tq4lzXS+UrBb2mJoaQxhL5njMPl9zSzEEYvrXcbjB5AXbyLVk+tSBKGnfEKPN2URwiyRLMVDdoJR9gze/06bWLc4wqotx+11vLkpFOQwVOmHXt7h/dS+AI/v9HsTelzkUmPjeebjtMBynfrtuR63VXKi6aI7rbnA5jGY4TbEZ0tyPOhf6YCK1uJgZYqCM5nMdJND1va2nr3NV3JhSJwNqdISUfU+lJAzHQlFl33euEjG1xHE0P2rxHBClVorafhqP4ySao9CnSCk67RtU6btkxsjaPBN0UgnkbHpaU7+aC1LqzPdYVF3SUsstoJglfhyQKmagdJQpmNErdcnVXxmtAlSKi9UB22+jE3atI1f7jlrqFB5uTMH29i5Gul1PLsXcA90TAQxtXl01UVwnQm5GPdf9OsMLirnoIZ7cyBW3UidmhJoabpzee2R0VQAwRRsO42hqMlWGUen2/aSfHnJhOBzNy8NPLRdQ7KtNYMXElBAjpWaKWpioVlvErgvsdz2KeHy+hU2O2RBZS3xh6hdboONgFsMoJsr1qbOIKI/QMSV+mBY9RqHqaE7s7iqUPTplMpY5Es4lU6qAFFLs0VLJFbQ2RGHTGsdC33fujtRQkxKTTKij73s7AKg5jVfxZ5jBpaqJoaiaeOZqiFKVEEGqo253E4rSkRkp2Qk+8PTZQEjRCVNgHMzYFIJHdgUoKZluKtjhpXlM6JxhrFnVg3sSCLO7nB1yM3aYzyyT2DmWQhXhKiXLTOYoPobAvrdD3BLDFFXKaNFLRQ0dWYx5ZIp1VxiGI9n9cw01F7QyIR9iIA/m5woVtBLdHct8fBULPzWR1zxUlEMeTawUIZcMRSkZrvb9pD7IxQiO5ZuwMFFz4wkEAjXbu0y+dka83e2quk9raJ4q5uoVQrAoo2AGMaU4cio2fgxcjGOGYAizuntAbVZ9EUTd8ObWdPPDxfaKQO+IPqbAcBzY970R1RDQnC2YoouELjAMFnElQajohBoNnJjqAzW1UdeZITbr7IsdU2IogzEHCZOP71iUKAWIU2CK6W/NkFWysu+i5RapkNUYqwXV2NnK1aK2alVSgF1nUlopxkBujm4oL2qunwujZOziFI5eamUYi2XKcwlMRDmOR0oZXcxpBvPzBq9Xm8DSoo88KqazgzjWMnHiGBO5uE5WjAAPg4mgEoSojr5CQEUQ59YtUYW/czO8HA6OMJt4Vd2jIHA/mDvROIyErvN4/jgRixY9FWPk+qYgYvHfVWVyPm8uQimZ8cbCKTMpBVBT/lepC0OcJaRpOs7gsdYxBvdfNFRXtYJGxiEzDCN9b6+1izb3Uhoybb6xuGtWQEKki0opA1qbAUYn/94gwthcy6q6zlfdkBUdsdlnLYR4HPMU1SZufe6SIUfV2ahACLjNaTJCzHpXqHX2by7Fkn6YTt0jePqekqs7sg/gEkqKtk7ZGVRzms9jtuephfIqht5qC4xwgxNYiG7XGRrOYglqzONDITij6CwxjTBn2mqqjpRMJLZpzghH1Z5jKhv7rAt2r2X3MnHfLPvelwcTiAjHAcY8smueEKWFf5ohNAQhdWFyibKELcX0kb6fclFidONP7MxtKQZi9MxVXSMLYuJ1hONYXYQ3Yp9SRCmUobgLmjE4m2N1W0ehZKhSkGD2g65ztZtaUIIdP2PKXQqIKl2aQ8qLE1EJgT6a611yr5AWyLPUuVefCxI4OjFt9o4YbD8rkN010HyVW2BL9NwgDR0baMhVPTcFxGQqkOaS+DsbwQJahTxWS+CQ3V/NdZe46FhdHSASDCW52FVd3I7BDQAu4ux3vYUpjpnmXG6BBWYZbpy3xYTnFpEika6zyBN3jrQxYoaUKHAcjlR3mQnR/BHBdXWuP7SMRXVCnBYPb6GnADvXYZoTe/LkNW4ckBk51yoeUpsmXTCqpGiopqFMSzxjblHDWM03tk6ngWGsbqSKxK7jeDRXGXN3CrR0cU3tEdzX8XAcnXkJRXXayE1X21QlyTNVlWY9Dg17qb/L5rZjYZ7SmaEj5zq5wV3te6jVI/Nc3CyWI2K3S6TYGbJHJwOPSQWRFM1aHx02yqQSEDegmZphzOIEv7poXTxgxQ57kEBxaQTUo+Dw0On2Tip9H30sUHJl1wfQylg8GsqNeHbgbT0KgmiYxoOooVIHDiXbXPsu0acdQy6+H9QZqdJeaTAjgCFpsTDw1PWUUrk5jKSuo+8T42CMBswzxJ0gnIAG+hQ5DiY59l2y0O8xE8VCddVzYGiFoYx07g1QSqGOTK5j966uQIxxmRSgdJ3lGxhzxhXMvnbJM32Z+1jN6jpxNYd/D4PuUqQW4Xg8Wg6CPk16ZgWG49H3WmTIxf2KTYIZh9HSIVbLcie1EPpIi6wbRlxfruCSSJdsLOx6B2f6O9/IBdD3vRkaqrjnhcXga1HyqBbvrMWNVBal1fe9+QsWC58TN47ghLjWmYgaTdKV+1b2CK5qxhMxy68EIQW3KMY4GaGqFnIVz+Ikbkwwy2UUmZ7fwmfzhPrMuRxXfRgCDkZIYqTrWgYvnZT0lqLPjHK5VEKcdUgxCGnnLkBjBbEomgcPegsdDkIMiRfXB+7td4CS85EQA10fScGzLJXs3hMeLRUCx+OMEAOeHSq64Q6gFvI450AAQ2u2DT1yTSx1YpDKOFiykJFMv+snhG/qCCPKQQQjMWYRHkudDlGzHlcsQYmnkDKXN0/C05BjiIGgFRF1JO+eHk4kLG0etu6dM28MJTUXMIc5oJZWskkEzXXM0hiaESrkYkbSIFRnqmaJF7/fE5NEsxccBhP3tQpd1zxHLCPZ8TiamI6J+809yXTBRjBaEE3bv1pNOjOPCPODFjwvMbZfYojsumSJk9yjBJc+UjL/z2vXceaWqQ1xyaYFLwi4v6sxIkOxtdr76rsOkoVMtwTaZSxcuUuXhkh2Qho7M4a2PLlHFW6OmT7KJBW0XLnTGSomWZndw/xzx2L5MWwt7NwM2XTkU8h1MJuF2sTB94Hlc25eOGYV7WJEQ0S1SYDMnjt3EFd4xQMNBEjuG5hzodTMmGc3GoDmd1prtZyRY+H6cCRXzwngSvMgRqxaTk+wRCnNM6Hv+wkZ9rsedctx9Hh0E4NMbzjkyjDmSccI5nF4b9czZnMBaf0GmXlcdKR0HI0g2uYtnhC8TglFkutWl9Eozd2o1jqluGs6tloVPBrI9HeBGJQUO0qFm8PR08CZH2bfd2a9j0Y4LB7d3G+aUS/nzHE4urO2TOoPc8MRUhJzc5JK6oR7+346AE09ULLlFXVtwBTwYMQrEyPsdj1CS7iB50G1g95ytpZcGAdPFJMMmedserVSCs+vDxyzEdc+eViy1sX6VXchioh4GkVMj0tjrkE8Z2j2pDAWPNF8W2u10OKY7B3b0QkeY98xB7sEu6YYwdr1HSrC85ujSQq5crXr2HWeKIjZNUklWLaqGlw9ohNarsVCayVY2KdIpGqg1jARV8ClMut3t9sRU49iwSrzPrffqxpQCcH2RIzRDIh+rsT16110u0Sx/dHSJoI56rd9UUo2o1KUKW9GEA8zz4XsRmrLbxvYdYl7u97VOAX1gJybw2iuXVOYLJZ713XmTeJsTCb6ObTE7Ca1NqlpzHafgLtDWlKlOeVgoOt6aBUMgjGxgKmamnSYi1I0TEEqNv3zutfWXnEEK8RoRoicR0uMkkxUI5qv683RMg7tdmbt1GoZ7e/1yRMJu3FDzAWlVgv8k+hJtcUOxnG0LEX7FKd47OR6Spe8QbCs9ch0OGzDMb1MqOxSP+kluy5ZTL8Ej2BxpXxgijU3VYDpj2ryBCxq4ZIiuN9nptY51WAuhd2ucwbsBrhkoZaWw1W5csKXSwvzNV3TlBzMAw/EReIQzcKqpaBifpzmSxnMUBfNonszjBbjj2+2ogzVXFzGMVvGJ6BLgrmRMaHuivnU7jxkualCjPiZYzoedy9uxDJ0q9O/5G565k4Xscx11cS/USe/4loz41hdx276MjNIuOU5CofDSN935qNcbN26zrJaDcNoqGh0nb6rZ9y3jMH9oMecTf8avBpCNjYyDOYlkKKw73emoyYwel6MFqoZgrDremdkkeNYoNbJH7ihwxAig7s6mXN/QIJJckwuYZ6rOBgqraU4sBAnrGr7xoR8+l1PVWHIlu7TJLmO6+ORFCJCcP2mSW2ESFY4DsV8Z3EJQSzCqlRl33t2q4qh4WGwsN5ka3wsFSmmj8d14pYNzStgVPXgCkHEbBXZSovQdWnKMiYIhWB6XXfdurfvOB4Hqpjfes7ZvD48AVMZBzMei6m1UoxU9/UOwZKn51p9LZRQCle7nuI+6VGEw/Hgdg/uBLGvOIGFYzan7FLLlCFLQ3U0Y4aE4/FIrZFdisQuUYNMRqIoggYmx3gjenHi0GDJeVuEh4WwWrrDlhXJdwHAjErd79ZQ7+wa03dpMtAs/XKhhXYWYt+5iiI5wpuNBOpuQhYUUIiOwLudG6482isXT9M2mj8h4Nbrgkhy4uZRR8nQ0pQXwHVPWrIxDQkcfSM2tGrEcqTWytHdXqqLTTF27DtLTm1Sr8WH56qOAAA1jh+CcDgM7PedhctGI7SKZTeztfXIJTFCbBJLduNY55Fw9h5GTwjSDEBtHzTE2vJFjGPx3KEWq34czTtiv9tNxgu0st/3bqwzY80u2phUmZBOC0aJnu+1qhIJ9PueWounJvQxuL6wWe8PY6avzQvAGPVxyKaeKiaJlVzpeo/Ccmt/wNyGjBlbmsSSC60SB41J+j5rB73ve4sgc5+mGMxfWjROkXkSZh18zYW027Nz5jHmjOmgdQousNBVMxyN1Qy90UIqaS50to8SVWZfU8vKJZb1jUBjyC1AJqZotpVqTHTXmyG66iwZirT6WmGSPi2wo4GbyOE4TlnTxpxnH1uR6Z7DOJpnhCPXljy7pQeNnlRfpLr6wP2da2HMI628k6IcxjrRg7vaK60iUKxSQXGn/pTi5MgvmIN6ksouRfrUmRN1LWgtHIfR4uEX7jzdrrdYdHdyVzUH9yaSI+LlR2AslrXf8rlW1+epu1UZ/7dx2Isw8dqswLlU68eTtZRqlvPQchPUMom6YO44iHHQUkZScreXMsfTt3Iz1UWjvks2/1ZZwXMjdH3v6oVq3hQi5jJzMPGpeAWFw+FoiUvcNzKIl2pJcUKtKblIhPlGNnHSiIAvhySsiJ9t3Gbl77rkBpnI/XtXBIluafcopoWaJ6bEcRgmJqWK60nT5MWRc/UQS9Nx23rjhsLqhjcT8W6O5lJVEbquJ6We1HUe2NGCL+c6YOBjUYEQjBmrTPl6VW1eLUOYiIeuuoEmuecFQaZUly0PRecqHK229jEGdzVjMpK2NJfjULm5Gaasb4hStTAMg6tI3OgoULO5s7V0jg2htbmYgDLrxGs1l8HgNdmCi/C7PkEZFxJXZ/0orrM3FzNRaImK+r6nS4GdR0WOpSJxNvyZj7dORD+oWf6D61ej4MFCzYXPpMy+35m3BC7GY3stJdun5jrliWNKZcjKkLONJVkNvUjgat/TdZauspTq79MCHkxFYGoic0+OltBeLU+CGZNnAzAIx+OAJVY3kDK4is/2a+N02+0VR7AWrmnJSFyfVitgFsO+S+x3iRwBzJ0oikczYZu686Qd42AZp6zJzIBUp2zztdh9MXQW2RTcUhgt23/JmTxahA5u5PJAGicsoLmw63Zo1y3QL4DVEbva7yYLdXLXpc7FzS51DMNAFfG0cnmKeR6HQrDk9+4zapmb1NFG37i6maCcKKTJACOik14KVXf/AlQIKdJjrj5BKvfu9e7eYuKZJdUG6c0XEw+EQCGoJcMQ1anoXwvHLDkTum7KzoRb+Pe7npaPt7jrTkqWKCQGz7HgqRlHj6xrQRc5Z/b7Pbtdb0bEzuLEm0fGcH0wwuVqCYsE2k1+rXFKYZdMnPdSM4AzTHViUvx5o+snzXpNYwJgRDsGbg5HV2m4dBPwvQNjrpaDtFr6S7QSlKm/FuBgBswyqaVKKWjzLQ5K35u66JgVqea50gIoqpgh1vajel5aAeZiiSHMqqCGzmLXuVFzDjc2fWq0QIg8GDEKbkBteSxCi2ASylDYpUAdhylJDxiCH4aRAoQUQC1kena7bEa4lq8gmEqmS4ClowzRCGkZhV2/M/9j9UOglX2yBEytllyMieNYiF3vHitGIJM5FFOKJXTpnMmZagPzlhFzw9Jawb1cYtfRx0Api9puxRIz4TrYKa/0mfaKE1jxeZjl1Xz9TM8DeD5T+13dGlrd1SItIrGa4aU60cUPbIsSs6w+ynvvvjUR2qFkdzUyAtm5X+Ik0otVQ+hSMD2du5A1d6/mhWCfVdBMwKuZuh+uBUEkiyQTQ9ZX+50bC4Qu3aO6v+f9+0bQo3sxoIpKnKzDDQ3lnLna72kJR/b7+04gPRt8ixLrOtSLFprvo/qhlElvFfrOnoNx6+bcXxxVJy9Hs9t19B2u56ttRIARTCt94yiv6bLdOBmDjaFvmZgShNBN8ehdmkNCuxTZ73pA2U9ZsPDwWWMownT+TlBZdcKS3O3KkukEkxbc/a1F+1RRQ3pxb0ixVYIUQyzJXYFETe9pKievBqzFkZ9F2Y1Z3eVt7xZrqGpZodQZO21flOYGZ8hRXaVlblZm2b+v1fWFzQ+2lUWyfVan3LJeJRZzVbME13WSWqpXBqjOiEJs6hobR2huj12k5IEUzG2x5f7ous5yFbtENWYDA4ZjLetXCxLpPIKr1bETCZMeVIIVzEzu5xuSkEKarkFbCRxDvtUlzda6rpvWdRyP5AqffPwZT4cXdv6rIs32EeOU76NqmTxVVOdIwaaaSL2pQMZxmHS4Y62kibqqq49/B+eDbaJpI0jNPcT0MK6Dc+dulUDyl9K5m1SQwHHM9MnQKAKlmuVTsGw/YzFn5qt7e/74H/3DvPXm6y764i5eOHJZ6LpcNGh6v3ZDy6oknmygGRpboIQlia7TtcaR58oHpudqkUDufi1NlJ69ClTNdWqKg9Y5r6j9WWkKPyOOVp5jtn4y3dv00M3HtemVWzBA20S4UQRt4aHNXahNXyfRclZZz6XOfZiTGqWVLWkJmmszzmjLAaqTtR8fV3TVjuD5V8FT/hljMERciCdrYEaYSnECaobKsGBUPgVjHmV0vWegVaxQUVLq/HrzhgiuL1ZHMbj+XMQDXtRcfwgmgoeAhTEvPE/EbyrNcIUgsbFMnd5nE7faPlkyfjsT4nOdPScsubv5STcCF8Q9DcocHGBdCOJ5GWJYZOr3DdP+NiNkPjmg9owy5d6YXr/OgSdCmPeE63orzAS2qdyqMctWnr3NfSrvMt2ziBZ0XXOtmRfXzzxHiHJ9fW3h4r6O5spoUkQpFVFBNXMs1d3+ZotVc2sb80jNBVySjSKedB/jrtKMpuch7CtNYAFaaedmhGr6UPM/dBeQ0l7I4rCK5ywILRnx4DrFbkoqnAIWCifKcDwyuXC0h0sLB8Vjru2z9vLnDPZ+jc4RSSwOgWo7KC2DlosuLv4vN087IMvP1619v8U9L3HT5ffLPpqR7Vzb+m45zmW44HQQq+Ud0MUBNaNHoetmwtvc2RqjEmmErpweKpH5oKnpbRVMPTERBPMWkHp7zEkE6WYf0dbfcq2t64WYmzpOiM3JArhRsda5ioYjr2k9pKIyEtLMbAVjRtO7C+Y6KMR5PI6UJ8LKfIQNoYfF2O365p9MU3dhDCm6H2kIlh1ORCan+7a+LZHKxEzFfWZXa9jumdbWaZIBi0ZM57UPHhTQPD4ag3J+bcZWadb44GfLDKVtuWdXtUa0y5QkKMhMvmJI3L96jQp0aWf14kJLdyhY7lomtCoKqRMr5ujgpBmXc0sy7pJu85+FVnFEbOP5vJcgYt1eeQJb60zCUuqmQntGoGbC0JKjjO7s37l4kDpz1k7u9lFKtuw+fe8qB/MNbG5T7Vknm4gFMavNRKInG7Ad0BYFNHsYyOmmtKtP7mnXL/s615ZEbfv7uv7k5HlNrG7O70YQFod1WoE27rr4XGkSmon7LchxjmhpfsnWliG07qHgocrB+0oew2lxFzIdvNB6dh6m1aP5HJkZAfGsSeAJPtra4AinEWRHg9rUMoAET1fX5uL6SeZ31kJ9VXUSuVHPP9rCh1H3jWx7pzYIB67PVdpLnsc3q79sfSz3q54QLHt7be1bCHF0dMwUENFyAoRkQTctPHl26fM94Si1eu7VmVBNi+aYXKd32II1mq5/vTPbfmq/z3s+THtCPdy1SV+tpWBeBE3Fg6dH1MXZacCq9V09W5zttRb91fvfkTweLYlMv/PISPH0o5mYEjWbNGzVcpsU50EFnmDe6va1zMAmeZjAnCxxj8zA6i5A8wMTWBH5BvBvAV/BTuAvqOpfEpG3gH8H+EngW8CfVdUvxEbyl4B/BrgG/ryq/uJdz+k605PVYjrYsSjiLzs1yzHmetVKh7Ta8jFZCruUTJc0erRX33dTtUwNQqg6GQMalwWb1ZKMqSpURwjagj0312ZB6E6525owTnT8AoLcvu+UuM+f3RZZJoKInNxrP+YDMqPIic3Q0klNhMwjjqbvJyTkgm1VF/F0Jl6055gezfLLzTqsppLBResYhNjNeVeNQOO5II7s+p0RxzZXbbpMH5cveSScrE11ItJ8LdvatTysS6IKLT691RhrkX2NUcRZheLjyE4IlvXZ5nXceI86SwIN4QWZXYRE4mLtdWLsOAMRJ644sWxXlaoE77OlCRcRgjNyMR2GGZ/EmEubb2tN7z1jaOd/CylrvSeXxPa0+ecLFUl7W6q3EbGG+d0AJ4yuuV015NjcsVoffd+DWKhswdSEEi34I0XzhhilsS31aE5/XpiNmzsPPMqleOl6c8eL0eq6zWj8t08Hm4H/lar+ooi8BvwtEfkPgT8P/DVV/VdE5C8CfxH4l4F/GvgZ//fHgX/Nf15sKVld+5vB8m9GCrveCsdltxSa5de5shfiKzlPm0QkLriex/V7ko8YTO9VcyMS7eDCDF+XJKuVA9Gpiu1STbAW8xthMUTIyWZQR1bqutlTndvypfl2cNTI8uDqPIYlgb0lysGsM213L8QbmT+cCdcCtU5roq5bPFkiI0RNqNVZx2L9TmqWSmEW8+fxNfVLQzv4HHyNFPBcCH3XLWL/bSxLFcJ6wzd98kQwFlJFW8fotZ4aIV0ymubnGafQW08yruYy1/SAUzhnI67M8zvZUzoTvDWTPJFigixKq1gUm1nvmfZKSwRt3VaXApz4yrz+zv8WEpPnWiieLW6l41z+XI+xreeawNrebTaD4CjcX32b60JC8JtOiZPv7WkfLfpfSl5hoSderpt950UlU2x8w5Pnj6DJAhbU9mufvPSUG6JFmewDFvpsZeNbWHTD7y1cvalmLrUfmMCq6ofAh/77MxH5VeDrwJ8B/gm/7N8E/jpGYP8M8G+prdp/LiJviMjXvJ+zLVdLRmKJJYASGEZlt0jAfTN4JYEENWdi11lY4xSLLlPiZTDL9pjN5eeq6yyGPoof8Fk/Jn7QbKMsdI7gG9k3UANScFI6HNYHp20E+70h3YYuzyFQsGxhLcJr+lpkGtct7NCIsTIlqQY1hX2bAKAlz8R1QbcXP+YPtV02EwtbNEAnrDTfvOpv6qk2Er5gW6sDu9TpNTF6OlBO4G297Z4lcV3rh1FjwIFGVC1PRJUlETVdYMSTfy94SJxUK4YOh+MRs867s30IlisDbjMPX9dGcNvSb0kgbewTI4h2Xdfc61ZtVi/5W/H3MdGvxZ7RJiaIeCUIv2JF5LbUWssxLRnYdF1d7POmBpn6g0nP05z7py3iSLY9yw+TMD//1ppsjHezidXssmgtgdBTtXqOAdglUwWIFxS1DHVGRC2/cJ04k6oylhbO6Z47enrOz7V/IDpYEflJ4B8B/gbwlQXR/AhTIYAR3+8ubnvfP7tIYG3hjeOMY3VHbvHoGUcgnuRiXOQHaG4rEgJSyrQ5zDqcp/BaM3jUKXv7ybOZyNC5eU+Hpl2ni++25jJv2tNN3ADV1sHDxdsTVOSna+L000lrSmuZdnJVQ/qqipSmGatT34pO/o3tHDowpeHZiZF418vFWhNinQiMH5DVGsydtL6wRB8AElbX2fdL0X25luYd0A7g6bo1cd4W6VRVE0SmHKJCK18t87rKcs7tYBuzimE2hM5obKItp2uz2lRWAJBb7dxBXRtQtpDv+vf5Gp36OHfPGvFv2Q6WRqblPdPzgtx65xPzXY5nwXTPIb+TfhcqgvbcZiiFWVo4YazoFO1X1fMF14LXjjQXNzEPhCp4aLTRiuvD0TPCucSCgpqUm4uy6wMSe/qub6O9RfDX7YcmsCLyAPi/Av9LVX26enkql7LRbvf388DPA3ztx74OGOLMwK6LFKzAmfm4ikXTeGnnpajQuHmrgoAEc3hvoYIle0hrsNhjdxdpIooPxjaOnzQFqNuHp71c5fKBWN7XRDW/cnFBO9wzgt563ulBWmxgbejAiMaUuFpkQg1NzzetlYB4vs/5Ga2/lSJkNZ412vClWxy607k3ne2yr6W+UkQ8FNaum40ly+d6gmzCJKlMk28o7gRFLvuf13spXZyM39dwyR0mHraxR2T5jInALAlwk5C41bbUGufaeg9caicofuPnyfg4fY/r77eeNe+pdm3wEk1m5Gp7sLlk3UVc72rnmMn6u5a6tJTRDXku/QIp9RyGwZmqRXvZPWF6t80VsFSrI1da/g4sl4L50s4M7NJ7+KEIrIh0GHH9t1X1/+Yff9xEfxH5GvCJf/494BuL23/cPztpqvoLwC8A/IGf+4PaSp+04oMUQZLnIC1q+S7dITtGT/enTCU8xsFjkzszSOx3vVVGqBYeGmMiVau1pZMYMM3QD9AUF3oq7i2IySQZr4jOuba29i/VBLMvw/TlrWvXIlyzwJ40mZ9zcv3JNQt9nZ4SshNCuNHWz9s6wFtN18THf7+FCmdBc57Q1Ec7yEsCsLz+dGy3CcXlsa4/b+NT1RNfVnttrYJDkyZOn94YmxHoLa+S20RvSei2xnhOQmo/LxHslyFwd+3f1kwfaczQ/E5xsb+pE6YObz17Pc5LY1zumRbVt0VcLYoukPPokW5mxxmz1TsrYkEQ+66lM+w8ab15GZSqlgyqqZNyy2+hXkUlOaib53Sp/cC5CMRm9W8Av6qq/4fFV/8+8Of89z8H/JXF5/9zsfaPA0/0Dv0rWG0jc8bODKO7pchMCIZSIZjLloXUet0kD8u72iXuX3XOyeyFt1LUWjGHbK0cbg6sD+VERBtAbCh18bJPNoIy6Y+E7U2ypcfa+nlpa99G6q3/y2u5HK9da0jD1CTBie2MNBpRoCFhH9eJ9K5bY11vvPmZMnEj2fh+Nq+t56fKtPZmKAknG3zroLb5nn53iihxhLPVTh2Wtvte/90I/fK9VD3tZU1MT9/Lqf54aVC6/b63P1/3c67/9XguEfXtvcxCulBQPdn37blLo9Ty/uWztvfF6fOX6oq1p8bJvAQvYW7XtBJMYIbeECyEWKQVUfTk5VrY9VYKPQb3nW6pFkczNEbRKd3nbenrdvthEOyfBP5nwN8Rkf/KP/vfAv8K8O+KyF8Avg38Wf/ur2IuWr+BuWn9cy/zEEEgRMowONG0SgRW8C47JwqYA7GV2R6G7OVCxCO+BEt1F9wNyK9XyzVqGdyTl6e4jVDnn7NRaUucsvGqRYmsEO3m3M4dbEdCghu3zhyOE2LZ0CcLJLV4/kshElkQ0BXymGa3RnDiN9xSLAotK1N7/kJyBpgMV9P1jdiJezyIvX9deBm0z6ahnfj1nkd8NnafY0PtCzXAhJkXKF993Evq2J5R59M1HfzJTakhVhb7hO39co7grYnP+rM18VxLBWtCvCRwS6+BdXuZ/dKkrclPWRtK9/U9c98lQrRUHSmcEK8tief0HmuW58CTmYemHrS/vZqZeRFgPvUxKCOtJpfRizpaqPOYR2MYXnYnREsFmj0jXlO13dV+GC+C/w/n2A386Y3rFfjnv9/niIgn67BMNuNoIv9u19PKEcOcvOR4tKTSKQaKKpQ66ceCJ6AASNESq3Rd9NR46damPB3/4uc58a7tsI1V+X5EtumQ1Dqhypfd+LKINFv2dw7RnDtsl9UbjQgtwyFPn3X67MvoejoojeCdQzHW4WIM28RkuzmBn66zGZy/bx7TpdZQ+ZZ6ZOtdTfkTFkRz/X7WY9oilq2Pc99fImbn7l+Odx06ve5/2vILmwRym4ncJbGdzLftI5053qV9v5YgmkqiqjCMxROhixeqMVWBVK94IVbOpvP6bZZOOFrhyuyVhbtuAcxAc6sUXe7cF6298pFcOY+eJcgKniGjOZk78anqfusiXmXAsuyLmItXcR/G482B1HdT+F4pmaurnnEYvfIBU/WBLbRwiiLmfyebbyFaw/lD0P4+K445EV+7gqw325LQmWh2nvC+DMFcj+0sIV/Oss2BGaU1PoPKJqm8RBCF9g4W6HyCmDKLoQZzmYhsw5yLA3x62DcI2GL8ht4F2SK6evuAn7qYbROOywz7buJ6F1FZE65NIo9nAGMWRu5Cr9OzTR47mee83r4GCwHk3Ljaz62xz3s6EsIeCQktR1Stci3LZy7Ch+eHhkU/1SvqugE0tmgyCzjIJROkegkePJ2oJySqFr0lvqX2uw4Fy1InZgCzunVW3+5l2ytPYHe9Wf1aRVMtBfWyJUql64PVd6otQ9LCmNBK62l1n8XmLmKO/cUT8+acUU5FX7vvDtQ4U5KZ4843T/eeaxdFsAtE7jbRB+U2Et06cO3vrYO5/O4cmlr+fnJAlsBzolmzKH9uLK2fqa+GTBeXNRH7hFpP/fmTRHwNZhXPatWYOtX2XE+u7QzREOvqPp3dzi69y+V6nHsPW9cuvz8nDn8/xHb7Wl/PCw49t0EEC1F9oaJhQVwXY2hM9+XUAPPfcx8KOnpQRWM4SvNq2Tx+8wCneYpYEiVFEVUkCMOQHXnaWRFtqLQyjgX1zHtdTFQ3kIm0jG8yBZTE1GH5iNp+OZ3HVnvlCWzqektajFV3bRmJAHsntYUX6lRZtVQI0VwrzIOnLZpMJa1RL1scoifqHqekHap6Xk81LaYtsjZxpn0si+vOINS5qzMH5oxouLxOnJIso4TOPWd9mC+h03P9rHWC677aAWvDfxkRddmW691Q+3lCdarPNeK6uH5NnCeRdutFnTxgXidphH0lMbQu5LSP5bXrPm8RLj2d3yUpp33/MoRref/kOzqrhee1Wq3tpMbxC2cC4obN1diX951j0Ovxb83Jl4eJFdcCZJaR2JfaOvih7YNWmWMZutu6LAVi0FlS8blLMP2qVsuuNebR+vG0lg2sVayGlyz2waV388oT2DEXd85238gKUaJlxa86JaNoGf3Vy5qgHqSqkRiE1x7c9xrydUpj1tIbNrE/53E+fmdEvbktNpYuXu700bw5l+0cEhIsVlwbYd44hGsi2bCE/Rqd0JWNw3PHTr04z/Pttth8ud9NEXY5r+n/5w+ofbAEVs2gOOsFjfOuD/ocvaQLYnMyzuUYdPmZnhwkYycrf+fpYsfDi3SQTU95wgQ22poAT+O6IA2d7qcwLcwU2yfziLde0MwgZWaMC3FkvZfWYzonYV1uZriUJZWCpuiyUvf+TtcqlHbP5rnApI3sibztTC+TjAtKoVQvpVNb2s1CVIvo6rvIWDKlCgQIZbaDWLIdT4Dj5/uyTPM7gMCuN1fjTBNhrVYbKhJInW2S5oaBtIWsU2nrVkt+zJlSLZF2zpkQm8h4+9ntubYRdd4OsjzUnFiK9czqvxTBeykxUf0wz7pPu8dzqG48d2ted43pZYjuEkG+LJFeHpz5vkYITi20U59byOiMmHZKjBbjWiDPbSJxXjc+I6Vw0sda8tiiocbDbxOtl2nr688RunbkJ7XRGWYOs8QwXePS0HpPn0gpFwh9u3YZddX6amNZj/9kfFOfzf3r/DpcIvTic2vzay5ipSr7LjAM9owhWwSgVSG2ZOlj8bpuYom/cy5oO0/qRR8xLyY9m9jmtL3iBNaQXEUY82D6mWAEMRE9C7lV7bTa9eo1zJVdl6bs7igMOZO8cJqWSpLmdXAEcC7nL2qFIE43mHP4Ge6cJn3xzVQdBS3Fu0todvY5Pd9uiVfT57cP4Jogv4xq4GXalvi3hbRPntPEeVl8sJbm2yFs/fuBP1X/yebJu7WuGKM5icSSxbPOMBibw5LJziqFJU2ZCcZK/A+3D75D3wVjPm0v807W7279DpYIThpiXXV5TpRf5u05Hff555+TQDYlM5cOT/uzMa6Z7PL6xiTO9bsc13oNQrC8AgTPxUBLmDMn9alqVTS6KBxHq9qcUkceh6lgat9ZNV+L6qp0IZFCXLjjbQ7rpL3iBBYePnhA0WqOwSiBSt9ZmsJavbqBlw1WxUNgw1TaorkRWVLjuYlYREhsMfBUlvHu6814KobYogszerNDDY0IBG4Tt3U7+awR641Nc+4e4RRtTGNZE7jFPLbaiQ7rJQ771pi20f7yoiVda8xo9jJQX8Czh8n/v+WXcJuhNA3bWje7TahOf98wEHl80jkmdW7Mt9/V3QawO9/54vkNLZ7aCy4T4fa7uIh7aV0vta21WI7zNP/BeQLZ7lujU/vq9vuZkyNN35x+70VHQxCOOdMFIXURkehFQBO5ZgIBqpK1eg0zq3JixS9t7w65Gl2p1cvJVM+Z0Vbt7vbKE9hhHIme9T1OXMWTt8RAqRZpUVrpBxGv4qpICFYeQ4QuWn35YTQHYnMML6SulXw+VYrDNqeeUJXOn68R7/T5mb7WzfoFmKN67iKGZw+rbByklxTztg77JeK7dUBui/1zu6uPdbvr+i10vkbSWwT13LuZv2/3TyPZvH9NBNZj32pbY7w053OqnfW8NsXu055haTx0MHAiNZzZWyJNLXeaNGZ93TbRPR3v1ji3xr9WNZzOezmnjWmCG7/NblOK+dBHL9YYEaiVfmdl10M11WEplXEcCdEk3eQJgGKybGZTAvdpwosJnmmvPIGttVom9qocxtGz6SgxiqNUW/DUBUKK5gfnmcaGUkjBitxpVWLVKflLrZXUGdKtZc7Qs1QRCEpLslkbAgGCZ2aafFSVW4fmLqS33swu2Z1tm+LQBvFZb+hzv58/iHNf63EuPz9HrLa+O0cwtgjdFmG865nLVHYvg7DPE5IlQrprbbb19ecY15KILD/feg+X5rH8ee6dnqw3lmVMZM4H3OIVTQJrOWVnt6P1Gq3ndRdhP/25LREumfbLSE7zvUx9br3DVgxSRDy/q6sR3dfdIjetYrIVYuxojkXFKyyr63CjV8Eo2StJO5gy+iC0HAyX9sorT2AbEUvJqq4aY/NyxiKMoyXDLbVShxFVS7DbpQS5kPPAru9pia1FLE2dAsNQrFKr17W37xeZ3ZeEsr3ExdmbXqzcJkjn2hbSWnZrottlMfFS3ycohXNEeBslbV17WrRQN3+/6+9zB2mNrC+hteX1t+d8m8Gtn7FF4LYR6fl2OsfbRP8uKeVlrjsdz+31PofqzzOrk56ncXtnBg5uqUW2x791zZp5nNunW+9wi5Feklra71u5aadnOMjIJVvSbWUCT3gYba2V7NWk+y5NLz5XK8ndJQtEsNpdDfGbTndWEXK6lmfaK09gDSkUq8Wl1RwtitUV6lIkhkBKEVQoZaTveo7DiFYLg0M6iyMu2aoc4GJDLqTUe8rCym4X/QXJzKnE4619JI34NR/J6bOXY753b2IRJ9Zior5z4Zc5UMt2F7FZXnOOuJ0jdnfN6RIBOXdAl/fdLeqeR4TL/u6awznEOTO5dt3yHW8T6PXfWwzsnNSxbudQ41oyOkdQ5xsCyyErvr90VnXd1dc5wrdFTOfxwaknyzbzXt9/8qwQJiOnrvzRz60PgpfHUXKuVqK7lCn3QIytbL1XzmUOoW3JeLQqIVpIbSkFpDLmuUxQkEAes6sSX+7Qv/IENnUdXUrknKkV+q43ZbW2l2jc5DgMmJhT2O+SZSEaxcJlcwb1VGNqBNYshfNLbe+/WXv9G+AW35/QrCWIaB+dJ2brdhbdbXkS3EFct5HNtqh9SZw/N8b1vef+Xt63FsHPIbFLz906xEtVwNZarOd07rqLTKExNJdympi7fMxd0sql738YBrSe3/Ka033kkiy2VednOgOvl9/py7bbktJSJdDGenveW9LJKYNthPr8nj3pS2B9ShWLpG73e0EKQgxWT82Tu4QQGEd7borRgx0scY8RXgu3T8FSmcbUzerE3/kI1rwAhnEkBaG6a1XX91bfqVjilnHMLuZXVAvjCKVkUorkWsjZPA8st6wtmiVprrbgyVQEta4PQDtYzWeASR2w3tStvezhvnQ4z23zcyigjcfu1ZMXvyXa3XWQtojjORHxZft52ede6mfZ7lrH5TXnGNJJ304fGlFtFQ3s+tNnnUP75/bC1hy2GeNy8Nx6j9tiNiyR9WLrTnu2Xb8sU75sW+j4nNR0fg9cRvdbRPXcOFjOc9OTYPXOZxETVbOnlGo5B3YpcjgOiLinUVWKI1NBiaEClSCRsVREdQ4oUCHuLAlUKzOlWA7p+aGNsWy3V5zAtgMKw+AJcz2PgJV9EboUGHPbGHZPzpmus6l1MVFEvcQMJCfETfQupVKpXO2tUumEWkWm3aqqi3eos/jyfRKurbbJ1Sfuf6qPfVkx/of5/NzY7mIc63GdI0br39f9XSKKW2NaMrtz7RKKN+JqBNbS7816tpcd69Zc1+uxNabl2KZrWv2qyaf1JYh4q1EmCwyn0/9uzWNdhma9Ruc+P09cb5fz2QIf63FsraeqInXh5rVCwGclESfGVp69ejn4MLlsddFUJmMuDGMhCFMlYlVLYyjNtRM8Es9yTA/HkUIxdWQUROrCsU1RLWfW5VUnsL4IokqXIjkrIQopRYJ4iV0VT1uYp7yuMJDrrORvP5sbVt8notcRirESCGgtU+G7rXFMfqr+0VkktGjn/r6LgzeeeNfGXhMX25CnXP/cPctxnPu7/X7ukJ1DNZdEwfVct9q5w3luLHch5EvIu6EkkYYYXx6lbxHZrWdufbde6zUT0wWBbMR7ScjntTgzpwtEfev6rb/XiFZ1UYX4hMjfftffr4SxuZfPtMt7ycR+FVcPjgMxBvcaMoNW8VDgMWf6rpv6CXFe91rVtLTV/GqjREKKBC9A+bJY6geuaPCjaAK8dn9P33dUAhqEUjOHw4FcysIvb9Y7DaOFwFaFlBK1ZisNE1p6MuU4ZHI2HUypwrCiq0si1MYxIwxmYnsGWa3vX7f1ZvxBReet/rQKOqGg7evWz1xu6nOE4RJCu2u8azXGJXS4ZliXiPBW2yIWlxgUsFKqtPULi3/20tdlfs495y7pYE1QRIQgcUKvdr+6G1DADFMy/a119X6lMVYLcImLkG8ROQmgeZnWxnSX6mBLslnPf2ttLgGPSwR2vWdlkRMAEU/+XacggZwz+/2OruthQsSObOtcAHUsOp3pECxvdC6KYl4FuxQIYt4IN8dhSne4Na51e6UJLCL82NsP+dmvPOTe/oqr/ZWh2hRRh/+1WmXRGBOKLVCMEdFKHkcQT7wNqAoxRK95Zfljc8nm4tUy47MtRi45ZPv13OFZb4RLxPZSu4u4rA/ydJCa1LtgBJcIwF3je5nxrwnopUO1dWhfhlCfkwDOEe5L/5b6SJMa/PBton8neGcQ9daYlnPb+nxJwKBJV8s+XPpqhiOjIid61YkQt9tUJx/O5b+7GP56XHcRyOXcv59+t/6tr1lfvx7D6TiEya42qVOsBIxWZZc6VC15dimV4zh6RQJl3ycr0S4T+6RYaWW0Vu7tjJ4cR6Vg+tcAJC8hsyk6bLRXm8ACmu7x468J/9BX7oOYCkBr5XgcLDkDQsm2yXa7zkpUi6sUSrE69mOGEIldoO8DfW8wP8ZoERy5zGiC05c6uXC8JOpcI5PlRjy3oW6LZO2idvi3EcJdYqAI05yWc9sSV7c28/L77+e5W8RzTVTXP18GYW0h460xL9uyHtT6EG/NaZsRnGe45xjH+rv1eG+PJ6zEzkY4dUH359+Xl9pz67RPZNX/ek+ux3sJXd4lWSzX7dI6r593jojPUsX59WwMcakrP50rdF3wAAKdwFNLa1pyJo+ZgqkRBDNq5VK5vhm4PmaG0rwMwIxg5jKGlpOCizYezrZXWwerShmPHIZMH6OhUxFGvBgilSDmyqW1MgwjWqHUCjGy3+0Yx0zoOkSg7wLDMFJqK/lspWa61BuCUaaX1g7WcvHOEcs18W0/zyGcrWuWm6eKOHFlSnt36S1uoomGyjBhs5X7FLb9Xpdt2dc5wncJnW3Nac1Qtq57mees+1h/vpzPuTme6++0KUwJ2814YpfcZjzfz9i2xmDXePghS4a2VEk0g6dds6Sw03znzk762XruXYj70rtd/m4/z393qc/N97CwyuvSlNTWVGRypWz3na578JpciYP7rIYQKXkkBAtC2u96u1YVFSEGKw0zRYfWSnVPhP2uoxQbS86Z1F1hhjQ7V6qyaTRs7ZVHsCWPfDHAr358Qx4GxjHT992EzgDGYbCXteDUqhYWW0qZxKRhGE7oVFuYWUe1cHfaEFfuOihbxPRS2xK7lu1lDsgaKbdrpq5WaoKtcd/1jPX1y5wNLzP/S8RvTXy35rXVz/Kzc+/nHMp8mfdzaX3O9b8mKpf+bfW1/HdbtD+P+Lav324vI41cmv82UJj/viRViGxXmD15poMch+HT5/P1C0K7HmMDJljlaHHpNAal33WMpRU8rV6Hz6Tcm+PR1Y2BWkzXHYMVU705Zs8Zaxn6UtfN+/IltASvNoLF0gz+5qPM05sDeThSVagUN16ZAcISvSRCFKwmVyCmSB5HBKhlJEhnZoMYqV62uxaIsTPH6+A6mEVzqQzgVpXYNSGGy5v1FLW2axvS2ObuAlOWMHEEszzArbKpopNr15LBmDGkbUi/8gJq3CIQWwhkLSau+1i3rTU6h3bOXX+uzy0ifI6grse2GXI56eLr4hmnqoJzqOzSmrw8UW9GtunTk/trZfJ6WM/ZxGrLmrjlP7o1pkuEdIvJna5n28uX1QrtvqUHwuZ+b9e7pLCl0ppEu8V9q4dbsietBCq7fW/lpRRSsBSWKmHym08xUkQIIaIUJGAFEyffeGUohRAtHwkCZcqoZf8uGT9feQJ7zJWb7ETE4X8QK9/dCFBM0XMKGLFNsZ9C2loQAWKlegdHu13XUfJI011FZPPQukA2tXNi4PqzS8hrJq7brWUumt/hbOU+2eztelWkqkenrftdbGaZZ3PuwJ+UbtlA87fnMbe7CMmdB+v7aGuUeO6ardI/54iL/W2SUGN6p+9xTrR9rm0x3vUz1+t5Og6HYCJOuBb7bWHkss/qST+uA5r0l7fF59uqn3NSynIuW60BBbuOab0uveNzqHnz/c9TP73vpA/1dVr0XSv7FLm37zmOI6VWcrbzFKKh13HMoGoRXSLuEmmqhFwGM3ypklIkVcvGJzFyHCrjcbRcsxP6ugxjf2gVgYhEEfklEfkP/O+fEpG/ISK/ISL/joj0/vnO//4N//4n7+pbgZvDYMhS1WOC5xcSXS/bEGEIgZg6M0xpJaXkCxtJHm7biFDLqgVzBvSptEfbWIu12zrMWyLQuQPmV3D7gN7ud94wl0W+QHPxCSfE9dYhnh65ffDXbbmht8Tvu1Dl1t8vg/TOtZchpFti5zlCtx7PCVHYYJLn1mE9nkvfnbvmNsGbRe5bfS3fY3Oqn1CeHfpza7HZH6frcWkv3Caa83zOPWvZ513ve/P9nV5w28NnC2ETqIgbt5VxKAxDZsyFUqyqiTgX0gpa1QksDtICKQZE7QJLgQq1jvSd588KAdHz67ts/yB0sP8S8KuLv//3wL+qqr8H+AL4C/75XwC+8M//Vb/uziZi+Vqj2MRDCJRSzJvAxY4gkGIwkQUogtdEt8qRx7FwHIwzlTFTS0UkkIsVSVSgVFijOxXQIJ7/5fbhuYsArRGEf+s/LURvq6+pj9Vpa9c2HagAQU9f4hbhEBTkcoKKy0jlsv72HPM5KTq3QjBbDuvnxrG1jufQ0Na9637uQtn+2y0PhPU810j/EkK79NzTvVVBlHMl2BH73kdovrFqvrLNW2T5zOV7uIuIXhrbjL6bb/Dt+bws413v+ds34HvfziCex1WCbEpyp2OsDKNl1dv1id0ucrVLlk86JKKI0xGhqlWwNe8jNY/nYnOUYGMbXQcLkYoQUudBCLM0eBkE/RBNRH4c+O8C/7r/LcB/C/j3/JJ/E/gf+O9/xv/Gv//TcsfpEPDqBFY2puosYlm8sJXkbRMMIqDVfGBz5ng8up7WJxsDXdeRYrK8kMwbf4lgl+3S4q0P+xYa+GGQG6on+qbWx/qwLw/TZjf+c4tYrsd1jpCtr93a4C97/fK+rS1wTlLYYmSXENhdxPfW+FQXa3Xax7n5nvv73DV3Efjls9aE+WWYysvsr3Pva8lczvVry3R5nV+G6d1Gnsu5zVLXufVfS2sis6gPpofWWiygICWi4OHyMjH4rusQCdSqdDEQohCTEemu60gp0fc9SiSroBIYcpkS/r9M+2ER7P8R+F/T/FngbeCxqmb/+33g6/7714Hv+qJk4Ilff7GlvuPefkffmdOwVSKwyrHqup/qJWUUK9nbdx2lVJBIhSkstpRiQQcCXReJqdXXqXRdnIxIcJkbb11zDsXd3synSNL8H+d/J8hAhIqVtahbh0tk6m1N1FUVxdGQefTRLHXnCMI54rtu5xjLsu+71vFSH8trlms4i/EYMTzDEC+h3NuITCZdfhMd/coVWrut334Z5nBpXOt2i6BWFpF5HsVFoCoUVcvLIZamryyYwxYDPF2LpXph2f/SwCaLf21/xpNxLue2/vyu9z+NC5cUp1errCVJf4iFZ26s4/QTEIlmyK6KqqBVGcdM9uqww5gZxmKJn1SJyVyzjoMFIxyOI8fBwJkljSnkYqlSg1a6FOi71Oxwd87xByawIvLfAz5R1b/1g/Zxpt+fF5G/KSJ/89Gjz4lBKONIda4xjJaWUJWp3pZtICNWquo5JIMvTnVk6wEHk4Oy6XBjjOz6HawU1mfR4AVEurXplt+HsIVeZOPfyYL4PXrrthYRu3S4np+nnM7ptnh1TrRdo4PWli5vS7Hz3HyXROzcd3ehsm2CZcS1lnLiD8nG7+c+W89tXt7l89rat3UJdxKOS0R4C8WePZwL4WUi/Np+iIvQ87/JX/rMeE5/zv+WlZTtDJ1+Ny/9lrprNeQzjOVSKab1OPG5raU0ziDntRSD+D5V9ZXzObpqoOt3RoCxIINhMOKrGMKNMbLf76Z+s5qqIYhl7cs5I1oIoltA/1b7YRDsnwT++yLyLeAvY6qBvwS8ISLNO+HHge/5798DvuELk4DXgc/XnarqL6jqH1XVP/rWW2+z69Jk1Ssle5IXQ3Qiluil6fNyziBiVkJf2HHMVkGyT4bisCCDECKlWI5YVUN5IcRpHA3ZLMY1/TwnTi8/W67+JTF2SQiXB3t5n2CGrJODuUBbW/u9bcq2MZd/C6eI5pzYvRyzqk46ya3ikOcQzea4VtcsP9siULevFaRZhVfXrse8/rd+zjlUWfXUv3Trmi2x9ZLouPZVvQvdT0RmfshLSRhb/Zy+59uE6tz9WykOz0k77Z5LwOPWdUtQ85Lzms/ABuCpts+NNkDfx6kuX1y45eWSJ48irRUD9OJeSnbeUEhixq9W/SAGZdfFW3jnXPuBCayq/m9U9cdV9SeBfxb4j1T1fwr8x8D/0C/7c8Bf8d//ff8b//4/0kur6O3mOIAEJES6LnG169l1nixblHEc7dCLeGCBEdlSLV5413Wm1I4O7au5cg3jyPXNDXkc3SnZiprNRMtfVN32Mb1jbfyn+L/biHGJNNVTMK6bIJMRaxv1XDpcMCcrWSKnOP198qwNwrp1zZrIrqNY1oT2ksh4jrjeRXiatZyXQKrtvstMboNRnpnPpX7b9WumtR7bS6F1EQen5v9chcnvuV27ZijnnjfP6HQ/bF93Ooe1MXJt+Ds7/o3+tto0B+P8K13s6VjWhH1equW19vNwHBlGc8na9xa5VdXoBcBVl+ijnYUmAeN2GMuiZT7y5i6pdKkDLELsZiimEz0z32X77fCD/ZeBvywi/zvgl4B/wz//N4D/i4j8BvAII8oXm+JcVCtQUK0cjoW+S1yFjlwrpcYp52OIQowdw3GckG2tkIvlJ2icTRwRxxQoRen7SCNWW9xXF79Pn90hJq0Jxl3i1fx9oxuuFlgQ92WftdapxEy7dLkBz4mq0/gW/98a/yX0+bLIa60iOHff2lf1HJE+YQAbLmfLdgllra+BJeNs6pjz41l/fm5+l4jsur9b81dFNxjhVj+X1mHxJOD8vl1Xi2hjW679Wpo4N671+z8ZxXr9fMOfY8BTHoHVWigYQV5LHpjN5cG9HbVWxjy7ZNa6yDkiQoy2JiFAHjO9r4FVT/FCqAIhJos0l4A275LN2d9u/0AIrKr+deCv+++/CfyxjWsOwP/o++27c/RJMS6jEjiOpnvrUqCLgZtjZdf15HH0IAQTIbVaPR3UUrgNZWS3203+sLUOVK2oBroUfOFOdZXzJrDP7kJI7ZrGFe36uw+rf3K6qcFcUxREbxd7MxGJ6VqtZtQK0yMtAYGcEVTOEaH1GNeH6pxouP5ui9Av+5nczS70uybS62ee63+LMF+6dnpFJ5LFNuLeIhznCOel8ayvVXX05MNpQKAh9rvmu26338Xc53puW3T3HEK+RFyX+3Ote91iCqesrLVwKkkCKuIJsnEXgdM7lxJhy7LXwurHnFGtXorbUhXmamoC1PJDX+0CWgD3KhAxr6N2jnd9YhiM8B5HVy0gdxLaVz4XwTBmxrFwOIyMBXDdakwRRcil0HmGrRDClJfAqkqmqYJBrbPvbKsiG0P0BN2WBEI1TO9si2C0v899B1toRk9EmbW4tN7E8wGYRcWGUjdFXXUd0jxAn8OCUGwELJxDDMu+18T1nBj8/aOp7fW9S4x8GeZ2SWw/xyi2kedlMX/Z7/rZ6zEtda9rn9TNPbRl7Dwz/0vS1O1xnkP0t9dhaw3ves5Jj2fOza39f3u0LnrbqEIIp4ix/bIhPRiDsmRPVa1kzHEYJ2Jvxq9KELPnXO0t1/Q4FkqV5pwCFAgwjtVBmjDmwmEsFMLk0XNursv2yofKZq+hlSKMxV5QcZcLPMsRqg7n3Z8VM1LUUkixo+931GqK6pwz4ol2oyeDDGKhtmPOJ3quGTksOf/dh7SJnbahT0XOS8R5q00bcxJdW1eNi8/XmTpDTmCB3eviIU7A7ZvN520R0nNEa/mz6eqWCO/cGp07bFvrsj7Yl1QX5+ZyTnS/hUZlDv+0tbzdXnbcy2vP/b2ez0TY/Y01MXjZfyMWS933JQS7RpLnGeB63efP5ltuE+AtorzFzM4x5HUQz6kqo6Fu1636Hj43DwssUq+C0u4zRFrdsygmk2z7Ltkqe/nuYSzEAEnM2D0MAyGAhIig1KK8dm+PTC5gd+tf4RUnsAJWYnu0MtwRq6kTJFDGcvIi24abwl/VorSGwZTapcx1usxDVNillrlcPNGLZTCftqOYn+kl9UD7fHl47O/Wy10+iZfb1O9SFeBjmo7j8vka2o0061xLXKKNU5wZ/5J4XCJ0dxHB9dwuIcH1vUtC/YOip61nnhPRb/UrwdRLq+u37rlE7M8xl0ui/sl4RE78Q5dtuUZ3PXc9ztP3CDNS3y6ICHgkU7t/9oVd7octZnzuHWyN1Txl/H6ZdjkTMPFfJ1fM1RpOz64mlpdaCTGRknAcRlI0byRRUzeIiNEGEfouufrNgpeOx5HU9QiVEPBCqcIwjuwkUfL5tVq3V15FkFJn/sUhUjBXi67vTPxPaXqxIQTziwzzAVFV+1uElDrGbAsWA1jSh0rxzFqtry0CBLc58SWx9dLnL9PWhGxGxPP36jLUy4uH2xv+nCi3fP65ud/13LvmtfXd8v41SlvP5dLv60N4CXEuCcTy3kvIeWt+51yatkq2nFMRSOv7jKSwNYdNNcOZ93Ru7S9to9O118U9lxnP8r5zzO0cs9u65xJqnICWh7m2PlqdPfGweYnBEsAUNbXAMqeARIaxel4PGHJhHAujl58puaJYXcBWpueu8/dKI1gF+i7RpY5hHNBilv9xOBJDdL3qrIiOUch5IMVE1ydQGIYRkdlKWlTRoRIwlBmTFUBswQjNGt/cM/DNV2kJkRfjW2yos2In26jiXD/Ln03UUbto+gydVRZbbT5YjfufBgWcQ5RbiOTSOF8Kia3+3hKbz92z9Zytw7YmiufQ8VbfW7+fm/+lddsi5i9D4NrebT7ak3jc3r0zV13f37rW+fd1ApJL72c9p3NS1tyWAQnn+91agy1mNl2/MBTpov7Z8tr1fjn3bgShSiVIIHXJkuuXSqkWuVkxZFtqsZQwHhUaouU3CSGQgniB1ULvkZ4hWMIXJTCWYvSijf6O9X2lCSxADNEchL1IWatdVIqVyg1BqNWiLFKKpIh5DmAcpksBpKkPrDxvLUrqokWJ1UoueKYuE7qn/aBMuk+9sJDrzbh2Ozon0mzde/J9+26NKH1sS6+Cdb/toN6FHNYEYgsVnUND5+ZwaU53EbxLY749x9sql63DfI5wXxrTXe9n+Yxzz3kZBDyhwiYDt3HPnZww9okBKFSB4XAgxUhIp0f5ZYjg6Wfb82vPa+i8qeDW/Wwx0PbZUmd8y2+aNn31Mfh5u4N5L6WN5bPa83I2OpFSIKhStZg3kkLf9Ra1hZJ6m08ubSBKLsXKUWklRRBpOacDu13PfrcHT5d6V3ulVQQChjBTInnElaoudFDV0abnFohWZ2scM4djtkQPviGa6FVLoesSMQRiDHSe0rAUdV3LbMmfB3IbkXw/G3gtJl4SjU5Fr20i/TIi+ul922NcE6dLYuXLIMGXGcu5vs8RyZNnzTed/r3oa4uJrUXWrTFdIuC3xrH6/lL/63ZKjE8ljXX/DclujxeO1zf84n/ynzHcHE4chl48ezYlJLk8puV3S8Y8/710pTsnmd0e2+29fY6JTUYrN2Dpwj1uLRUs/22dofavqlJrnhJt29mGkivFjV373hLw3xxHQEhBnZkZE0gx0HWJWrDE/Kknpj33+8R795Oj2rv3/itNYMHSCB5Hg/pdtEisIOJ5BBI5Fw97NS5Tq61TipEUOtPJtL5ype8TMZpuxvQrluShljzpa8A3TxO92D5UW4frEqECNgnJWdF4oXdt7irtepHb1uEtYrUc2/LA3SXKrcd1soE3dI1b163Hcla0W32+JWI3pCOKhUPWWZw+t+7rMXw/CHM9xuVY132e2wvr39vf03MVUEs5eGv+wpQqc81J7PvAb/3qN3n08cfgKTsVCxf/+7/yq6hLeFvS0zzv5XuCudz7/M/uk9ld6gxIgFkHfQ6tr9dc1Xa4Cm7Yaik8N8KT2zs/syenf/5fCsG8AmKgS5EgSkqJUpQxZ4p7Ee17S9xSiQSB6LYc1YJgpWa6PtH1O/a7xE++ecV+35+oNi61V5rAqlqEhf2ulFpIKU4vW1VRd72CeaP3fY+ITBEZMUbzf4uBUoScTXebUpg2Rcsf254LTBZ6+3A5rvMi57lrzl0rziy2iMqWn9CWKLZF/LcOwFI8u0v0vYS2b5W83iBcayL//ZaQXs9xa2xLxncJKZ0jrJeIxfLzrfe9ri11DqHdNZezTWe6urX+OY9879vfYRxGq96h5jnz3b//WxyeXxNjmvpZPv/SeJdzXs9hHTSw/K5dv11R4/Tac6h369qt8WyNdT23lBIhJYoKg6sKqhc63fcdfYrT9SEmVKFPcVJ/xGQIVSRA6Nhf3eNq19GHwt/73sd88WIAtTx2d+3lV5rAAox5RFCimBGrauF4HBCxRA6xi4uk2fMhzl4V0l5AoZbiutoRiXZAtBoHTckMWiaSNV0QUyq46lxx3c4dQLgsZq7R57pPUSUsDtjLtrMbU/G0d9vXtuvX362RWNvIk8fFmfuXaOdcX3e1iWAuc0EIcwax9vtizHcd7nX/597fkgDfldhm+Yw1kb8kTWy9KxFDrNXRK5vrZfkEPvzu+zx59AUSPNSzVn7z7/4qf/9Xfo1+vyc0Yrfk17eY5W0Efjo2j57U80xza65b62ro0qz2egsh395/671iWgtfEzU0O40HAa9MYN/bHV0MdAFiUFIQN2AF01974MEwmBfRcRxREcaqjKUYPVGIaUdMOw7HI4+evOBaI8ehTKj/rvbKG7lCsDRjNTRkGeh6g/NwmnC76zpKKYZGJxFpRomW8CVO/rVCoY9xRqy+HycBavHFcosvic0aUa431TnR+6zYaJ/M/XJejF+L3+2zLTTXRL2Fl+/qu7tR9+bG3xjPXfN7GQlg/sx8JI35tU9uz//S+M8949x36zku33d7zjmG9P08d81B2xzX67ee5/HFDb/yN3+Jchi499YbhNTxzV/+O/z9X/k1RJW3/sDv21YrcLon10PbkorUidWW7+16fus1ufU+1Jji5BkzfXz7vltMaOkI7rHE0zV+xhvqH4aBkgsSzesmhAAhWIASuB7WDOWNiQJoqWipEOyz3a4nSuX5i6eMxwO1KrEmKnMQyl1g4ZUnsCBIsAoGMSZ3yzKr4Dhm8zCAKZyu69LkctES5qbUuf6lOBMUDjcHdn1PziP7LoHMCG+N/iamyDZBEVmiw0ailyjgfDKTRWdttrbBuE2gz4lpa93s8hm3Divt+42VPnNYzo75TLskGrf5NI+Qc8RtydymAyTfH1Fdtruu2xrHXaqFc/esf67fS2P62zLKksX79ThRcrvBr//Xf5ennz+yhNF9z2/9xm/yve98lxAMyb3zlffOzm353HmJdTGm22h1ef8WoT3HiG6vD5Ms2Kolt77Wz77Vlw+4OlIVCbMedPpfQ5VCKWqJ9hehraJqqnvEVYdNEjP1QReF2CXGbImlasmMxyNjzrZGvl/HcdwEMVvt1SawtpLkXDzSyiapoq7TYyJetVZ/aZU8KgQhuSFsOB6JKbhRLIOaTub5i2tHsp5XVuayNGCb2t7YLGptE8owEaz2sxGRu9Hq9IWlRpRt1No2ert3nUbuHHq4TTQXyHB1AM4hp9Nhfn+EbX3vOZS7fubJ9+E2odq652VQ6rk5bRH7rbGv0fwlZL7ZFPN5nfj3auwzxZj6LDnz2UcfoyiH6wPv/9a3KZ5iUyTwyYcf8+DhG4Q33uT+vZ6r+/duzfn2u25zKpNkuJ7vraGviN/6Gcuf28/WFUs5/95uEVlfr9DqchkC8eNpsNjeY0ZioO87UormJaBWslvE1G/Vc3eIiLt0QikjgwY7/yJohaEM03PNDTRRStNAtLW4NfST9moT2KmZ4aqMVp885wKuv8k50/eJ5E7BJmYJIUXLkCUVdpFhKLRKNqo6VZyVEAhhztYvTtRPENRyJBvo7JRw3b7Oxrp1z+lnIWwjgHaYW5Ka9XPOqSnOIa67kNkpMt/m1HcR53Pt0qE/1//WPLaQzrk+7xrXyzKLS8/f6m+T8J8C1AtjU2rJHG4OPPr0cx59+jlXD+7z/m9+h5vnzxjHgfuvvcb9h6+R9h27fodS+fHf/ZPgieOXjHmbsZ9fr/WaNiPlsr+ts3BJetlaI5NMbrt/3TojripqZ8mIrvfv9LedfTAienMwo3guBa2VgnlZdClO4b/H42DI37SulFyIKZBHUz3GqeJDsBI+eC6Ul8QXrzaBbWhNAiqBEJUh28SDWHBAjH1jZoRo0VshVsZcuBkN2ocQ6bqepktqeSFDjIwlI7FD0ZOE22AGruk8aHPsXw6tiTlL39n1ZplFMft72xdT1YMZRNwFab0UL4fethGiTiBc9XbI4/r+JQFZt+Uhe1kxadn/ub+/n3bueedE1fU105xZCCie41Eu9L9FdJbvc7qvWd8mqLWUbJgIg7ZL1cRXBHIeGYfMo0ePuLm+QWrlN3/179Fd7fni8y94/Nnn1Fp466vv8ZM/+zNc3b/P4TigpbLrO/IwQC1oCCsiJSxR6rw0y+9vS1jLNW0Mfk1g19Laub2z9S7az6UEsX6PwEnxUqYzN6s6miSgtXI8jlTEozmVfWfVS8aq5ApkKyXVdR2EiFLpYmAci4fZN+OmkseCYHYgFSF1FsSkeAiubit6Wnu1Cay3UgvD8Wi/50wIlq4wiHA4HFEJlDLQpYhW0ym1el3txVxf37Df974RKqqGWoMIZfTMWhMVWjxc5kNnLztsoE892cinxOcWCL5FBKdNOfVweu05McyGdxuVbiGVNpaTg7QS0baQ113I9dxn6/YyYvzW95cO6jm0dBfhFxFzRgeuXzzn848+4er+Pd557z1iutvVaPm8zXWf1nl5/dzH9Kbb12JFDA8vrvnOb32b4Zh5+ugxsU8cXrzgOIzsX3uNxx9/Qgjwxrvv0Xcd3/3N77C7uuLq/n1Sl6il8LC+xjge6XZX8/OMqvteXI55uW/NAX89n4nALVRSy3W4RFDvklDaWjQCfe66tqTtHIqc90IVgd2u5+mTZxQRSoE+efKXBerd9ZbGNEWhZCWExK4PllGvFrpgaFWDu3QFB3SqjJ4P9mXaq+2mJTK99K7vEYEUmwhgeQZSsiS6D6527t8GIhY7HOOc7zXFOVt5iGlKAtOlyK7vCCHO+Qc4PbAmvrel2tZnzf+23VXs3+n1MwIWGvJdEtr27NNnbaPb5ZiXRLulb2zr2fqciPnqsCyJ1MuI/ZcI51qcXPZ/6bmX5nrp8+W4tw79yToB1MLH3/uAPAy89fbbSAov1fftz6aZgFuYJ8e+xVqzJK4Y0cg58/TJEz74zvv83V/62/zyf/ZfcP3sKYeba26eveDpoycEFZ49eQIilCHz6MMP+eSD75Fi4L0f+wqHmxsAnj97Ti4GRqaCkIt9dvsdzQhwWdDRhnqeyWypCE6AwktIGG3tmny/vmcKWphW9fT9TXt7usaIp6qVhbGS3ErqAlmNwGot7Hed0YGiHI6j+9DjHgYGlmIMVAkMYyF7AcVcLTlMUfOZP1dkct1ecQTrSbFj4HA4AoHUgbghqgI5V3fP8kzmWukT5geIuWaoWnby5kg8ZPOl3XUdXTLFdqmFkvOEYC+JmbBGedujn++9TUBOEddpv010PUdct9Da1nXzGPT2PatprVUE67/Xcz6d3+1x3LVu637PEdn1fVsqli1EtdXWz/v040/p+x37B/coWolVT/SBW89ZMp4m0aCOdibNwFInBDhitu7EaYpyfX3DJx98xOeffMLjTx9xfX3NcHPDcDhyc/0cLQqlMuSRwxc3aC0cr6/pdj1XV68Rux0xdTx4/T5X+54YhSdfPOHNN99iPA5ECUiMLFP83V6POElYa+S/tQ4/iDpoDVZOPmsI2RnRieqlKVfbsp1570vJQbHihE/L6KHvntRFZzvIWCopCH2KlvNVzJZTRKil0vXJa/uZNCwBqBVPZUAXf8QlY377mkwiW1WljIVOEgFl13eownUZiZ5MwhBphwTQoqgs8jkqHI9He3Ex2IYEUHU3jOAlKU6J0zkUtHWo5cLh3NrcpwTcnr3cdFv3rRHyEjmcH2e7Z3LSuqUJWd9z/kDe/v3cONfz3FI9XFq39t2LFy9QVa6urk4CGC4R0rtUC+OYGcfMixfXhL5jHEfGceT+/fsvRSBYGC4NtRoaW85nqx9V5XA48PzxEz7+4GM++/gTrp8/58WjR4AZX188f8FwfY1IYDwOjMcDIsKDhw+5//AhhxfX1Fw5XF9zPBz4yte+ggBPnz1nd3XFo0ePeO+9r3J9fc3V/QdIuL2flvPZ2k9b128x3a01X39/jimeXLcg8tP1jnC3GG9w90yW8xG8nHsFArmORMH1qEr1sPnOPYZa7tcQIkEiIShBLLIrCmYAT5Gu6xhzsWzRalVmdVGZ4pKU92oTWFXbupKwulkmW0uAYRwIMZBSdE+AwDCOKIGcQYLQB8v+M2bhOFjOglqVUHUivIMneUELbMB+W7yliHUZHd2ewikRvISM5zr0d4fhrZHUuc1tH5obWSOuhmAv993mdA4tb/2+Jmwvg2LXraGXJSp5/vQFVSt5zNx/cJ+u684S9K227K9q5Xg48uH3PnTmbUvx63/7Vyiq/Mzv+7288cYbm3Ofa5sJVfzwT4h0MVed/1LgeLhBgOE48vjxYz796BNunj3n2eOn5HHg8Pw5h+trdrsdVSvDzTXD8YgA4+GISOBwvGF3dYXmTC4jh5tr9jXzwbfft3V5+IDDjSUuKSXz6PPPef3Nt/ji0SPeeutNWBhoz61ZM1S1NVuuwSUi0t7bcr2Xz7ikX91ihifPEqbghM2zE5ovrNg1QaZMWPtdxziMpCiMRSm5ggpahVwLu53llC61MpbCLlrOgpYs36qiKIK5xKn7zh7H0dIioKcqoI32ahNYzK81iHD//j3G4WB6lqqoCipKECv/khcbQZo4ESLFZx9byGNQoHoZCfUQ2jrpaNnGdqwNAFvtHLq9hDBPP5vnvUXIL6GP5fPWbbpuiTJaZb075nFOPbAmpFuId2kZvjTOu9bmylFZiEJ+knn48KFZgH+ANThc33B9c8N4OPLrv/ZNhoPpK/MwknY99x/cIw8j77z37m1krU11w7Qflk+eGB6KKJRh5MX1Ux4/+oLr5zfcXB843Bx4/vgpx+sbai5kzQzHAyklLymtXD9/QS2Z4eaAlkK/21OGgTzmKTtcv9txeP6c8fqacjzQ3dvz8OEblPHI2195hzEPlOL93Vxz7/592gu/C3VtEdRLqqKtdf5+mhEvNWJ5QlxlQqnNqHUyhvZ7u0bMVjJXNQFCZMzF3bOaO6eQj5lSrHRMqELOhkxF3DVLjVGFIFYYteI+8kcOh4MXSzUi+zsXwbrY1aXI4ebo0LyQYiIXi76guHXQN0UumS51hgSGOlkP+65nGEfLL5vSlCBmt+sZjkf6vrv19FMicH7zXFIN2L23CePy8yUxVTVn6DUBuiR+wWwUaJtr+Yyt/LSL2IlbY1yLgss5X3LIv4Sit1QFL9MUuH//Pp9//vkUTPL48WPefPPNyYC5nO9pW8wFE80PhxsOxyPf+fXf4NP3v4do9Rpvgf29K54++gIQru7f4979+wv3oObgLrPP5a2ngRXYVLRU/t6v/RrHmxtKVj7/5FMPDjBAcDzcoEWpGHFv5VJqKZTrF2jJjMPRIhLHEQGONzfcf/gQ1cB4OEItXN8cSfuep59/xqP4Ed/4PT9Nlzp2u54XN8958+GbHpk0v6N1kMry3V16by+DaC+pgZafn+wFP7+X2l1SlTDn98g5o1gYfYMqnRdANaLpXkhBmsswVQzl9p15F0gQupSmXLa1qjG4sIgM83+3RINF+6EIrIi8AfzrwB/wefwvgF8H/h3gJ4FvAX9WVb8QW5G/BPwzwDXw51X1F+94ALu+JwiE1CHDQK4ju04IfUcuIyHiEV0G7WMw3UoePW2Z++4djge6lChlJITONkm0vAQniat1rWub1+8S4Zmv3da9LdZsdd8sWllKytu6yfbZUoTb2mTLg3NJVG/6qqbzXT/rErpcfiYiJyL9UqxvOsn1My6tyeYhUpAY2O12jMNAf/8+JReePHnCW2+9dRZtTf348hZVbq6vybnwyXe/R66Ft7/2Y1w/e8o4HCnHkcOLGz794GNePHnBF598yj/8h36ON999l7BwuZoMWYvxjePAi+cvKGVEQuDxp58TQuTpF4958fQ5+/v3uXnxHK2VlHrGceB4c+PjruRxICVj8FULjCPjcXDxODCMZjvIw5Hj9QvSbkcIwjiayPr88RNTXsjA4fqaFy+uGcaRN958yPF4w70HD0/2wV1odGu/nJMUtqSPc5+3YAGFqQS3LvbhufFsvVv/Y/Z0E0/sLWEqt90Foe8T2WtoSQhWycCz6qUUQY1e9J15Fmm1mn/j4JFyyJSxT4T52mkMm8Oc2g/rpvWXgP+Hqv5DwB8CfhX4i8BfU9WfAf6a/w3wTwM/4/9+HvjX7upcgP1ux5v3d5Q8ElJiv98zFotysZcgUzWChuBamsJGkOrCCBZCmKrHVhfxdr5hT0V0I6zt4K8JwHTlhjpg/d2sutgiyv7dfNOtftvf59L9icwpD9coeZ0Nah7LbUS9vO4uRgGz3q19Xkrl+fMXfPbZIz768BM++fhTHn3+mBfPr6cE0FsEu9bK4XDg2bNnZkkfhnkcKFWE+/fv89kHH1uZ9r5jGAaeP39+q6/TAc+/DsPAzc2NRfTkwu//Y3+Er/3kT5L6HTFExnEkdol/7E/9SUSET7/3MX/3F3+Zzz76kKoWxVT1NBeE1sqzJ0/47ONPOFxf88G3v8ff/i9+iV/+z/4mv/bLf4fhcOR4uGE4HsnDyHA4MhyOHK6vGY9HqJXheJhyEbf3a9nh/B0A2WPfBQtEePjWW7z7Ez9BaGoSVQiB/mpPiIFnj5/y4bfe57OPPuNwPHA4XtN0+uf26Na7Wf69xRDXuTEuMfXWfzW5+oQZX3r+1l4/N+ZT6c3GOI55OhspJVMtKUBgHDOqxqhKLQyj7TvBUh6qqgM4UxHGGKe0ppfUAsv2AyNYEXkd+G8Cf94nOwCDiPwZ4J/wy/5N4K8D/zLwZ4B/S21F/nMReUNEvqaqH156Tux2/O539+SbyMcvlOOxWHXHvvPkLYGcbQEQ26QxWeEzXehwoxvEbo6FFANIKzdTJxeRBlQs4YpgAQT286zC8nRNzm7Krb/njeLPlEYEt1HoEjGu2znVRWtL9OufNOWVqVdaHyqTCrjpttyKgLQgC2m+tYYQD4cDTx4/5fPPP+d4PJrUESPBK0zUYkQtpcQbb77Oa68/9JwQVl3CROYjzbhwI8IwVg4vbri6t6fbXfFrf+uX+Og73+G1N97grffe5uFrD7m+vma369nt9jY+aXPwaBsB9Wqpz549I4+FoQx0+z3XNwdKyZRxJI+Ffn/F7/rZ38P+tXt89Se+wYsXL9jdu+LjDz6k23Vohdj1RE8aNAwDz754wqcff0I+jnzx6WcEEY7DkfF4Q+wi4UXieH0gdB2HF88RVeK9wHi44XhzDUHI44AANY+2zlWhVFrSn1oKqBKSlzYZR3IeybUS+46ajYCEFNld3WM4ZsDCOb/9zb/P4ebAN37qG+x2V8TYnyWy59Q6l1pTN5yTck6+s5fD8igtpYB2/s4R6Rbx1hhN+0zAclXAtIctYbbX0qLMKUxzhhinHNMSEsfR1Ai1VCu9I0IQqGRLMqXNywj6riMg5ht7Ien8sv0wKoKfAj4F/s8i8oeAvwX8S8BXFkTzI+Ar/vvXge8u7n/fP7tIYGtVOlF+/1f23Hxww8cH41TDME6GDsRC3IIfLKtsYMEIXReJIYJaopiqhrRSShb15S+n1fjyDoFTB/Jz+qotcWt93eXmO2epj1qhg5fRW36/xH0KJloYa6ZLVj/XaKOqMAwDj794zBeff8H19QtadqPkVSaiAs71Y0o8efyEw7MXjMejGSXzSNdFui6djL2hg+vnz/jwOx8x5pGnn3zM4w8/oNvt+bVf/K/4Q3/ijxHfCNy7uuLm5sbDoC20EX+/OWeG8UCtmZwLn33yGQ8e3OfpF49Nl29yKojw8K03UBE+++AjfuUX/7YZksT2RN/v+OyDT/nww4/Z3bsiRM95kQvXz19wvLmhZktzV1N0BFoYjwNVYTgcCV00F0FVigRKzpaZCSz2XcygklKypPDu/G6JtTNd35G63kTVceDRRx9PuuHU7yAI+/v3bN/nwjiO9Fd7jocbvvet75BS4sFrD4mxn/bKcl9soc3lO9mSvpo0uO7vrBrI99rmdxuqi+U10/NRxmEw3/iUjCEvPRQcudZqNCAI9H2a0xSWwjAc6VNES6H6oxrBBBCPEBURSvW8BTG4N4EYiCv11Nf5QvthCGwC/gjwL6rq3xCRv8SsDmgLpCIX/IE2moj8PKZC4Me+/vVJLEtdZJ92CJYBCzUH4pKL1etqOR6zfR4kInFOi9f85lKzMFav2ooR8Zb8RXXWDy3mwRLBnn7d1Oi326UN2r7fEsuVBfG+vT52fXvyGfTQrm2/bx2k5bW3Pj+Zk23a4+HAs6fPePbkGU+fPuV4PE4qluqWWhEhpmSDy+bxgUIdC/cfPuD+wwe8uL5mv985g3RVjVf3rFoRAvcfXnH18Irx8cCzJ4+5euNNrh6+xrMvHvGbv/ZNfu8f/P30ux2qlc8/f2RGDjWkPIyjGY68/McXnz8Cz+/57MlTQt9z794VXYzc+0f+IBoDIUQ+/NZ3ePb4KU8efW6pLIeRXAshKLt9z/XT54Sm07++MZegnAkijLVQbwYGF/9LqaRSODx/Ri6GOikVFXGVgKfEq7ZfY4xoVUZXF4hYWrxaCqnvCTFRGhrLGd11xNAhwGtvvoGkyM3T59w8f85r41vs7l3x+ltv8OijT/ji088tPefVA5blWNbAYGvfbO2RS3rWdv9at3+pNWCxtT/Xai/bMzK5SK2fbVZ96JKpAkuxxPqAuXS6vrfrrGqBlYaJaAiesc+CjkxlY7kLUgyEZG5bpTDpZu9UwPLDEdj3gfdV9W/43/8eRmA/bqK/iHwN+MS//x7wjcX9P+6fnTRV/QXgFwB+7g/+Ia01I7Xy2bXy6MXBIi8AVBiHI0igZqVPPbkM7suqhOCRM033UyvD6Al2kxU9NNJveWXrlPG/onqaX7XpdOZ2SmzVy0cs5nBLDFu2NeFbfk7rSdqTVlZ81cnQsqVAv3QwlmO765oqmOhVKk+/eMKTx0948uQJw2EAtXBEq4sWOd7cWAhy8KgmRwO1BJMaauVwvOHNd75KzgMvnl/z2oMrC0l0lKYoWmViiF1KvPve2yAwfOMb7kIj3HvtIR9++zvELvG7f9/PkrNOQQKqTtBFGI+DMYRHjxmuD7zz9a9Sc+Xm5pqrELl5/oKHbzxES+bzR0/Y9Xve+7Gvcv3iOY8++Rj6jhfPnvPmu+/Q7ztef/N1Hn/+mDyMdH3PzfPnU/z/MJhuFYXD9QtUC8GZ8ni8oZSR3W7HzfPnUKuJ/aJOaNUrdSh1zNM8gojpaTHJouZs9wHjeERq4e2vvkXXRYoWpBpje/bocx5/esXDt9/m3mv3uP/m6zx5/Jj3v/1d7j14ja7vXe1znvBdQpdb+2tLh/+y+3HxVM6p4U7uWwKMjbFpbTkXlK5PjENh18cplakEM1qFGP1dBlPVZPO5NwO5eZWEoIgWC60XiFg6U0uNGCbXsUvtByawqvqRiHxXRH5WVX8d+NPAr/i/Pwf8K/7zr/gt/z7wL4jIXwb+OPDkLv1rW9anI/zaRzc8v7m2vI4BSg2oFPZ9ZMzVxT6ZNo6CW1rNNcY2cqDFXOdS6KbSJoZwzXVrW9w/swbT72uRqtUAugtBXuq7WVy/n3u2xrIm5ieb3hVgJ9cBovD08y/47nfeNwJxtbdDngvIXD3i+dOnE0Joz+MIfSnsPfLq6ReP2d3bU1Gu+o7XX3+Ne/ev0KqU4gxOFfO6sv61Ksfjka989T3eefdthsOR6xfXHK5voFo44+F4JARTMQQJ3NzccDwOxNSRjwPD8chwfaDUOqGSt999jwevv0bOVjIkdGkqEPjGe2/zID/k8SefmQiJSTyH5y94/Z23eeOdt3n2+Ak319fUPPDixXNyHhciv+UjrSWDwqhQx2yugiFQgaKVohViZMiZXd8bsc2WHD77vUMpU+L4mjPD8UgIpmcupaDjSNXKW1//Bm+8/oBf/aW/w/HmSBkHvvjsY4Zh4PXxHd5+7x1qLnz0/vt87Rtf58133nM/3VND5jn0eGtPniGid0lH5/b+TBzbzttu5/q/NUYqXRcRDySqankH9p2V2ilSkQiqxZk77jsraFaOg6mUrnaB1DUfWtsf5t4VuNrtTLX2Euf5h/WD/ReBf1tEeuA3gX8OA1b/roj8BeDbwJ/1a/8q5qL1G5ib1j/3Mg/QUvnO48yzw2DVDLRSivm4xSCe11E87tgYXErJXC3GgRQ7QpRJNwbqFThNeZ0k0feWynC9XhNydUX8us1E6fZCN68EVVMTnagANohu+2m6IBevgqBe1mK6HiY/zOZ+vSWqLZ+xrF3VDFrTte4Qa2KafV9L5cP3P+Cbf/dX6PqOd776HuNgsd3JjYvHm4MRGn9OLS11n+naYpcYhoF8NMvsfrdnGEbuXd3jjTceIiIc3Gr75NFjbq5v2O33dLsdV1d7xpzpus5Qnir9rif2PW++/TYvbp5Tx8r1ixtee/gAUFKKdH2asqhpF+npiX0HY7ZKVp6E/cPvfI93vv5VChbyeHN9w73XHhBDME+V+/cYjwdj2AG++Oxz3vmxrxCj8Pq7b3HvcJ98eI2PvvVd6pgZjjfEaGi91EIdi9WMGgdTceXKeLCggabsrqoEMhoiAaHkbMYXNXdDrWYUbAUOOdq+jl70s9TKsy++4LW33yJgNegs7j6xv7rHiyePTRTuO958510++/Aj3v/Wd7j/4DW6/d6Yqu8AF/XcfcrAyNJPerW7GgCepCvbns0xz/fx0uPCz9sSdc42AKjUUzTYDAKudwVZpPCc0uhMZ8H6cKkRZRxGqEJA6ZOt1XFwtUsp9p5F6Hf95L0Rgz0iiFWaBaVUtUClWumbaqK6lIROk7gExn4oAquq/xXwRze++tMb1yrwz3+fT0CBoRixEQ3UbOJ46qLVzzHqgKLEoHRJgEJV050hhVqFWk0HYxyp+vszneswjHQpEENcwf4w6UQbERI3Qq3VAI3Q3xr/igCftZKuXpJImJDl8vrJybnpgVaoonkaLMe3VDn4zbc3RZtHKXzwnff59m9+my51vPvVr3AcTPwtVRkOB4abG8bjMNU0av3VUmzzRaG/2nG8vuHZF49566vvMQwDXegml7phGK1SRSk8eOM1gijDceRQKk+/eGyGmQf3+fijj4ldZ07iYyFdXVEO19x4dNLbb79JCaYm2O12aLWInK7riDFy//WHvHj6jHEwv9IQ4KNvf4erB/d5/fWHPL95ztW9e5P7zXEckBC49+A+jz75nDwMHA4HEzEFqIUHD19j9+47EAKff/Qx4ckTxpsbilZEIkohVy8/7frUWooXKDTFTgy232qxa1EP4ggCRay6hjOLts6mbmnp8wIvnjzmo299i09jx1d+7Kscy8jjTz7l8OKamCzV4aOPPzE7xa7n0Wef8dEH3+MbP/XTzqwrSnSNpoGJ0oyrValLHVTbLk7VdPHRHM0kVrCRWU0kYgHGqgvSqLY2suhLGpFfaQOaFLc05ch6P2NZ96y0VMuiF7k5mP9wdOBAMJrR75J5WxTzFFCFYy4OakwX2/cWWRfwIIQxTy5eUyYttTN3LhQYXvVILjWukotBQfWNGIIQVE0xXSrHYyZEd2PS5spkhotSbCukFIBTf9QWVQOKhHhL9zn/vkB4rI1ct/VTS1H7NBFx+3T7/sXTXLfb0MFK5L/FOefnqVfLvLm5wVzUAv1+bwSu60hdsqxj1YibrXElxUTRwvXT53zrN34TCYG3v/oeuRTyceR4OHJzfcNwcyAfj2Y49EiqEAK5ZMbDkYAgyaSCmxfX1NEzl+16rtKeftdRap0st8YMhN2Dh+xfM4aXc0Zr4ereFT++7xkORz7/6GM++fAjvvLjv4v3f+u3+JP/7X+C4/HI4ebA/QevkXMmpjgR+1IKefQIqVq5fv6C4Tjw8K032O177r/2GuOQKUXZX115nHmk5MzxeOD1r7zHR9/5Hvv9nrffeQcqPHz9IcfDwVY6KK+9+Tqx63n64AGffvc7aE5WO87fgUhA4iK9H3Y4U9e7a1CZGOaYMwrEEM3YImIEo1iOjP7eFccX135NsHmWwvMvHvH62+/ywfsf8PWf/gm+8Xt+muF45NFHnzLcHCnjSB1HgvRIgGePn1LGDKIMh+fmmC9+NkKYbQoKKucCAE6Z/DJc9JLqYEUTZwChmPHPgUFw745pzUS8jEud9tv8LD9bEggaveqAVYZNqTOJNrbUg9nyEgyWcLtPwRLDTFmyImOx6E89jkZnAmYwx/LBDmP2DH0vp7x7tQksMIwjx2FAa+VwPNKnjoAtxiGP7nJliV5KkVW+lnkzqFrFghgT45hdPzvQdSZWFrcaUk3BbdUN5JRbqjonNh2OJd9m0pTqdI2iWibXLysRbo7qE4H34m1jHqfNZK5lddq0Wj30Vcydp7oDegzR/C2HkX5nvo0pmrN8HjM319dm4VfFIlXMTejq3hX7q92EwoEpAGC32xFS4NMPP0YVXnv4GhJgvBl5+sUTxmFkOByskGRLOJxH9+gwB3itFfFNHUMgHw98+uH7ECu88w7v3X/X9YxlMlrZYanksXrsvBHYq6s919c33L9/j/29K+6//hrS9Vzde8DP/P7fxzvvvkvOme99932urmxeh8MBQcnjyOH6xvKkqnp+1JEXj5/xxptv8ta77/Ldb/4Gb7z7FhoiZcw8f1y5//A+w3HgtYcPefLkKW+89Ra7B/d5a5e4vr6h5sw7X3mLx58/4epqh6gwHEeunz6jSz3dLpp/ay1TbuHiBKOq+VHGFt7r4KGWQs0juZg/a6nVAmGK6W2/9tM/yR/9U3+CB2+8zn/6H/7HfPhb35lQVMWSwTz74jH91T0effgZEpVv/PRPcO/Ba3zvN7/N8foFn5fCuz/2dR6+8ToEGI5HdldX5HGcxPxllrI1Ijtl7jMyXf5svy+Dehpyn77bUIm15PfLv3O28QRnJLWWCdQ0RN/GrNN5gy71mO87DKP5WMdg9hZDshYG69DY3AkDxJCwJDCFvosUl4JUTfV0OA6klDiOJjHnUia6cld75Qls9RyvKQZC6KgIORsR6rpIjJjFT2wqpWREOmodLVZdAsMw0Is5tHedv+Agc7RGWFqzgWKotokvrTVBSrWYXsx1ReKuX6COIDN5HBnzaDotR2WlZPq+XyBnVy2o++h5HaCSy5RDYbffk8fREtJ45p9airkL1crx5obUJVIM5FI43ByN0OZMjAmwue33ewCeP39Oion7D+5T/BoJhl7G45FPP/yYh2+9xYOHD3jz7Tf45MNPOR6OZpVv4Z3FXLIaI8keRKBqOrzg+ipjGIXv/vqv83PvvMVuvzPjUm7+nWlyT7IY8ZbwBGp1i3nO7K/uE4Ih8VIqX/2xr/i7FbP8P3/B4cXBdZuVkCL3XnsAmFU/H15QcuXzjz/l/sMH/PTP/h7+9t/8Rb74+FPGIXN9/ZyHb77J4cW79PueKMKTzz7nD/xjf4Srqz3xwT2++V//Oi+eveD1t17n3a+8y6NHXxAkEIMw3hzMNTBGO/wIEhKK0snMfoN7roQYycfBEw2VCREJBihyKYjCj/30T/Cn/ul/kn6/Q0LgT/5Tf5q//yvf5Jt/51d4/vgptShUOF7fkHZ7QNnt9xTU9vze3NjKYbRsXff2hCh88ehT3v3a10n9Pep4uBXu3P5u5wIWhFRODaKN2LVyMjlndrudzdj7ayqOpevW3L+tgUVbxZMxwIxWcy4018zpLLghMKU05aUoY7YEOV13Imm2saVktpmYOoIYoFKXqFSVTipRhH6X/NwW+q434yPixRTvyoExt1eewEZPlH2Ti3Ms25D2gjw8Vix6ixAYB5z7NVFxNPVLiCQvHZFrJR8t5tjKgFtCmS5FpFpCGYej1DqT2Mk3VJt5qbrFu3kf2OcxRi+WZkixuD9jlzoEYRwGcl6G77rzuhOVGGEcR4qa399utyPnzPX1NX3fTwEW2Y0l4kzn5nBwFUogxcThMBhh6ncLgqjUMlKfPKcUE8Np0U6PnxqzioH9vb1ZvMfCcDxwfHE9hWyiUItZz2uxw3H0UhuGYq3W2f7BfX7X7/29fPCtb7HrknF+tbI/CoxDYcTE5BDShLpDCByPVq0C4HgYaAQ7Yrq7w3BDrZXrm2veeOtNrl+84INvf5fHnz+mYkaM480NVQtvvvM2H73/Ac++eMTjzx5yPNzwh//EH+fTjz/h+eOnfO3qx9nv91w/e8Z3f/0jPvjOd/kjf+of5/W3Xud4feCL58/4xJH9px9+ytd+/Ku89dYbPH701BK950zsgu8LK6IZ4xzFNI7jpCKqjpTUvQ0sdDfbvhhHF4OVN957h//GP/Wn2d+/smKfwG6/5x/+R3+O3/37fpa/8df+E0qpfPT+9xiHgdTveO3NN+n2PV2347MPPiGPI2WwCLGbZ8+IKXL99BlX9+4Ruk94992vcF1Gy8+h1QJy2l5XNemKOf9p3/dODI0pj8Pg+uA5wjAle491ur5ORLjrzHhk/qczYQohsbZfzMjUQcswEFMy33UHNMuQVfPaURC314i5upkqSkkxcP+qc8KdvEaXJd4upSKqdClh0UezDlm1gTY7p4KQAp7X4LKBC34HEFgRM66EGOe6WXX06gURJVDUkG7XCRIglxFVHB1Vj74pU9atBEQxQ0J2PSC4kYbT3AMneqRm4V05a6vWE/WAvSC7pTi3DSFMKoP9fo+6rvjo7jchhCmhdAiw2+0nV6Lr62tEZCK0pcxGHDsIefI+SJ6gXFUJngJvHI80/XNL59Z+Px6OhsaBp4+fkkvhxfMXvD68wXAY+OSDDxgP/1/u/ivW1jTN78N+b/jSSjudfXLlrq6OE3tIDsOQEiVbEmzwxpZkA4YsyNCNDQO+sgwYkGELhgwYMAwIkEFAgkVfiJYFwaIsGTYtijItjcQhJ3Jmuqu7uqsrnjphh5W+9AZfPO/7rXVqpoM4N9VawEHV2WeHtdf6vud9nv/zDy1Du59GuRACwY/CQ06LwDHhnU4NWFfhhjHRtAyXr7xC0TSMQ0rtTEuI3IVEHyf45GU/WLGjzBCHtVb0+6Oj3ffpeUiHZArL3VceYsuKq6sblssV+92eoW85OV3x/rvfo2oafvjd7/HmV9/h/Xe/x3y1pNvtePrxJ4QQOLt7ycm9+1y++pC7jx7y/IksjD547wdsnt9wfu8e19e3zJYL6rpksVzw7OkL5GDVDP0wTSPHBVasCB1agxuH1PU7YvSEdPABUzFqmoaf/3O/KoUkiMzbe8/mZsc4eow1fOWXf57zizOefPKE3/3130QpOLk8xw093/2932d3dcvdxw/Z9ANVWTJ0HcF57Kxku9lRz0ra/YKiqHCjvJYZhsqFK5P581LtWO3okxpOay1Yd3qOuZvMXV4uuj7JV0EK1iFY8BCmeMBgX05giIAtioRby4RyHDgp43xmXciiaxw8Wstr56KEoJJ41z6mpXgOcURiYDJMGELAauGca3OANHRa2K2aJJABDD++i/3CF1iQTHLvI5pAP4qpsChqSEusgNHZvAFAoAM5NQvREgPaSmKk0C8OHWW2LgOmDiL/kYsiFXbkZQ1RxvSMp8mWU5ZFMkqA+EkGkS2WIlGsqurQySRIYhjk4h6G4aUuQDBK6cTLsjgq9PbouclP18ZMqQwxMokArDF452mHFmssZVUJHplVb6lQ54t58+JKfAOGkU9D5Pb6ht3tDf1+hxtGYordUFrh3Th1JSF4oZNZUdRFL/E7zpd459ld3fLd62suHj6gKEp0ohrZdEjIluGwRLze7mjmMxbLeRoRI8vlgtubNV1SSe12rdCWjGa321FYcTgahhGtDP0wpIMnJgaJpWtbjDZ857d+l1e/9KaMroVldXnO3QcPaBZzXnz6lGcfv+DpJ8+py4JPPvwAa0oigb7bY7qK9c2ak9cesW/3XNw547PVkr4bkreFmw5TrfUEQw3OJ9MYR991qCiyVlG6CYUwxIixhle/9lV8UKzXW+H1Gs04BD7+8AkhBFanS+bLOdfXa5QteOdbP89H332P937vH9Cutzg/sjg5Yb3dgFIi00Xet4vLc6qmYlbXeDdQ1TVNPSO4kajlOhDhjccURrrgEChtwTD0icZ1MPnx3lNW5dQkZKFE7mQzO8N7n6TrWUGVFvtK9iYxklgeLyffeu+mbb5JijuiHLykopyXfrLrcCiVYl8SW8iHkERFqYirw/XmgxduvUpy+dT1amXSAS5c6AhTjMy6dTgfqH6KRdcXvsBqpbCFpe8i1hbYRE7P47hKm05rNG4U7lrUAY1+iRIzRW7HgE5FKReqbMad32RZQBxgAnmkjpWUVKvz50lHi86Y42ELClCW5aR48mlznqNr5EIspgsyxshut6PvR2azGerwbY46i4PWPhcQrYx0uQmeAA4k9dSZzGZzilJwKZeWYwL0O0jd9Dh0OOcZvWNzc4MfHW7oRDKaDC+U0rIUUJqiFKzVu+4IY/N4N8rYWpRiB9i17Ddrnn30MTGNi847oiooZgt83xL9wMX9e4yD4+bFC6zR1POGs7uXXD58zOr8TLLT0sEmfhQDSsuCTmKBIuPoxWouwy7I6/XaO1/iD3/zd6iWJwx9x/vf+S7NfM7ZvUvKsmBzfc31sxd88v336buRCAztXnik9xY0s4btZkM9jgzdQNcPFGVBXdesLi4Y+16ct4Iof3IXZgqLNgVRa9rdFj/0shQNCPacSOxiSgNvfeNrvPm1r4oyDJV2rordrqXvujQ9zROZXrNYzTFG8dprD3nv29/jd/7zv0vwnt1my5tfe4eymXH99Cnr5y8geN79rd9ht9/w8JXH/Pyv/imqWUNRVfRuTNdooKpquq5jv2tlyeQCukq3Qe5oj7b+xAO96tjRqmmaCfs8YKkhNT+pW0V8V5XWxCNILr9+4zjKe16WqOQD4boEVaEn9khZl4BJdoWGGOXAkwlJKHJuDAI5KvDI/kCKc5RJNh5+tg8BokALPhzw14BmvWvBv+wk9qMeX/wCawxlWbBXkWHoptFfutJIVVrpSINE8Ir6IkwFKRevTEGxKiL7JX3ocMcxjfFHVJNUXI/B/+PR5ZgqonV25zKUhZ4YAbo4fH6+GHO3mpdOIUjnadLFM5+c51U6vYcJcw1BYlO6bpxEE8HD6Hpms1qWWnlJofVEShfcVt7qoiiEaqQis1kzdSy73Y6AXNDaeYa+xQ9OliTOEZwjcxGdGyirRk77UZRHGXaIiCpp6AZgy+bFC/n8hB1HLRisdyPeiyovIN/b9z3DrqVUMkX02y2f3t7w6Q9+wBtf/RqXr74OHNC6EALzWUNZJpconZ25pOATIm4YxZRl31EWlr5rKRLB3IfAB9/5Hu12K9fSbIYuC5rlku52QwgjZbVg6HpiVaOVZrfdYIqKJ5885fErD9Ba8cobr3B7c4t3A8O+RRvprMdxpG876oV09m4YiaNnDA68YIsx3dgxRB688Tpf/dYvEaOmaaqXFkfNvObVNx9TliV1XYI+jNgghiVvfu1tYvS8+zt/QLvr2FzfEm/WVHWFLSxdu+P2+TPa3ZYfbHbEqPnlv/CraGtR8aC/D8n/tB8H2l3Hfr3DFobLB3fQ2lHM5gDT6P/ixRXDOLBaLlmdrKZ7N09dGS44TmaelHTTmM5UuI9H7qIopvc3u675hGlnFV+hS6wt0Vqoht7J75AVhlVppsWypEMFCiMLtkgg1dJDqokGpQw+KAbnqRKW7FxAF5JA/dM+vvAFNqZYF5feeBUDVWmJUWG0oh9GIpK1pazGKkmLDBzMUpx3qJCiNgpJm1Va0fcJvDaWYZS2X0YKwYuy+0+W1wpedMg2ku2pnrAlreKE4eZ///xW1LnMJMgdrJm27dmfdr8XvMwn+WTVSCG2RlMUJc3MMI5Ofi+VMEircX5kaAfqRFsqytQ5O8mh6jsZ2c4uThNWLIbmtioFGhgdY9ehFIxDTxhHUWhp6dizWmt6b2KUze7RTRFDJDjH2O0ZUucavZetrTUYWxBLEt1LsDNVCi/UFBasxoRC+J5GoygxVcXqzl3Gvk9jYurMfWC3bwFRaA2jo9/vCd4nYUEkpjiYqp6Blg5n6Hq6tqWZzyjKEnN2Kt3s3TvsNltefPop3a7l/PIuSgu2qoxwbMPoGdo93b5is92xXM45v3NKTE5eu82WftdNxSr6kd3NjbAi0nUVkyeG8y55FsDFo0d86y/+BeqmobQlMfqjRa3H+0gIlrIujg73kCYmIwvN0fHKW28wW674jf/Pf8p2s8Fqw/76Gu8cJxdnvPnNr/Phe99HhcjNiyv+wd//be6/8lB8GVInenNzS13X2KrEWI2xwgftdh1omRzrukp2lJr5Yk7ta+bz2QHXVAd/5uM9htwL/tB0GCuvrVaTi9Xx/TNdWyFAEDpiXZYTjasoCuEEk6mTTPdUvvcKq/A+pgNBCqr32U9AJk4FE4RjtMG7kaKULMDMaQ4xYjgoQePxffAjHl/8Apu2iFrl1h3aPuFdMTK6iPfDRH+KISZn8vQCoyQmxhicDwxjYiDIZHO05ZSOBgXaloLFKqaLjpfoKkfMgggZV8g3w+HzmMj003IohJcuwKlriCJ33K330+LGWsvYD2xu1mitWJ1my7k4PYf9bksM0O5S6GMI1E0DSJrm5npN1w0T/alMQXDeOaqmRiX4YnOzZrde44ZeJoS+nzT6El2sJ7zCGpOoYrLV9QnKiGl5MI4D+81mEmgEHzAWmvmKsqmJSPzJ0LaoKD69ckiUNDPw1hKj2O4N48gsYcfWWuy8IQKb9ZoYFTYYxu6G3W5Pt92zvrrBFhVOCdXOjw5blpR1wdDuQRuskc4neGFBeOfo9jt261tunj3HljXnd++mbbVCG0UYR2KINIuFpCNsdzx/8pzFrIHCCG+32nN29y6bF9d0u32i63n6rk14np/MtWMUCbOLsDg54+t/6k9RL2ZEHxjjkPDlw7YchOaXISg3Otnyp+tPaZXodI5xjFTNjJDwy2x/+OT9D7i4f5fV2QXtZsPjt17j5Pycs4szsvBaKcWdOxfyM7ViVldcXJyJkEcrlJjsvrTEq6pygr+6rpuu/+zvccx9zVDdZH4NE+f7+HH4XPm40QZTynWSF54TVSxESHh34BDpEhKP3PkgjUiIE66rTSquRqTBPtWYsijTvaxRUWG1oh08pZVJ1Wg1vZ4/zeMLX2CVUthCxAUxufXqpOAKRGyR7bWkha/Tph3SzR1DGps9URnRG4NgP4WZutCJUuUDNp9PuVOd6NUHjmDGc4l5A85LHMFxHNnvdux2O1CG+XyONTK2gxDMvRfK2NANgj1e37B5cZvwS0vdNMLPS1ST4AP73Z7lyYrdfi/guw+8ePqCTD6vmpqT01O8D7S7HZ99/Cl1M0vdqyU4x/p6w9B1zJdLmsWcECPr58/ZrW+wRjb1IRuYpMPKJANz+X2T1NNotCrSuH9gY8QgNn1KmwljLGYzqtWS+WpFURaJoyuwzqfvfyg36OhR2qLnc5QWeGNo94x9R7fdYcuSsztnwou2lnbf0+873DgyDCPDbo8bBjQHYUcm1w19x9B1FFUlnWy6sZS2aCVQkTaaoio5OT+nWS7xzjEOI6MfKG1BXdV4P3J5/y7r61t2t1u2mx22OKGZzTi/RLLjennvFUxLv77rIUlnUbJo1UA1n/PwzTeF3+llYZO7vGHIhHop9EJ7gu1aCnZVl1R1gbUGrSGGmtvrDVfPrpifnOKGlt16Q9OID4SPnudPnmBsQVU2RAynF2eS7uHC4T5IC1sTjSykiER/sJ48cGIPjUIusDFm/DRMo/0wDNMewlpxppIl7mEhWxZFolflhXI80CHj4b7Kf7quwxiBv0KUQ98aI4KVdP9bK6q4GCWGO/hAWYqfw+SsFcPUNAmzJwJefGDF9CzxtOWaCzE1cGnafIll9Mc8vvAFlsTx1MbIRaBEqZOJ7VYZohYsdhxH9l03jQ9a62RmnBY+EarCiuoryOkUUgdQFHYa97Nff36EeDBgEThAxAuyWQ9EJS92URQUVvCaze2am5tbwSiVYbfZoZXi9PyEsimnldnti1uunl/R7/e4IccDe2JQbNe3FFXF2PWpSAi+13U9pxcX9PuWq6fP6Xd7uTmTefV2u6GwBeurG/p9K9hncIydsBaMkYNGKU3fisIr50TZ+UIMhTMkg0hItbZimpM6a3l9DRiLSV3SxFl0DhMiykS8c5RVJTeqT+782kio4KymrEq26x2L1ZKbq2vpkIzCJcOUbOKtoqje6qaeGng/OoqiZHu7kYUjGaIJuH6c3r9uu0PPS3zwqCEt4KzFK83p3bts17eszu+wPF0RvKeez1HWUFcVRveE/UgMgksbJ6T91fkZty+ueP70Oc1yhvaawhYslsJEMMbQJyK8d/J7u0SDMsagYqBeLvjqt36JOw8eUjU1dVUSY8DavGU/KPwy/W673dG2HUM/MgwF+mRBYRupR0lTeHK6pCxf4/r5c4lCabu0mLW4ccC5kXo2Y75ayCg9yCGYAwGzcYonT1sCRxxiiTRa5z2HSvuABJlpO3W4PglScoRTphjmohRCYBwH6rqS7xWEX+pJE5wxGJWw/cRE2G63bLdbFosF2ojna2YpyPQoewCdRlSrwaUiK52zLPLAojRiFZnweB8DJi2xs6JOK8uiqYRPGwMqqkmU8JM4sPAzUGCVEjrPAec7bNPzJtH7iPeRsqzwR9u9zKXMWFChOTLOILmhp5PJOzRRjCE4qE+yabNcNLI1H0ZJJ3WDLIdsKRr/PLbsdztubtaMyfqs3W1AyZiz3W65++AStGHY93z8/gcQRM7p3YiPkcLKIiofEkPfI4sBOZkXyxXeOYZxwBYFIYqCx5YFVVPjnafft9ze3BBDYH19TVVWiddnkqeDkg2q1hJDnBYb+TWboIzUtZIoNVFrIVlnRkOMFE1F3MvFNvqDG79OET62KARTHh1+dJSnFdWsJiq4enGNLStefPaCoirkMPUINzbdkGjJsVdorp9f44Om3e/Zb/cUaQGR4ZZ84wIEJ5xRYmTsB6IPxGQENDqHqWrq5YpmtaJZLmHsKZsZKI0bHSoqyrqi6yxDu5VlTanY3NzSzBeJijRye7tluZhJgVKGoeuFpubc5FWbOzyRKQea2Yy3f/7nObt/Xwy1tZoECcPgJg5nntZUokcZo1mtZsIuUGKaM45iLj6m929xOmd+Mqewhpunz+R9t4jCbbbi7uMH3H30CFvVdGmyOZafyn2npsKVoa1jDrX8YSrAecFpdDbIt5OxT1VVL31vYOpoq6pIBTim51IyX87Zty3D4JjVdvqZxhgWi0X6uop6Nkv0LJMwKvAuUBSWrld4JweD8N+BoOmHQVz4olANwaTdR2YS+Wl6rUrLMGS2a8A7DUoWv8fF9Wcag82xHiGSui6FMUeGDwHqSnimeUzNwYfWCEF6cNL95I2mDh4fwY2Osiom0w0fk8TRC9c280pRSUyQXlgVoW871rdbqqqi3/fouabd7rFLg9GaxaLh6kWP63tRvMTIvh8oZzW7TUtAOivX90lxFDm/vOT5Z89QMUoUiNJoW4JqaTdb/OhoFnPatqXqJb6krOVCs4VltphTz+dJhKC5c/8+66trut2OruuwxtDv96zuXGCsdHQ+0XPGric4oXSVTYEOhjAOAj2HgPbSqYsJjiYmCbACQlAUdY0bepwbxFEpBIxOeLeRgyyMLnloSmc7eoEbbFmhzBY3jEmfn19rTxwHMJputyMGz3o2wwd5P9r1lq0fsWWBKZJKJ5KyzcCNPaZZMA4dQ+cSh1OgGW00yo2Q+KgKzYtnzydxCgqKcoZ3nqKucIOM+N6LFLNtW0yCOna3O4L37HcdYfRoU6CVYuj29G0nnOFw6AaL+YK3f/kXObm8x9CPKDTWirAkE+ez3aXWMpJ2Qy8YabJZF0FNwI2y4DSFprZ1KoKa2+tbPv3oY0IIvPPz3+Deq4/45L0f8NF773N+eUmzWrBbbxn6gcViTllXzGYidBGnM7lfiqKg7zustYnvKkvC25sbYTQ0FUVVsVgsCDHQ9508SyPPM9+nx6GjL38c9vs93kjskwuefugprEWXpbB/0oIxKkXZzKhm88kakghB5evMSgBkOmydlw51DAGjUlMWIsokuaw2DKPsX4yS61ql+z5T/AKRGBwRTV1ZXDgknvx4kaw8vvgFFmERGKXSls9Pm8khxYIcbygP28usPonJu8CgVESaNkPEUWgzndwhRukgx4EYRPsf02Inphc7n1TZCEK2t+I6HxJpPcMRs8WcqBRjN1CuN0LNWs6YLeY08wZjDHVVYCtLv2/Z3q6Znax4PJ9ze/UCa0tMwqVmccn5vXv0Xcvq9JR6vhC/1a7HKPEr0GnxpMj6cFHbSDe7E9yosJRNRd2I76oxYs1WFSXrWrTs3g1AlezehMaitSEkf1YffLpIFW4Yki2k+KgWVS3eEd2eEGXEMklkERNn2Pc9fdsJmRuNGwa263UqcjLieucSZU5ulOtnT2RBVpdcPrxL1464hE967/CtwwzjoZOI0v12+z3z0xOGIO/RsVGIcCsLYghcPXvKiydP0EYxmy/FuSmzOKLAJUpJHFFRmWkcLZJCShvFeD0IPSgtsoauFfJ+5v0GGT/rxZIv/+IvMj87o7KGzXab5JolQz+yWM6E45o6NqEYqsQ/lYikoR+ILl2z3rHbdCxOFsxmjXBSQ2S/3TJfLqmbWg7h+YxmPk8xNI6qKijOVyjAWsGf82hf1yXem2nJpFQl95mWFJGhb2kS9Wsxn4GW/CpjDLPZbKIc5scxJ/uYiiXKK8dyuUz3sZnu583tmuurK4y13Lt3L4VNOoqyRCm53z796JPE4xYM/e7Dh0RtkkeDsIyIMpUq0vSQxv/c9eopS06ng9dMniRuDJM0V4VIiOIzccBtf/LjC19gY6JmEQWTceqwIfT+gAvJxzLIDplrlxouWWjh0Ua6q6KwxGQ6UpYl0Ts5qcKIGweGYSBGUZ4Ya1HGpoUZiWNqsYVl3+6p6opIMtpIWNN+36ZuT1HNKi7u3aHthL5jbRr3rKGZzZgvFlSzGd45ZvMZymqa2UyUac5hTk7BaOarFYvVkrIsGIeBPgaKquJkNqPtWknF1IrFYsFut6WpC+pS09SW/X5PPZ9zducOthBerC0swzCyvd1QNVL03TDi0u8eknFJ9B6PjFQmbfiHXkw6lApEJeqybPY89q1syN1I2TQy5qeLd3t7izKaZrkijiM3L14w9p3wGNOBIgsqEZE4L1OGNiIzXZ6sWKwUm80ONGyu5PmGZEc39h31fC7+DyFQVAV1c8anH304XTd52x21od3tePH0KUUMnNy5RGlDNZvR73YM4yDxQkWBshYVBTPU1jK0Lc18LqY+SVQBATcMQhkb+mlRmPHU+uSEP/WP/CXq5VL8hwvL4nRJVZcoJEhSKZJyj4OENEK7FxWaS2rFYRgnmtTydEE9q5k1NZJNJgKG9YsrTu+cieIwBjGNUYoXT5/x8PVHoOUasIW4SR1ggnTTRJGoylJSiu18MUedn0lHqGVfoBJsBEy/a2ZAHFOtjousSfL1/H5I43kwbdcGLu9eMIwD/bCnVpUsuv1ITEu0O3cvJnGCsQKVxShOWiEVQu8Ds1lF9D6pHQ2CDoqXyTAMVKVIXyeBgU4euSEmz5BIYdJiO50bWdf5M7/k0omDOiaPUKWE/KuSKcnoxqTEklRRoczJRehjkIEqFT2loPeDxHjrtMlMkizvpFtzbqTve8YxUzFi4r8pjLYTnrs6OaWZjZyen0oyalKNEMBYy8nJCRCxRYEb3eQyFGIq7gG6ZGJik39qfrPmywXHA0iMkd12DygKW0w40Ww+lxEpeJqmktdKS3R0WZXS+WiFqWpOUZMAQbawPbHtJBgu+NQhGcahp4mySEwO07LYywsQL6IDkAhppcCWBlsInWm/bRPlJtFZ8ubXO4ZeURtDt93iR7E/7Ns9fhwYVYcuS4rklaqTZaT3I9GDGwbZvqfOcb5o0AqGRAsSF6WY2BlCuzJWWAxeeTY3a5QxxGRQMg4jC1vQbrfoKFONSRi6dyNRK4IbsUVBOZ9jreX2+TNCcLTbtRwSiwVVPUPpSNmUdPuO0Q3JtDoyuoznRU7OzvmFX/vznN69R4yynJMoeTGmKYqCorATnioFSBgu290eayz9vmdM6bPEgNFl6soD/b5l3tTYQjDnxXLOfrvh/msPuffwHloJQwKU2DDWIpyY6FlHk+B03SWcN8Rw6EilgiavWMF15d7LlKoDhxUOWG5+ZOns5HfwuWVRxnOr9Fxn6Xuo+PLPjkphj2hfIUTc6MXBLtPbksOcG0NiNcjP7roOlGYcxZ8kpH1LiBE3OmwhizADItZRGp+N/q3GGpmucoDij3t84QusMQZb1mhbooKD4BhiZBj7xMck/cIHoxPBT4Szp3WEFBUyDMmrQIsoQAjGB/szENpI3/d03cBs1siSzcjNp9AvnVjHslSl0vdSxzZrOhlbxLSJ1wzjQNcOk2osdylw4MyKsiRO3ycXlRgiw9AfbBXjwQVfOZW6efnavh/SNlpRFIK3HssY888tKznd66ahKIUrmse36DxEKTTK2In5IPLEbOYh71NMHOTgxmljPOXHjyN4jy1K/DhyfXuTRk7JTvLjAFFRKS0pnoXFE6ZRLsaAHwJYjTZKaEf9LU1Tilw3RmigYs7Vxx0Ez9i3nNy5YLvdcnpyQnAOW5WTp20kUpSlyE+9x+cOzgsDwY09Xd+RxSo+RMq6odut5TXSkigwPzmjrErKomC0DltY2hBSjpMUocX5Gd/8s38WU1ZC31IqhTUO1HU5jeW5WGYsNi/ufAgMvaiq+rYjAuPQcXZ+DkZe99msZrPeAjH5S3jGdi+cWe9RyZCoXsxpTk5o2266nidK1VHBUEpPqQoxRozVf8Sm7yAIkAJ2vBSTj8epwOYl1/Hv9XlTl1x4pfM8bOqVUuSIQW2O9yJxOpAkpSRKRJRK71nyivbBY006iPoxHVwRrQuIbuqwC61R+JRG67HaHCUzHO7VfKD8NCjsF77ARg02bXVD6kiVEsxEvEfTGxwiYxS5m9EmbbMl70jDZGCsVFKMaC0qnyBuTnKSiVKkPOqihJJkyVEyxxfES0oTDrQa7z273S51pdJhThfCKFvIEBR/fE68SkqUw00mUlxNUDFZx8VpWZQloT5JWlX63UwiyefnJTLPLWPXszw/nW6gmLb8Smuq2Yzd+pqh75nNF2L04QTXjd5BiBSVUFbk91HEKJHGOSTQBTfdQMYUjP1w4Advt6IJT8Y0JBmv0nrCwJVS+FFwHmUNxpTMT8/Y3d5ijKVIXWZdV1RVyTAObDc7oheedDufM+5l6VTNF1y9eMFiPseYQqSyRoIKTYJTunZPcCOmrEAlXM4aSjujd45+v8MaO2nhdTpIdrdr0Ja+66mamUBThZGolXEUU5oQmC0W/Mo/8mssL+8Kxc2YZM+oUzZZLiIkjwpNLszGatp1x37bcnt1jRtH+v1erglrxDYQxeJkQUxF2FiLtZHTiwsWpyt2N2v8g3tohGd7enHB9vqW+w8u8TFgE8RmjUStH3BXNU1Ex9c7MC0TVRRanEpFcUi5bcfS7s/DBccm9PKxQyKz9wHvY7L6zKnJB2c1n5guSmvhYSuV+NSgCpnAfDRJaJAUV0q8Dnyy0yyKAoL4WQy9TGDinWxwyedCKGjC/fapiSkK4RqPLiUekHrYz7EjPv/4whdYkDfGFpYYHH0/YrQ5OPCQX1iP0cmQOjpiUCgdQBmslaA+URYFRh9QXrpaawXcJsZE9pYcerTwGk0y7sgj0DGHLxfWY2wp//tsNgPSiBXMdPpnKpf3fvJrBaYOV76PbHLzzxOv2AghsNsKc8EkF6wXT58y7Dsu7t3FNtVUOPPPzpQTFUHHTOxOv1N6bXPnXNYVWim6fcvq7AzTm5QDBYKxMh0Y8r6IQ1nG30Lie+bXJEZR3dTJNLzvOikK6RDQxjAOgmlqraebQKEwZYkJmnI+E3wtwG6/ZuwHyqpO1KfAcrlMeLF0WdefWbodYC3VrMF91EuqbV1T1wXdrmIcXRJKSJyz1tL5u74lJOmwD5G6bnDtXkxfYsRYhSkLirqm223ZrW8J3tGub9nd3LC4OKfd7hm6Pco76qbhF3/tL3D24D4qgCrMJLVWQLJ4mvYITXOw7RsSrux9oO9E9WYLy+JEfl9TWGLwFFXG02UvEJGllbGGk4tzGXmNcJhRmmbWcP38GcPwKqYoJg/euq6nfUTmOce0MJsUU2lZZUxytEoNS5oX09eZaaLL1/rxcuu4a82WjfnfJlhBS2rH1LiQZeqHBVmmLE4ULFSqBWmxlYxrhtFjk5BEPKKE6hZ8Cj80gsPm+1CUneJzElV8iSbnfHLi4ui5Hj3vP+7xhS+wMQqu7J1HE1I0SkocdU78Hl2gTLZ5KE3vAqVcA4xOXHPs0SlbVeVUhLJsLng5yaqmARSjEx2+PIcgUcwcJLGRzBuT/8Tp+b78wocjRdEwjkcXa3jpRM/vUSZLSy5VZLfdpQvBYrSmyqYpSorKYrlCrU5kuzrZ/gnAH2KWqRru3LuDfnSfTz8WxyfCwbVeJ2/WajYDBW6QVARTlAzJuSjEIJewdkf+nRFDStANQRZLTrrbzWZH2/UYDWenJ9KZ5iWkMWIRR+py0hiMiYRRFpMmOFQEW1dsbjYsT1acXdzhk/c/5NV33sa7QOcHSKP+rKmoZzWfffAhY1UxW8wpCks9m7HbrDm7uKBsarp9h3eecehlqaJFCRhDZOw69kqjywrs4SAI48iuHyhrkVDrtOQc+p7ohf5VlHuGoRM63voWVOSdb32L80ePpFjYNOKmgpRVYiF46rp+qQDJOKpRIbJazTk5XdLevXNEoXLowjBvGrSV+KHCyntyc3PLbrvn9GxF1Ir1iyuIB9Ps9c01m/WazXrN8vRUooLSvZElr87FaUzPLnATXOE988RG0Eh3Oqaon2yzmb8u463563IRywU4++ZmS0ppQmQ6zRPjS4+sJkTUnVnw5UNIftGWGBKlM8g0VxhFiOJFElEMSayUGzQ3uuS1odM9IYwDnSZkZTURx5Alv0rRtu1B7vyzvuQS3r+YR6s0fuUbM2OO1srCKyLa8yKNf9L+RyGOZ8lc6hRjyk0qbCE4IzIeRCU3VHCy4cQIW4FEGyKbq+QC4cXA93A9HBgNB++BtCUNh25RzDtykT0Y/R6PVH3bcf3kOUZrynnD6fnZRCiXN1VT1uI7kAu6T4dOjOIxagtRvK1v1ym3zOGGcbrIM15WlmXq5DQoz3azYXFyBlpyrVSyNPQpLyr/qrJckGWWd55hkHDEvhedfAyR9e0tVVWJeoqYzJndwdwj81JJYoYYiU64yfsXO4IPjN4Tusj7f/gd2n1PUVc8fONVul0ry5++Z7PdgdZU8xl3H97j8euvcOfyDn/7P/iPePjaKzx+6y2GdqDdbfBerofl6pSx6zDW0iyW2Kqk3W2p5zO5aU0hgXy7Pft1x+DG5BMgo3iyGUl5b5q+ben2ex699Qavv/1lbCHqLOc8OhF0h2FIi1Q57I+ji6TIxGnqylhjPZOuPY/kxghnVA8KUxh2bct81lDXNcPgWN9uKcqGbrdju9tydn7KvQd32W/W3L13yfnZuaT1FocdwLGAR+iQOhmjmz/SqRWFFdzzCCKTQqymyJjcPGRRwTEmK9+jSJS3MOGoVVWlZvRl2C0mClnuHg9FLYrSL+HJPnHarZFiHcOYphQpoKW1AhEVpfhzKA3asN62NIXBGkVZmNSAiSF/FtlIV34Q2fw0jz9RgVVK/c+A/xHSwP0e8M8DD4C/DlwAfx/4H8QYB6VUBfw14JeBF8A/E2N8/yf+DCKns4JrW+DHkUjeMMa0SBDDXu+F2lOVBTn4wPtU6JLLjrESxxJDxJpS5HCjfI9M01AYikIfYIVsc+b9S+ONLLXyc5TsKCKTkuy4eDkXJkpK5nYOw/hS15L5vVn9kzvL03t3ZAmXuIUTp3Lys5VHLtxu7GVzDyhtpojy3gxoowVeUGY6kMYUfKcUyWNUEaJmfbujmS9f2vTmC1gpJppZ9GLJl3Hg0bn0muYbNklXsydojAQlB0TQSaWnhZh+3PVPnOYgRbtodxilCW7ko+99F1OX3Dx7xvVTiaXu2hY3DDSrBW9+7atYa9lsttzcXHF2cc4wjuy2O2EdBKiaOcpo5qcrrp49Aa3RhUFpS6El5qeuKlSEocsLspYwDrhxpKyqg1mJAlOK474xBjTcff0NVGFBR+Ior3NZFBNOLraDtTBK0rh8KCQG753IsZNHQFEUtG3PYrlMTAlPcJ59chNbrGYoo1meLun7gUIblHd8qjWLuaifFHB2eUG3b4VRkXYB+fr5vFIrX8fHHVoussbYyctDYDZP9kzI3ytDCLlbzWN9NqA3xkzOcvlnHSvJ8t0lk5OSpW5apuUCGBO9K7vYxeApjMZHYXHIzzepiMv3OzahkTYlUBWZBZG/r5qWoYoj6lkkLY9/NCxw/PiHLrBKqUfA/xT4WoyxVUr9O8A/C/xTwP8hxvjXlVL/J+BfAP719N/rGOOXlFL/LPC/A/6Zn/iD0njqxj6B2lp4bGmDWFhLl7baWikxsA4BrSK9d4m2IuoYq03i7im6fphyvFT0R0YTcChckjwbonARfYq7NlbiwGNiCIyJhqWUYvQubRkP2KxznmFwtK2kpB4YBoekWSKMw5h+qqzmjLGURUhSQmhbIcy7BJGYQhyJsqm21gpry8NNkE0tkiIt+Chm1Ml6TehqshQYR8/YjwRVEHXEDZ5u38khEsSwJHuX6kIJRJGVU1HwWbwcJj7j0UiDoJL5igsBWxbSeaEwQpdAUiLShIAQulGyRDCFxXhHv9vJRtdojNLsnz/j9slnqQgnj4gQ6LZbbp9f8+pbr7NczLlGvs/y5JSnH37C2Hdg5f0JLjA/OZHrxogyzSD4Xdu1sJPrIyZupzaybByHgWGUzLBmsaCeLej3W25fvGAcB1YXd7i4ewetxNycCHUp6Q3WyKEjmWPFBFslnALvenQqct6DHz0qwK7d4ZzjdrxmNquFn9pULBbzhL/qNAUoykIYAbPlgsX5eYqlEdrecrkQA5tksqIShnk8zsdIYrkc2ABH9z1ySYg/h9DJ5POz2c8xSyV/TfYDPi7Yxwu1z1O2pFhK4dT6gK/KwjXKpKnS9XeEiWYx0jCO030cg8cYgagyfJGLvUrXmVKyNItIioF84+MWKjN2RJxDOCznftzjTwoRWKBRSo3ADPgU+EeB/376938L+F8hBfavpP8H+HeBf00ppeJPOAoiim0rF7RROrkNeYbRk2RZRFIHB/h9ls0ZQlQE56mKAl3KqeZTgSEvyaKckSadvjqxC3L0RX6jUQrnRpzzVKrCpItxHEfaVgQEKDX5Jsi2UzDQcRzY7zuJ3NCKQ2SGEvPrfHKGoxRNL7zdqiqpqprRS6EO3mONlaI6OokdSaB+zHlF00UaUpelkjDDp0PCTURr6UojIbh0o0tBiUT27Z5FUx0ZaciF78aBSOYo64S3iQlNcCNEwcIVMGvmzE+WtNst7/ziL9DM53z3t36b/W6HT6+zIU4TApAWa5IczBE9JseoZyPx49EzRskmK+uS9fPPWC4aTs5OsIVl8+Ka5/NPKAqRdbphpO/2LPUpOcgu+IDre7kBrWHoWlSMaCNuYQTP2PV0+1aEKqW8B/vtlrKaobXFDTtijDx64w2ZHLqBoR8FYlHSufngqapyOmi9l6RTP0q3lOXKXdez2Wypqpq6qeTzCsN8uaAsD1Z9kUg/DBTBYKyZimbm4pZNQwjiB9z1PbO6plnMmM2bCRvNDJuYNuaisJJClaNgjimJGdYCuSby1+QimYv1cYE9XnBl85fcyU73epqQJjoX2Wgm3ai5kMZIQBEm1gPTEjorzpRWjGNIsIswBIRPdPAYyVNmCHG61uRjPjVrlhDTchypLyp5T/90/eufoMDGGD9WSv3vgQ+AFvh/I5DATYwxs/Q/Ah6l/38EfJi+1imlbhEY4fmP/UHpwqys0GN8GjdDVAmTER4oHDpGay2jc+LiHwF18F1NFDohoHtHURaC3XopXj441DSmklow6fA2GzFYhrw0yDBFfvuZlhD73R5rC9FUa01Ti+MRQd4s54QZoKNi6Ecyv450QU1kcyVLOu9kJMzSwOOxfeoqonTVRptUhIxQZ/KyLvlhRsVEbxlHR13XVOWMsizwrk8FRcQNs7qaDMgnoDkv6oLHWjUtQvpeOuyElKG05tUvv80r73xZXOSbGVVVsDxZ8ft/9zfY3dzK2OflcIoJ61YogQNCmHwJlNZ4jbye1qYIZonuVkoMlKumoWpqiRCpapGAFgUxiQKsLaavyzdq3Yj6LqRMtICY8sQYGDpRmIEYd4fkBkaUsXHsB0xh6HYbTFFADDx8601e+8rbWFukQ0K6uyrp+Luuox/G6WPeSwfrekffSwBlFp7cubxDUZVoHamqUuSiUdKHfYK2isJSaJvipE0SZ6QCURSymFMiWKiqCmVMcjc7UIvymJ47z3wfmSM/gXyNWZthjHS9wsR9zdfisRz5wG192UgmvweZ2XPAcgX/zd2qyKelAMbE+dYJLphKRLpnpBlKN2NizwyjAyUZXirhuD54jE4ccyX3QG64YoSiLMX5KwSmH6WscHEVab/zo6lZx48/CURwhnSlbwA3wP8N+Cf+Yb/f0ff9F4F/EeDhw0egmPDHkMxWfEgYoFaUhZ38GoOXohq8dLukgqK1SRCBxhQFzjtMVcmmkbxcEEGBdGgpgypRRUYnya7Zy/KYJG2MISqFSVv16ASLms/EKCT4gE/xGIRIm8yXXYq1IR6oMPlEzTJcEUzIaFmUIlnMDIbszp7hhZgoWNlnVlRjIjiIWQvuPSE4inSD5cWTZFqFFKudDhdgHD1DjtlIRs8xCgf30KFEnBtwqfgrnQwzgMdvf4lXv/IORV3RzMRmMITI+YP7/IX/9j/Fu7/9O3z03fdwo0vmIKLYySm92SQcwEfBflVRMjtZcfPs+XRNyLZf4BzvHfPlMhHSA6vlKlnnBZZnS9rtTmTQIaSk1SG9Tw7jHCEdIlFGG7QWq7+yEB5sM2tk7A9hUgEN3Z7KLKgXC97+5jfQ1uCS4KJpKsqqoCrLhFsWbHdtGlGFN6qVwZjIYrHAlnayx8zsjKauWZ6d0LUds6JkHHqcFQeqQ1YadElEEdJixo+esm5S0TTUVpqJcRjSoXZwUMv/zQX2OObFHzmkTcyTxDzImHl+5F1AURTT93iJP5v+PnW16eINMU4T+TEtMgReLs5R5fP9qLs9QATaKDmIuoGqLrFedh95GX64xkEpebcLK+GiwWccXCAFl64Ha0TBqIzc/7PKTpPP8e/3xz3+JBDBPwb8IMb4TH5Z9e8Bfw44VUrZ1MU+Bj5On/8x8ArwkVLKAifIsuulR4zxrwJ/FeAb3/y59JortClQUegY1rhEanbJeCVAcko6nGZ51HFCO0nf/7B4cuJCpDMek07hcIgOFicd+fzZbJa+X/bOFAMaa+1EMwphnEYlH8FFl0jMxfQm5M2p1qmAxEhQ0l0XqTPLz9YWhZiNZ3rLxP3TtPtWxmqlcD5QlBUQpUMpcqcTKIuCctYgLlIeVE3V1ElumdQzafw7vbzDR9/9btrgyhKs7x2lldyzfLCgXg6+k+41DS3JFP3ea6/wy3/xL1Av5mn5o6euoKrFsOPn//yvcvHwAe/+9u+ye3GdXLDi9PrmQu9joKhKyrISZoPKN+VheSZJvwGP5FP5IB1nUVeJljUwXy7odwvEwAba7ZbrZ8+mhNyYRk9t9JTa4McBh6Js5ixPT9itb5O3ghxyLniKZkZZVsxPTzi9OKcoU4SRkgNDYlcMVSnQwOl54IP3P2C3S6o5YydrRjUIPq6UbOOffPQJ0Xua+Yz9ZsvJ+TlFZVmslqKWSwKcsiwn2pPIPS1uEA5s349SWFJPKE5Zm5fSlPMjH2rh6D5I9/cE6eQCmwtpvqfy1JWnmSotAo89YJXKngtpoZW5tcVBGJOnSZMSM44fx5za449NRRk93RfEII5jIaJ9xAf5XaxOyrDkWBa8GHJHlZ3MckS5OPcZo0SpGBNLR8WcefoTH3+SAvsB8GeUUjMEIvjLwN8D/hPgv4MwCf454N9Pn/830t9/Pf373/pJ+CsIBhsQp51soqG1UIK0Eas86QAOqQTi+hQZRofCJ7d6kdX6hP041xECFDYtzoI4UFljJwckQpy2ljk3C2Jacvlp0eOCZxzGpMQ5YIK6SJrx0hBUeImqEuOBViXkbPnvZICRfCwjXtgOaVli5R2fqDAxRorpe6aLOFHIxMdSHkZZSqT4GGM5OTnlyWdPANDjQNd2eElZSd1qYqYhwYSytE2jYsY/E2VsGIT+lce6xemKn/vVP422lm7fYktL38uir2kqhn6UkbbUnN+9x1d++Vd4/slHfPy996bAQmU0KopblMhsa+rZHBCnrADoEAk6ddb+MCZWdU3bDqBuU6H2bK+vMUXB5YP7GAHbCN7hUcxXJ2xubhL0IrS7mKYLUJzfe8DZvXssTk6oXjzlk/e+J4eTkS6zqmu89yxPT4VTHaHvBp5/9hylDadnJ5yc6CnB1BjDg4f3ub1ZHyh5fYcbPUoLnj0Mo2D61qCqkqZpCD7Q7/c08zsoJBVhuxY/YjF0iWlBpSeuuK2KSV6a5ayKxMcVP79k4nPs1aoZxz4ta4uXt+5H00sutPlxzELInW3bti/h5IcOWe6paAzKyNI3M2ysFjgQFYT2k2tBTGyMI+bBAZ+N0zQXjojpSikInrKyuFEoXMpolI5oVdANAmuNPqSvkeI6DE6w2wTduZSjFpVh1wfGMNLEAyzyox5/Egz2v1RK/bvAbwIO+C2k8/wPgb+ulPpX0sf+jfQl/wbwf1FKfQ+4QhgHP83PQSKN5ZeWcchQVgXDMFBUB2WUGABpoo8MzkGK7tZRoVOXS5SgRGvtRLfIGJNLeUn59M6Lq7zgyc7y8sSYCpnW8WgkOuBSOVcrn/TH29UQmDwFfPDT5tgaSbktTfmS7dsUtpjggGO1zbFuO8b4R07944sgQyC5Q8pfa61lcbpKvMuACoJnjcNAXYo1nU4qrISTkG0Rc/AeSEH4hT/3Zzi/dxetDP0w0O07wc+UkgVT27I6PaFMi6JxHHn81pc4u3uXYb/nw+9+l+tnL1JKgnSxzWLO6vwOENncXB8OqxjF4DqNfvl3ff97PxTYJ71fz558Cn5M8c6ySPMoXnz6hDuPHlFUJVdPnqDTuOlHjy4Ml/fvc/7gIVUzp5rNObf3+PT9HxDciHcSKQ9iRnT56IFMQEqzvr7hsx9+xMndS4qqoKpLitIkOlqCHMSJiBADVVUccEkFTVPhY+T87p3k/lZQL2Z89O4PWK+/z8W9u9JNaUW36agrWYDl4ua8x6BoU4dalsWR+ilRC8eRQh9MvZ0bk7xbEYJEKuXuMHfI+RrLz1W4vJKA2/f9NNFk8/AMNxxTsOQwNih1RH1MUwkwiWxyYT+GII4LekzL2MPSLZA3AAEwSlNYMLoQ4xqtKdNkOngPrkMbK0kZyWrU+4DSBlMkAYPWOC8zpTUaFwUydJMZ1I9//IlYBDHGfxn4lz/34e8Df+qP+dwO+O/+V/8hMIyjbNVj0ggbK3iKE8EA6c0rrHi+ikGFmWR0EYVDp9IXpXsJATdG2ThysDoU/CuRo62diupkepG63fwxkCWNTeP9FFsRjzeihwKZ38Tcu2e39+NmPl/Mx2qRHD3uRofV8rYdsDq5qORnH0a7SJxy4uWXjJOl23a7TQwKTdvuEhuBRFtLGKS8VClOx6KP+H9D1zOZujgHyNb/1Xe+zBtffhsXIn3XTibWj159xHxWc3Nzy81Vy9g7dmFPu2sB6PqBGDXn9x9w+egBXbvn+99+l2effEq73tDudjx88y2C8zz96MPpwHApjBASV9Fa2u2GD7/9HYzSzJZLwbhD4Pb5c2wthishRkyEm6fPaOZLifQxkj81ek9dV8kycqTbrmkWc0xhmC3OZCninUAlUXLDXv3y25xdXkCEvuvZbfcM4yDhkUFEH9liEOQgratqWrAKGT5O11S+VGfz2eS/EGLElIbFfMX53TtcP3/O5d3LtFztp6kmBMHgtVLcbrZorambihDkkO92Irs16XDIi+Ei4f5918thqASXzVLSjNcfpxwczFbc1I0bbfBaJjKbiP1KHSJkgGkUz9ivtZaMVpjUKecinbtn5zxlWUz3Jwmuyte/cw5lS4wWvsDQ90mlGYhotJLMMz/KMtM5T6nkcPHaT6wFFR2l0URj0kRgMEZhjRKKWAwJzfjRnWt+fOGVXBnsl8TYMC1zvHcURU7dlFheOXHEPSjjKOIVKdQNrRQ6Rax4ZMElOIu8UZPBce4K0xb4GD8iSmBixgfzBTMVUy2mMdk8WE7zgzQwE7LzgmLCNWHqPo63sHCkPjtahKUvIEZZpLm0XLP2QO5WqSBGBL8d2p7ddiek9V07XbwQkwlNxtwO+fA2yWhRh22wH1O2Ekx0Nq2gbBq+8cu/yDCK2GC/26Ei3D5/wclqzjjUEOD6xTXb7R6lpEPWyQBlt94wupGiEqf8V95+h0dvfYmA58kPfshH330XbQy7m6vp6piKa7oOyqpEhcju5gVaG3Sh0VZxcrLiD37jN7n3xquJfiVx5jrC1ZMn4sHqJO7SlCXz+VyuiVQEhn6g9p6+S4vEVCAKrXn8lbf50je+IfQ4FQUKQOO6Xrx1feKYpMM+H1zDMDAMwqfNblD5PSjLMgX5He4EPwxcPrxPPWsoSsvd+/emTt6mazGP6TEKi0MmHZXex5r9fi8NRhR1JLlJCH7qSnPce1lW0yTnvX/JajBfr3lBmpdNcu0rzi7uYYzgs0+ffkRdlhhtMdXBbyEXTmutuJilwl2Wdvq41pq6rum6AWPsxH7JteHQlyR4IcMYSjFGGAcRHuRsuRihsAYXAqqwk9BDa2EXKK2oigLn/KSYjMHjgkOrEq0tVuuJXfDj4AH4GSiwSilKk3h16MTVzMsq6eCkmKmUcKAmHMiagn6UbakmTh3kFOWtI/3g0Fowx8LahDsdQPQDZkp644CoEycz4vXBJCImzLDrhoR5xTRCy/MMIafdSkHMEMDxYkepwxiUR6vj10JrnbK+3LTFbrteiok2hMJMF/3Yd4yjwxaFJL22neB4oZ+cknKBny3mKCJlU6PW21Tkk/9AXmaNhxHusBE+PK8HrzxicX5K8HLBNrMGWxSsr664Xa9xz68pqorlakE/jImTLL6xgwtUdc04jBKIOG9Yjxv63rE8WfD217/Gf/of/j/Z3NxitXgZwGEp88ZX3uabv/LLRAUfvPcDPn7vfaqq4sHrr+HHkYv798QQ5ogAvzgTjwTXdXR+oKxK8VIIgb4fUjDgKSF6XD/QbXf4MDI4R1nXvPX1r/Klr3+N5dmpyKB9SEY6auL1Kn3IylKJG8x0SCqykYi1ZqIj5c4oF6KMXRZFwcn5mWCpSoORwti2HXVdA4q+7ydvYaEtHcxjugSlZL5zkahPedGZF25KH/K4DlQrM00r+brMHWZMew/nRmIgEfk9VT1HoVguTtjvNjiVvQ3CQVSjwDQGW1jGIJHzQ9+lny/hlEVZpPyznhgPHNv8SuV7VBZuqVFJ0EFdivQYDGMS4+TXvC5KgUus+JdopeV3isLU0chhKYXU4ANEdcya+K+BFwFB5Jey6RUcT5RCBqVCwotCGrtV6nD99IJrlehGcaQq5ATLjk7eh+mCDkHiQQQfF1OJwbtJ+WHUwfYQMjYM0fvJxFqehzztnN0OgjnFGCditfeesswYqj4q4gc3LVBT8RjHMS3yTBI1pNgWkv0hkaHrGMaBoiqTExGE6JNuXjwGmvmMqpHvb5LqpyhlCaKNoWkqirKS3ysKW0FwuMg4jNLxpxvKWrHqM6TpwGpe+8qXAY02UCiNjQZbWh6+8ZrAKKsi04oZr6+pT1a0ux11LdS5uqrZ7XcoZIw1SrLr3eDQVck3/vS3IAS21zd89P4P2b64oaor7r3ykL/w3/zLVIs5L55f887P/RxvvvMORVXx4rPPqKqG1Z07lFWFGx2/8Gu/xnK15O7jh5R1xfr6ml//m/8J+9tbipRMgFIE53DjQCDSbteT6u/s/Jw/+0/+41w8uJeWgiEttyJ9Yndsb67p+ha73lAUBTdW44aknkIxdB3NrKJpxAOiSnBBu2+n6zzdAOn9kw5RC/ifpjpFCLBYzKaCl7f2B3FGnDpoaw3WFPjRU9VlSk1N4/hwKJaZAZA9YK21aZF5wB7zx+Vr3XS9aCuKxN36hrGXBRchJMNq+Q1CCNjUCIiSMC2LrKGcNcxPT1HI62S0Zhh71rdXZBEAJGyYMBVT0h7Fh5GoQBlDXWuMgn4YUUqoVzodzjEGunHEpqVjYZNRUvIaIEJQ0sLFdENYo4lK4b2TWBr+a9DBRiSpVE60KBn2iQjsXEyqlpBGB2EZS2JsTmFNBGptKKyVOInUPZRFgVIy/uWQtnwqZSlpttKLyUQidz+CHclX+KN/E4zWMpuZabQ6BvnHFDn+efJ17hSkKzgY0wzDAGTDDMHAxmT9N7RdIpNXXK+3SQYc8dFTNzX1bDnRZkBcrDImRf7Z6cCS/VlMh48U0ukWDxIwF33epB7oWflwOL13l3uPH0+dUzaTAZgtF2RDDxLFpdpV9EMv5tqZizmOyaQDhn5gTO+VTlvl+6+8wrBvKauaupnxvd/9A1ZnJ/zCX/xVvNbstnvKspSl0XKO0YZPfvBDLh7dZ7ZciX+Atdx//JDTO2fMZw2EyOr0hD/zj/4af+v//v8ArbFofHAEN9J3rXBs+46imYF3vPrlt7jz8D46mYOrNDX5GNFGYbVlv1mzu3pBt1njhi6xLrIzlZeR1cpB2u3WtF3Lydkpi9Vyui7ytZGpScf/P+HsR5+rjg4/scPs0qg7HjDTwSXTGCiqMglu/IShGmuYL+YT1tn3kjqrlNxrsowzR8tNkXULTqvS3iILW8SkJ0Me+VopU4pu3hNkaMONjm67p76coZTFGHHMalJkTbffiuwgHgQNgLACyJNUcnZLVC9dyEQRY0owUYHCHE0JKIYUlpoTErIEXClx35LJNYkulJqUhD/N4wtfYFEHlx/5xT0xitFJCLLpM0o28bLUkYgLAhRlMb2oSpGECTniN0LM/6ZTR3xskhYnsD13q3kkys5XWc8dYkzSRIEBPs8++zyVBQ7jX74RQoiC+yGEcWuLaTSXES5xPaP83BhCUqU4iCV1U09jnRsGQmllr+U9zvuDLV362eMwJA6vGNpgspsXSRmX1C8yg0384KyIy8sRbcSw5eu/9IuimorIVBDFfT5jbRpNYQxFaSiMod1s2G528jlJDaeragr4i0jxKtMS0DnH0MKTjz7htbe/xNnlJauLC148ecr3f/9d7jy4z53795CWUqGCLH6G/Z57rz7izuUl2/0ejeLpp5+JgYrVydw5cnH/HhcP7rF+cZUwdlHpqTSuysHt6fd7vvTNdyAi/rlGo0Lgox98wHazlec5OFSAy8ePKRtRyPXdjs8+2jIOI36UUMS+bTk5P2O+WHBx7y5FWTGMLjmKMcFIwNSV5msnw2B5KhKrzkNHpbVmvpjT7jpcwsyLlK8FUTp1hfCEvaesSlkAhTAZvucQQ+fcwdgmYa3yM3IMEcxmzcRzbtuWoigY3TgpD4uEawJUpkrdNTJ1JTl3DJGPP/qIqEQg01RzykqaEWMNpigYu/aI4J8cuzwpcQSUlolNlGwlzo34BCfYhMHm1GDv/cTqMNqk4EMn12A6JKrM7EjeDMYUlEf84Z99iEAlTCeAj5KN5b1ndEImZ4hQWOHDpqUMKBEl4DGJvwnS2bmQLooYCCkfPc156Y8sbNItNRXTDMjnpRswjd8hRnTMG+BDftHn9dhwEBrk5dDxxdv3QsCeXNrTDSSF2AnIr2V0LetKOLtEuu2ebOrixl68YU3qKhI80PeS/+WDTz7PqdMcE5WMA5k8W/BJ8XO4hPUe6GtSROXCi7z6lbd48PqryUwjkIgYyXRHUc1qlII7d+6gtIzH9x7cFwGIEolvGFyixAk3uJk39P0oU1tWBPmAMWoq8MuzMxZnZ+gY+P4ffJvZckE1nwnFx0iM+uWD+9x//BDXO4yynJ2t8KPkNq1vNpycLOm7HluWPHjlMbfPnqc4HJUcp2Ki48XkkeA5v7xMtnqyTBmc58FrrzCbNbRdy82La/6D//w/o237KTlDG9G3qVRYjLW8+dUv841f+UWKujp0hEFG5ZwJF44YEt6PWHuAlKy1QvFLvKuisEcHeKJXFYI9LhZzMrtFKWiag81lfsQYsUdTWv5Yvu7z58d4uLZz0QfxiFBecXK6miCK7Pd6rH7suu6lhW2XTIxiFI75i2fPefH0OUZbHr76iKEXF7GzO3d4dvPZ5BOQl25FUVAYm+mwkAqqPGENqTEhCoyojUQVVVUFQQ6Aw4RwwF0Fb9bTAkzbA+shez38pMcXvsAqpVjNKqyWrbg6orUIcVuI3VqniAefqVyaEFOpSJjWOMiCy4v2kxAVmixSSEYUfmRoW/Zt90fMRPKYnxdh+XG88QemYpzlhEVRvjTy3d7eTmNcVZXkhNzcORzGv2xiLIF+fdvjnaOsKvquo/PCBLh99pyAKJmGbmB+eiJ4XJWdtTRlKYsvU9iE00oXb61FG/HFDSkYTinpAMqymCCNCRII8v2yAOPk/l3e+sbPsd/30/g6GY74g0mMH0a+9+J7FGXB7fMrzu7eoe8HFqdL4dA2kc3tmqap6buO/XorG/bUoVlr0YVlcXqCNVn5wBR58/o7b/Ph93/A/cePsGVFoQ0ff/99vvzNr3D1TBgFQz8yn1fcvX+XcRzZ7Vratqeqa27Xa2wpJu4+dTli/GKTSk4gluXJSug7IWIKw+3thrIoWCzmuNHjPdSzGbYqcds9JvhEGxLlkEZwzdX5OV/+hZ9HlaWE7x3h+NnTIRegYz50CAc5aoyCs6vUuYphkTz6fkjvaZpMYJIj930/QQoQE3xz0NcLXCVFNV/HGQ46fp7wsk+BZIGJd0ReNjXJbEYsP+MEWWX6V6YkDsMwcWrdODKfz8mp0UJ/dHjnWC4XsqBOr0nf99P0KiyIw5iflZ1lYWh7j/OBbPiig6j26qlb11OHPdWXtJDLv593Irfd99Kp/xT19WegwAK1TYmxMSbjCvG2NFrjI0I10QofmF6QfCEK8C1yN6NlOWCigOUmUbpClEhqlZZF2+2Wm+tblicr5vO5vFlIQdIxEPwoCpWioFQvy0YzTjopSzg21pYucDaTpUSmSAnhWjavkv2TL2rxtPRDuiD7nu3thr7vUveqqJrktNV2mMLSzGcyWjc1TcqoL6xgWQc2wwEf9SHgRsft7lpglOwHqqEsLW7wL7EGjpVt8+WKb/3arx24pql1jRnRTcWhH0aiC7T7DpDIbjcKeX53s5n8dsdxZHvr6fct9WyGKcs0USihDlnL2cUl4ShLKmoZ78rZjDe/8lWunj4j7vZstOKNr36ZomkoEoncWjG/yVv3cXSTn6ocDAWTuYgS85mx7ymLkrJu0Cgu7t1luVgIb9gHxmEQbD8xIoZenNUePHyFq+c3Yl5jpNO0SNGxRcFstaScNRilcRwoWtM1O3GoDwe5YKXZCyCnYiThgII+DIlqJGkIXexp207YNIN4H+SDve/7RP/LsFWaWnT2AZC7L8NzSuVqkia+I7ZDfs75es6vZz5g8+9grE6USPletmjkkPAhRUJl2Et4ud55irKgmTWgIn3fpp2IqL901FRGoob6YZBg0OgF51fgYqBIVLpRi61iWRzktzpGYnJoc0mJaI5gAvH1SEnVQGEj3o8YGrnef4r69YUvsKDoR0kXHeM4bUvzFGO03MDi3H84VSGB3kZho05d7MGkOmOrSulkai43rJDqDcvlcurc8kNrnbw1kyXbkUVbfq75dM4dRhYfHI9T1tqpMwSO8KlDJwOJfUDySw0pkjp4Tk5P5Xe3hmrW0MxqcUqyZuIzqhTOl2+ozFkchmFySQohEJzj6ulTtlc3uBjY7/agoKoKtFGUVTXFGoMU4KAUMcBXfunnOLt7IbdcECpM7u6FUpMLdmS/74g+cPPZM7quk65VCUZcNg2uF2hjeXkhXXotjlKmKBLsEFM8u8iMx9GlhZzg7945irLi4tEDrCHhjkJPsknanGN6ZCs+kBVA291WSPSzZuI2Wlsw9IOIM5yTA9w5Vpfn06Y9xjjFp3Rdx3zesJjP+OyjT/n4w4/ElS3lOGXhSjObERJ1LmOJx2mt3rsk5T44rMV4nOCRrzcpANcvrtMBrzm/PIOg6PaSQzYOA8TIfLHEjSPGmumwzFBBvhemA/fovc5Nw2Eaexk+4AhC++Mexx3v8eN4IRdl/BSloD7Ivad7LHF5Pw+1HU+Ubhx57w/fZb6Y8+C1V1lvdrhEFdRKMXrxaChiTpv1R7sVOVi8T0mzSvYHsrvR8rHEoSd6tJIsquOJ9fO/3/HjC19gFTCGAw81eEdVlvSjwzuPNaIJj9FTFKVgJ0ldUqSb09o8CjmU/nygm58cnLIiRAILO6HNJKgApfEcfCKVUgSyo7qMZIIz5a394QQPKZ7meDTLxY6kHpHESzvZ2g2DUG6MTW9oiIzDnPPLC1GfGXELCyCWdFGwybKwAuaHiIteFg5lgdZi8pGLtiIreMQr8+4rj7Blyc3TJ1w9/YyysBOOdQyTxBgJPnJ2ecHb3/waTVWJyTgvd10h2Ok96/su4bFCc5ktFkQi9byhrCuKQsxfjLWUVcHJ6YomRaYr4Obqhuur9aSvPx5lpbuSriaGMEVw5620TsU0+9xmDE1u/rSJDmJfaatKuhilk149+89aId0Ds+WSze0Waw11XdP3PavVihgiv/nrv8HDVx7xX/6tv023XmNVwkatpZ7PWKxOkaLkZalVl+RJxyQVmU2Jxs2smX7HyW0t04dSp9eNI5998BGn5xd8+tGHjG++xuL0lI++/wHrq2sUMD9ZoUzBfrNjdbaaphRZjuXi4tNiMsqi7HOLWJlYshfs8TXB9Fp+vggfF0KBDAI5JeSYBaCTCX7wHtDTx48x21zoixT0eXwghCDuc7vrG26ffMZsvkwUxHwYKLpejJ2UOsjTrZXXUltDcCOzyjI4T1a1hUS/HKMjRJ8gD/FQKKwou6Ya9bO85Iohim0gwj/TRtMP0sLb5PJ0zDfNHgNiap1P18QhNDaduIIHBS84miKHnYHSBh8GlFZ4J4TzqqomKpHWCpcWDT4ellB562ytmjqEHA0do9A6jrHZgzrGTkqtY9lsttgj/Q5u9PRdP9Gnrp48wVYVfdczm8/RxlDPZ4SoceHgGiYd/4DWgmUWpZ0it7URk27xdejR1jBfLaUrdE6iUcqS2WxG27YTzKFC4Ku/8PPi2OTl8zJp/jA96KmA1XWNtSV+HFmcnciNQpiWhcdd0s3zF5ytlmIHqGUBpmJMS6ZIu2vRVlOWx6qio8VjUaTxWfLI8pY9xwvJdZKjRPRUcADqusFYK14NwQheWmjq5CVbzmr5XqMYgcjrmEyuDXz2/R/y+/+/X6cfe4RLK0s5hbyPRVnSt3spayFS1yU6dbeol81QhmFIxPmDH4B0rQc4YT6f027WKCL9bssH777H6eUlvu955+e+znd/7/cZu57oAx//8EMWJ19N1p5+4lgLJCVMDqPlUHGJsSCvzcsMmMw7z69d7lKPr7f89wyRaX3g7R6zaI4Nt6NWL3398ffM3WKW5eYCm5uoEALLkxMWpyc0iznz+ZzN7QatZFcg6bAKolwnGhhToXcp3qgfBVeV3URAqSiwAQI3FNYwuCCQZIxThM2P617hZ6DAgtBtxnGQuG5tiEZydMYgiZ4HHmCQDfjxKRojg5PlQ1UV4u3oZHwk8feqqkiguVCmbm/XScYonZlCT6enSZvEvu8nC7P8hufRv6qqiR2Q3X8yTSZ3dSAWiBNumcbO45sJDh2Xcy7Z/Cm+/wff5tmHH1E2Dbv1hsXJitnJCW99/SsM/UhS704sh4jAKqL2YYI+tNaYwvLoNfFEt8ayX9/n3d8+0MPquk50rNQhAovFgsdvvzFxVvPCQXDOIlHY3IGeFmHbbkW5pRUtUDc1s1lDjBIjY4xFaXj/0yc8++hT7jy8T900FGXBbrPh5uqaO/cesLm5ZX66xFozGegc39xyqB5wb4FEDgkSMTkyH9+oJP6vTTxhgsGWpUCFOlLVDUrBfLmkrhsZO51DqWKCrIauY7NdM47JdDxhw1VT8/hLb3H17Dl9u0fFgC1KPvvkU36h+GWaRIPKi6tcTDK0k79X/neV3J5MYem6PV3Xszg55dHrr3JyfkFzsmJzc4spLfdffczNi+sJCz9emuU3Jn9fnepETGN09ujNuP1xgTzGVo8pY8cUscMyTBZmWYxx/DOOu93jQnXcuX5emvv5z83vs/MOHzzNYgEBnBfudt6LBH9IR4gpicNaieXJkTLKCPtIiqt01FopyfcaHChNQXJc8z7foj/bEEEkUFo5TcuywIUoEtfeYfLoHzxKR6yW7PI8auiE7Vhl6fsBoxKgbiw+OCKK0pTEiJgYe89utyMET1mUjIOfOtSu78WbICW2ykZ6jk3jZD8MUxHNxTXjRznI0DmJPJY35Dgv/nBiixpNTcRvuWYPjkTb2zWffvABWkVsYXjlzdfo+iFtiQ1FGScWBTHStoMUtkJT2GSInQ6DXBgzqVxpzWJ1gtYW74Qnq5NLvsbgnGzX7z56SFFXUzedb5RsSC7Cj4OvQl4e7FrhMJa1LK/6vme/3TNfzihKn9gUkbppaBYLfJDNr61rLu7f4+zOOUUlz9W5kW4Qn9P9Zsv5vcu0GHEJz8sSyTi9B/I6H3D13PUKJSqNx8YSR0dR1xNRvVksCRGa5ZyhH6Zx3nmP9wMvnj7jsw8+Zr46wQ8DtrCc37kkWktR15xd3mF1cYcP3/0u++2OqPZ8/Uuvo5Tm9mYtr1dKbj0upseFJftkTIutqEBpLu7fpWwaTi4vxAshRkY3AoGzu+cYaxmd59Grr4mGPk2Chc4dfCpY6mVskhizbCddq7K/iHGcJsNsAnP8PI+zvvLEV1o7xQvJAixhoRMWrF76c9hhxJeKcP4ZfxwO++jN1xNVK05L0BA9PoLyAWUOnibO54QEcduKgUSDlOW5VhFrkjQ2SM1Qx106YJT5I8/nj3t8sQtslDe4dyPaFLiQuYGOpq4IYZRfPAJRJaWXJirhzEoHECdcJeOlY6JEWWPoR5cuXuliz85O2W62dK2MaEKYdnRdy9B2kBI+c+qBqK36xJ2UMSZfeMdqp0xVaduOoihkQ5+607quJ9OYfHEexixe+j7b9YamaXjty2+zPDvFFpb3332PoRuF1qQlRifjdEXyHGgWkjpapDhjMczxEy5lrcUoxersFFNahl4oYN1+n8j/yTNXwWtffosih0uaAyk9Y2eHhZjGGKE4Oeeo5zN8klyCqIRiCPTDiEnCitX5GfPlAmMN/aal9556PqNMnXSMgSc//GiaFLz3zBZz3v/Dd3nja+9grWW32x+phdT02ubnkW+Kg5lO6rjUIQ21ms+n97RqGoZhYLlaTt2fsRKS9+H3P+Tms+cUtmBxes7jN1/n8ZuvU9aVdDqjY7/e8L1nz0BrmuUCAFvVDM5R1cUErWSc8bi4yPV+ZAIfvLAfBsdmveb0zqVMGlVNPauJGl55/RWJBdKadteB8SxPVlgD3oVp3/ASjnlEBcuvgY+ByGFC+HzBmyakeGgWMs/78LwVdlZRlU0KkIxie0lkv90kmtlhmZbZDZ/HdF+G1YrpEAoh0O732MLy2aefsdh3ogL0srdoqlICN5MZUu5ilSIJIUAhBXkcxgQmRpHOBseQmiyTBAkZUslN0s82RKBkMx0QFYcfAyHL/nQqXM5L4msQorUfJUpDXOlTMGEqhFVZ0vdDeqFTkXEBreSFz9zTY1u1LAiwpkDVmYgvL3bbtlRVRVlWk3xuSAqpPOLl7bXcPAcv0swu0CkjyPlsgRiI/hCPnRVT4zDgRsdiueCVt79E0TTsdy0+BJrFgpNTic7ZdS1lUUyuWrapqBaNLOggYcWCwWamw5QvpIQ1UDcN3XabiqYjONHmxxhZXV5w58H9pJiL0+uTb9Zshuy9n9yanj19xnazoyzKyYxkc30jUdujo2wa2nLL7HRJPWv4wbe/g9aadrejahpefftLiVY1sN2s+fT9H3J2/x77/U4+r1Vsb2755L0f8PjLb1GWRfLnNdM4d+h6mDDuY0xQlseJS61VWpZ6ikrM2o0VP1xRaknkyvrFFeubWzlorOKVx48pmznXV2vKqmC+FMnpvVce8eDVV/iD3/wt3v2d3+fkzl3GYaQw+qVimq+7YwzyuKCFECYzFTMz1LM7KC5lyRuiYOJTwoNgnH3bikRaCQRE9FgbsSk+RhuNpSD6QxHP6iamwqmPXreDafzxKJ+v9/x6aqXwSnH9/Iq6mlGWopY0hWDbKGhmC3a7tRTkCIMbXkpCyD/juEM8ZiVkgU5ZlgzjwPt/8B2Gfpj8QvL9r5WYOflwoMJpm6lp4unrk+VoN46MLhCQHU1dpwnXi1Wi85GYGCiZp/UzDRFIy24SQVhPo4Y7MmpBRwgi/8wmwd47rBFWQUgO/ePoxLsg4bQ6nfKkJCYFSbapJPY3HtRNfT/SNE06xQrqqgYEGzWFpW2HSV2SzYcP44+ebNGIwg8dx4MhR98PsmBIxTT4FH/ij+SP6WttUbA8ORHpq81OTUu5IZQiRmEiZJaeHBwkx/8ARidxg5+KTO6ujTVoY6jqevq9j31pQfH2N75OWVdT93B8s+UuKGOK3a5l2LeMiRoW3JjcyAIvnj4jERC5ffEc70a+9Rf/PPN753zwnT/k0+9/AFpRNzM+MZbw+mPu3L9LU1X4caDfrpmvlmitmC/nPPxzv8K7f/93efHpEx68+hgQZsZx95Uhm2Opb4YRikIORV0WqGHE9TKFeBdo9zuBUbRKG2q4ffacq2cvKBL3+NGbr0qMz37PYrEkKpUEBNB1PWVZ8I1f+SWK0vK93/8uzeyhvIYxpuvqEFudlzd5wsmHWL6hrT0EE0oSR0ypBQdfAqt14grLNVDXVdLTG7pOMtTKqsTHl43KIzK6y9LtwJI5LnbHzzWbGuXrZcJ507Lw27/9ezz7+Alvf/2rjMPA6eUd2QVEaXD6fUvZVHKdmmJafB3LguFlatfn4QSlFd2+ZRh6Xvny2zzZ/oBubNFaUSTcV+lAP2STlkiMWhSTaQfig8TFV1ZhkORqUXwp/Ci7A+/l/ZoV1fS8frYhAhL+ZA3OO8axR8cDB1BOlJEcv1KkkQU0xkhWleCRB3OGvhuFpKwVVhlskUaGtFhyPlGbrBUunNYYYDZLRr+JS6iTXj9GCVKEw+Y+j3riXSCm4OM4st9umc3nmMKymImAYbfZkONqFIoxWb4Nw8B8Madqqmmcz8WbdCMMg3z/di/Pt2wqlsv5RBPLggU4XKC5S87JC/nfQ5C46KgVi5MVzz/JHz/gYfVyyZ37D+V1OfraPNLBoZCBuPIbrahjQ1WVdLs9m81WCr1znN6/i9aKzz74kPnilNura6rFjNXpKdU7NfVCcqiKsuDZhx9xeuccpTWvvP0W7b7l7V/8Odr1FpM8C2YnS/a36yNq0R+VLB93i8cb7WEQHLuwJaqBsm4Y+47gPP1+R1WdslgusNay3+64evqc+XLB4nTJ5b17XL24TvxhKVoKcWAbR0/XbbFGs1jN+fI3v8bidEVVz9IiBdq2ncZqpRL+nuhL+X3LjmghTUPOu4mBIGfrAac/Xhx555L0+lAI2nafUmgtGiHqo6IkuyZoQA7L5MdwVFyPp4F8qPb9wGI+l8/ROuHA6ZBt97Ttnve++y5nZ+eMwbO9XXPvwX32uz3b9S0PX3tlUrl9voAfF6/jYvb559Jtd9y9f5+Le/cJ3/4+NgmLBuewStJKjNZoJYs3o5PkOsaJmSGBJ0InMsrgQ2AYA6UxRCVKOH008R3vH37U4wteYBUg+Il3A2IpKNG5xgimarRsybU9EMitLRhGP3VdkzEDTF2I0ZroAspKRzyOwyS58066BmVEmhuImKRRCCGAETqQS4B+33dT1pcKCu+8nNDOE6NDA+vnV+y2a6qqZDaf0Q+C1e7ajqZpqIqCq2fPUyEtaXeSYtu13bSkEWu3OPFgY4jst3tmi1nCUj0qjvgQ8eNImUbGopFMp67rUkdrMDaNSibHgxSEKGF+JxcXqfM/+NOG4Dm7vEQXaWFoNGWKChHLxMNNIXJJMKVE+8QUuVHOGs6qGZ99/AmLs1OKskBpzerOBXcf3hdxwOio5jNWd+5Q1TXhUhgbTz/6lH6/R2vF5YN73NzcMLQ9vfM0RUm777n/6qsMw5BMUl7G7YDpesgmKlqLws97eU0UYArL9uYGVRQ0iwXddoMfZUrZ7vbEEHnx2TNijDx6/TWaRcPTT58QXKRsKnQSLFhj2K03dF2Pi5HSWsbBsTpdcv+VVwCmuPZs7CxThaTKjkGWqCK/9ZORtS1ExlyXzQRj5Rp0fJhO8EIIWKsZnMcqiQhvmgpbiN9qVAcvWDl4ghwySqO1cFeHbuCDH/yQ+XxOt2+ZLeZUswafkoQ3my279ZaLu3cgZq8LmQbvP35M0zSc373k7O4dMUO/XeOdxD8tlit0FOFKUOGl5/9HOtUf1S1Gob1dPnxAJKb7LjA6ed28MYhXiSTEYoSaSXDTwVFaKb7ep9hwrWRRG1LhxTD6SKEFf7ep6Mrr/zPdwYqno0Iy0d2QDYohk7TzxZc7R6UUFtnG54TOl3E4GU+aumJ0YRqVs6x0MrpWisEJNDBFW6S4FqUVTV2z2+3QVriQXdtJVHJiHgilxWHLkuunT/jsg4+4uHuJ9w7nAi5lg2XWQTOfyamqoAmN+FpqhS1Fagky6nWDiBrGvme33iQMUG4Spxx914GCMaURhLbHj3Iz7JJ7ljWafuipq/qwwTZyKCxPVul1OoysSiku7l4ym8/FuDtGOtcxDgPr2zXL1ZJmNptGqRgjvpcAu+DF/jF4z3a9ZewHQoRu1xG8Z746IQRF2/ZcPX2BsSXBR7pOFh62rrj7+CHOBdqthPwtT08Y3chiMSfGRD2LkXrWoHU2Ymdavh0WOoJNWmumf8/QhgJc37E6O8PUM2arE3yS8c5mc07PTtmvd4xdz+WjBxR1ySfvf8D3//DbxBi5c/8eX/vFn0NZjdGK+WrBrh1w3cBmd8N8OZfFYyn4cEjG2fnaO+6GylLsHMc0pWQ1k04E90w/m9gR02Lxj2635fe14DP1bkZhBTJwMUw7CVGRyVLyIOLQ3F5f8we/8ZvMFiva3Z75ckE9a1L4Z6BsGoJ3BO+4vH8XjEEH6MaR04tzgg/MFzKxaRQ2Hay2KBj6XtzjUoRNxkjz75D/fpzqcXxt5vd2drIi56/F9Cd7O4+jLLuJgXEMyeTlwNI4wEaREEZZQHuPwqJ0oB18ko6L4jLLZHPj+jPcwcrpfLGa8QEKj6GqxPw3eodKzlmZUCyYm2BU0pkILzanGBAP8rmgJCM9hoiHZDkYKcqCxXJO8JFhHKkTT7EsqzT2D5NtoTKGejZPSwElS6wI+92e4CLGWuGFRrB1zeLslGa5mBRHxigxuI5RmAiFTSF0itmsnoyIrS2wRkjz2mhqXUwYlx961jcjhS0whWV9dU27XnP+4AH2ZMluu0+iDEOfA+oKJZ3RGBhCT9SwOllOXfjlg3tUTQ0+5Z2lm7Wsa8ZhIHhJRygSv3exXIr0M4k1tNaMw8j+ZsvQ9mw2a4qypCxK2nafFnme282GetaINLQoWCyXBO+omxk6dciibrKolWL0LokBDEWZHe7DJDTRkUl5JZxkl/BMgXtiFE9T70PC4w9x6lpr3DDQdz1lpThZLbn/6iPGoaPbbdEpDnu/3dLu98xPlnzywYfcvrjm7FICCG+fveB3fv3v8mf+8b8Eacl0frHih9/9PpubdTqsDIuTeXqt1FF3LdfvIS1YzETyMio3SfngHseBYVAMvfC13TjSzGqWqyVVXUKaKHKAYGEtWBidoyhLMag2hkpXyfISjLa4hDfKc5DnMWYhyThycraSuPMnnzI4ue7myxW7dk+72aC1Znl2grWWppFOvt917PcdKjEElicnOOfpu466rib4IwtrjJFFW05azg3SMYc3F9dhGNLhcghiVCrHvkszJQ1UTN2oWIqWNmfoBfbdgNUyDRdFWuIhTd3gAmVmdjiHIIkv+3n8uMcXvsAClEawEa0NwQvPsdQyvI8uEEPCqIym7Uas0knLrSSOF5jXFudj2tZbVMxLCD0VXqV06hQzlzDlpqfI7twpZcpX1/XSfVJMH8sBiOM4os3BvPvy3gPu3bt/ODVLe4TlKlk8ZQpKkhaWpqAoJK+JqStWRCxD2/PJe9/n9sU11XJJXVV0bUu321HUFdWsZnF6kihY0i0V+44Xn32GrSpZNCjFsxdXDG1Le3bCoy+9gUJJguvpCbcvXiQPTZkCnPd0+z1lXTFbzpg1M/pB4p1zF6iNod3t6Pc9u9st21txqdpt1vTGTjLMZj5jdXZGILJMHVFVV7hhYL/vKOuS+UL8cXM3Vk4SShn36voQ8pcZIBODQevUpcrfhbYlP7vrOqpKpKLHEMIk40TRrtfsbm6YL5aEcaSsSinUgxTm4AO76xusVoKBFyWzkxPa3Ybf/ju/zrf+sV+j0IZ2r3nw6CHr51coItubNc8/LVidLlHGCC86LdlCFGwVknjDJ8glTWoxBKIDrcPUSY2j5/r5NX4c8WcrpI8QmhtpKZNNrSMQSI1EYackDqOPhBgIxzckWazWEid0ce+SzWbLN37lF5kt5txeX3Pz4oo//K3fQzcFrzx4jbbt+PTDT2QEj8jSL6bYpAjXz5+jESrebLGgbmZYo5O45xalNIvFgmpWMWsauad4eZL6/NIypzk3eZeg9HTIi/l9jp+POI7ER4kJENP1U5RC+RPz+WzV6bEqwQRKXLgUKSkih3L9hMcXvsCGGHE+41SyIR2dwyGuOyEgAoIgeuosVQ0+8fAQ3XEeG46J3AeJrZ/cdLquY7vdSQ56UkHlVAHxElBTUYwJkxXcT4yShXyeMbXkn+o9i9OVOCpZm9BxpqWVYK0tfdtRGJvincsUl5H4rbYgq2gikaHveP/dd6XDCYEdntPTU0aj+Mov/SJlVVBYS1HMk99r5He/83f59m//Dq9+6cuUs5rl6QntzZr5yZJv/9bvsDg94ezyDkVZcuf+PbY3NxglxVlpzZ17d1mdnhJ1yo5K4o8QpAPXSdKcuYy2LFicnbBYLScpaDOb4b2nmTeIQxppNHxZJllW0h3n0fmQByVTizjty3LxEGsyTJzWLDIJadGZN96i2tJUVSFYdYJ+Joc2a9luNyhr+PC992gWy6lAO+e4ub6i34uT2m69ISAGQV2/5+zOJWeX53zw7Xf5jf/47/Ctv/jnABiD57WvfImP33uf1d273FyvubhzTu/GpH6T55kpbrk7mw5qpdmsN1RVzTC0zGYNoLi+viEESSbQStO2PXVTixgiGHSiHCpjpkDBcRxlZ+Bz3LZGKzvJd42WJapOpH3vpQO++uw5r779Js18htGGO5d3qZoZV9e3vP72m3z24SfcffiAb//OP+Dh668yX81ZLBcEoGvF+PzZxx+zfvqc1eUdvvTNbxCVqKg0Ejcz9CM3ww037z7j7oP7XD64R518a7PRDxyKa37f8j2cDXTk/T9E5qj8d+S+y6ouETtAXZaMQdgUw+jFttMarJFEXKMl76+sShwHCttP8/iCF1ihplztknFxoqQYncYJEFd6rZKCK8gFEhGbuGQiEbynjyFtZWVLa5PLkw+Z9gIxSlqod24ye54UKckzwDuHH+XnhBDohwGVLuSMIXnnqOoKazTGWkySzpZVKViT1hNXr6pKhrHns08+4eTslGpeJYxHFjIKlXT3GVuTYvni0894/PobRALL03PuvvqYQive+/Z3qOqSru2IZaKkhICLyTtzDLS7LUTH+08+RSvD4nTBxcN7fO/3v83P/dlfoakrzu/d5Yff+a4s1IJ0kFVdYguRFDsnf7wPVFWJsQV92xG9pypKyrJgsUqk+sLi/TgdJkPCkEEYIpmp4KNnv91TN7UU38RflA5Gola0zvzI5AGgFWUh3X1ZCZSSjXfEBjHQdUMiix8kos55AoquH5CpT27Mi3t3+eQHHxCCp6wbiqokeCfii3bP/vaWqmkEP68KyqJk6AZm8wVndy+JwVMu5nz03g+5uH+f0zvn1GXFph+oF3PharvA7XrLnbsXwmFFcFAdD8splcbeDIVYY2h3+0T/GglR0e4Epikr8bF1Qy+UKyIGjSe5kFmTfDrkkK6qMo3+AzFaIHfwBytKiFRlLXuJUuCoxckqQWmSX7e5vuW1N15nNpunDK+C/XaH7wf06VLUUF4i0KuqoJ4v2JgX7NZr3v3t32V1dkY1n2G0Zr/bYYzh/PKSft/y+7/xG9x/7XXuP37I6vxUWDejS2q7nCb9shlM8J6o7MTGkQQTO3WpRicj80RdU0pRGo3SBkJk8PJvdVKeERFfBi3sChdiYiAJzBiJwtVXP7rY/sQCq5T6N4H/FvA0xviN9LFz4P8KvA68D/zTMcZrJVfF/xH4p4A98D+MMf5m+pp/Dvhfpm/7r8QY/62f9LPzzZAXVXlckC7ETJQWUTqGiVzvvDiRD6MQs21VIMpRnUDxkG4ycSb3SmzKFELGzuNF5qpqrQlKRAeFEcJ513WCFymFTomgGiWFPZGui6rCFkUatyLdXpzci7JguVxIZxxl/KjqKjEYhAIVokRp56WddNe9dGMh8PyzZzx49VVC9GhbMfQjWMPp5V02KZ/LeE8ImjEKf/aNL3+Jpx99wuMvvcErb73G2A289+73eOPtN4kB/u7f+c9SfHKY4muOlwqSJOFQyMFg7cFdKSpP3ZTC5UUJ5sdhZM+jXZZS5n/Ll6bW4vEwX86o6mq6gPOC7ZgXWhQF2shzKozQ4cQysD9Q2YhJniwpC0rJaH+gZ8lUtLlZM5sLPIGCR2+9wdMPPqbbbAVHbWrq+ZxyMeP608/EurDR+DS19Ps9CkOzXBKB08sLzm/usd9s+eF338PHwJ3LSzHArmrBeNMiqe1aFov54RBPY+5xDhukKcEF9rs189WcECLr9YZ+36GiGJHM5g0tkXEcqIIIOgJxsqzUR++DGMnYCRKRP2oSyuT33Lkhj308fPUxXduyXW/Jbmwvrq547Y3X0ShmywVFWXBydsb18xdcPLicpsSylKy5e48f8OSDH3J6fk5ZWq6ff0Z8RooOl67y+vlzTk5XnJyc0N6u+e71DW9+9R2WbyxEuRcC/igU8njqAUQaqxRWyx6mG6SZci5gzBFDwSS3uODxbpRUEiMBjcZoXIIPtcl7npTHZcT6VFJxf3IX+9N0sP9n4F8D/trRx/4l4D+OMf6rSql/Kf39fw78k8Db6c+fBv514E+ngvwvA99Kz+rvK6X+Rozx+sf/aAVIe18Yg1eRfgipo1NTTLIbR8qiRBGIwU+QgGyWB+l8k3ggRMnlyie1LHCEWJy5gsZaKjQRudiKqhBNvLWM/YCPUQxd0gW7WC3Zt+3UvWVFjlEip7RliXeOthVzZz86irT13u33xBg5u7gjvglFIfhVu08YrfAMrZULoyylmDbzBT5EhsHRFDVEaLseZQpSDgtuFCMbFzw4UGXBW9/8OsMwslvv2e/3NLM5YxCi9dnlnWQyLJ4L+ZTPXcJ+u2d17jBG7BTzxQZy8emiEAqXLZKRtziR5QkBDl1HdsPK1KmyLGU0V2Luk4tqFgfI9rtKMTiaojTsd53wV9MBlA15sj2kUrBazVORFepOLiwgz69p6uSMleJ6lFDgVAzsNxs0ivLeJZUtef7xp4LX1ZWIRXZ7tDHMzlbU8wX9fk88W3H3/l2effQJTz/+mMdvvs5HrKPyogAAjj9JREFUH37I6dkZL548pZkvKYo4pUhkvrRLkdLESFUkochEkdP4MlLWkkQhyRaeuw8u2W525BDCk5MTbCVTlC0LtpsNLh0EXd9TJwFJZs0cIuoz1UilXUKg6zrGUUxfur7n5N4drLUiS01mQWd3zhndSNsJdasoC97+ua9OrIis8JooVkQevfYqr33lHS7vXTJ0LbdXN+w2W3747nfp2pa33nqdt7/5dbTVtPuOH/zhd7h+9oKHjx++nAuWFnBaCyPGZS5rXgbGiAp5So0JWhJvhJySXFgj07ATzwujpZBmAYgbB1CRMcUxNWV1hE/HVJ9+/OMnFtgY4/9XKfX65z78V4C/lP7/3wL+NlJg/wrw16L89P9CKXWqlHqQPvdvxhivAJRSfxP4J4B/+yf8dOTzU8ihD+kFGRhDkvvFIHG6UfKfXPAQdQLoRS6XpYPG6ImekfHTgzxWsLpshtL3vRguJ2KySlHfY1Ij6ahkQ+o9wQfqqkKh2G+3Ey0mhsB+u6OcNRChqZsJ5x1HoW9l2ergxLgkRojeEz0Q0/MYHMbUaSRvGUfPK2+/RYwyulhrhVUwDJTkoigSwXYvlKr9bosfHfPlisVqwX6/o64rMV5RglO/9vaXkqmFFNlj6pCGJC32Ex2GvGvNnEWtps28pKiKH0C2kcwfz8XOmOy4JO9FToLIXeukMEtOZyKJ9lO4Hgo5WNP7lUUUZVlOhUugpDj9m1JMy6/5fDapoeq6QmnNs74nEtlvtuIHWg3UTcVus+X506dc3L0v5PTgheWgxGZyv11zcfeObJzrimaxYH97ww/f/S6vvfNlTs5P+eB732dzdYXW5wzDOBXQoihY367Tks9RWEMzq/Exd9+Cgy8Ws6TyG1EK6pmo+fqup9/33DrH3ft3MNqy3++5vr4meGEmKK3puj5NcHY6gEKI02slXbQwThaLuSzSalidrPAX59P7nLHhdC9PS0KAk/Oz6b2Gg4FM8IGr51e88tZbnN+5mJyv5osV6/UaYy2r0xOur64wVtSWRVnw+K03ePH0GW3XUSU3uEmuGyH6gFeieLTG4gKJMQL9KDCBTgtxmQyP3eTEeMZo8QB2Xpy0YEqlS4Gq4qI3jg6dopWyCU6qkT+ygv102bN/9HEvxvhp+v8nwL30/4+AD48+76P0sR/18T/yUEr9i0qpv6eU+ntXV1fIuafw6b/D4BldRGubxs1DAFpRWLQypGiddJNG4Zx6GeKNTuKBhHXl0SkbXed43jy2180sUZBkmbFcLbi8d8nJ6QkxRk5WK8mxgmkZcowLzeYzrDGTV8FxRLHPG/6Qs6wyhiuYnFgPimVi1/YJ90zjUYJCQgjs9ztubm7Y7/dEJFbHecd22/Li6QvaXcfYOdzgefLBRzx78pSiqjBVibaWrhuEYK3Ac8Qv1C8TvI21E61mMh1Ph1Tmk4KYp1h7+Psxrvh5T9z8PaS7Zyq62TAne5dmmlWMQp87NqoZkpMZMN3cx96hcFCyHag1cgjFGA65UH0vUUDGUM9mLE5PKGc1dx7c5+bFFf12T7NcMLai8HLeU9UNm9sbhnZHkTTxddNw9+F90JpPfvA+u/2efddx5/KC3eaW3XrD5nYtsdpePIFXJytigL7rOeaCgtzAkjwc2Kw3k9GNNgcfYaU1ZSH0vaZuiDFSleV084vBUJkWhoKfjyltNr/2+Z7J71meXlwSBZCujWPDnDyeH4cfZuiBo+VkJDKbz5ifLCeop+97nBt5/vQZ53cvOb9/iTGG/W43/T7LkyX3Ht6bpOb5Z+Z7AEjBjyIVD/nDQRoyCZqEYXAMTtgXfRKjKCX5fO3g6F22sTxYbw69m64dCUJU+KimBNvPv2Z/3ONPvOSKMUalfgzK+1/9+/1V4K8CfOMb30wtLHgfsUbhjE5dm5HFB2oan52XDtRGn9zoPbPK4qOiGz2llWCzSMRHKNKLadOiRS4Uy3w2pywqooLdfs8wjGlETVHHRTkVyrZtpVNK36dK3L9xGImpA/G9OHPFIhl1B49Ohs0E2SCPzuELMVXREbp9J12ZLyjriu1mAyiKqoQAfdehrUEbKJQlDi5RkUBpzQ9+//cZupGyqXntnS/T9z3tZkPb7an2DU8/fioBglbUVtIpaoKTQuu8x9hCeMIp56muq8x5eWmzXxTFhN2VpSSktq3giNlvV2uJecnqoxz2OI5yozdNSVGYJBU+0KeOb9zciYpLV1a32UlgkuNhjDVTYRkG91LkTS5czg2T45YUdTloM7/X2oLZakU9a1gsl3z0gw9kIec9ITh8cCzPzqalzsUbr4I1bG627LdbPv3hB8yXC7rNhh/83j+gmTUsTs+xxYdsr68oK8tNU9M0DWWasoa+o6llIRoQ2EcpxdANFMmsaLveYm1Bu9vTty11U7HftdRNk/BruTZvr25xw0hwPi1xpIuz2qSt+sGzFfLSJ8V/k9y0EiwmXb6bXqdj2eyxPPzY7WrsB1kka8lNizGKIEcrYQ5EKYjtviWGwGwxI3hJ7B2GEbVvWS4WIkxYrKaCrrS45RljiDrixlEWxkqjdUzdvnDblRbLRecDhbVSJ7xYGGbzfecFbigL8ZOOQfK30FBUBmKgKiR1OcaAJk5iIIEpfnzp+4ctsJ8ppR7EGD9NEMDT9PGPgVeOPu9x+tjHHCCF/PG//dP+MK0MZaFxY5gwuRgVEdnG68KKIbSGECRqRaukHkLhQ0AT0KZAhyw80GijJB1hOhVJHbHEkmz3O5QSvmUmWxutWa/XxBBT8aim7sJWB15mDB6r5Yb8PKUk57ZHJXEqhS3ExLkfBGxHJX04wu3dyw00DiNj16OUkUKWzjVtDEWhEgVMghuffPChJBFs1/zB7a1EWWuJren3ohC6/8pj7r7yYFpGiCmNnjiAzXxOFyEGibopymISHeSuNKcwZJ6pULbGqUOZ8sEiE3wgNneySOz7feIrRvGO8DEV3nH63NxNoQpyxtf0b/6gfsrdmUpEfGM0s5lYDcbwcleWpwkx8umnsdOPYp04DmL2U1aVmH6v19SzGUM3oBRUZUW72xGd4+LBPerFHBXh6vkLNs9fsDpZ4UKKMfeeoe3YBEWzWLB9ccXNsxcURcVytWDW1NRVRVM3bNZbfPAicPFugk36Tt6zsixpZjW2EDHHODjcMOCtlb+nuG+iYLXABNNIo+LApw04B46x94kbm1gKcs2qIxbHwUgmTxP5tcyv/3GasBsdXSuKwrxYq5oZ+1bEIVVZYG1B1/dCpwvCeHj29BmllaZi6DpWy+V0fwIMo0TR559VpOsud9X5UVhD13sKqyiSuEQ8fjSmkCVWTPBBUQgk4cZsEqWxyqAnD1lEcmwK2bukPz/N4x+2wP4N4J8D/tX033//6OP/E6XUX0eWXLepCP+/gP+tUuosfd5/A/hf/MSfkshqEdlyjs5jtSAkY1pwSRhgRBtkBEgRxCEK6d05ITrb1I1lQrzRIqNFKYrKEHN6ZDqJ27Zl6HrqWYMbHRlvzEs3MVweOZmdCItAiISTCkZpoSAJmF5QlAXtXkaxvJyz2mBKGT8mz1LnadPiBgW2KtmtN6JvtyLVKyqDtofobJAomGwy7IaBOw8e0CzmXH32GRd3z7l69gzvHN1+R1mV3Ht4l4/fe5fV+YqT83OxmwshBfV58TJoGvl7kM56ggqMResoGWjxgNVmH4CMu+Xl1DiMtLs9q5PlxMXUupK4jhTh06ebehzdtKzwUbigdVMxDKMEGxZF8lRQCZZ5uWhORPQQaRMtTSVP3NxhZR9TyIGTcnO2+5axF0w8eUNLsOR8xtvf+CofvPc+2/UtRin6bmQce+49ekA5b7CF5dmnT6hKy8//mV+mnjV88tEnrE5WnJytWJ6e8p0/+A66sJSzmm6/Y7te8/yzF8wWMy7uVKxOT2jbjnbT0u5bmlmNVjBrahSK9e0GDESVVEsBhqGV6yJZ/nWdZMidXZzStztMEhQMgzAtSJBIfm8gcUi1ZLyhDplz2bdBitBB9TYtrtJepHcHTT8wLYaLdKBm/rPKFLB48Bkoq5LZTHYTQz/Qbfdc73Y8eOURNy+uqMqKqi6nAz0mj1rpQAWH9+6QBaciWGPYhy49x5C4r54YZVKVWytn8sUJk9dGU9oUkJp43iFIonTmrxepyz8gsD/+8dPQtP5tpPu8o5T6CGED/KvAv6OU+heAHwL/dPr0/wihaH0PoWn98+kFv1JK/W+A30if97/OC68f+8gnY7oQNEJpyvnlIjoQOWcMGuegH0a0UpTWEKKj60bBqryWIL/U2cYkJFBao6JKCi5ZhnVdN/m6qghDP+C8Z9ADxtiJfF0WBSTVR0ShlWRw7fd73DBC6gx99JiUy6WQf58KY7pwnfcU1tIms+jsxLVdbyjTOO19kPgSI/HZubCIhBChbCXccnV+wcnFBWf379PMG17/+lcYupHf+fX/gnuvPODy8WPWN1fcXl1zdnEhhVMf3LGGrk/jcMAUdup+RZSRnLeidD1d6q4yXmqLQqS7aczM6aa312t0oSnLkq5txWJyHKfOsqoqmbxSJ1oWAod4LxxG5w7SSKGsBZqmmRZnOZ5H1HTCiXXjKGYd4YAZ5tcNmMbc3JEVZUm32xGDMA1iostdPnrIh+/9kN36FgW0uz13Hz2kWS05OT1ht9ny1jtvcHn/kqwKXJ2JTLZZzFEalrOGZ0+eUjc1Y9cytHu2N7fcXi2Zz2dUdcO9h/eZ3c5EMlxWwixQgbou0HpFUPL6XO9uJK68KiiX80k0UNUlu+2OzXZL3+7JuWg+ddNaHZRhebIqigKC0ANRMiILPGM5pGockpKFtqSkUCL3QTZez2yOY5w9LysPMuD40vvgvYSJtm3L9voa5x231zcsVis2mw3N7O5UD1T62TnYVCuNSywhmQx1cs3SkwWl1AtNFO0sTLCiWJiqBEk1VTlxjElUtBhj4h4nLxJjJjOcDMT+OJjgp2ER/Pd+xD/95T/mcyPwP/4R3+ffBP7Nn/TzXnqkLgUlhHDvPZ6Iilo2+USMgr4f0dpSGIVOCp3cAdZ1nZY1pAsrWbxZIMjXxwA2YXn7/Z5hPOCH2de17zpcGtH6vpfnFQPb9Yb9ds84jlzeu8cQ3YRD5SwkN/TTjbzdbPHeTbgtSrqt4D299yxPV5OTlrGWytTijp8KTSRizMFl3miNzyM7EMcxmXMPWKtob1qaqkKjGbqBO/fuMk/O/KvTU/r9nm6/p4q15FAp8SkQR0HZFGfFW1lKTEzGnmKM7PditaeiiDqstlit2W+3xBiT96dACJNxTVoolVYWL3KgjdPNntN0M11m6MckUPBJqXXoWM1R15onxMJaur6fuLg+d81HhiGZj5tZJGKGHmmWCzY315BUXkEuXoFNhp7N9RWnF5e4YeTT99/n6Scf86WvfIU3v/4V5idL2q4j+sjN8yuunj4HrTi7e4f9ZsvJxSnz5ZwP3vuhmGN3HdubNZ9+9CnNfMblPYsxlpPTU9ZX1ykPzbFe7+n7gTKl3spBW1LXDZvNBlOYiQ0yrxfUTcP6dpP2AsU01htjIArOPF8spgIn3ZslBinEASkkWfl48CMQRk++t7TWKa6dQ3yMUpMZ+7EM+fOJCQcGj1xH682W9e2a3WZDWVdcP32GMqLoy8GX+Wvleaik5EwxTkdlI9sRgmZ0IyoV1GxCpNL38cktzhpF1GJPOGbD8iAdujFpMRqFxdIODlMmWOSnaGG/4EoupjYd0iYYUfj4EMEJ6B28B53GhhhQUdJdnSeRixP3bXRgkuUfkaoo8DGmBZeaxjFiZLvZywhTljjnaeo4/V0n7pz3Lp2CI2VV4b0TPMcLJcQWhSyjtCaMjqK0zBczdpstwXuaWUMA+r7DagNa0Xc9pihEjllKxpQfdOq248E1SYvSZOiEVqSMod1s6XZ7us2OJuGFdVMTVWQYHcPQc3pxhxACt1c3nN6/x/bqRjh/IdAUEirZ7vfiyBUj49CDNtx59AhjS8bBvSRhBSaT5BCyTvvgTRCjmLVEHSesbeKspoNQRXFWsmVJklVhtHTBIYriq+96rDZs1+IPawuTGCFAkiBrUwmdyzuqtHXOh0NVliit2e/3FFUlG/XU9RbWUlpD9Ib5ag4oVJbvRkCDjpH5yYq6njH2PUorhrbF73b89n/+67z7O7/L7OSU2XKBC579ekNZlDx84zWy8ffmds2jV1/h9uqK5/s94+gIuw3aap4/eUozq4Q3XFac3jnDpeWqUKlkrM+xSVVZQghURQUJJx0HWRBWVSUULqWoZg3dvmV5thJjk9tWJpPoMZJxIV167sIU4AJojUbUjYpjaWoOTkzOVypCiFgtfB9iRCUKo89wTTwYsRxHzMCB5hWjwFMxRi7u3eWj977PbLnk2gXuv/IQFeJL15z4IjN9f0jpszrbGzKJeJwbKcsKreKE/ROFnmVLESGM3mONoioNfTrICw0+KtpupCykqTM2eTjk1+onPL7wBVahmDdiL2cwRBzORYwWmaxLccNC0ziccCI0IHEWD8sx59yEJzrn8FM3polKY4sSSFhp6nyON9rZ5T8SKWuREhqrhSeXyPfH9CRg+rk5OqasSmRkOYzI2ihUPJgky3Ktod3v5cLJXVTqiiPTQh9jLGhFGB3NXLT+s/kcNwypWFkIcHp2BkY4vIGIsQVn5xeTJFDkwT1uGHnx5FOGYWC2mPPal99hdXlJPWsY+2FakOT03Nzd5KJaJZ/YGAUXzG77+U8IgcIWEmeixTaxmiYNubmttfJ3dzDMIVPWup6Kkmigb2UBF/sxmZcEnFKp+zsscgCGtHTLy5rNbje91uM4MpvNWC6WgDihFaU4lLl+wM5mzE9XEo2ectyyaix3gt1uw9i3KDRlUxNj5NP3PyCgePD4IX3X8/zZM77xrV/g2/b3ef/d7zEOPfvNmvX1Ldvbc/SJodt1fLYXU+y6rpnNZkJB1GIveHuzlu7NB3bbHfPVYqKqGWPY7XbY9NxWp6dc3r+bTLkVru25vpID3oVsNnRYdpGmiPxeSjGOUyLsMdUtLzsNUlDhoMjzLk4Tw+dNWnKhPYYozHxBVZa8+Owpr779Jh9//wcija0Tp9ocfu7UGZtDJzy9zwnnmCwolSytZcKLWJNgqxRymBOCq1Iw1tGNhAiFEk69c5HCiom/+LvoQ+caX76+/rjHF77AohSLsqC2QuEJKdgwRLnAMg4bRpd4sBE0EzXHGCs2YwrG6CdrwZgkcSqKQYvSabSZ6CbiJ5DgcMakuy9rQ1OW7LdbtBVjjLqpyfnpLmE1mRvovGe/34sVoZKbsm5qNusN69st5axhNm9YX9+KkYbRlMbQBU/XtSLP0+IUFkKYRrC+74VHayTJVWnN/GRJVVaTMYlzI4vVUroyATfFXDmIiXgIkdF79psdZVNSlAXeR7S1FE3N/PSEs3v3Ob17l3ImJG83jmnD+/9v709jbUvT+z7s905r2NMZ7lS3pp7YTYmkzCGMLDjyACiRZcG2MiGQE8DyAAgGbCRGEDgSBCT+YiCKEQMJbMRQYsGWIVtKkBjhBwWSbASRHYO2RLlFiRrIJtlkD9VV9555772md8iH51nrnKqurmZTrO4q4i6g+t7e9wxrr73W8z7v//kPUtj645HVak2l9KLuKAoxweGEUmeNQUYFhpxE0ebW8m9TnDgejrJ45UTdVJItdjiwWq0WpVZJsjDtb/aklFhvXmMYemwxHI5HWXw0TbSpG/puUGxcML71aqUDrSTdsA6JfKgxxjGOkZQ6MrDe7uj7XmJEcma/P4KRz9pXgWPXs95uyW3LOI3LUMQ5jZ1xjqefewtfDBcvXnJ7ecV+v+ftz7zNerOl60ZOnzzh/PKaX/vlX2Y8dsRh5OrlS3xwnD16xBd+x5dYbVfMCbZTmsQTws5GJtLd1spLjjEuEetzPDvWsNquxcgoK+VrGhiGDmsdpuQHz0OhqFfwvAjOLAtjDbbI4lWMYRpHivM473BqfFLKvTOVdSLNtQ+d2OJ9/PyCd6tSL4RAcpG6bfjsl36IdtWK+rFksarkfsCKEY76rEKz/t5DNmf5HMTGcFo45veKLxGsUIoyfDJJhRWzIhEszs45bkLdqoKjGE+Kov7yXiLs5+PvC4P9JBxCx1GBgRE2geSVi2vWFNNCAbrnUIrLvmCukjyblCngvVuMi3PJi4zOKBcwBM9q1RJToR8HPQujER0y6Z6mkWa9xjnHNPSADKn2/VHSSOekVi8GMc46jnd76qYhThPeOaq6onbyYZ09OQcjnpv7G5E4hhAoaqHYVIFJC+zYi6lHrV6yxkj3TM4MZdD02Fp8UUPg7uaWGCObzYbCxNj3WO9FdjuOpGmiL5G6bojqofr42Wv0Q0et5Pmahu5wpGkajvuDqGjqClsMx8OBcRqZhoEiYnBiPxKz5D7lJA9KnCL9sZPPaYzcXF0JpqpGMRgYNXVhGAbSOMm1zIWrlxecPxMiepwmjnd74U7GvNC+pig82BnPdc5yPO6pqnrpVEEkv7Nir24acSM7Hkl6fidPHlMdjnQHEQ/UTUscJu4ub+n2R7ENxOBCoNLiEccR6zImeN74/GcZY2T39BFDHOmujwz7I7/wc/8NddvgQxBGx/5A5UR+fUwTKQ68/aUv8oUf+WHqVvyAyVJQ0oyhqrnOYb+XGHk1NIqKvZ+dnz/AVd1SdA1gvWc4dgzHjikmjP78UmSbbxDuaEz3cTrei++Gre+7UKeDpPTAK2POYcuIOmpe5GfWxkM618OdjDjPBfqhx/vA6aNzMWOqKjbbDeMwLN8DLIwQqx3zvANc6kQpYKUpmtkhWd/jlDKGTKtJ0Va/znmHpTCMijMjcxkx4REmBWYesAnkOM+Gvmvt+vuoe9+Xw1pLdA1jBkg64UPhALe8x2X4wT0kIIzSouC2JBxY65imRPWAe1fMLJudeX2iZQ5VRTFioJ1iJOaCHyzDMDENI9M4MeQeQ6FpgqRh+n6xPqus4GaTGTV7K7PZ7Th2R8Fgm4YpikDAWYEfvJOtaQiBZrUShkSBYRwp8yptZvMXwXeNDnvu9ge1zhup6or1bksaJ7r9UR5QBMsdul6ux1oerJvrS5p2jfd7QghcvPeClDO73Y6SE2+8/Qa31zcMwyBdZS83fVS3/1IKzaqhPx4Zu55iHcF7cT3SRa/yHgskhRMurq+5u7lmtV6z3u64fPFS4JXg2G63TN1A7zzb0x3GGrrDnttLCRjMMdEdj2x3G5qVBOaN07iolYZek4dLptIttrOintsfDmI7eHFJaGrOz89JOXNyesr11SV933FyeirdmXeLfy3Ae++8Q7Nq6Y8sw0kxPlFusws8fv46GUvsRv7af/Zf8A/8np/m8bPX+MavfpXD9RVpZqdoplu1amk3EhH+mR/+IZ5/9m1iTuTDUeYKuijM1DfrLHUl/g7e1ez3ewxwdXnJ2fk5h4Ok91Z1JVN73ZXNqa93N7cMx04piQX7oBN7KDx4SOF6aAv5sEg655bh4fzcGGU5LKb0D6hbM1wwD3wP+8Mi4hGP3cJ6s2aIkTfeeouzZ09E3EAhF3DzMNewwCH3vPhZPTknWQhjZxbQlFKwarvZTUlSUoyBohFCBoLzxCKwiNVrjfoQWDWOyYN4x1qn+P93AWI/0QXWIMOOp699hmdPX+Ply2+KVNQiPEUkvG8mSCe58og7fFFTkiT4poFGE2VjKRiT1eJQprLOC8UjZ8X7inRROQsnNCWRrTa5Zhp62bb1oraqas9qVTOMIylPjF0vNJ3TU4L33F3f0Hcd548fE6eJOE7Ltm6eonvleBpradcbDrd7gXgUb0qKdVZBrAtjTgxdLzzNusFWnv6wp6NQ1Q0WQ384EqdJiO59zzQM5JLp90fZ6t7KFu1we0d3u6c/7FlvN9y8eME0DqQ4sTs71SIuD5ELnvV6zeWLl4zqj3vc37HZiQQyTQlf1RzGOxFsWImi6bsj292OOA50xyPTMOCtmCNPQ0+eRqZeIJzNZiPDPR0WhaYmThMX77zL+bMn8r11xd3dXiNMtpw8OmMaekKoyFjsOLHerUlZsDZvPSV3eOdpT1cMfc9qvaYYuL284u7qWqwJozz8q82a8yePubq84vb6htVKTGHiNFE3NUm/LkWhBYa6pl1v6Q+SkdasaranW/76X/nPOXv2lEdPRU0uz7TB+SCT7ix47/PPvMWj56+pnZ5ZeNHWGGIUT4uhl/f37I2n4hWsk/uZrpZT4fLlJScnJ7JTq4JwO2ef2ZjoDgfGXqS+1hgRtWjxniWus+NYUCf/hwPL+c95HjF3rdbZxUhnVvg9DBtdumot4sfDkauXF3R3YmqUS6FdtTx57YnMH3ZbfFWTomD+VrmouRTZueZ7T+e5kJeiBjnG4K0hF0MuyGyibjBkxpRB0yNmiqQtVq0OBXYsCAd7mkSgZIwhTzowy4lRKWJiaAtLONeHHJ/oAgvqqL7a8uM/+Q/xX/7nf4GhPxIzBOXnDVPChQpvHcdh1G2+Wfhv88paioSXoZPQUu63MlJIYeb6dccjh31HKnnxGk1TpO+6e1+CqqJdN9RttbjjWytFlXwtndI4cbi5vee07vdLxzdzAt0DkB6kK3Q+LDewf7DNm6ZJYATlCdoC+9uezXZLiBPHm1v6vsNVgSfPnnN3t6duag6HO6auJ40js5OQUd21UZVPjonjzQ1X3pGmKNtTA0/ffM6xO9IfO0II3Fxe4aogtobDwNgdGUdhQYzDQLta06iptjFwvLqiWBhWLXcXF6QpUjWNZNmrb+v+5nZ5eI43t4tXbrc/gBEccexFenmr/EjvHDcXV4zDyMXFJU+6jvV6xYubF9ze3OCd563PfYYQxLPiOB3IpbA7PSEEwfcuX7yk7DO3V9eUlPFVII0Td9qdWHfD7fUV290JaVzz5PlrvPu1r4uaTvPOZIpn2ZycsDs9IxkJd9w9Omdzesov/Y2fh5y5vroSMxctPCANhHGWJ288Z31+Rnfsl63nvAsbh5Hj/sjQSf7Z6aMz2b7qrqtpmmUbnmJm1a5UQSX32DRF/CR4vrNO6HMpLwbxOfG+DnDuSpOaxMw0q3nnNBffucABWngLcC+dnYvXMAzv47vOA9Cqrjg5O2OaIquwEez+cOTm6oanz5+x3Z6IyObulv7YCbkhRqx3yzM4n9c8eBa+uBZbVLVWRKI7TCN1cMsQ1WKIOsRblGIa1T1OkkDrLZSsqrH8QET0G4AG5uMTX2CNkQnlm2//EP/tf/D3cXX5LS4u3hNakwFbtZyfPSGUib/25b/KMCju42RrZZzVgnqvS541yXIzSVJCUd7jOAyMw7QMV7Kbc9PVlFgdpdrNSug7VoYrizO+96x2GwqGcRi4urxcJsHGW5FTXlxijVEuIgtYv9/v2Wwk7qMYUbw4X0uCg2K64zBIUF4p7C+vOB4POKDveoxz9MeO4eVLxmMvoP52K8qscWTousWgOY4jOU1QBF7wbZDhRRGnqDiOovkONd/6ta9ze3UjxjdVYLPb8eQzr/P1v/2LYvOHwdcSCwMGFyrlmVopvlUg9gNTP1C3LTnLjZxSpPSFkhL9MC7BdYVCHidsaGjWK84fn7PZrHnna1/HREPMYpRz8a13iXHEOMeNMVwZQxxG+sOBdr3m13/1qwQfKMDJyY71bruona5fXOiWUAr+2Pe0mzXf+JVf5fb6QrO5KpzzfOGHfweHw4GX3/wWzXrF0HW4bCjWLDicd46L995jc7KjuztQ1cJi6I5Hnjx/nbd++It89e/8XYb9UTwksPim4uzZU1a7Ld1+DyD+ASkRx0nyszRCaBoGTh+fs3t0Igs2/n3dm/eeOHVUVeDYTVAMzgnWKzlqmWkYOewPNNqp+0oTDazQtcRrQcQE0xTF8xiW7f5DXFa6PKE+pjjhg1863vSgaM3UqrkoPzTlOT0/0/ywwjSIzHdmyuwPd5xWZzRNjXdeDX8ijYpxZr8Ja3SQqawKjBMRjApzAPGCtRD1NWtlF+skTVWYJ7ngVUloSiZlcYdLCiE6UKhA4ZA8S2XLR6IEn4oCK4fjc1/6cT5ffoKUI7OaOhWI08jN5Tfx1c/T9f2yncVkgneiXsmFYYqAJcZ55RUHnXt8SIqyqICcrtYz48Dd407qyJ9UOeSdkzysvsd5TxUqzTxyrNcbQvCM08SqXrO/u1OccKYmQVKJrxhXCAfPB88w9Mrji9RNg7OW/c0tdzc3EunhrGwDvbAMQlWz3u5gHi7pVHV7csZQ19TjgM1QnFWjaMEBjze3uCrgQmC13sjQahRj6Kt33sN4cZcKVUW9kgLpMHRHyf+qqkomsyGAQabWwN3VNTmKrZ+xlrppKTnS7XtWux3r0xNiPzIcO4o1xGkkKKWt3awwVorI3X5PSYU0RdIkBib97UE+g3HC+cL+9m7hW27PT6jU3Dp2gyQBxETdNLz7jXdYbdbsb24ZuiOnTx+z2qwIdUXTtlRtzbd+9VcoMfPkzdf5kZ/+SVzlOQ0nTHHg8O4NvhabzGmMNOvNUsTPnzzBeCeDmpzpjh0nT5/y+PXX6Y4dp0+e4F/37O/2GIWlDjc33F1cEaN89gXEh6JocsAUyTny7I03mMYEKdHUgaoSD4y+79lut4zjSLuSeBXvHd5Xwl5xXrnYRqhb2q2KC9lEpXh/IdOaWgUJlpSK+hBLR9tqdMti8lIKyv2SDk8Vj8bZ98lq5454/vtC7dIdqNevDZWIKIwQ3+X5TGmxo5yLu8Q2SQcqooi0LHIpJUmZqCqOx37xsSgp453nPqjQEJzUhTT7NBSVXVuLkwGPZORVYiJUVQGMQGXezanTKKvhO9evT3yBBaWdGVFmYDLGasxFAVMSJWf2Xb9Y+S1YTzJM6mgfvNfY3cIUpYv1DkoR3HWm13jvl+378XAUW8GU9CGVbsBaIbn3xw6L4XiYk1s9VV0Tpyg0kCIO8zFOhLrm9uZGaDbOCdEduH55wcnpOdMgMczjNFHpAMwpJccYmVj3xyMgZGfnHOvTU+pxxPrA1A+sTnaEpubJG8/Uwd0Lnco5dmfnNG0j2/G6whrD3fWNqK9CzcmTR0v3VLctJY5ChC+J52+8tXBKz548glzYH+549Pw17m6uBUterXj61pvSiagVXNM21I9OxXW/qcV3oBTqumJ7fia0oX7g6uUF27MTDKhnQy+qIsUMq1qkiSePz5n6QSEUiTK3weNCJfaLKn3enZ0yDYJ1yyAzc3d9Td93xHHi+uUFfSdS1e64x9tAs9nw3te+QaO6d+MMq82Goe957TNv8uLr3xRafo50BzH9dtZhg6derbHe8fKdb1By4Xhzw6M3Xue1t95gtdvSHzs80KzXWOtYYxmPHUPXcfvygtBU4iqV8jJYGfuBaRoJlRT+F996j2n8Bm997vdz9uQxJom+v+s6ZjMV55z+6cl51CEo1E3NFIW54r2HkhQrFWhhtg0s+b4ISsYaWNssXOd73FWGexnBQPuDmMYvgpMk+VgLTqrzBux9RPlDGti8MFqvw9GMpDeP0+LWNkttrT4/0vyIs9rsZLfABuX9gzuSYK7AMuxLRVlDzkEqxDyJqrOIm5ydLRALy5AvxojXodosYIGFDvuhx6eiwIomeJ5QzlNJswyzUskcD3u6oSdYQ8JqSOLs5ejwutJkK0YsRgu2taLimibNiTIwTr2yEApxnAT/6jvJ+QmeumkkOsQory8ljgcx2XCaIw9WA/4yoQrsb25pVuLTOQ0j1BWpT6w3O4ahZ44xDtoRW2vpu45KC0dWiMC2ZqHRVE0jcs4sxja705NlSOOco2pqjvsDd7e3cqOHwJPXnjFNkVBX1G0rTlJGhgExTFDES/aN9RcYxpGT80eaPya84DiM1G2LM47TZ08pxtK27YK7TmHgeDjiVyvq9YqT01OsE+34NAxgLVPfEyfZ4q+2W+mKkwyW2vUK6wNVCIxxYn9xTUwSm75Z7zSFFcjC9Djc3snWcSVuYzOrIqdIu2qIk3Ck4zRKt5QTOQpn2tkVUzcwpRG6ntPzUw53t5ycn7O/ueGtL3ye1z/zNrvdKf7tQLv6MnGcVEpt2J6d421gVMFEjlFUZt7hEPOSksSg3BQ43t7hnePq5QuOt3umSSJZitVt6jiS86QQgIxwA4Wu73n+5pv88I//GJvthjgMxCif+Xq95vbmZvGKEK7riLcSj1OpE1zTNovJd92slM50/4RtNluGYVgEF7NXgHg+SIKyPE8ea2EYBzBGpaxJKYwaZ61sgTmw0RmLDfJ1IFttyMsgbxEfmHvpLdbSrFrGflhEFN57kcUaQAtrnIQfLQwilp2otdJczR4b1hVSvPcmBjgMmbaCkiNW+dLiL5LVu6KIn4g2Pgunu0h0kshlzUdKZj8VBXY+vjOhVxz7l3daIDjZ/o5TFLGBbg28M4tXQUrihF55pzhtvudLFlEq9Z0U1lGJ/e2Thr4fGLqe1XYFQNf1jOPAql0JR/PmjtA0suXUdNTZ7HgWCsR+wFUVq/WaFCMVsN5Kx3TY7/Eh0LatON3XtXAhFxGETGpX243cXMbSrleUkukOR9IgfrMuBOq2ITS1yBABrHjKCh9YOm7ZIsLNxSXGWU7Xa6ZhoO864jSBlwIwY37zlq+qaz73Q1+Qrahyfodp4vzZU2E/lIwzlsPhwHqzZqrlGtwOYv5SUianiLGWs/Nz+lHw5afPnom6KyW8cTqdzjhvaFcrrPNUbUN/7Hjy2rPl3ui7jne/8Q6nZ6e81w8CSWAIVeC4v5PiVwf53RQZollZWENdYdX38/SJ8G3HGMkGursDddPwE/+d38PP/Rf/JSugbhu2J6cc9weibo3Pnj/X7W3h5uqCmGQhC97x9V/5VYaul0WoP1IK+FCJ9+/+IN3aOIEqlnZnp2CkG2/Wa56++SbNdgvANE6MM9tgmui0wM+slLqqEPGfpMRWq6BbWRFDNE2jxPt7+ersuZFzXrbhVVVxOBzk2jvLMIxquD5bRSZKytze3LHb7RiG2bvCkrqeUAmu79RmMqdE8MJBnTvuhyqv2WN5HvDNYoRhGJbuOPjAlHQm4YI2WUKlCiGQMZRsGIcJM7MfDMQoH413YsGYixRkWQTmyCHBg71zTFnMbuKUHmDQBkpevEQ+SmAwH5/4AjtPNx/y6R5y8VJKTGMk55lGITaCpkTZ8juHsZrRg11C4igCXkvHGjHOgnGi+UfismcaSFXXpKphZBDGwThhK0+oavGnNEK3ubu74+TsjNA0rDYb4jjRrtdL8kDwXgyaoxT2otPaqN6v0xgpJWtBFdetzelObqBs6PeHZaDRrgU3FA/ZLCY4CI603m5otxthPVSV5Cgpdlw3tUzNgaDY6P7uDkoRRZqdzTwM1gfaWjT8Y9fz3jff4a3PfRZbOdbrc0rKXF5eSjZ9cLSrFW4cRfHmG8GQrcF6S2hqTh+dk6bI2A+44Nk9OsdXkjIbi9Bj9rd3ShHy7A9Hzh6dybCpCnhrubu54eW3vsVqvebx89cWEv3xIMOj82ePoRhOz844Hg40TUPVyELjvUhfu+ORm4tLCobN6RnNWvwhhqOQ3dM0sTt/xNXFJY+fP2MaR0IXWJ/u+F0//VP8nb/+84Sqplmv8XWNA+7u7nj+2bfZ6CL58p13uXrvBdYLlOSMoV2vWG033F6JE5YLjtgPpBsZLK1Pdjz/zNu8+MY3RapbBx699gxrLLuTjdCMRp3EW0vf91y+vMAZQz8MrNYr+r6naVuOx56hl4JuveCdq/WaqgrUq5a2XRFj5Pb6mmbVyja43Gv6nc4VZt4qCOx2uDtIVI6mFAflr+5v98I7rmraVcsYp6WQS4EUrHUchmV4B3N8jyerudDD5zynJKGt5t4FbRzvcd7ZCzjHpCqtQjYCB1h/b0M5467Ozs5zInttgqUOlag0h16xVAPqi5xnPxfDohSU2iOm4b8thAYPjw8W1/nPcTjyzje/tkj2gvdIjpeQqadJyMYByXnP6DalqMlzLlRWFCrTMDAM4qJV17UUIu8puw3pRoj5qUTylDne3nH25DF9PpIOB+I0cXd7R7vZ4Lzgn7c313jrOXv6mNnx6nB7J8WwFF6+9x7tak27almtArfXN0TrJN7bOd32vp9OA+IdMO4PbNUVaX99g3NSPLruuHQ3+1txJ/J1TdM2YFFRgJrQpKRm3JL9XvLA2bkUwpOzldLYRo63d2w2G+mWRkNRRdpqu+bk5ITj4cCdDvCMEa+DEDxTlC3nfKO36xVPnj+jakSrf7zbi9nMOHE43nJ2fiaMDM2KatcrSox881e/yvnTJyJDfeM1hnHk9uaWOA4ygMmZmCJT1zNiWK/XtG2rgZWJYTWKQY9iu7vdyeIXEKpAmiLnjx7x8sW73F1d02y2OB+4ubhlvVvhTyo26w312zUXLy6Io4QIulr8Ap5Xb3NUWlkphbppWO82PH/7LY53e7UslHtujmjZnZ7ijOXq4oKbi0u2Z6e0uy2Pnj7h+uqKk9MTTh6d8eLd97i6vGK33bI9OSGlTMqZZrXCqSqsXrXLgNBax+HuDoOhOx4punj5EEgp0rQtUTHV0/MzQIrY5cXF4uK2alux1VRK2Tj1kn+VxGxa1HMiN641cidNkRICx64Tnm4/MOepLbJV9WCtqlafzyxueOZehDBzZXPOBOeXhmOaJlWulWVBWBaAIsKjrL4d8+B6hgln2EwUZwWYsWGxJ3RehmBOzaCsMeQ4c341u8s4pphw6T7V9rsdn/gC+9C7c/7/+jdKmc0lRg77a4JzxJIoOuUsSCSJsY6CTEYnzZ7yFtF5zfiP80zjyGiKqo/Ex9Rby+FwpFq1PH7+jP31Ne1qxfFwZJpGVXlJt+uMpbu9w2wz1XaHQaSYaZy4fnEB3pJH4atiLdWqxWLIMUpnFyNBJYYYgSgk5RXqul2yo6wVVyij5O7jQaRFPnja1Yph6DnuD4RKhAtztzCOI+ePz9V39UYkhbpNX29PWG02OOd48c63hEiPwhHjJI7uTU3dNKw2K5EwGsN6teKw34uTk0o2ZzPk9WrF8YV0cXkUYYR3Mhg6vHhJs2rlHCYRGJw9Omd3csIUhQrXrFeM00QcpCtrm4Z+GESM0bQyDAOBQlYtMUWssfTdwOF4pK4r1idbArC/PdAfjmxPT3j89AkgSRDTNNHtD2xOdtS7NW/tPocFfu0rv8zh5oqmbdidbtlutxInHjyf/9Hfwd31Nb/2S7/C+VNRG81ClTRFri+u2J2c0Crz4vTJo8WXIqdM42RQ0q5aUfRtV2xPTwROCIG0EW+Hd7/2dbn3U+b28pqz88dLV9YfO47dJevVanH9meGjcRzp9ge2Jzuur65ph4aqqjFuACO/uzse8SGw3m30Xp9om3bBf29ub0WVp+yQVMR9bpqEwhi8wDTTOBEn6VZ9CKDqqZjFw9dYI/CQQhlNs8J5uX+bppFkkH6kXa0oWfins4z5cDwyYmjbVs3cZXFwwStXWnZ5i+9ICGoBOqu5jDYawoyYZxczTDf7DTDvklX4IrHdAvVUQWY1MUaKybigw1Thd31XmOATX2A/7A3c65Jl67DdnXB6csZ7F99i6EfqEHC+MAziRyBRvAnnjeQ+TZJOa0rBFokgiTFpQTKkNDH0R5wLrFYr2o3gpJfvvisy1qbGq1NVfzxwdn6OMUJTOX/6lFBVYAz72zvWJxveu7jAh5qqqbm5uCA0tUaCiDR2td1gdep+PBwYuw7vN8tDULctxltWqxXTJJ3YatUQS6bvO/ruiLGSYttuVmKEExPTIEFzixonZg4HwQxXm5Zxitha3m/dVNRNzeV7L9nf3tIfj6x3W3anZ9ShonPCnNie7MQfIIkRNUa6xc71tHXDe+++S84d692WYRwEhgCGKdK2LUPf49Rb4OzxI3H9SiOnj8+pqsA49FTWU7yn63roZbJ9evZI3JmcY+wGrHVQkIjwlAlBOLB1U7Neb8RBiaIR5Xes1ytMKdxeXXH26JzjUba/GMNmt+XFt97l+LVvcvbkESdnp5SUdOGM7O8OtNe3nD06lzwpa6nbli/9yO/kG1/7GkYXaOstt9fXCl1FfF3TaSFZSPk5U2JifzgSjHRfJRVc7Rb6VCmFq4sLNtstL999T1y+Tk5kO56TKP9cYNWuRYizW9MdjnRq5F5yYXd6SsmJzW4rjAdlWDjnOX38RDLhxpE0JVHY1ZGL/qWeY2HqRkgFG4RoX5KEPM4WnGIa7+Tzqiq6ruP09FQ67JyEMYPMJ07PzuiOR+ZClbMFa+mP1xhniSp8KUXMiCqNyVmvNmKX6Syr7UaYB+OEyTITKMbczzZ0N+Z90NqgW/lS8N4ug1yM2DfFLN4i3jtKlA4YI74gMpsRN60xQRWE4matzDVm6iSY79rJfuILLLxfOTFjsuUBFcP7mh/64R/j3f/fu4JtkhgG4RQ2TUWKk9JLJPgMIybM9oGdnXy44k40k6G745Hb22sZDKxahuORYejZmBPxCUAtCa3h7NEj7u7E5Hjci6nL7uyUsR/Ynp5y/fKCq/feFcrMOCKptQ0xJdabzQLmF+D86RMOt/KznPcibpgmUGeuAmy2W5wqY6yxHNRvIKWetmmZkzzHfhCX/r5fOqZhGIhZLA2TJpSO40S6vmEaR9q2xZTMa68/Z5rEhPn86RNCJVv2aZrYnZ+RXspW8e5OJvmjeiNUD7aMMmpEcL66Zr3bUnLmLedJJbPabtjsthI9oskHVVVxc3WLV+cxowPHMaqDV9/TNMKACPrA5xSX6JHbmzvW640O/sRx3wVH3x85Od1hDNR1oNPMqv7YsTk5YbWSDu768grXtDzb7ahXK/ph4L1vvcs4DNRNxRQj3eHIydkpj5895bA/LIX07PHjZaItMuCRpmm4vbtd/FFvb244PTkhl7wkZ5RcGLojwzDw+ptvcHJ2xma7xVeVGAaVQn/osF4GP9dXNxo95Li8FNHENI20m7XIhWdjFu/F3Gg2t2lXFGsYVHiStHA+evyYR08ec3dzo3QdsXc8e/KYy4vLJVRyHkyttjsZEFe1yLWbhpQl4Vg8jR3P33gDYz13N1cc9hJfMw9IvfOM4yDDPu8oc+KtehvIgPm4qN7m9FtrxBu4aZqF9D9Tr2Y4b1GaATkVEVbkuMxURMUpuHcuwqUHQ7AiRJIOF4pXVkMpEgHl3JI6PUMn3+34VBTY+Xh/NyuPrmB7lpQL3hZs7SklE4LXr8qytcFI1EkSJySKmEzP+eZeVSyUgteojPnmD1VgtdligMPdnUaoCCbknXy415eX+mHLA7/Zbri9vqEgeFy7asnTyDiMVNYRqlqUJkYUX9MwUAzsTk4YtdC2bUvWld0Y2eKsVitW67XISg8H9vs9u92OTBGFmRYZGy3dsVcTEkNdi/hhtvSbxsh71+8IW6KVrX8uEeMMNkgOlQ2erXadx+OR4Xjg+uKC8yePub26kjSBGHHGkmBxfIox4o0XjMx5+qHHRgmoFAtIS9XW3NzcsNOB1s319XID5yT5XuumZntyIgvd3S214p2bzVpVRgWjrmgFI915jJyenWtnIwOPelVjnOH5W29wPBypm4YGKT7zfSVRzLptTImzJ6KJH45HSsoMuef68pK6qaV4lcLN1RVVXQt04Byr9Uq3sjKJnr0CDoeDFKjjkdPzc15//XViihwPB1brBuckOr1pGppVS8qZ00fnmAJPXnvG4Xjgm1/7Ol3X8eZbb2IwbNYiWjnspTuHQrta452HkkUE4p3YeDaNxLjf7vncF7/IydkZ3/r618kxcejvePzair7r2Gw2WGt48e67TFFk2Sc7UdddXlwuETzWWLruiK8r2qZdindKicPdXoaL61a4vRimUSCEcZpk4Lko0OyCD4/jqAtng13kxIIhz/z09WqjkUGOKSWsDo6nSZ5T8c+ZvZ+DUruQ/D0sHtm1ljwniSSKdYvJ0xzzXZSvndI966fkTCwRVwwuzPFKUjt+Wyi5PggVzJNBo39fb8SwtztOGm5oFn+BKUrcQ+Vl1SnIdmGR21khJ8/JBnGSZNrnr79O13eCXxmHDxXNaiUDqiy5VHM8ykKAjhHvHdfXV5zsdly+vKDb76nqmvPXnnF7cUW2wh80qq5JynH1TqgvGMPnvvgFSSi9vsVZx3onW/31Zk0GKucJVUXOwp/d39zQtK1scXKmCoFcB6Xi3FOsSioM46j5ZoWT01OCJsOOw0COkdVqpVBFz1A66rqWjtkpu0I5L8euEwywSKe86NZTglIvg7q2XVG30mlbY8EWsjViGH13y+5kR9MIFc0ap5DAGVixQhRl2UjOQkMKlWCBJ6crYomUKOdOycs1sdaw3x+EJuQc/b4X4+oqLHSm9WZFUZ+Km5sb1uv1+1RI1jkO1zdCmi/irjYO8jAP40gNZO2gG/UwtcZyd3fL0OvWue+om1Zgo+Nx4R0bY8TTIYqvBNaSnCcmDb9ULqlTitrz199gnETqKrzWlqZt5H3e3rHebpAI9kqgEwMnZ6f4Kug9XBHjhPWGqxcvVM5bCzwQI3aauLy8pK4CTVOTY2YqE9/4xtd58uyZykMzKSceP3lKKZnryyu9t4TmJyotSSNeb9ZcXVxgrZWFo21UzVcvIoPZnGUcR6ZxZH+3h5MT6T4fRLekSew+D8f9IlQQdzTBf41i4LlkbMmavaX8eVjomGKbKUO3rD4fUITSWYQGaRUrTznprhYwBWsDRkK7RWUXI/fF9TvjsJ/4AjsfHyy083BqNrOpqhbnanI+AML3M6bQDxPTlJU/dx9VUcq9xeFsyea9UzwvcH0tpiK701Pubm7ZbFqOhwPGWNabDddXV2xPT8SFyYk+f+x7Jk0tWK1XZAq7kx1d16uJsKpb9D2067UoUbTzE/5dZr1eiWLMOU4fnwvNBkMcRy4vLheKTq2T+Jwzp+fny7Var9ccDgdKiqxPdxIMFxM5Cx/30aNHNKsVVdOAgeN+zzRIt+W8aMqnceT26hrrHdvdjlBXkItgb7pNyiVzc3NDLpK9NY4jOSXxOVVZ5lHVZyknNpuN2hI62lUjw0jNSRJ5Y4ezhV55mN3xyGwyvttuGQYJo7TOcXp2Si6ZmDy3h2v2N7e44Nmc7MgpcXlxsXyufd/THXoVJ2TOH4mt32a9JlQV770nOOfQD3THjrpqmKZxWTSrVoQl1jsqI7gipVDVUixCqET2rO9z6GQoV0rheCPRMXEcGXphPByPRzabDXmUgVHKmakfaFcrGSgmmRGMXb8ooaz3DOMgMuJWLA5nb931yZbuds973/gmp+dnsjuKiTfefhsXhIly8fIFj548Wu7/drNme7JbaHoz9pij2BymmGmMpEx0ulXPMRGcxzpLu1rfR2Ubg3eSbVbU9KhpGq6vr2nqmsN+z/bkhEYFM+MwyK4zRkm9NRJTH5wXoxokCmle8O7u7jiva7x1XF9fs90JH7jvZdGcfyewGDylnBnGeYeZaZsKvOxiZ/vDflRfZn/vsTCOo+SJFcnrE8vDIoIkV8hF1JV5rj2/HYZcM0b6YUVWZIKTTByjuMvPaZPYAli8t4zTiFMFlw+Cw+Q4qUZZtw0Lt69irbQa5wJNs6KuKplwK2Y5jVESRo1sNa0TvGacRuqmUbA/Y1sxBTk5P2ccR04endO28gAfjz0Uoa90nXQZzjlSnNgPA7uTHRjL9dUVkwYupinSa7prqCoZOtzt6ZaV3fHi5h3q1YbHT59pjrxhihNDP1ByZnOyo2pX+BBkaJYSqYgz03q9lum6xrPkkjkeDtQpis9oqLi+vqZuGuq6Udy4LJJCZwxOB4XOGYxmPgVvSXGkXYmj1H5/hw8O6yxdJ05dcYr0cWC329F1HYe7vYgiSmZ/J8OYuq7pup44RrCGu+tr3vnqr1OM4fnbb+KspQqSbZVzYhhGQGg/4zix2Wy4uz2AgYuXF5w+Ome1XnN9eSU+uRmMmXDWsl631PUzXBBCe5zEgWoYRw43Qn/bnuw4PT1V05vMdrvhcHe3JGI8e/01fBUYp8iz157hddGRCG3JM6vresE5jTHs93tqzQ3LRtJWA7Jw5pQ4HA7CCw6CY7arFd55nr3xBi+++TV+/e/9Kq9//vP8wpe/TLte8dkf+gLnjx4Rp4lhGNjudpw9Ckrd8oxDL/aW4yi5dOsVZ08kTSGOE++9+y7WGh4/fcw4RdrViilOS7GP2s3lLLaKc7NgreFwPAiEFCfqpuGu74Wx84C+hzEi1W0FZx7GURKHx4mT89NllzdMI+vthsP+sET/zDHlcUpYm9THV2YtpTjBWbPsYkvOYpRknRg/GTHhLkgx9Rqr48w8OZDdLgbp0rMEQvaTdLjmo7ABPT7xBfaDA66Hf5+nrsfjgV/+yt9mGnolEYsZdQG8U3MXlXvOYXtilC+4ZkJURcZ5dtsNx06UNsYY+q7neJAPdPZrzRROH50zDB3NuqVuGrWYE2XLerMWnbxzlFzojz3DqpdAO9UxFwMndcN6syVOUfigqtQqJctEfRyEnL5q2MdId5zt+1bkJJ1uVTf0+wN3V9ecP3lMs2741td/nc89fSIpAjlxfXUlhaGTjudwOHB7dcPJ2Zm81yRbsIkRW9fElKS7OYGh77m6vCSlNbmR7ufs/HwxrZljP66vrrHG8OjxI5pVswwh17utBAuGe+K3c+JhO03iWDYMIoesQsXFywvpBGNSi0RRiNXVnPMltKH1Zovzjst336VtG55/7jPUbSO0r5Lo+0E4n01DyXBEttaXFxdMMbJar9lsJPJ7Jr5Pw0DXy9S6Wa+5u7sT/uX+jt3JibzPy0sx//HzwihUJvEkFlzu6fNnHI8HrEYEYQ3deIspuggqPawkgTSsdzx97TWuXr7k7vpGAzzvza/lfrpX8ZlciMO4DA5zTKzWK07Oz/FNzTd+7WusNmuen70JKvme7QZXqxXWGZy3i6z46bNnmqArz9PliwuePHvC4Xhguz3h9Tff4uV772KtZbPdSKcaE7vdbjF9n1MWhLqUub29wag4YR5CjcMouHeB1HUQPCFIU2G9e9+1ma0sb25uaJpGYJimoR9HyNANR7zmlNlKGCSz/H32qZ3jb2Y8d0ppMXxpKotFsGNvCs7MjAMp/ouizKDDNABL5cXEydnfSHn9DRRYY8yfBv5J4L1Syo/pa/8m8E8BI/DLwD9fSrnWf/vjwL8IJOB/Xkr5i/r6HwD+j4jz1/+1lPK/+w2c32/ouHzxTS7e/ZrQQka5KLL1jioRFYmscWEB40sBi9x8BsgpEkIlbuWDGIoEX0GAuq6QsL0O6/0ytFqtf4iUkxiWXFzKAKVtlkWhOxxlYt3U976dzuOsxTWiDR+GnuA9oZKh0PF4pG5b6XIVP6yqit3pjr4fCHVFGkbqtmG/P1CyFOPV6jE+BPrDgRPdJnfHIxcvXpJzZrNZs91u6YaeCgHtj4c9LniGIVKvRM99dX1JXTeA4J/CAz3FYGTbq8C+MRuqELi724upSyNT4H4chN+qhPo5BXccxyVh16isc73ZcHd7y2zubJS/OAw9lffsdlv6vuf09dfYqO1iVUkHfXN1Qbtecfr4nKdvPudwuyeoTWK2GWPQxfFIHIVXG2PEB/FwTdPIOHq6Y6ec5gllRtPv9/iZaeIsTdviQ+C434tKrao4Oz9nnCYOhwM3F5e8/tabXN1es9ttOWpQZdDFdBqjRD73IzkVhnHQwMuRJiXinWCEPgRWmw3X19eyPa4q9nd7phg5OzuTbffVNZfTS7rjkfVmLYKA/YEnT5+Si+Hv/NW/ytPXnvH8M2/JpDvLtLw7iHuaRMAL3anowNNawfN9FdScXCz/Vm1Ldzyw3Z1w/vjRsjheXV6JtaXGzW92W1JKsjOq62XCf315hQGatmW/vyPHLK5wzjFNYqRdSmG1Xi+CAee9cKqLePcao+bjWcQoJJFEN6uW7ckp4yiLcz8OPG2fqrudFVtShQmtNKFUCgGIklOERcUgeKEavYxRKGPeOaLOb4IX8xvjAnbKVHV5MOT6aJjgN9LB/vvAvw38mQev/WXgj5dSojHmTwJ/HPhfG2N+BPjDwI8CrwP/qTHmS/o9/w7w3wO+DvxVY8zPlFL+9m/g93/oMSuDnEyoxMauSBRvyYk4ZWJKy4VwVoLS5m4KJCKiHzulyWQ1rHCqSZYVKjj5UIZxIOWIzYbbq2v12RS8qGRRj739+c+JE3+S+ODTs1OxIFTycz8MODtpSmigqeWmGvpepraAcbNtItRNo1sayzRM9MejwAatMAXOmoa+61i5Nc7Je7Iaq2yMxKz03YHNZsM4DoBhszuhaRouXrxkGkeqqqJqW1xVyYqOIyUYp0EKQ5IJ+Hq7JZvC/vqWtq2x1nB32LPeCcVs7HtV9zjVr0vHEnyg8p5j10GBu9s7Ts9O5SEbBvpjx+njxyISsFYdzya2uy3rSiSuooi7WahCAJ124+vdVnwg1ivJaxvHhQqUYuSwF6WYyYa+6zh78ohHjx/x8t33xNxkHJVZ0BLHifVWHvY5q2zsIq89F9PxcZxYrWXIGWdrQeXZTv2ANeKsZq3FONG5CyVOhnAlZaahXwazVagWY3aDzBKePnuGcWLOXoVKFFfZ8fLFC+FE1w3b0xOmcaTvu4XF8N477/ALX/4bbLcrfvgnfkLcr7KwKNqmFZPxGHFetu9xEjOklCKlwN3lnaTDNg2u8hJLo7zZu9sbMRZKkqxRhSDXYJyWKXs2hjpUAjVoI1AQm9C+kySJ9ekG7zzH44HdyYk6XMlCvl5viCkyDjKvsM7KXMCJo1XSoRdeLDq7/ZFxjPjgGPTe648dvq6XZ/l+x6Qm3FmioubuVDxHiuxKswzCZUGUJJM5FTclMUrKFGyQtIOUCnNd/Sgu7HctsKWUv2KM+ewHXvtLD/7vzwL/Y/37HwL+XCllAH7VGPMV4Hfrv32llPIrekJ/Tr/2uxbYh14EDwUGy9+t5dnz16maluNxT3AwIdLS5aLWNUMvno7zxUhJuluhdxhQo+eUxIhinpp66xYVSd00WOtIqiBLUZRLVS3Cgaap2d9K9tZ2u5PhlQYg9n3PiVKwUpLYiVaHVM459ZKt2GxX9N1xsU+8u91LNpS3nD+RLjVUNXe3d1S1+NaOMRHznJTQ0B07pilSNyuadsB4CS7c7XbsTs+YponX3nyDaZw47O9IUyLbRCwju53c6M4FgjOc7E4YNeK4pIzxYnQ+DAPBe/IUubm7Wwrr7II/48pBqVDOWsZJLOcmvZYyCLlh6HoOhyPBO4VR5HOq61oWuyJBfLkUBsWqT09Puby4ULXeRHCephFqW9d1C0XKarfeKrVtfyfxNsJ86GlqCXMsarpi/Zag9KMOI2bco2SRCd94z6ADwdV6xeH2lkfPnrA/HnDWqnBCFEnrzYZ+HIgxSQEtShkcp4XBsmpX3PRXEkXTtgyj4IxHZUDkLD7BPgRxYctFYRBh2gqEc8Hh+pbtbsOXftePEWoJUsxxEgvAumbnKi5fvmA2fBkfDDXHYaQ/HIWWGLzsLK5uaNuW1WpFVct9PXNSp2liGqclxmiaJrHvy5mqbVip5WEIgbvrG6WfrRjjJAPpRnZ54n0s8IF1jk295XLoKUay82IcF15q33VUTU3VSBwSaExNFdRNy4kYoUhSBypCmpuVUellcy18GPVdKIunbckFY0R8VDlHIhGT3GM+VJRkME6GeTNG8PfbwX63418A/rz+/Q2k4M7H1/U1gK994PV/8MN+mDHmjwJ/FOD119943+owF9YPvqG6XrHbnZHjkb5X5aAV0jGl4Cis2qCYilCx6uCICUqCXCKZTEzTsiUfxxFfVaJjH8TEu+8GrPLuqqrCWk9BKD8xRe7u7sRQpW1k8GWs8jdrNTt2+KQGxqsVkw7U+q5DumzkhCi0qpM/PdsxDAM+uMXMY397LfCBlYLTHY+cnJ4RY2IaenE8Cg7r4NGzRxgQ/9OhgyJpD1N/pDsehGS/3RCCI4RG8dCBsR85PTvDesN47AhVzdnZOYXMSjto2cLecfHigudvvM5qvWacRFZrrePJ48eLdHNO+7VGOpJZtfP6W29yuNszjV4jzVeMQ0/XdUwp8ujxY0oRLHgmkc8eps9ff53D8YjzktAgjlo9wQuDodsfmGLkqMVhs1vTdz2Huzvpgg6SB1XVFcfbW+I4cryFzW4HQfxCDzph352fSiR6I5hn1TTEmDh/9IjjsZMHsJbPuCD5UtlA41oVgCScCxLYVzJlmpCob0fTtqQQmFKiPxyFu6vxMkTlF1thA0i8kQzTJLI+8uz1N0hPnjKNE9MYGXtN48jQhEq4sc5ig5qZr2TAGUIQapkVa8yu70m97CqMEQOjmCSNuGnE4GU2gjmOB/Z3d2IwX1Xq4lULJpwkXNE6UR9uTnaUgvKwZSAqPNPMOPZCi/Ri+F43K+IktK0qBLquJyGMG4PBZNmNnpyf4YKnPx6Fi6sLVl1XIjBQtgS5KLNHFF0pRmrvlJqJqjzFJB5zL6PNWXbAINl+qMViFdwSnT5X2L+vDvajDmPMnwAi8Gf/fn7Ow6OU8qeAPwXwu37Xj5cHrz/8ve9jFWAM290pL977Grq4LYT3oLp4MBQrJts5R6ZsGGPEGzHtLfPXaEe5Wq1UDWWo60ZsH1NW9ywZjsl5wLHraBqx/aurGhdE3XS83dOu2wVHcqNs/U7Pz7HAzf7AejuvtFZt0ERJVUpZLNEmfRjHblA4JNIdO8FFVy1VXdMdO81lkm4z6RawqWtSFslKjpHry5eq9Ema6CkORU3TyGCwFKU3eQqJGNFJceLli/eoQi2qo2FQc2bL7mS3uIKVnOm7Xh5c7cwf5jnlksjTKCm9o4Qq7u/uBBY42erWVxaJOS/t9vqG26trqkZJ/VagnJubGxna7Q+0q5a+77nb3zEOI6vNmv54JE3SxU0xQtezOz3BOUnXbVYruv1BvBKSdJnrzRbjrOLnhjSMHHNhHAfhI5/uaLdizuO8EO+xVg2qxTc0eM96tWKIE9/82jdleBO8yGyNOLo55zh//Ijj8UgsmZgTHhny3F7fst5tpLMrYpCDEfw0p8SjR4+4vb3FWpGK5igerNuzk8W+UGiHnpgSh7tbXrx4ITHvSeLjCyxUo77rOD0/4+T8jPfefW9Rn+3v7ghjReUDztvFZDrnxGqzoV21DP1wD0l1Hb6VpIVhGMkxcv7oXPBrldamaZIkhq4njqMMeI9HgnMyv1BeebtZU9c16+1ann9VXU4qUS8lL+5fOSdIgpnPycvOGolaKmJ7KwYyYsw9DxBjzngLY7wPafTWYE1Z4t+NM1ThPsGglIIDKvsxd7DGmH8OGX79vnL/G74BvPXgy97U1/iI1z/y+DCI4APnAUiRwFis9VDkgqWYoYh23JCExO49Oan3gPeAhJ8ZzfLxIaiuv9D113iVfh464X8+fvxYBlq3dzqJ3nB3e0MInqZtMVa9NVNWuzhJzFxpBPdqJTdMKrKdCrXGx6gv66i46OwhOw8WUowcDgcohb7vF6NtpwOiqgoc90c22w3b0xP2d3d0hwNutWIcOlKKDMNAKpnT0/steFXLYOjm6lr11obdbrdkIJUc1b1f4soNhjHWrLan5KmjrgLebxm7HrcSVU/KGU9hs9vSK0ywV9/U4/4gQX/Pngl+vN3w9NlTUbSNElGy20kESpwmUhZV3mq9YpyEaWCshEtevHjJy3ffxQfZJnrv5TqXQlF45tHTJ0zTxF4DIAvCub27vSONUuRdKWzPTonDyHA88qUv/RjGGI77Pd/46q/RHXt88DRtzW6zxQa//K6729tFkmyNYfdYbBz7YSBpdE/bNAzTRB97DKKq87p4zJ+pt47VVgILt9uN5CVbKcY+iMNViiI9ziWzPZFr1A+DTr4jzXrFeiOv15q31Q09q7YR8/dJBp+b7XbJ30o5cTgexcf3kfgwWOD68koMrY8dw2bkdHVKjGJFKV2sxenWvOhA0xjDNAwY4PT8TNy3SiaPEvo5S4MpMlieG4fNZiOQzSD4eqXwkewu6oVBMHOgT05PdL5UaNt2SVqQfDypC2L8ow2TNRoSWSipUAVHSkLNskrJmmOPSs7gLdZ7TExUQZztRPylidMGHZZ+9+M3VWCVEfCvAf9oKeX44J9+BviPjDH/FjLk+iLwXyO1/ovGmM8hhfUPA//T3+Dvet/fH+KwKA0kVB7n7y3O5u8RGoejFGENTDGSkhh8ZJCVX2NoyGJeEuNEzpqiacV2b46DMQWGOHFyfsbQ9RK7cne3uCAZ5gIquN/rn3mLUgpt0yzwwQwdWGsJ2+3Spc64rySBCq613W6XQhidY7/fq0pN8+Cdkxwka6i0WI7DIHQZVMlSVHKbM6enpxy6bjEwNorlGStQxsnpKXd3B84ePdKOulCMBPeFEJZE0OEo7AOD+H/alMWOr0iHsVqvhONoDduT3dINzvAJKTP2vSjKnKNdryTmRQvsye6E/WEvMME4iiAgBJx13N3dsdpsqJqW09Mzrl68FE9gjVLu+x60m6pVaowxnD460+vmwFhCXVO3DdUQ+NbXv8kXf/R3cvnigsu7PV//6q+rVWLLG5/7LLfXN+xvbgl1JR2qtdxdX3DFBUY7I8HnDd6KKEDI82n5XNv1ShbgUuiPR5y33N3eYopM2ROFJ6+9hrOW9959j075o3XbiIrMWqrVilQS3V5YChulwG02G9kpxEy7W2GtWxbrECRLar3ZyP07DOJnod3rZrth1a4YhoGLFy/xzilUI7uodpZmZ5GBT5OKYnSgWYXA4XAQS0wvQoFpmlitN4tRtXeOzWazuFkNSm1bbwRrNtbStA1ulIXfey+5abd3sqWfI5z2BzV9EZl4rYvqfD977yXW3ugWvhTqSrDhMWZlDGTGQXw6gpMB1pwcPQsU0pixc3x3LJQ8UYzw6U0pqhDTrfIHatQHj98ITes/Bv4x4LEx5uvA/xZhDdTAX9Yf/rOllH+plPILxpj/GzK8isC/XIrkRBhj/hXgLyI0rT9dSvmF7/a7P3h8ewerwgEX+NEf/UkuX36L/f6GsT/qm5ahVag8RXLNpDPAkkuUyWCKWCvUEGMsQ99hjFu2wOMwQs40dSM6fv3gRForJiTNqiGnyN3traRTqrt/ypntbiuha95zuz9IgUEMonNKXF1dLcKGmTw9Y8BzVyAFsrDd7pgNjEMIC2dw1a6xzlJtKoau5/b6hpNTYQuUIjhaXddKwPbLdn3+s6prTs/PlyI8u89XVZD8K6RgbXdbBo1Gb9oaUwSXCpVkSjV1zTiMizN9p4OTvhczYzMvCikxTBOrzXqBEdZTZFLi+tX1lWCEPggmNhvI5MRmu+F4d8ftzRVpiosPwBxRAnByekqKcTGMpjZSqHJmGibubvfinGYctqp5/pm3qVctr7/9pjhpFbi5viVMmWE84ivBKnMRH9KmqUm6MDZtw2F/YL1rGbuemyvp/NqVWOxtNuICVfmwTMLXO/G1mIYJkGGQN2KucvnigqoKtKsVt1fXhLpaEgec95KEGwIxCVulaRsKcHp2irV+gQdynlVsHcmILDU4edynUfD1YgQeyEkw3tmi0yDWfavNhqZtSCWxv95zenayDA/nmCJjjFwfJeLPnsVFt+tOPWqHQSwkR+1wU0oYKw5yMmPwNJsVJYst4qiS7ZlaF+qa52uVNud5aFiWz3yaJlr0GZ/xV9S3xoB1kNIcTW50YZSOtKhs1+puMarkW2wJC5iEs5Cywbmi/NrEbwlNq5Tyz3zIy//eR3z9vwH8Gx/y+l8A/sJ3+33f7bjvYu+twowtnJ0/4Ys/9CP8jb/5c9SVMAGmKF6wWaWHxggdI+VIFRwWKEHkjj546ramWa3pjz1gxKjbO/puwnrphmdGQavmFQ40ZkaMWorSQ8Ttqac7dljkhmo09dM5x/b0lP54ZJszJ6en0nkeJLa7qipWq9Ui3ZNUzxXNyQm3t7cyOQ0yMAm1fO1s4uyrwNNnT4VGpMMEq+Y1PgS2iqONGio368JDVTH0nXAhrRV4wTtaJ/HK27QTVyydvvaddA1VXS2dKEpkv76+glxo12LsPE/Dm1XL2aNz+q5n6CU/6tGTx/Sd5N6fnJ5wOB6ZYgYiVRWwWXBNjKFZNYtXbpUyt+Mt9apZYKSZfmeM4ez8nBgnTfsdOR46cimMKsX0KjiJw0SoPLfXN1LINFTx5PxM8NWYaaqacC6R6cfDgWygH0RBdHV1JdxO5VRaY5g0VXe9la5xjjBvmrXwnIPEn9ggnrDOOfb7A92xY7vb0fXHBUqat8C9RgmlnDk52Uk2nEJIfd9jCpw+Oifrdc1awHJKZF1I0yTQWd1K7E5Uo55iMqEWD4ZhGGQLbB1elYIAvR+5uduLLaNzHLuObajUOEkMXaoQKFZSmedFsVdPhmmaBNutxajdGClyoi6UQplyYr2W9z0bqYdaBCpRmQoxCkNjxoPvDZnkd4SmFTWXirHEG9qQovDjKy886FyyqL8wi8+tCCLE28IZwBTGKamUNko6h63IxWBKXiwIPrYh1/fr+CAO+214bIFSLG++/QXe/fov8rVvSedS1bWSzAtjFpcsjGT2RO1GU9FYCTtTN6SAzIbAxlhWuv2ds4IAur6ncp4SPG0jHMOu71hvdosp8aw8Mtbiq4ptK3Z4sxuT1UGL9Q5fKqqput/+q/plziIyBuXwSnccKpGWUso968F7+nGk6HQ6qHJsdnmfH1SJeKnJWMo0Cr/PWdabnajSKOyqaiH2pwKuEm6wGJxPhFoWixQjznpyiaRSwFnW261s2SrPadvQtLVgqd7jXaCa00GtJVTVMpjwwGa9xmycSBENQjdzMoj0LuCs5CQZB4+fPV2sKOu2Ub+FTNOuqJqWkGvWmy03N1eUJJ2HMciCYJ10XaWQogz7ROIZMM7JgjMM+JRoWtmi7uzJwvE0SEd+2jTLrsBVnqGuOK9lop7VaX9exKy17HY7Zj/R0/PzJep8ZiWUUqjaWv2B28UjYB6qOi9ROk3TaP6UdJIuOBl0hqC0Jy8LaxVIOUknjEzHZyOaEDzeNgszwcy/Ux+t1XoDSHEWJ6uBrBDVPNTabrfLz8wp0TSNypTzwlmen5u6bRb113q3XbwmTNHmRL/OefFIrkLgsD8wDANtu1q6S+vcEqs9G/dQRIWWU8Qg4oKEZJKlaSJ4dfxS9kJwRpJK9N4DSHlS6pdE7EzqE1uKYLs5JawXEUsqRbpbPn6a1sd6vI8t8OC1+9fvmQS+TGxdlA8BMdktCCm8rmuxK4ziVG6tsAjmeIqqkqlhd+wYo9yQ/SAPky0ybADBcdGO4DANbLYrYpIo8dCs6ccJpw+NXP+M9YHgAuMkXaXXeAqsw9eOKWWqul002hlDsWLwko3QdEwqFE1OSCUzpCyd8RTphxEfKmKxhEo8ZnMuCsrLdgrr2Xcdznq6YSIV1P3dqxs/EiKHDgQoJGMYk+R8lTFhbcHZQM5ooGEhK/1KcsbEc8A3K6JiWUVJ2TEnupggD4qzVcQ04pdInIyPWgSVuxg1r965DMaSYqddTy94GGXBBmM36YNsyF3P7f5Iwep2Vm6TkqUAW5AHa+pF8lgKJIOJUDS3LWpX7pwlKT9yKlB8TSwGfEMuiT5mXImYXMjGYKqWqRjyKHQkimxNczE4Y2XHk5MMYIylGPEEsN4TrGCAPvhlECQd6sB6J5xOQ8FYL5+pse9vDkrBuAoXDDlFppQkQVaLpzOGCkNoxahcNPkREyoq68TA2gtGnVIB6ykl4YKn9RW+EpjFOQfWixJxytRtS9XUi+x1UH+ANgRa7aYl4bZlGCewTpMJREgye3AEL6GFYxxovNDbticnrDebxXhntVnT9R2rStRioW5YrWRRcF4xduWp92Nc+LBzokHOkl5rjag4pSueVNEpz7WzYn9qrcOoKhA1OJqmSBUSxvil9nzqO9gPOz7YxRbA+MCQoPZWyPdJ0yldoY+RVe0xeB2IuOXGK0UkcT/7175MFSqmmClpWrrmnOSBcN4pfiRd7+yDOXdEc5SvdeKU7p3gtYPiu9JthgX/nCYxp8CIu3rwdqFIzaB7jFkMSCyIB22UCBzFn5y1WK3+45SpazEWkeJQyEkHdka6YKsE7aLBjrOT1TyQKCXfK1SsxVvDpD66TSU8xnkYYB98DillcjG0TVhW9qR2kSnpTYoBI0VUIj8K1hlIktjpbMFYx3GQ95WzWMrFJItRTiJdTSljisA+haI4vFVtf6AgLBEQd6WgWVTzOcm1cBRgVWlOk3Z31gm+OKuBvHfL1jTmTCkyFLVYnDXEXKBkmrqmH0ackwHINEXqKjCoqYtVvaZXfFver3wOwzgu4orZJk8KjnhZTDERU8Q7J7slubBMKYuU00nHVXn5fGLKeu3RRdEqPxfZ9ejqP3ftOQlTY5wSdeV1uCMD4JSzGKcgMmaKkuwR2EtMlVDRREtJUbFNiZevQqCpZDeWsgyMp0k+C+/9YsA0+wCkeTVEdngGKYhzV4wR+pWZb+h8//5iSpASNyovFtcr+cxTnqiDJ6o8N+viHNUeNOVMpZzYrLsno14Fs2DJe9lZOU2I+H4JDX7Ah765UhgJXA5iLzZXCVmXLI23qtTIBCc+kHMXK19q6OJAzJK17rUrKAiO45whjrPfqT7UXop4KpY0Dmp0UWAEF+ySqT7FJN2UkQd+/mCc9YzTpA+MdCfWGuxgtQgYpdJk5f5JAbRWziPl2QlIbshMIiY5524QZ6R5mt02XiCBIg9ZzCL1E//bpLintlxFzoMUMc4zTTq0Oo6EykkKL5lkLE1ViYsZcuPT5/uOSae6Mzk8pahdQlxYFylHUknkbBmmjHVyjVxlls/X6gNQSqYkKW7y8CEG3TkxpYw1gdt9J50M4pTvfFBPAS+YdFLcPEeapiIWyLr4Ob0vDAajqqWM4cXlrQxaXNGoaCi2kDL04yCwwzRRhZphEJl0pjDNXZAu0lXwHI6igBujFMyYI8YKzaro5yzuVGj0kWecxMtgipGYCiXLIjup1aM1ci+MU8RYWWidlc9aPkuLMYlRsWGJqJciWqlTWBUTw5TpuwFjxaTa6DBrmArz3GihQ+X7aG2y5N/1GsOTc2FKop5y3hG8hZKXhWM2rZl51DFKQ2CNOq7qfSlwlLhWzSbZxlilsGmYoRr1pCw2oCVnkbw6EQxYZzGmUIphSuIxIAVWGoiSkjqSFMYk935be7yzdIN0wCLBl+dqduqbO+XvdnxqCuyHQQWiVpGBF8iNOUxRBlIFxnEQMwtEuTFGFQdozrt84FYKF7piFelMClkTZyHotRzHWW4nhS5GmLLET3jvxc4OOZ04yXY16Vbdq+ekNUY9EmTaaorRQiHfWHKhn0baupL3YspyI6dYdNEWpZR3UoCLldXUKQc1pUjKcmN4b6lrGVTkeTEp8hDORco42e5jDHM4pEgURSlknSVYy5QTKWZKEcPyqrJMuQjtyen7sA4b5D1KFykuY4svhH6Es+Gyc46SjXJtRU7qrGWKGVMSOFFGyQPv8bZAlrwko1vZUgRbcy7R1LXEKxtLKoUpTpQCTWXox0hbi1Cico5+6BVrjTS1pxtGVm1LipNeTwMFquDYbDeylSwJUyxxSkvUSNuImXguYrvnjMNZz+EoUtw5sjqrwGCMkazv0yAKp2mUezLlopp4x5DE2FwUcLNySO7UVJDOWS0io34mpkgnK1PvQkwofpvxBqrgGWJmGEYqjW2XxkAGolUVmOKIwzKOEeuM8MeNdr7WLtDE7GbnvScVwURJkZzBe8umFVXVFLMYrMh2SlKMnZcUEmeoqlqc1bwTUYyVjtlbRywSolnUJyTltAyNZ7olFLy10ixh1Gw/L1l806Qx4YXFFH4W9nhNO7C24PV9xRi1U3XKtMnkkgm2pliHMxZjZZ5jsEJT+A7Hp6LAfqcW/P0QQVHzCOm+UhTXI4MMYooRgrEBplgW7HX2Cb1XUyWRwBZx/LdOMK6YDUa5sBRZ8WR7aHT7ZGRrr4OKOjgZWuDAFqwpAj1Yi1N4Yh58GGPAyhbMFIPJWTPi76elxhiyycrfc6QUcZrllHImlaLdrXjCGt0jJsW/vG43vXYmIQh/M+dMLNLtuMqJzt44quDv3Y2Sygr1XCsPMRmmWChloq2cUlxk6x+LWUQQM/QgFLiROniBKuy9KY2xRh9U6SBLLmoyLsf82Yhnr8UHK7S7B5zo4AS7nVSRJZ14pq7VtWxMBCed8DCIh6ps/bIUIsWVUxLf11BXy0KaiuH69g5TYLWqAMl78t7SDxP7Q0dTVWLAXYSHKBzROQtL0wl0qMc0Ym2QwUmODJ3krFmFlIKXr+3HTDGFdSOUsr6fsFb8hwuWaI2ESTY11pZlx2Lk4cAYCN5SimCQWTvqutJ7PWbGJLBG0t1LKUngrmxwoaLkSbrIIu7+SeGmedjrXKXeE1Lk5N+E/tRPUT2KJWGh6PeggYTWlgfdrEz3hS8ddWA7ARLlgpEuWmiHsr0veRIJ+xgJzuKdZYxZcXvpVIM1NNVKlVp+4Z3PMJ0xRq/V/YIxeztbm7DGL5huKeCcJxsJZvwo7HU+PvEF9jspuN5XXLVQSrufl04qZ8GoYs5YDCaL76kYSciWOARPVRsZKGXRLBtTFGOVGIopCqblvERG5FKYYiF4I5K6SYqYAcU3jZKqpbt1bi7YZgHXjZHuUowlJN8r6/vFINv5lIgYxeLkfaSUMDEpZCBbR2ct3ljAibF4EGwraMESR3bpBEsRAcY0DFRqkTjNQW96Qwpud58nb5GkB6v58Ea37BirGJoU4GFKC5+wlEJdWSrVv+cipG9JZfVMKVOHOaxu9j9NTBmKMTijE+CcBQssUbfuViEXXXTmQZczWmCQlFZvSAniICbsTSVaeoxRxy7pyAQPnFkqM95rFswcY2SLq3SerNdcOUDs1iucDxy6Xs4jBC28A03wJF34x3HE1JXcC9mAkZ1TjpG1+pxmhGQ/TnLOdV0xqr9AXVuC1/unFArSoW1WDTEJ7GWNmGaHIPCGsU4phJYpzR4eQnkLzmKBKZplR0IpAvOgwz7m1BDZidXe450BIzBR8AZnIU46UFX1qvdOB6yZoO8p6+csA+j5HrPS3Mjen6z3ltdYbu9EmSmDaYE0rHN4WyjW605OrscwTurXLN19SnlJKoiLv6s0YErylPmFNULlAsHIgxdPaSu/L+ekbnuJlCZMDjRVTVWvFivOT/WQ60NpWTwsvEWxGQGi5wGQYEQO57gnP+vKJV3uvcv9XEiFKyoPkzXzKud0y5HIUQZYucw/Q4q4/HzBiHJOTFn4c+vaLyT4rIUnJckAo8gHbq2ciw8ynBJpqNXEUK9qKwlqlMGZbCuF/mUELzZQdHrjlefn7L2YYHZuMgYlk8tDNk66zc4G51ksAyVBUybI1ohrmEg0NMsMQ1tXjFMUOKUg32Ol+GEdBcELLaKIc0UWvX6Eog99SgaD04VC4BpZ2Fge7vvP+35bmlKUcMkpLcqiGAsRGdjZhcQhRurL0E5x4qpy9IPQe0oUBoCATAJhyIMrgpSYVPWjdnXzbsUYWYyv7w7UlQ64tGOvq5Y6yLBIOic5Z0olO44kP19grYm+NzhvlKNtdRAniRvWsuSElZJJ2SxdatFFLTjBtYuFKcmOpqml4GKsGqyIcqkfk2KKAiU83E0UAZd14SxAXiKUQpDGIEVIcdJOUgrv7Kksn50+l8VAcQK7zc+ylrasCRMUS9CY7RnnlHQN2cUYCtbL7xU89X4wbQ2QlO8rVFwx0ZnFBErjmmvIXBOEITFRqSVpjEkGesbIwHUBVmWn54wjpiypximBsZydneNChZ074I84PvEFFu671Q+HCgTMdtZSV2Fp51NiGRYUxeJmepQ44bBs0SHrv4khirGiPzbWav5SpmkDKWaGMcoU0YhbkdUbdMYRsZY0JXHuKTIQiylpYZy/R7ik3nvNlVJWgrOUpBAAOm4xwqPt+wnIOiCRouW571LnSahXp6AUhWBdcsHkuGyHvS5AVRDMEUEnSDNsYizTlICE1y3h7H5vrZGilotmabEYU3sjQ7oqWJwpFLzikkk73KL+nDpEmmlFVgdVBlKR75UhTFbOpeDsKeb7qXdBOijnhFVhBHcDMWWJMTPnrRmZbKo1njzsOYkset7mFmYoJVJXNXjRtk9ZyOjGG7q+u+8eiyRlhOBZO4ndaRsJjvTOkaJ0X0NMy/m1TUvK88MsQx9nrIRT5oJHIJZxynjriTlTeY91EsIJMjQcJsEHvfMKy8iiYY0UZowsEv0wUemCbJnx6CxTeWUyJA35FOaLYLy5ZCmBtl4GUVCIYyQVWYYMAj1Ya2Q3oQXM6SBRBpNFmU1FxSFSjGWHmBTOmai0wMYsnFarg135TJX4XxR31oYBI2Xae6NybqHALbtCZTwoUYWC+BAY5+8He0bO3VuDDw4xgpEZxiwhLyisZwR6sD6AcZyev4Z1ko783Y5PRYGF7zzkkn+T7fx2e8oXPvs5fvFXvoIxktVliuKHSu+ZJ41iSxgWPCllcdChRPphoqkb4XWqC9I0RoxxuuIW7Xj192eNHp6kCzBIofBWOr46SGcn9C1wVmhCIL61VrfZ6Ko9jUlpOhZjC9Mk3akxbnkvlHtX9ZyyDnnEbi1FmbTHPNO1LOSErySaWjq+TFsHhUCK6sstwyjd5JQSU2JZgHIquOKkqKWseWZuwa9iARcq4jiRtdO0lcGbeVGTblsoaHMcsmWmyMlWXOC5nGRRkYdLsVogYcSNS3FnY4WeJFNiOde6Dnif8FbodBKFM1PT9FxjEjWVkeve1BWGzKqtMYgDWTdM5FwIlQgSrGL7MSWmVAjWP8DOJUpkStPiYDVOspCEUCmxHZGjGt0dxaJF1hBNWbBFZ3SwZq2G7gHOM2UwKWOLJHPM298pZrXdE8zbW5YurxjLME0UlA1TBDYoKF/ZyXB3mhJxSoDQ8jBzUVJ6XYGmEcFJHCPBV6SSmZJQ0ebhcVL9foyR4DVWxUIp4gUs1DQd8hpL5SzzmMpSsKHCGdRv2RBTZE56no2vxTxdncCK7FinSZ4tciZbyc+ScNG5PsizEaMM4KZ4P8DKGLy1IkaaZEeckuC1At/JAjKlROMDm9WaZ6+9qTLh704j+NQU2IdKru/4Nb7mtdc/xy9+5RfJWbZcTqkezLSrIvhknJMHjGy9MU4mwNbgggfrmaZhAcxTktVRQHkpvHMibS5yU0wp4q0TTl4UD4RhmIg6RDFIcY8mU3m3TOSLYkZxTr9UZsQsasigQ4qZMA6yos8qNEetZjdG2KmiJLO6UdaBk7wPNbXQbWpVecHLEBK1c47CPT9Y9NvIliqj4L9dBl7ztn6MSQcIOvE2hq4fqOug23Thv9aV4HEpys0vE+jZam7e/ksHV3RAOw8FRXGTFU6QXchDyhDIwx3jhK2CbgPvH9ichKIk7moW4wW+ieOowyCZuE+T2N155zClME0DFqvKH3ngjZVEgpgmvJfCZK0nZhGt6B2JiQp1WEMxhsYHJH5cTH2sAZ+i4oOzYADl7k76nhIpg6/FKc6p4EBw6KIbGFksnO5QnC5+3jv6QYacsyBhGEdC0+CMUL/87Cng5PtGldTOn+8wjoyxSNF8ME94CL05hXZmbB0MlZNtfT9GvJeAJpllBNnl6Hk656h0ByYsCkGAnbN4LxixcZ6cxvv71ltykaYgeJnopyL856TXo9JnImWW+2+md7kHcEPMmWKEXWQMSxOwtHNae1KB87PHrHdn8mzNQo9PMwb78Pjw4qrYouyS2W5OOGlrXqg/Z9ECCUWTIBHgXOlFKWdMKtSVrGYpy4AkZvm5zsu2crZLA+lcp3GkGHkIvbME6wneYciS7+WMOtcLJloFHdgogN+PGWfup50pFyV7C3e2CoZxQgpsipgitKmSZcvivIMiD/o4RYLRQUFOMgBxMvyS95SYohTxugqy+rpMxtD14kofqkqGPFEYDEGDBrMWPkohJhnEFGQNKMpUMEg2U9KOIen2PhfBTgvCYTVGFF/iNJAwGYYomOCcQhqzlg4ZsWOcIZUMVt5PcDKYi/ogBn3gQ5AO0mAJXrjH4udrWbUtMUWmNEemKM5ZDMejmI+sVzX9MEhHJKsh3jgymXbVkKbIECOrpqEbJq5u73BWWu7duqGbBsFhVYffthU317esNzucNYzTJLlsOXN3u6cKFh8qpgzeyI4nz91SlELjnKFMwjslJ+IUcU7z5YwTaTJZpvTOUvI90yPnLDsgHFbVSIKiZNpa/BvGVERNhpjOT7FoMKPHFrm+UnjFZN5WFucM4yg7g1lQYvQ5kgXdLAtezOJSl5U6VpRHZik4L/DOFKMq5eR95ASNd8tAbH4+chJoxFirlEft+qcIWKwXTqzBMA4jbVtjTCFNOo9QcybBZ2XnEVzAGhlihxAgZ2X+yEIsnayVXZgLvHay5Xf+8I9gqxZjLXPs4W9bocGMzcxTYDAYH6jrSvdWZhlQDIN4cWIKUfOvvHeY9HAb4QjBKH9TCpBFhlGlzNsg+ZXOB11pUVy16DBIbopxlImnyVJ8grfKy5tv9syUZ87iLOlMc/Oqr8nWxlmJGSlZ3qsN0uUMU5IV2RjV7ltVoiCS1oKqywxV7THmwTTWWHzwDINgTrLblcVl1axk8h0H7SQ8lKwpuchqVsRD11iHQwrSNExSYJylkHDIoGHhu+oqGFOWzslarPMi6ihyUzsv034bC6PipmhkzTilpdgbO/NupbBEdYQS0rvidMZijWPQxRZjGMYIVaDrB062a2YGxO3+oJLqlnHsqapALobjsROSfcnKT67Fud87bg9H6nYF1jBOoxRT5+i6I8djry5cNd1xr9dBh0aVx/tKBzpQ1U49iQ0uBDIy9XbGMiW5tjOX1hqBxESebR4M/ySPTWhW8hmlhckiOHbRIZTmzOoOTKCmqqllFxXTgwGv0Z1BpGlqci70MRFjpg5WnhBjSDFqMZddjwQPzph4VFhOfROMGuIoXQpj7+N9jFX8XTp0Z6BoZw/SkReT9fcHTEmaQaePO/I+QwgMo3Ji7cyGkM/Z67M1pQhOdlfyPKDqQmkcMsKWSEmet3Xw/PgXP8vZa5+TxcXITvG7Zct+d5T2E3x8GyaLBedYrbeKaQkFpyhpOCtWKhJMwcKq4PHByWoNpGkSbDVHjAuytTczHpR1dfOK79xPvqXgzGoro92WJVgwzgnAnu9Na1IRAUNw8+AkLxhVMZYhGpKC9aUk7VKgqu8nyiE4ediykMFzSsoxLIuypQ5+iZS2VoyDBW+2SplSr1tjwTgyhr4fMQiNKCklSAqaarVNoalmoUMS6SKyZZ4nwSDFbxEb6M0bY8RiNPHTiioJ2fZNY1R4RLbYzjtdcCSI0Tt58Gb13UwHm9VDszT6IdY6yzmF9lSL4Yx+NvfXsGBdUHECVHUNReJHrLUM00AhCf5uDHVTE4InOCmCY5SFseskgsZ5eTBXbUvTOJzJNE3FpFzMkiHGQUj886BIZubKSlFzm+AV67N4L/aUBqvu/nIPgMA2JQsjJiXxO/VOPs8pyrg0F+kkYxJ4iGwoWVyzBPfWoZ+x98MkWOiGgsrKjsh6i1EhQ9JO2dl79WGcu5B5Z6K7q9nDeIZz7GyGpAPYlJSTrGbywmeXXWdWqarTBUXghKwcXDEzytpIppzJKSuLQCEC7awlvbjITk472aau5bpi8U6oaMYWUSI2Lc5XfOnt55x//idxoX5QXD+6e4VPeQcLLPAAMJNoOI4Tkz7kpiSxbNMUyPmBnD9Y5wwe1LrMyhAgq0lJ0eKhuF2K8kGWnBYC95SSau1l2+K9k8GVEfB8dm3PKZOSCmFUames0JtIGaOKrRn/ochkPhdzjyFhMDkxTIJTGuY4DGELeCe4nVX8ttEobZD8rEmdtmSAVLQTVR5kLpQiQ4tsYJgGvPPEJJQzSMsUH1THHeUNBadJETrIMPNDSsE48QaofACTVeEmQw3nZu5uYsiCLdosmKkpUjCJBYNg1c4XnAt4I5LZXASjiyVr8bJEK59LKZKBtVq1TONA0Q4xl0IU8JJ+kM42pQljhIESp4lhmrAlExphTKzbRjopIw98n3vZZTirtnYSQ1Kr6fPNbSewwNjrcKkwDB0Ft3AyAfp+WOCNtvL0owxmBdtMGPVGwFhROhlRl3ljifOgT7f9ThdwEH72NKn233m8NcSMLCZZutzZm6G4StWQBacLXc4K9aSkxjgRrz9f/CcswyT3fe3N0rkui1nODDEKl9U69ZVQLFrphCkVbJFhphRosyySWDHRLyXr/VAIVib9RZ+JmGaFowgv0iKlVViqSKcaU8IUQ1NZbJCGJcZCVvzbzaGcIRACqoKURdohcOIbT5/xwz/xj1Gvn4pqEsPSM390A/vpLrAzt3M+DGCsJ1PpRdbcHd36+1yIxShQbpdBQCrinpXUVGOeDnvnCO2KaeohZWUFFEKwizXenPc1b6cETjDMaZZSCO8TLr23jOOs+3eLzj8l+b4YM0lVTTlLp2Gtlcl8mulH9p57aAXX0maGUFVKzL4fCAYvHbldBmZOOJbGyACJtFDa5vdkzazUEcqbpkMuK3uclO5mZegzqYlIzrLd8pVgbjJVzqIUMsIxDS6oO1nRaa9wikWaWoRGpV1ZcKJ8M9pFLYM+HcxInE56EESnvZaVIL9h6LBOFqO7/Z66qkhkDt2Ruq7o7sShq1KDc2fF5rJkuL68lPdiMhHxgCWJ21nT1AzDKPBLFZjGgb47qsm5TNpNgf64x/qAsYFxGKiC4ThGvK/YrJplGCldW1oW/7kI55xxXhbikqEYi/WO1HW6I7rvxuddWlVV4llcCaZvrSOnSM7SJEg5VevPrAXfwJwGPP/upq50uOqE4WARHF2x/HEcRZbOPU1Lx6pEfT7ls71/SGcuq/dePHW9l0VKjVkMD/wYiuzwck7vuzb3sEjWmcMy8lNa1gytzTsl3ZFagVwKllREpZh1JzRMheDQXZ56I/jAFz7zeX7ip/5R6t0Zs6PWUm++y9AdPoUF9uGb+vY3KCtL3bTCMY3STY6KK9XB43XwkrOA7bEUpinhY09TCdc1JoOtoA6OcRCOoa8CaRwxRuKri7pfWCMfrrOynfLekxCJ4xylLTiT8BLjJNw7KcJyzoY53VKKlnEzrUYwsbpuxAtg5p6qt+U4TTptFm33ECOhKDKkFLGZmF9MpgoBSpaAPiNrdM5pEV+IpVteUjWdyVLcvKcbEk2Qgd1sThO8KMeKdrGiwEmKcyfdmmnx9l4wVmdJOQqkobBKXYk1o6juBOXwzuCC0y5buvd7T1TpoAQ2EcpX5ZTIVWSzZ7C0TaMFWaCIZrNh0u1nWzeyY/BiZVnItE1D5WVX0tQVq1a4rSUL9rluKr3N5pBDKWxd17FatYJhW8sUZWsevKOpa7DSpVdVhbdQgiMEkXHLfGCS7DcXcMEzjCNxSmQLMReCqWSAZcST9DhJUakrL25rWtamKT3AHwuVtVRh9r4QeMc6WcSD0rxSnl3ERPItcHPRbh/BtLWJcO5e3Sb4twxFnbS1OOvV5DtiiyHmCJaliM3NUM6yq/R2phXKbmeKSTH/mfOqU38dlOY8O2zJ3wvybBVVdNl5DqOdq2p/xFzdKIMGo7tHq/L1CGqV6K3ABKHyeOv44he/xE/95O/Ft1swbsH2Z9bGh9eg9x+fugL77Yque4hgVmMEDSTz3mODTEBzzov7kFxcZHBjhJcqrkGCpTVVILSN3kSieEol4Y2lGB2UzV3wsioC2hvIuTiND044o0VLaSTe33dfJacF8PehYibYGyMG4cZKSKPzEpYneFMWVyfvZQzn5OatqoAhiVILC9aoaYXgStMUccFKbhSCoc380fmGmXGyrBPdaYoUIwXUaKc9k7oLOn0tMpDqxkmxON0uOkmB8EEexmkehhhVl00iLaVI/5FBeaBSJFO6FwPEeN+5zribkO3FkEaUQGZ5P2UpzNIVheDFOtAYXeDkAW0bHcgUS9ZCwcyUyJKV5lXObJyoosZxEnqbkc98psMNYwYzyzfl+tqUSEIolkGXDcKtLkUcz7Trmu/fpHMD7+WzdN7RDxPeWZwXaMc7Q0pGLhjuAYVPFk8nLS/TlO9dphQPjdrtGyAVEWJ4Zb/UlWeKMET1pS1q/DObJBXp8rKAXrIYxYkpGdqmQuSx8/OoxtRJOKpiQyiLYfCOYmfGiXTTSeW+4hBn1G1N9mnDMChdSwZ8YxLToVVTM+9qlqbLymzBW02WzgKnZGU0eJupK3FRS6lQVRLBVPtKfHadpw2Wz3/2h/jRH/+HCM1GmRbfThP9bt0rfAoLLHxw1dBVy0BRr9HH5+d8xVlKspBHLEIUngfgzpVlNZbJpg6f5mn4OIiDT2iIkwxwmNVfin860acya+9nfl5SF6lGQXRxnS/6YWeq4DkOo2xhdKoagheCv0IAqWSxpbMF44wOe3QqnzPGBR2sFGIcCb6iCmpU4+au+t5JvuSCD5YxZ1B8OJe5C5KiPU2j0HMMTNNIyQifM5ml6AhFTbihc6ZR0a0+RiAAs9CF1Fg8yXvOBU1nKOpSNgBQxkxdizotzzhhceTY62eikkUrCagz73iOkc5F2CBRu5PZcAbut6imGCJxEWhYZQ7ciwImHe7MgZlWFx/ZGaAFymn7UgdP8J6uG6hCIAThPScd8hjQ+Bi7bGEFK5eBmLdKAXSyuFi06M1sEGZ11b1sWexHBbYq5MVTI6lrm4ganEzUVYBSyPdO/rMRLuILW4zej6owFK8KwfudNdRVg3ciQhC+5/y4WYEJctFYIkMTxETFzA3HJNzgEGQxpAgbpPK1ij+smhPN+VkG65XXDFAiObsFyrNG7gFThActOz7DpGwgdEhW1WHZ5aDDxyo4MYAxDutFgTfFSDGOMRVWladuxP/Ah8CmafkHfuynePNzvxPjGzkjo9DDg53zt9ehDz8+VQV2fkPf/qbui6yzjvPdjl0VOBjDNIjlW1MFwbBKUXVJBiw5FbJ2s7M3pVjKJZpKhkNmGolpAmu0czH68MptHLwlRnXKN4ZVUwtkkItYryWJdnFWVlOvTktZMcoUo0YICy2lCV6n7wJjmCwq+FwUW9UprUWKs7EQkR8wR4gA8n1ZxQAYVk3QB1iK2dzZCH0oETRFoQhVAp0FkTKEYLGIoGD2ThiGSb1DLSbJzZyLpCHMq9nsV6sIKmBJCBYXYyLmRB61u0rShVm9p8dRto5edfCz/WMuwpWsgpNhT5yn3kVkyGJAh7EFUx7uWsyC+eYipt1SlOcBEVqklOFpjH6us92kdLr+AY5YMnIdFOfx8xCwyKS7bhqs0u+cExx9NmNZDL4N4kubxQnK6pCmFINDnM90877onlJmEXDkounKxjCMBWtU4QYYc49Noh2m02Iu5jCJprLK/03agBhSHChZo3C04885i1dCka63tlq4kfPwRnYL3oviL+ekKcpSFiXye6aAyfmI77Is4kI1E6e4ReaeC20dwMrnOiXhfJcgu8lxlLwzGYqV5boG5+QeS1GGVcrWiSmSi6WqLY1ixt55mmbF07NTfvLHfzebJ59RPH/+zGfI5F5N+lBZ+ttGaPCdjrngGSMDkXZzxltna3755Q2TDVhXIMUF2Lc6dBI2gBMTjyIbQxscWWlWWW+qzFyIdNsRJ03sHLR7QCV8sx67LDI9MeyQldxXFeJoJRhuCEEwWeelmFhDVQdVeCn9CJRHK4mzpIwPjuMwKilcqFWlFNq6kdROHQA0TUWKhZyjYnVZ6GJFKF82S1e4hMjpfRJ8IOl7kMKmfEQ7xzULmd7bSag2GILSy3Iswt+1gtdGRN3jVQ1nnewUjAka0zNirVeMUeWLWXKarBGduLWaJJHFDMerz0CmMMZMCNUynJwLyzxsC04UVqPGeov4QXFuLToCxcxyYRGnxKxeFrmQle3gQsDlLN1acDp4EsgEC8EIp9d5R+lHZu5m8B6sk7A/63QoOC3cYFHnCQaakG13rVaHM+XMWcH+hcNtljyxgizkEt8jOwyn5i0ippGIGgo0daBE+Zo5tqapw3JviSBhUkL+fcGap/Hz+Ur6sbBkco66Eyrq32qoglmokXLNM6SkVDOzQHozdjrTwgRTddj5WXRuoT/2g+R7eWtFtJMyUyo0wcuik2Vhd74SOMJKDJKdqWwKmRlT8IgRfDaeynlOtmt+6DOf5zNf+FFce/pgx/agU+X9hfTh3z/1GOwHO9fv5K5lkI6x3Zzzxd/xI6S//fP8+uWBsVTkNKmTlRht5CyKq5iS8vVUColgTu2qxbjAFC1DSuKeo3STpqkRr1Hx8zTG0jRh6RKMkWlkSQnvDViPM0bNhAEMJgSclUVhmiZC7VTOaHB1DX7e0qk5tSmkAs2qFcu2IlQggTjuCeehbriPw5ECMyurZoTYYUQcUAoUwaCdr4jTJDQtZvmf+seWLAYveaZHqfw2SBig9yLhzMVIF2MMOUtX3vgZYHRit2eFiJ51FBVskIIQI0Glu+M4EVyFadSKMEgAoXE1DhVUWEPBUTVOPW6ViF5k6m6VseDUxMSjXg664BWEkhNCTfBhycqqNDiyqT3ROUo1q6RkCo0x1N7JNdWudU5QHaZI0c7b+0p+Tym4IJ2gsRKn7ZwRPiU6uS/ClpjjXiRSXGCp2RsglUIyidppcq6dWR5+wV9TSszR2eMk955TNoqzQp/yFOnSi3S23olfLYr/Wix5SrJzo2hxLrSh1mI9u1KJh6wNHmec8m6tZMdlhw3alBjw1lO87JqcY5krCLUxg5Xd3zSKOMPUjfLRtZul4KuGoHSsWAouOFatXWwQc75fyGT2pdLY+Z63Vnm0hTZU1E3L2ekjXn/+NufP38I3JxTk+Z83YPO+i+V/v3Nt+k7Hp6LAzscHV5CHb8yY+1be+IqTz/5ufvr0Ld766s9xcXXLfpi47aPeWJZYRGgwm0rMJG9rHTkmTmrZ7h2nRDpZY4x0INbdSxGtrZiSRLOkNOKsV59ZwKCT20mmtuH+wYgpQ5Gtl7ViiVepJR3AnK45b3FKgco5MYVGup2T3RlWdegxZvXJFCOLqqqUhzpTru63NTMuW2nAYjGyFc3IlnGm/Jw38Gjl2dbyXq8HeO+QZABSZPiViyheZrnwpK5PhXu7yLm7d14KXRGukT6oaaFfCU5+P202Dz7juVDNqiSjE13JJJMMtoTgbKVkTqtCZeF6lK1xLDKFnhRPd37OPItsapGFris4RuhLJRlqRXikzjoqm3i8CTgDfbZcH+V+MVbFEtptxTRj8vN7nT2DPTlOYsLjZpWehzTS+sKmMljnOSZHcLCtDFMuvDxkYpYOMCn0Y6xbzFRQcUrbVMTiZbuuuyOLFlwbJDYnRnIS3NtaoxEtyi3VRQzuaXY5F8WFtcO09zjk0pXq4zgnMxRYfABC1VCyqCYbjRfPpcjk1FhM0Qw4Iw5c4gsCxnlIA0X9eq0+F8Y65dgmxI/B4byYXqc44a2KWKqKptlIB2xERFB5S06T8JTrNU17gms3GN9QjIh1FueB8qCYmuV/7ifp36UuffD41BTYD3sTy3Zy/jdzf5EwDnf2Jm+evcFbaVq25jB3wnNWj+A8xczTZyDL4AEz67HvMTP9RVjlt2YBdqVYmHm9lMmowEyiXc16YxqFHpb3tCwMM8euLF2pwj9aVO6t9RTPAM0aMjg0cAy5S83SzZX8fq7wfJ0cGrCHSl7NDOaLq5Kkns7XM/LcWH6nPmDzAE3epdolInEg8vPlOho3/8y5sM6/Xqf88qkI9mbk+2ZCr7Hm/r1q8Z+HDcZYXRjkZ7rlJ8n3Ge3MhVZTlqFRUVB5NojBiMm4gA3oNfX6e5P+qTLi+dobodjJZRaMbtk+luUNymUrD679MhBU/Fx3Gej7Fhm30PNcUcUheu/NOLLeB0tjYbTL0j9nCGz+ffpRsJxaYf6penfed2gPz9vo9VyKy8NDbsjlc1lukbJ8PPMPe/CzHzRGzHKg+38qej/LHzOnVYaT83fMUMnD4/1nX5Z7Q/5Rzq+U+VlUfHaBpIuMy5aCmu/P09yf3/11//Bd82+LIddDQPmDx+LpqV+z6NB1HJAxOg2E+VLa+79+2C30vmP2RcKUpZQs917RB9SY+6+bv/wjPpDFa0k/6PsHYP6A56fBYMo8cNGb7sG5P8SJvv0oLFnjxTy4xb79vb3/+pYZObj/Ofdns/zGb9NYm1lVpAUVZAGbL1b5qIfjQ67Xg2vwYZlH37Zm8LCY3RcKOQf99wdfbR983fuui7m/xve3XFmK7X1R0fMr31mP/u3neF90ZTFgecAfFumkjBXMg0WmII5PWpDmU3jfBrY8uB8e/PL3f573Yoz33UzlfdXxHnfUc37/+5jxUi3i6m4g3/Dt57J8fGX+7vm8pLERf9z5fS0WMvKV2nzMC/v9hbw/ddnyzJ/zXPEfLHKU96WFyD3+8AKxLG73DetHF87f6NeY38gX/aAOY8wL4AC8/EGfy4ccj/lknhe8Orff7PHq3L7345N6XvD9PbfPlFKefPDFT3SBBTDG/LVSyk//oM/jg8cn9bzg1bn9Zo9X5/a9H5/U84JPxrl9qt20Xh2vjlfHq+OTfLwqsK+OV8er49XxMR2fhgL7p37QJ/Adjk/qecGrc/vNHq/O7Xs/PqnnBZ+Ac/vEY7CvjlfHq+PV8Wk9Pg0d7Kvj1fHqeHV8Ko9XBfbV8ep4dbw6PqbjE1tgjTF/wBjz94wxXzHG/LEfwO9/yxjz/zHG/G1jzC8YY/4X+vq/boz5hjHmy/rfH3zwPX9cz/fvGWP+8Y/5/L5qjPmbeg5/TV87N8b8ZWPML+mfZ/q6Mcb8n/Tcft4Y81Mf0zn98IPr8mVjzK0x5l/9QV0zY8yfNsa8Z4z5Ww9e+56vkTHmj+jX/5Ix5o98jOf2bxpj/q7+/v/EGHOqr3/WGNM9uH7/7oPv+W/pffAVPf/vpp35zZ7b9/wZfhzP8Hc4tz//4Ly+aoz5sr7+fb1uH3rMJiqfpP8QuckvA58HKuBvAD/yfT6H58BP6d+3wC8CPwL868D/6kO+/kf0PGvgc3r+7mM8v68Cjz/w2v8e+GP69z8G/En9+x8E/t+ITuX3AP/V9+kz/BbwmR/UNQP+EeCngL/1m71GwDnwK/rnmf797GM6t98PeP37n3xwbp99+HUf+Dn/tZ6v0fP/Jz6mc/uePsOP6xn+sHP7wL//H4D/zQ/iun3Yf5/UDvZ3A18ppfxKKWUE/hzwh76fJ1BKeaeU8tf173fA3wHe+Ihv+UPAnyulDKWUXwW+gryP7+fxh4D/QP/+HwD//Qev/5kix88Cp8aY5x/zufw+4JdLKb/2EV/zsV6zUspfAS4/5Hd+L9foHwf+cinlspRyBfxl4A98HOdWSvlLpZSo//dngTc/6mfo+e1KKT9bpGr8mQfv57f03D7i+E6f4cfyDH/UuWkX+j8B/uOP+hkf13X7sOOTWmDfAL724P9/nY8ubh/rYYz5LPCTwH+lL/0ruo370/MWk+//ORfgLxljfs4Y80f1tWellHf0798Cnv2Azg3gD/P+G/2TcM3ge79GP6h78V9AOqv5+Jwx5r8xxvx/jTH/sL72hp7P9+vcvpfP8Adx3f5h4N1Syi89eO0Het0+qQX2E3MYYzbA/wP4V0spt8D/GfgC8BPAO8iW5Adx/N5Syk8B/wTwLxtj/pGH/6gr8w+Eg2eMqYB/Gvi/60uflGv2vuMHeY0+6jDG/AkgAn9WX3oHeLuU8pPA/xL4j4wxu+/zaX0iP8MPHP8M71/Uf+DX7ZNaYL8BvPXg/7+pr31fD2NMQIrrny2l/D8BSinvllJSEe/D/wv3W9rv6zmXUr6hf74H/Cd6Hu/OW3/9870fxLkhRf+vl1Le1XP8RFwzPb7Xa/R9PUdjzD8H/JPA/0wXAHT7faF//zkE2/ySnsdDGOFjO7ffxGf4/b5uHvgfAn/+wTn/wK/bJ7XA/lXgi8aYz2k39IeBn/l+noDiOf8e8HdKKf/Wg9cfYpf/A2CeZv4M8IeNMbUx5nPAFxEg/eM4t7UxZjv/HRmO/C09h3nK/UeA/9eDc/tndVL+e4CbB9vkj+N4XyfxSbhmD47v9Rr9ReD3G2POdFv8+/W13/LDGPMHgH8N+KdLKccHrz8xakpsjPk8cp1+Rc/v1hjze/R+/WcfvJ/f6nP7Xj/D7/cz/N8F/m4pZdn6fxKu22/51Oy36j9kqvuLyKrzJ34Av//3ItvHnwe+rP/9QeA/BP6mvv4zwPMH3/Mn9Hz/Hh/TVFJ/z+eRqezfAH5hvj7AI+A/A34J+E+Bc33dAP+OntvfBH76Yzy3NXABnDx47QdyzZAi/w4wITjbv/ibuUYIHvoV/e+f/xjP7SsIbjnfb/+ufu3/SD/nLwN/HfinHvycn0aK3S8D/zaqzvwYzu17/gw/jmf4w85NX//3gX/pA1/7fb1uH/bfK6nsq+PV8ep4dXxMxycVInh1vDpeHa+OT/3xqsC+Ol4dr45Xx8d0vCqwr45Xx6vj1fExHa8K7Kvj1fHqeHV8TMerAvvqeHW8Ol4dH9PxqsC+Ol4dr45Xx8d0vCqwr45Xx6vj1fExHf9/cOTsycuvA6YAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -306,6 +334,12 @@ "execution_count": 6, "metadata": { "collapsed": false, + "execution": { + "iopub.execute_input": "2026-07-03T20:51:40.815082Z", + "iopub.status.busy": "2026-07-03T20:51:40.814961Z", + "iopub.status.idle": "2026-07-03T20:51:40.817562Z", + "shell.execute_reply": "2026-07-03T20:51:40.816933Z" + }, "pycharm": { "name": "#%%\n" } @@ -362,14 +396,32 @@ }, { "cell_type": "markdown", - "source": "## High-Performance DataFrames with Polars\n\n`data-wrangler` now supports [Polars](https://pola.rs/), a lightning-fast DataFrame library that can provide 2-100x performance improvements over pandas for many operations. You can choose your DataFrame backend on a per-operation basis or globally.\n\n### Installation\n\nPolars is now included as a core dependency of `data-wrangler`, so no additional installation is required!\n\n### Basic Polars Usage\n\nYou can specify the backend for any wrangling operation:", - "metadata": {} + "metadata": {}, + "source": [ + "## High-Performance DataFrames with Polars\n", + "\n", + "`data-wrangler` now supports [Polars](https://pola.rs/), a lightning-fast DataFrame library that can provide 2-100x performance improvements over pandas for many operations. You can choose your DataFrame backend on a per-operation basis or globally.\n", + "\n", + "### Installation\n", + "\n", + "Polars is now included as a core dependency of `data-wrangler`, so no additional installation is required!\n", + "\n", + "### Basic Polars Usage\n", + "\n", + "You can specify the backend for any wrangling operation:" + ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "collapsed": false, + "execution": { + "iopub.execute_input": "2026-07-03T20:51:40.818940Z", + "iopub.status.busy": "2026-07-03T20:51:40.818825Z", + "iopub.status.idle": "2026-07-03T20:51:40.874597Z", + "shell.execute_reply": "2026-07-03T20:51:40.873897Z" + }, "pycharm": { "name": "#%%\n" } @@ -515,6 +567,12 @@ "execution_count": 8, "metadata": { "collapsed": false, + "execution": { + "iopub.execute_input": "2026-07-03T20:51:40.876124Z", + "iopub.status.busy": "2026-07-03T20:51:40.876001Z", + "iopub.status.idle": "2026-07-03T20:51:40.879860Z", + "shell.execute_reply": "2026-07-03T20:51:40.879359Z" + }, "pycharm": { "name": "#%%\n" } @@ -650,6 +708,12 @@ "execution_count": 9, "metadata": { "collapsed": false, + "execution": { + "iopub.execute_input": "2026-07-03T20:51:40.881164Z", + "iopub.status.busy": "2026-07-03T20:51:40.881074Z", + "iopub.status.idle": "2026-07-03T20:51:40.884956Z", + "shell.execute_reply": "2026-07-03T20:51:40.884525Z" + }, "pycharm": { "name": "#%%\n" } @@ -777,27 +841,149 @@ }, { "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Loading data types from saved files\n", + "\n", + "Every example above wrangled an **in-memory** Python object. `data-wrangler` can also wrangle data\n", + "straight from a **file on disk** (or a URL): it auto-detects the format from the file extension, loads it,\n", + "and wrangles the result in a single step. Here we round-trip the same DataFrame and Array through disk." + ] + }, + { + "cell_type": "code", + "execution_count": 10, "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%% md\n" + "execution": { + "iopub.execute_input": "2026-07-03T20:51:40.886094Z", + "iopub.status.busy": "2026-07-03T20:51:40.886001Z", + "iopub.status.idle": "2026-07-03T20:51:40.893571Z", + "shell.execute_reply": "2026-07-03T20:51:40.893174Z" } }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Wrangled a DataFrame of shape (7, 6) from sample.csv\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ByTwosFirstDimSecondDimThirdDimFourthDimFifthDim
0012345
12246810
243691215
3548121620
46510152025
\n", + "
" + ], + "text/plain": [ + " ByTwos FirstDim SecondDim ThirdDim FourthDim FifthDim\n", + "0 0 1 2 3 4 5\n", + "1 2 2 4 6 8 10\n", + "2 4 3 6 9 12 15\n", + "3 5 4 8 12 16 20\n", + "4 6 5 10 15 20 25" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "## Wrangling text data using natural language processing models\n", + "import tempfile\n", "\n", - "Next, let's play with some text data. By default, `data-wrangler` embeds text using a Latent Dirichlet Allocation model\n", - "trained on a curated version of Wikipedia, called the \"minipedia\" corpus. First we'll split the text into its component\n", - "lines, and then we'll wrangle the result:" + "save_dir = tempfile.mkdtemp()\n", + "\n", + "# --- DataFrame from a saved CSV file ---\n", + "csv_path = os.path.join(save_dir, 'sample.csv')\n", + "dataframe.to_csv(csv_path)\n", + "df_from_file = dw.wrangle(csv_path) # pass the *path*; the CSV is loaded and wrangled automatically\n", + "print(f'Wrangled a {type(df_from_file).__name__} of shape {df_from_file.shape} from {os.path.basename(csv_path)}')\n", + "df_from_file.head()" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" + "execution": { + "iopub.execute_input": "2026-07-03T20:51:40.894658Z", + "iopub.status.busy": "2026-07-03T20:51:40.894575Z", + "iopub.status.idle": "2026-07-03T20:51:40.899957Z", + "shell.execute_reply": "2026-07-03T20:51:40.899496Z" } }, "outputs": [ @@ -805,7 +991,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "loading corpus: minipedia...done!\n" + "Wrangled a DataFrame of shape (7, 5) from sample.npy\n" ] }, { @@ -834,123 +1020,199 @@ " 2\n", " 3\n", " 4\n", - " 5\n", - " 6\n", - " 7\n", - " 8\n", - " 9\n", - " ...\n", - " 40\n", - " 41\n", - " 42\n", - " 43\n", - " 44\n", - " 45\n", - " 46\n", - " 47\n", - " 48\n", - " 49\n", " \n", " \n", " \n", " \n", " 0\n", - " 0.02\n", - " 0.02\n", - " 0.02\n", - " 0.02\n", - " 0.02\n", - " 0.02\n", - " 0.02\n", - " 0.02\n", - " 0.02\n", - " 0.02\n", - " ...\n", - " 0.02\n", - " 0.02\n", - " 0.02\n", - " 0.02\n", - " 0.02\n", - " 0.02\n", - " 0.02\n", - " 0.02\n", - " 0.02\n", - " 0.02\n", + " 1\n", + " 2\n", + " 3\n", + " 4\n", + " 5\n", " \n", " \n", " 1\n", - " 0.01\n", - " 0.01\n", - " 0.01\n", - " 0.01\n", - " 0.01\n", - " 0.01\n", - " 0.01\n", - " 0.01\n", - " 0.01\n", - " 0.01\n", - " ...\n", - " 0.01\n", - " 0.01\n", - " 0.01\n", - " 0.01\n", - " 0.01\n", - " 0.01\n", - " 0.01\n", - " 0.01\n", - " 0.01\n", - " 0.01\n", + " 2\n", + " 4\n", + " 6\n", + " 8\n", + " 10\n", " \n", " \n", " 2\n", - " 0.02\n", - " 0.02\n", - " 0.02\n", - " 0.02\n", - " 0.02\n", - " 0.02\n", - " 0.02\n", - " 0.02\n", - " 0.02\n", - " 0.02\n", - " ...\n", - " 0.02\n", - " 0.02\n", - " 0.02\n", - " 0.02\n", - " 0.02\n", - " 0.02\n", - " 0.02\n", - " 0.02\n", - " 0.02\n", - " 0.02\n", + " 3\n", + " 6\n", + " 9\n", + " 12\n", + " 15\n", " \n", " \n", " 3\n", - " 0.02\n", - " 0.02\n", - " 0.02\n", - " 0.02\n", - " 0.02\n", - " 0.02\n", - " 0.02\n", - " 0.02\n", - " 0.02\n", - " 0.02\n", - " ...\n", - " 0.02\n", - " 0.02\n", - " 0.02\n", - " 0.02\n", - " 0.02\n", - " 0.02\n", - " 0.02\n", - " 0.02\n", - " 0.02\n", - " 0.02\n", + " 4\n", + " 8\n", + " 12\n", + " 16\n", + " 20\n", " \n", " \n", " 4\n", + " 5\n", + " 10\n", + " 15\n", + " 20\n", + " 25\n", + " \n", + " \n", + " 5\n", + " 6\n", + " 12\n", + " 18\n", + " 24\n", + " 30\n", + " \n", + " \n", + " 6\n", + " 7\n", + " 14\n", + " 21\n", + " 28\n", + " 35\n", + " \n", + " \n", + "\n", + "" + ], + "text/plain": [ + " 0 1 2 3 4\n", + "0 1 2 3 4 5\n", + "1 2 4 6 8 10\n", + "2 3 6 9 12 15\n", + "3 4 8 12 16 20\n", + "4 5 10 15 20 25\n", + "5 6 12 18 24 30\n", + "6 7 14 21 28 35" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# --- Array from a saved .npy file ---\n", + "npy_path = os.path.join(save_dir, 'sample.npy')\n", + "np.save(npy_path, array)\n", + "array_from_file = dw.wrangle(npy_path) # a NumPy file becomes a DataFrame\n", + "assert np.allclose(array_from_file, dataframe)\n", + "print(f'Wrangled a {type(array_from_file).__name__} of shape {array_from_file.shape} from {os.path.basename(npy_path)}')\n", + "array_from_file" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "## Wrangling text data using natural language processing models\n", + "\n", + "Next, let's play with some text data. By default, `data-wrangler` embeds text using a Latent Dirichlet Allocation model\n", + "trained on a curated version of Wikipedia, called the \"minipedia\" corpus. First we'll split the text into its component\n", + "lines, and then we'll wrangle the result:" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false, + "execution": { + "iopub.execute_input": "2026-07-03T20:51:40.901220Z", + "iopub.status.busy": "2026-07-03T20:51:40.901129Z", + "iopub.status.idle": "2026-07-03T20:52:07.525273Z", + "shell.execute_reply": "2026-07-03T20:52:07.524847Z" + }, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/jmanning/.pyenv/versions/3.10.12/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loading corpus: minipedia" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "...done!" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", @@ -958,9 +1220,6 @@ " \n", " \n", " \n", - " \n", - " \n", - " \n", " \n", " \n", " \n", @@ -974,7 +1233,10 @@ " \n", " \n", " \n", - " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", @@ -982,14 +1244,107 @@ " \n", " \n", " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", @@ -1122,12 +1477,12 @@ " \n", " \n", " \n", - " \n", " \n", " \n", " \n", " \n", " \n", + " \n", " \n", " \n", " \n", @@ -1181,7 +1536,7 @@ " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -1255,7 +1610,7 @@ " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -1373,7 +1728,7 @@ " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -1431,7 +1786,7 @@ " \n", " \n", "
0123456789...40414243444546474849
00.020.020.020.020.020.020.020.020.020.020.020.02...0.020.020.02
510.010.010.010.010.010.010.010.010.01...0.010.010.010.510.010.010.010.010.010.01
20.020.020.020.020.020.020.020.020.020.02...0.020.020.020.020.020.020.020.020.020.02
30.020.020.020.020.020.020.020.020.020.02...0.020.020.020.020.020.020.020.020.020.02
40.020.020.020.020.020.020.020.020.020.02...0.020.020.020.020.020.020.020.020.020.02
50.010.010.010.010.010.010.010.010.010.01...0.010.010.010.510.010.010.010.010.010.010.510.010.010.010.010.010.510.01...0.010.010.010.010.010.510.010.010.010.010.010.010.010.510.010.010.010.010.010.010.010.510.010.010.01
\n", - "

24 rows \u00d7 50 columns

\n", + "

24 rows × 50 columns

\n", "
" ], "text/plain": [ @@ -1447,7 +1802,7 @@ "8 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 ... 0.01 \n", "9 0.02 0.02 0.02 0.02 0.02 0.02 0.02 0.02 0.02 0.02 ... 0.02 \n", "10 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 ... 0.01 \n", - "11 0.01 0.01 0.01 0.51 0.01 0.01 0.01 0.01 0.01 0.01 ... 0.01 \n", + "11 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.51 0.01 ... 0.01 \n", "12 0.02 0.02 0.02 0.02 0.02 0.02 0.02 0.02 0.02 0.02 ... 0.02 \n", "13 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 ... 0.01 \n", "14 0.02 0.02 0.02 0.02 0.02 0.02 0.02 0.02 0.02 0.02 ... 0.02 \n", @@ -1463,11 +1818,11 @@ "\n", " 41 42 43 44 45 46 47 48 49 \n", "0 0.02 0.02 0.02 0.02 0.02 0.02 0.02 0.02 0.02 \n", - "1 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 \n", + "1 0.01 0.01 0.51 0.01 0.01 0.01 0.01 0.01 0.01 \n", "2 0.02 0.02 0.02 0.02 0.02 0.02 0.02 0.02 0.02 \n", "3 0.02 0.02 0.02 0.02 0.02 0.02 0.02 0.02 0.02 \n", "4 0.02 0.02 0.02 0.02 0.02 0.02 0.02 0.02 0.02 \n", - "5 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 \n", + "5 0.01 0.01 0.51 0.01 0.01 0.01 0.01 0.01 0.01 \n", "6 0.02 0.02 0.02 0.02 0.02 0.02 0.02 0.02 0.02 \n", "7 0.02 0.02 0.02 0.02 0.02 0.02 0.02 0.02 0.02 \n", "8 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 \n", @@ -1475,22 +1830,22 @@ "10 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 \n", "11 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 \n", "12 0.02 0.02 0.02 0.02 0.02 0.02 0.02 0.02 0.02 \n", - "13 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 \n", + "13 0.01 0.01 0.51 0.01 0.01 0.01 0.01 0.01 0.01 \n", "14 0.02 0.02 0.02 0.02 0.02 0.02 0.02 0.02 0.02 \n", "15 0.02 0.02 0.02 0.02 0.02 0.02 0.02 0.02 0.02 \n", - "16 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 \n", + "16 0.01 0.01 0.01 0.01 0.51 0.01 0.01 0.01 0.01 \n", "17 0.02 0.02 0.02 0.02 0.02 0.02 0.02 0.02 0.02 \n", "18 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 \n", "19 0.02 0.02 0.02 0.02 0.02 0.02 0.02 0.02 0.02 \n", "20 0.02 0.02 0.02 0.02 0.02 0.02 0.02 0.02 0.02 \n", - "21 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 \n", + "21 0.01 0.01 0.51 0.01 0.01 0.01 0.01 0.01 0.01 \n", "22 0.02 0.02 0.02 0.02 0.02 0.02 0.02 0.02 0.02 \n", "23 0.02 0.02 0.02 0.02 0.02 0.02 0.02 0.02 0.02 \n", "\n", "[24 rows x 50 columns]" ] }, - "execution_count": 10, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } @@ -1517,9 +1872,15 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 13, "metadata": { "collapsed": false, + "execution": { + "iopub.execute_input": "2026-07-03T20:52:07.526843Z", + "iopub.status.busy": "2026-07-03T20:52:07.526668Z", + "iopub.status.idle": "2026-07-03T20:52:28.646449Z", + "shell.execute_reply": "2026-07-03T20:52:28.645536Z" + }, "pycharm": { "name": "#%%\n" } @@ -1531,9 +1892,15 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 14, "metadata": { "collapsed": false, + "execution": { + "iopub.execute_input": "2026-07-03T20:52:28.648246Z", + "iopub.status.busy": "2026-07-03T20:52:28.648125Z", + "iopub.status.idle": "2026-07-03T20:52:28.654911Z", + "shell.execute_reply": "2026-07-03T20:52:28.654379Z" + }, "pycharm": { "name": "#%%\n" } @@ -1545,56 +1912,56 @@ "text": [ "Top words from each of the 50 discovered topics:\n", "\n", - "Topic 0: angle, points, normal, units, equal, measure, distribution, distance, unit, constant\n", - "Topic 1: foot, feet, double, speed, running, course, action, round, distance, motion\n", - "Topic 2: game, play, team, played, rules, sports, field, events, competition, women\n", - "Topic 3: mm, metal, plastic, glass, steel, diameter, sizes, machine, strength, cm\n", - "Topic 4: 2008, million, 2007, 2009, 2011, 2010, march, december, 2006, january\n", - "Topic 5: color, green, blue, yellow, colors, brown, tree, dark, plant, plants\n", - "Topic 6: music, sound, film, rock, played, television, play, record, records, classical\n", - "Topic 7: hours, night, hour, days, minutes, 24, week, daily, sun, working\n", - "Topic 8: theory, self, behavior, science, cultural, concept, studies, individuals, model, relationship\n", - "Topic 9: earth, sun, god, million, appears, visible, bodies, believed, billion, ago\n", - "Topic 10: computer, data, management, project, key, electronic, access, online, devices, technology\n", - "Topic 11: church, god, christian, religious, roman, religion, tradition, eastern, traditions, st\n", - "Topic 12: military, forces, force, ii, arms, russian, royal, service, units, operations\n", - "Topic 13: objects, mass, object, field, core, space, matter, fields, visible, energy\n", - "Topic 14: building, built, buildings, construction, house, floor, room, space, houses, walls\n", - "Topic 15: class, classes, anti, active, business, fall, military, 1950s, divided, feature\n", - "Topic 16: cross, symbol, sign, al, et, shaped, version, appears, represents, link\n", - "Topic 17: wind, ice, scale, energy, temperature, weather, speed, pressure, flow, sea\n", - "Topic 18: gas, energy, temperature, heat, chemical, carbon, liquid, compounds, acid, reaction\n", - "Topic 19: gain, southern, species, models, california, northern, frequency, active, components, spring\n", - "Topic 20: pressure, flow, fluid, test, volume, supply, liquid, inner, internal, outer\n", - "Topic 21: gold, iron, silver, metal, steel, value, carbon, bc, pure, ii\n", - "Topic 22: death, stage, dead, die, remains, man, performed, stages, carried, bodies\n", - "Topic 23: species, humans, male, female, million, ago, live, population, living, animals\n", - "Topic 24: language, languages, books, writing, written, words, text, published, formal, literature\n", - "Topic 25: health, medical, care, treatment, poor, population, million, studies, report, risk\n", - "Topic 26: animals, animal, skin, humans, eye, eyes, wild, kept, domestic, raised\n", - "Topic 27: cells, cell, growth, plants, structures, layer, plant, acid, functions, biological\n", - "Topic 28: women, sexual, children, men, female, male, child, woman, man, mother\n", - "Topic 29: oil, fruit, varieties, hot, served, consumption, grown, fresh, content, sold\n", - "Topic 30: service, court, legal, services, civil, department, federal, government, laws, issued\n", - "Topic 31: blood, disease, heart, risk, diseases, treatment, health, causes, medical, loss\n", - "Topic 32: vehicles, electric, speed, built, drive, safety, equipment, transport, electrical, technology\n", - "Topic 33: art, style, london, works, 18th, museum, tradition, saw, famous, william\n", - "Topic 34: political, party, government, rights, legal, organization, exchange, status, organizations, economic\n", - "Topic 35: fish, sea, ft, river, deep, land, fresh, 200, island, 500\n", - "Topic 36: city, road, street, cities, town, river, urban, population, island, travel\n", - "Topic 37: god, fruit, trees, disease, risk, treatment, head, million, cultural, medical\n", - "Topic 38: soil, land, plant, bc, plants, rock, regions, region, india, stone\n", - "Topic 39: story, damage, article, loss, ring, exposure, protection, journal, published, severe\n", - "Topic 40: section, big, principal, differences, ii, fully, model, wind, 32, split\n", - "Topic 41: base, lines, wall, pieces, piece, opening, figure, upper, vertical, branch\n", - "Topic 42: property, elements, numbers, element, table, properties, real, value, classical, theory\n", - "Topic 43: worn, paper, wear, clothing, fashion, women, men, style, styles, cover\n", - "Topic 44: chinese, king, india, east, african, africa, japanese, asia, indian, spanish\n", - "Topic 45: species, trees, plants, leaves, winter, wild, tree, season, summer, northern\n", - "Topic 46: foot, et, al, feet, science, political, height, 18th, court, religious\n", - "Topic 47: market, price, product, products, goods, store, chain, supply, industry, company\n", - "Topic 48: school, education, training, schools, degree, college, children, professional, programs, degrees\n", - "Topic 49: wood, head, image, cut, wooden, tools, edge, tool, images, face\n" + "Topic 0: cells, cell, blood, structures, skin, growth, layer, functions, outer, internal\n", + "Topic 1: sea, ice, land, river, ft, winter, weather, rock, climate, flow\n", + "Topic 2: music, sound, rock, play, played, classical, style, plays, note, double\n", + "Topic 3: elements, element, table, earth, classical, symbol, matter, names, things, theory\n", + "Topic 4: face, tools, tool, die, edge, foundation, stone, removed, base, skin\n", + "Topic 5: building, built, house, buildings, floor, wall, room, construction, walls, houses\n", + "Topic 6: species, fish, wild, male, female, live, young, feed, adult, humans\n", + "Topic 7: population, african, cultural, cultures, africa, native, al, regions, region, asian\n", + "Topic 8: soil, plants, plant, root, matter, growth, brown, field, dry, formation\n", + "Topic 9: women, sexual, men, female, male, woman, mother, man, child, birth\n", + "Topic 10: game, play, team, played, rules, sports, field, events, competition, association\n", + "Topic 11: pressure, heat, temperature, glass, liquid, flow, hot, fluid, cold, volume\n", + "Topic 12: angle, points, lines, normal, numbers, units, equal, value, measure, distance\n", + "Topic 13: death, dead, remains, die, carried, performed, medical, removed, blood, circumstances\n", + "Topic 14: store, storage, distribution, items, goods, space, stored, department, big, equipment\n", + "Topic 15: project, performance, computer, techniques, construction, patterns, technology, site, style, machine\n", + "Topic 16: blood, disease, risk, health, treatment, heart, diseases, skin, causes, medical\n", + "Topic 17: political, theory, science, concept, definition, property, economic, cultural, scientific, knowledge\n", + "Topic 18: chain, title, medicine, medical, equivalent, review, degree, usage, college, post\n", + "Topic 19: foot, feet, running, height, figure, figures, step, cm, fall, standing\n", + "Topic 20: animals, animal, humans, ago, living, evolution, species, million, plants, evolved\n", + "Topic 21: speed, electric, electrical, frequency, devices, mechanical, device, machine, sound, motion\n", + "Topic 22: color, yellow, colors, blue, eye, skin, dark, green, visible, brown\n", + "Topic 23: green, blue, party, political, yellow, dark, spring, brown, feature, environmental\n", + "Topic 24: military, forces, force, charge, service, units, field, operations, unit, mounted\n", + "Topic 25: million, 2008, 2011, 2007, 2010, 2009, 2012, 2013, 2006, march\n", + "Topic 26: health, service, services, care, medical, poor, community, hours, treatment, access\n", + "Topic 27: training, degree, professional, science, degrees, field, education, programs, engineering, knowledge\n", + "Topic 28: church, god, christian, religious, roman, tradition, religion, man, story, traditions\n", + "Topic 29: earth, wind, sun, scale, mass, energy, core, space, objects, night\n", + "Topic 30: class, japanese, ii, saw, japan, russian, germany, france, anti, britain\n", + "Topic 31: city, street, cities, town, urban, london, department, road, paris, center\n", + "Topic 32: wood, head, metal, mm, steel, plastic, cut, flat, diameter, shaped\n", + "Topic 33: language, languages, key, writing, words, data, test, numbers, computer, formal\n", + "Topic 34: film, television, image, video, record, records, released, images, character, media\n", + "Topic 35: art, objects, object, museum, glass, collection, works, subject, fine, gallery\n", + "Topic 36: paper, books, money, online, exchange, published, issued, text, value, electronic\n", + "Topic 37: 40, class, operation, australian, 27, buildings, property, 1970s, properties, cities\n", + "Topic 38: energy, gas, oil, carbon, chemical, compounds, acid, reaction, properties, liquid\n", + "Topic 39: record, head, nations, government, service, class, operate, represent, past, formal\n", + "Topic 40: worn, wear, cross, clothing, fashion, style, men, women, styles, popularity\n", + "Topic 41: children, school, education, child, schools, college, young, secondary, families, care\n", + "Topic 42: fruit, leaves, tree, trees, plant, varieties, grown, plants, species, served\n", + "Topic 43: legal, court, government, rights, civil, property, laws, service, federal, serve\n", + "Topic 44: management, organization, business, board, organizations, company, security, companies, activities, course\n", + "Topic 45: india, bc, king, chinese, roman, east, royal, empire, indian, spanish\n", + "Topic 46: self, behavior, theory, experience, individuals, relationship, studies, positive, negative, activity\n", + "Topic 47: market, products, product, price, supply, industry, trade, sold, demand, goods\n", + "Topic 48: vehicles, road, built, safety, transport, speed, electric, model, double, models\n", + "Topic 49: gold, iron, silver, metal, steel, bc, value, stone, carbon, pure\n" ] } ], @@ -1632,9 +1999,15 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 15, "metadata": { "collapsed": false, + "execution": { + "iopub.execute_input": "2026-07-03T20:52:28.656073Z", + "iopub.status.busy": "2026-07-03T20:52:28.655977Z", + "iopub.status.idle": "2026-07-03T20:52:28.658536Z", + "shell.execute_reply": "2026-07-03T20:52:28.658051Z" + }, "pycharm": { "name": "#%%\n" } @@ -1644,7 +2017,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Line 1 put the most weight on topic 2: Where the deer and the antelope play\n" + "Line 1 put the most weight on topic 10: Where the deer and the antelope play\n" ] } ], @@ -1672,9 +2045,15 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 16, "metadata": { "collapsed": false, + "execution": { + "iopub.execute_input": "2026-07-03T20:52:28.659837Z", + "iopub.status.busy": "2026-07-03T20:52:28.659725Z", + "iopub.status.idle": "2026-07-03T20:52:28.662521Z", + "shell.execute_reply": "2026-07-03T20:52:28.662030Z" + }, "pycharm": { "name": "#%%\n" } @@ -1712,9 +2091,15 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 17, "metadata": { "collapsed": false, + "execution": { + "iopub.execute_input": "2026-07-03T20:52:28.663909Z", + "iopub.status.busy": "2026-07-03T20:52:28.663801Z", + "iopub.status.idle": "2026-07-03T20:52:50.073079Z", + "shell.execute_reply": "2026-07-03T20:52:50.072550Z" + }, "pycharm": { "name": "#%%\n" } @@ -1724,7 +2109,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Topics match!\n" + "Topics do NOT match!\n" ] } ], @@ -1741,38 +2126,672 @@ "name": "#%% md\n" } }, - "source": "## Modern Text Processing with Sentence-Transformers\n\nIn addition to scikit-learn text embedding models, `data-wrangler` provides comprehensive support for state-of-the-art sentence-transformers models via [HuggingFace](https://huggingface.co/models).\n\n### Installation Requirements\n\nSentence-transformers support requires additional ML libraries. To keep `data-wrangler` lightweight, these are optional dependencies:\n\n```bash\npip install --upgrade \"pydata-wrangler[hf]\"\n```\n\nThis installs sentence-transformers, transformers, and related HuggingFace libraries.\n\n### Popular Sentence-Transformers Models\n\nDifferent models are optimized for different tasks:\n\n- **`all-MiniLM-L6-v2`**: Fast, general-purpose sentence embeddings (384 dimensions)\n- **`all-mpnet-base-v2`**: High-quality sentence embeddings (768 dimensions) \n- **`paraphrase-MiniLM-L6-v2`**: Optimized for paraphrase detection\n- **`all-distilroberta-v1`**: Balanced performance and speed\n\n### Basic Usage\n\nHere's how to use sentence-transformers with your text data:" + "source": [ + "## Modern Text Processing with Sentence-Transformers\n", + "\n", + "In addition to scikit-learn text embedding models, `data-wrangler` provides comprehensive support for state-of-the-art sentence-transformers models via [HuggingFace](https://huggingface.co/models).\n", + "\n", + "### Installation Requirements\n", + "\n", + "Sentence-transformers support requires additional ML libraries. To keep `data-wrangler` lightweight, these are optional dependencies:\n", + "\n", + "```bash\n", + "pip install --upgrade \"pydata-wrangler[hf]\"\n", + "```\n", + "\n", + "This installs sentence-transformers, transformers, and related HuggingFace libraries.\n", + "\n", + "### Popular Sentence-Transformers Models\n", + "\n", + "Different models are optimized for different tasks:\n", + "\n", + "- **`all-MiniLM-L6-v2`**: Fast, general-purpose sentence embeddings (384 dimensions)\n", + "- **`all-mpnet-base-v2`**: High-quality sentence embeddings (768 dimensions) \n", + "- **`paraphrase-MiniLM-L6-v2`**: Optimized for paraphrase detection\n", + "- **`all-distilroberta-v1`**: Balanced performance and speed\n", + "\n", + "### Basic Usage\n", + "\n", + "Here's how to use sentence-transformers with your text data:" + ] }, { "cell_type": "code", - "source": "# High-quality model - better for production applications\n# Using simplified API - just pass the model name as a string!\nquality_embeddings = dw.wrangle(lines, text_kwargs={'model': 'all-mpnet-base-v2'})\n\nprint(f\"Quality model embeddings shape: {quality_embeddings.shape}\")\nprint(f\"Quality model (first few dimensions):\")\nquality_embeddings.iloc[:3, :5]", + "execution_count": 18, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-03T20:52:50.074513Z", + "iopub.status.busy": "2026-07-03T20:52:50.074404Z", + "iopub.status.idle": "2026-07-03T20:52:53.360818Z", + "shell.execute_reply": "2026-07-03T20:52:53.360288Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Warning: You are sending unauthenticated requests to the HF Hub. Please set a HF_TOKEN to enable higher rate limits and faster downloads.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + "Loading weights: 0%| | 0/199 [00:00\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
01234
0-0.0128060.115035-0.002113-0.0205510.013699
10.014780-0.007010-0.0224780.015275-0.052132
20.0252680.0239970.028487-0.0069820.029362
\n", + "" + ], + "text/plain": [ + " 0 1 2 3 4\n", + "0 -0.012806 0.115035 -0.002113 -0.020551 0.013699\n", + "1 0.014780 -0.007010 -0.022478 0.015275 -0.052132\n", + "2 0.025268 0.023997 0.028487 -0.006982 0.029362" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# High-quality model - better for production applications\n", + "# Using simplified API - just pass the model name as a string!\n", + "quality_embeddings = dw.wrangle(lines, text_kwargs={'model': 'all-mpnet-base-v2'})\n", + "\n", + "print(f\"Quality model embeddings shape: {quality_embeddings.shape}\")\n", + "print(f\"Quality model (first few dimensions):\")\n", + "quality_embeddings.iloc[:3, :5]" + ] + }, + { + "cell_type": "markdown", "metadata": {}, - "outputs": [], - "execution_count": null + "source": [ + "### Model Comparison\n", + "\n", + "Notice the difference in embedding dimensions:\n", + "- **Fast model (all-MiniLM-L6-v2)**: 384 dimensions - good for speed and memory efficiency\n", + "- **Quality model (all-mpnet-base-v2)**: 768 dimensions - better semantic understanding\n", + "\n", + "### Practical Applications\n", + "\n", + "Different models work better for different tasks:\n", + "\n", + "1. **Similarity Search**: Use `all-MiniLM-L6-v2` for fast similarity search\n", + "2. **Semantic Analysis**: Use `all-mpnet-base-v2` for deeper semantic understanding\n", + "3. **Paraphrase Detection**: Use `paraphrase-MiniLM-L6-v2` for finding similar content\n", + "\n", + "Let's see how these embeddings can be used for similarity analysis:" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "collapsed": false, + "execution": { + "iopub.execute_input": "2026-07-03T20:52:53.362252Z", + "iopub.status.busy": "2026-07-03T20:52:53.362157Z", + "iopub.status.idle": "2026-07-03T20:52:55.838952Z", + "shell.execute_reply": "2026-07-03T20:52:55.838427Z" + }, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + "Loading weights: 0%| | 0/103 [00:00 24 rows x 1220 features\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Count -> LDA topics (minipedia) -> 24 rows x 50 features\n", + "loading corpus: sotus...done!" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Count -> LDA topics (sotus) -> 24 rows x 50 features\n", + "Tfidf -> TruncatedSVD (sotus) -> 24 rows x 29 features\n" + ] + } + ], + "source": [ + "# The same text, embedded with different sklearn pipelines trained on different corpora\n", + "sklearn_examples = {\n", + " 'CountVectorizer (minipedia)': {'model': 'CountVectorizer', 'corpus': 'minipedia'},\n", + " 'Count -> LDA topics (minipedia)': {'model': ['CountVectorizer', 'LatentDirichletAllocation'], 'corpus': 'minipedia'},\n", + " 'Count -> LDA topics (sotus)': {'model': ['CountVectorizer', 'LatentDirichletAllocation'], 'corpus': 'sotus'},\n", + " 'Tfidf -> TruncatedSVD (sotus)': {'model': ['TfidfVectorizer', 'TruncatedSVD'], 'corpus': 'sotus'},\n", + "}\n", + "\n", + "for name, kw in sklearn_examples.items():\n", + " embedded = dw.wrangle(lines, text_kwargs=kw)\n", + " print(f'{name:34s} -> {embedded.shape[0]} rows x {embedded.shape[1]} features')" + ] + }, + { + "cell_type": "markdown", "metadata": {}, - "outputs": [], - "execution_count": null + "source": [ + "## Vectorization vs. embedding\n", + "\n", + "There are two fundamentally different ways `data-wrangler` turns text into numbers:\n", + "\n", + "- **Vectorization** (scikit-learn, e.g. `CountVectorizer`): the model is *trained on your corpus* to build a\n", + " vocabulary, then each document becomes a **sparse** vector of word counts (or TF-IDF weights). The number\n", + " of columns equals the vocabulary size, and the values are interpretable (counts of specific words).\n", + "- **Embedding with an already-trained model** (sentence-transformers, e.g. `all-MiniLM-L6-v2`): the model is\n", + " **pre-trained** on massive external data, so it needs *no* corpus. Each document becomes a compact,\n", + " **dense** vector that captures *meaning*, so semantically similar sentences land near each other." + ] }, { "cell_type": "code", + "execution_count": 22, "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" + "execution": { + "iopub.execute_input": "2026-07-03T20:53:24.476488Z", + "iopub.status.busy": "2026-07-03T20:53:24.476398Z", + "iopub.status.idle": "2026-07-03T20:53:34.102994Z", + "shell.execute_reply": "2026-07-03T20:53:34.102442Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + "Loading weights: 0%| | 0/103 [00:00 1220 columns (vocabulary), mostly zeros\n", + "Sentence embedding -> 384 dense columns (meaning)\n", + "\n", + "Semantic similarity (the two dog sentences should be far more similar than dog vs. stocks):\n", + " dog / puppy similarity: 0.641\n", + " dog / stocks similarity: 0.022\n" + ] + } + ], + "source": [ + "sample = ['I love my dog', 'My puppy is adorable', 'The stock market fell today']\n", + "\n", + "# Vectorization: CountVectorizer trained on a corpus -> sparse word counts\n", + "counts = dw.wrangle(sample, text_kwargs={'model': 'CountVectorizer', 'corpus': 'minipedia'})\n", + "\n", + "# Embedding: a pre-trained sentence-transformer applied directly (no corpus needed)\n", + "embeddings = dw.wrangle(sample, text_kwargs={'model': 'all-MiniLM-L6-v2'})\n", + "\n", + "from sklearn.metrics.pairwise import cosine_similarity\n", + "print(f'CountVectorizer -> {counts.shape[1]} columns (vocabulary), mostly zeros')\n", + "print(f'Sentence embedding -> {embeddings.shape[1]} dense columns (meaning)')\n", + "print()\n", + "print('Semantic similarity (the two dog sentences should be far more similar than dog vs. stocks):')\n", + "sim = cosine_similarity(embeddings)\n", + "print(f' dog / puppy similarity: {sim[0, 1]:.3f}')\n", + "print(f' dog / stocks similarity: {sim[0, 2]:.3f}')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Training on a Hugging-Face corpus\n", + "\n", + "Beyond the built-in corpora, `corpus` accepts any Hugging-Face dataset, referenced by its full\n", + "`namespace/name` id (bare legacy names are rejected by `datasets` >= 4). Use the `config` keyword to pick a\n", + "dataset variant. Here we train a topic model on the Children's Book Test corpus (`'cam-cst/cbt'`, config\n", + "`'raw'`):" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-03T20:53:34.104426Z", + "iopub.status.busy": "2026-07-03T20:53:34.104315Z", + "iopub.status.idle": "2026-07-03T20:53:39.000615Z", + "shell.execute_reply": "2026-07-03T20:53:39.000042Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Topic embedding trained on cam-cst/cbt: 24 rows x 50 topics\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
0123456789...40414243444546474849
00.0100000.0100000.0100000.0100000.0100000.0100000.0100000.0100000.0100000.010000...0.0100000.0100000.0100000.5100000.0100000.0100000.0100000.0100000.0100000.010000
10.0200000.0200000.0200000.0200000.0200000.0200000.0200000.0200000.0200000.020000...0.0200000.0200000.0200000.0200000.0200000.0200000.0200000.0200000.0200000.020000
20.0200000.0200000.0200000.0200000.0200000.0200000.0200000.0200000.0200000.020000...0.0200000.0200000.0200000.0200000.0200000.0200000.0200000.0200000.0200000.020000
30.0066670.0066670.0066670.0066670.0066670.0066670.0066670.0066670.0066670.006667...0.0066670.0066670.0066670.0066670.0066670.0066670.0066670.0066670.0066670.006667
40.0100000.0100000.0100000.0100000.0100000.0100000.0100000.0100000.0100000.510000...0.0100000.0100000.0100000.0100000.0100000.0100000.0100000.0100000.0100000.010000
\n", + "

5 rows × 50 columns

\n", + "
" + ], + "text/plain": [ + " 0 1 2 3 4 5 6 \\\n", + "0 0.010000 0.010000 0.010000 0.010000 0.010000 0.010000 0.010000 \n", + "1 0.020000 0.020000 0.020000 0.020000 0.020000 0.020000 0.020000 \n", + "2 0.020000 0.020000 0.020000 0.020000 0.020000 0.020000 0.020000 \n", + "3 0.006667 0.006667 0.006667 0.006667 0.006667 0.006667 0.006667 \n", + "4 0.010000 0.010000 0.010000 0.010000 0.010000 0.010000 0.010000 \n", + "\n", + " 7 8 9 ... 40 41 42 43 \\\n", + "0 0.010000 0.010000 0.010000 ... 0.010000 0.010000 0.010000 0.510000 \n", + "1 0.020000 0.020000 0.020000 ... 0.020000 0.020000 0.020000 0.020000 \n", + "2 0.020000 0.020000 0.020000 ... 0.020000 0.020000 0.020000 0.020000 \n", + "3 0.006667 0.006667 0.006667 ... 0.006667 0.006667 0.006667 0.006667 \n", + "4 0.010000 0.010000 0.510000 ... 0.010000 0.010000 0.010000 0.010000 \n", + "\n", + " 44 45 46 47 48 49 \n", + "0 0.010000 0.010000 0.010000 0.010000 0.010000 0.010000 \n", + "1 0.020000 0.020000 0.020000 0.020000 0.020000 0.020000 \n", + "2 0.020000 0.020000 0.020000 0.020000 0.020000 0.020000 \n", + "3 0.006667 0.006667 0.006667 0.006667 0.006667 0.006667 \n", + "4 0.010000 0.010000 0.010000 0.010000 0.010000 0.010000 \n", + "\n", + "[5 rows x 50 columns]" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" } - }, - "outputs": [], - "source": "# Fast model - good for quick prototyping\n# Using simplified API - just pass the model name as a string!\nfast_embeddings = dw.wrangle(lines, text_kwargs={'model': 'all-MiniLM-L6-v2'})\n\nprint(f\"Fast model embeddings shape: {fast_embeddings.shape}\")\nprint(f\"Fast model (first few dimensions):\")\nfast_embeddings.iloc[:3, :5]", - "execution_count": null + ], + "source": [ + "cbt_topics = dw.wrangle(lines, text_kwargs={'model': ['CountVectorizer', 'LatentDirichletAllocation'],\n", + " 'corpus': 'cam-cst/cbt', 'config': 'raw'})\n", + "print(f'Topic embedding trained on cam-cst/cbt: {cbt_topics.shape[0]} rows x {cbt_topics.shape[1]} topics')\n", + "cbt_topics.head()" + ] }, { "cell_type": "markdown", @@ -1793,9 +2812,15 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 24, "metadata": { "collapsed": false, + "execution": { + "iopub.execute_input": "2026-07-03T20:53:39.001954Z", + "iopub.status.busy": "2026-07-03T20:53:39.001836Z", + "iopub.status.idle": "2026-07-03T20:53:39.680385Z", + "shell.execute_reply": "2026-07-03T20:53:39.679947Z" + }, "pycharm": { "name": "#%%\n" } @@ -1803,14 +2828,12 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -1837,9 +2860,15 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 25, "metadata": { "collapsed": false, + "execution": { + "iopub.execute_input": "2026-07-03T20:53:39.681955Z", + "iopub.status.busy": "2026-07-03T20:53:39.681852Z", + "iopub.status.idle": "2026-07-03T20:53:39.769515Z", + "shell.execute_reply": "2026-07-03T20:53:39.769000Z" + }, "pycharm": { "name": "#%%\n" } @@ -1876,21 +2905,40 @@ }, { "cell_type": "code", + "execution_count": 26, "metadata": { "collapsed": false, + "execution": { + "iopub.execute_input": "2026-07-03T20:53:39.770793Z", + "iopub.status.busy": "2026-07-03T20:53:39.770701Z", + "iopub.status.idle": "2026-07-03T20:53:39.772882Z", + "shell.execute_reply": "2026-07-03T20:53:39.772403Z" + }, "pycharm": { "name": "#%%\n" } }, "outputs": [], - "source": "# Using simplified API - just pass the model name as a string\\!\ntext_kwargs = {'model': 'all-MiniLM-L6-v2'}\n\ni = 10\nfirst_lines = lines[:i]\nlast_lines = lines[i:]", - "execution_count": 37 + "source": [ + "# Using simplified API - just pass the model name as a string\\!\n", + "text_kwargs = {'model': 'all-MiniLM-L6-v2'}\n", + "\n", + "i = 10\n", + "first_lines = lines[:i]\n", + "last_lines = lines[i:]" + ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 27, "metadata": { "collapsed": false, + "execution": { + "iopub.execute_input": "2026-07-03T20:53:39.774122Z", + "iopub.status.busy": "2026-07-03T20:53:39.774021Z", + "iopub.status.idle": "2026-07-03T20:53:44.378647Z", + "shell.execute_reply": "2026-07-03T20:53:44.378171Z" + }, "pycharm": { "name": "#%%\n" } @@ -1900,12 +2948,46 @@ "name": "stderr", "output_type": "stream", "text": [ - "Some weights of the model checkpoint at bert-base-uncased were not used when initializing BertModel: ['cls.seq_relationship.bias', 'cls.predictions.bias', 'cls.seq_relationship.weight', 'cls.predictions.transform.dense.weight', 'cls.predictions.transform.dense.bias', 'cls.predictions.decoder.weight', 'cls.predictions.transform.LayerNorm.bias', 'cls.predictions.transform.LayerNorm.weight']\n", - "- This IS expected if you are initializing BertModel from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n", - "- This IS NOT expected if you are initializing BertModel from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n", - "Some weights of the model checkpoint at bert-base-uncased were not used when initializing BertModel: ['cls.seq_relationship.bias', 'cls.predictions.bias', 'cls.seq_relationship.weight', 'cls.predictions.transform.dense.weight', 'cls.predictions.transform.dense.bias', 'cls.predictions.decoder.weight', 'cls.predictions.transform.LayerNorm.bias', 'cls.predictions.transform.LayerNorm.weight']\n", - "- This IS expected if you are initializing BertModel from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n", - "- This IS NOT expected if you are initializing BertModel from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n" + "\r", + "Loading weights: 0%| | 0/103 [00:00" + "" ] }, - "execution_count": 22, + "execution_count": 29, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -2017,15 +3109,36 @@ }, { "cell_type": "code", + "execution_count": 30, "metadata": { "collapsed": false, + "execution": { + "iopub.execute_input": "2026-07-03T20:53:44.994357Z", + "iopub.status.busy": "2026-07-03T20:53:44.994259Z", + "iopub.status.idle": "2026-07-03T20:53:44.997166Z", + "shell.execute_reply": "2026-07-03T20:53:44.996570Z" + }, "pycharm": { "name": "#%%\n" } }, - "outputs": [], - "source": "# compare the first lines' embeddings:\nmatch(sentence_embeddings.iloc[:i], wrangled_data[3], 'first lines\\'s sentence-transformers embedding')\n\n# compare the last lines' embeddings\nmatch(sentence_embeddings.iloc[i:], wrangled_data[4], 'last lines\\'s sentence-transformers embedding')", - "execution_count": 44 + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "First lines's sentence-transformers embeddings match!\n", + "Last lines's sentence-transformers embeddings match!\n" + ] + } + ], + "source": [ + "# compare the first lines' embeddings:\n", + "match(sentence_embeddings.iloc[:i], wrangled_data[3], 'first lines\\'s sentence-transformers embedding')\n", + "\n", + "# compare the last lines' embeddings\n", + "match(sentence_embeddings.iloc[i:], wrangled_data[4], 'last lines\\'s sentence-transformers embedding')" + ] }, { "cell_type": "markdown", @@ -2041,89 +3154,402 @@ }, { "cell_type": "code", - "source": "# Wrangle data using Polars backend for high performance\nimport polars as pl\n\n# Convert array to Polars DataFrame\npolars_df = dw.wrangle(array, backend='polars')\nprint(f\"Polars DataFrame type: {type(polars_df)}\")\nprint(f\"Shape: {polars_df.shape}\")\npolars_df.head()", - "metadata": {}, - "outputs": [], - "execution_count": null + "execution_count": 31, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-03T20:53:44.998444Z", + "iopub.status.busy": "2026-07-03T20:53:44.998348Z", + "iopub.status.idle": "2026-07-03T20:53:45.004966Z", + "shell.execute_reply": "2026-07-03T20:53:45.004563Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Polars DataFrame type: \n", + "Shape: (7, 5)\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "shape: (5, 5)
01234
i64i64i64i64i64
12345
246810
3691215
48121620
510152025
" + ], + "text/plain": [ + "shape: (5, 5)\n", + "┌─────┬─────┬─────┬─────┬─────┐\n", + "│ 0 ┆ 1 ┆ 2 ┆ 3 ┆ 4 │\n", + "│ --- ┆ --- ┆ --- ┆ --- ┆ --- │\n", + "│ i64 ┆ i64 ┆ i64 ┆ i64 ┆ i64 │\n", + "╞═════╪═════╪═════╪═════╪═════╡\n", + "│ 1 ┆ 2 ┆ 3 ┆ 4 ┆ 5 │\n", + "│ 2 ┆ 4 ┆ 6 ┆ 8 ┆ 10 │\n", + "│ 3 ┆ 6 ┆ 9 ┆ 12 ┆ 15 │\n", + "│ 4 ┆ 8 ┆ 12 ┆ 16 ┆ 20 │\n", + "│ 5 ┆ 10 ┆ 15 ┆ 20 ┆ 25 │\n", + "└─────┴─────┴─────┴─────┴─────┘" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Wrangle data using Polars backend for high performance\n", + "import polars as pl\n", + "\n", + "# Convert array to Polars DataFrame\n", + "polars_df = dw.wrangle(array, backend='polars')\n", + "print(f\"Polars DataFrame type: {type(polars_df)}\")\n", + "print(f\"Shape: {polars_df.shape}\")\n", + "polars_df.head()" + ] }, { "cell_type": "markdown", - "source": "### Cross-Backend Conversion\n\nYou can convert between pandas and Polars DataFrames seamlessly:", - "metadata": {} + "metadata": {}, + "source": [ + "## Cross-Backend Conversion\n", + "\n", + "You can convert between pandas and Polars DataFrames seamlessly:" + ] }, { "cell_type": "code", - "source": "# Convert pandas DataFrame to Polars\npandas_df = wrangled_df # Our original pandas DataFrame\npolars_from_pandas = dw.wrangle(pandas_df, backend='polars')\n\nprint(f\"Original: {type(pandas_df)}\")\nprint(f\"Converted to Polars: {type(polars_from_pandas)}\")\n\n# Convert Polars DataFrame back to pandas\npandas_from_polars = dw.wrangle(polars_from_pandas, backend='pandas')\nprint(f\"Converted back to pandas: {type(pandas_from_polars)}\")\n\n# Verify data is preserved\nimport numpy as np\nprint(f\"Data preserved: {np.allclose(pandas_df.values, pandas_from_polars.values)}\")", - "metadata": {}, - "outputs": [], - "execution_count": null + "execution_count": 32, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-03T20:53:45.006199Z", + "iopub.status.busy": "2026-07-03T20:53:45.006119Z", + "iopub.status.idle": "2026-07-03T20:53:45.011826Z", + "shell.execute_reply": "2026-07-03T20:53:45.011327Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Original: \n", + "Converted to Polars: \n", + "Converted back to pandas: \n", + "Data preserved: True\n" + ] + } + ], + "source": [ + "# Convert pandas DataFrame to Polars\n", + "pandas_df = wrangled_df # Our original pandas DataFrame\n", + "polars_from_pandas = dw.wrangle(pandas_df, backend='polars')\n", + "\n", + "print(f\"Original: {type(pandas_df)}\")\n", + "print(f\"Converted to Polars: {type(polars_from_pandas)}\")\n", + "\n", + "# Convert Polars DataFrame back to pandas\n", + "pandas_from_polars = dw.wrangle(polars_from_pandas, backend='pandas')\n", + "print(f\"Converted back to pandas: {type(pandas_from_polars)}\")\n", + "\n", + "# Verify data is preserved\n", + "import numpy as np\n", + "print(f\"Data preserved: {np.allclose(pandas_df.values, pandas_from_polars.values)}\")" + ] }, { "cell_type": "markdown", - "source": "### Global Backend Configuration\n\nYou can set a global preference for DataFrame backend:", - "metadata": {} + "metadata": {}, + "source": [ + "## Global Backend Configuration\n", + "\n", + "You can set a global preference for DataFrame backend:" + ] }, { "cell_type": "code", - "source": "# Configure global backend preference\nfrom datawrangler.core.configurator import set_dataframe_backend, get_dataframe_backend\n\n# Check current default\nprint(f\"Current default backend: {get_dataframe_backend()}\")\n\n# Set global preference to Polars\nset_dataframe_backend('polars')\nprint(f\"New default backend: {get_dataframe_backend()}\")\n\n# Now all operations use Polars by default\nglobal_polars_df = dw.wrangle(array) # No need to specify backend='polars'\nprint(f\"Global setting result: {type(global_polars_df)}\")\n\n# Reset to pandas for rest of tutorial\nset_dataframe_backend('pandas')\nprint(f\"Reset to: {get_dataframe_backend()}\")", - "metadata": {}, - "outputs": [], - "execution_count": null + "execution_count": 33, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-03T20:53:45.013139Z", + "iopub.status.busy": "2026-07-03T20:53:45.013057Z", + "iopub.status.idle": "2026-07-03T20:53:45.015785Z", + "shell.execute_reply": "2026-07-03T20:53:45.015291Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Current default backend: pandas\n", + "New default backend: polars\n", + "Global setting result: \n", + "Reset to: pandas\n" + ] + } + ], + "source": [ + "# Configure global backend preference\n", + "from datawrangler.core.configurator import set_dataframe_backend, get_dataframe_backend\n", + "\n", + "# Check current default\n", + "print(f\"Current default backend: {get_dataframe_backend()}\")\n", + "\n", + "# Set global preference to Polars\n", + "set_dataframe_backend('polars')\n", + "print(f\"New default backend: {get_dataframe_backend()}\")\n", + "\n", + "# Now all operations use Polars by default\n", + "global_polars_df = dw.wrangle(array) # No need to specify backend='polars'\n", + "print(f\"Global setting result: {type(global_polars_df)}\")\n", + "\n", + "# Reset to pandas for rest of tutorial\n", + "set_dataframe_backend('pandas')\n", + "print(f\"Reset to: {get_dataframe_backend()}\")" + ] }, { "cell_type": "markdown", - "source": "### Text Processing with Polars\n\nText processing also supports the Polars backend for high-performance embeddings:", - "metadata": {} + "metadata": {}, + "source": [ + "## Text Processing with Polars\n", + "\n", + "Text processing also supports the Polars backend for high-performance embeddings:" + ] }, { "cell_type": "code", - "source": "# Text embeddings with Polars backend for better performance\nsample_texts = [\"Machine learning is fascinating\", \n \"Data science combines statistics and programming\",\n \"Polars is a fast DataFrame library\"]\n\n# Process text with Polars backend\npolars_text_df = dw.wrangle(sample_texts, backend='polars')\nprint(f\"Text embeddings with Polars: {type(polars_text_df)}\")\nprint(f\"Shape: {polars_text_df.shape}\")\n\n# Compare with pandas backend\npandas_text_df = dw.wrangle(sample_texts, backend='pandas')\nprint(f\"Text embeddings with pandas: {type(pandas_text_df)}\")\nprint(f\"Shape: {pandas_text_df.shape}\")\n\n# Both should have the same shape\nprint(f\"Same embedding dimensions: {polars_text_df.shape == pandas_text_df.shape}\")", - "metadata": {}, - "outputs": [], - "execution_count": null + "execution_count": 34, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-03T20:53:45.017049Z", + "iopub.status.busy": "2026-07-03T20:53:45.016959Z", + "iopub.status.idle": "2026-07-03T20:54:27.241428Z", + "shell.execute_reply": "2026-07-03T20:54:27.240894Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Text embeddings with Polars: \n", + "Shape: (3, 50)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Text embeddings with pandas: \n", + "Shape: (3, 50)\n", + "Same embedding dimensions: True\n" + ] + } + ], + "source": [ + "# Text embeddings with Polars backend for better performance\n", + "sample_texts = [\"Machine learning is fascinating\", \n", + " \"Data science combines statistics and programming\",\n", + " \"Polars is a fast DataFrame library\"]\n", + "\n", + "# Process text with Polars backend\n", + "polars_text_df = dw.wrangle(sample_texts, backend='polars')\n", + "print(f\"Text embeddings with Polars: {type(polars_text_df)}\")\n", + "print(f\"Shape: {polars_text_df.shape}\")\n", + "\n", + "# Compare with pandas backend\n", + "pandas_text_df = dw.wrangle(sample_texts, backend='pandas')\n", + "print(f\"Text embeddings with pandas: {type(pandas_text_df)}\")\n", + "print(f\"Shape: {pandas_text_df.shape}\")\n", + "\n", + "# Both should have the same shape\n", + "print(f\"Same embedding dimensions: {polars_text_df.shape == pandas_text_df.shape}\")" + ] }, { "cell_type": "markdown", - "source": "### Performance Benefits\n\nPolars offers significant performance advantages, especially for:\n\n- **Large datasets**: 2-10x faster operations on datasets with millions of rows\n- **Aggregations**: Group-by operations and statistical computations\n- **Memory efficiency**: Lower memory usage with columnar data format\n- **Parallel processing**: Built-in parallelization for multi-core systems\n\nThe choice between pandas and Polars depends on your specific needs:\n\n- **Use pandas** for: Familiarity, ecosystem compatibility, complex transformations\n- **Use Polars** for: Performance, large datasets, memory efficiency, parallel processing\n\n### Automatic Type Preservation\n\n`data-wrangler` automatically preserves your DataFrame type when no backend is specified:", - "metadata": {} + "metadata": {}, + "source": [ + "## Performance Benefits\n", + "\n", + "Polars offers significant performance advantages, especially for:\n", + "\n", + "- **Large datasets**: 2-10x faster operations on datasets with millions of rows\n", + "- **Aggregations**: Group-by operations and statistical computations\n", + "- **Memory efficiency**: Lower memory usage with columnar data format\n", + "- **Parallel processing**: Built-in parallelization for multi-core systems\n", + "\n", + "The choice between pandas and Polars depends on your specific needs:\n", + "\n", + "- **Use pandas** for: Familiarity, ecosystem compatibility, complex transformations\n", + "- **Use Polars** for: Performance, large datasets, memory efficiency, parallel processing\n", + "\n", + "## Automatic Type Preservation\n", + "\n", + "`data-wrangler` automatically preserves your DataFrame type when no backend is specified:" + ] }, { "cell_type": "markdown", - "source": "### Performance Benchmark Example\n\nHere's a practical example showing the performance difference between pandas and Polars for array conversion:", - "metadata": {} + "metadata": {}, + "source": [ + "## Performance Benchmark Example\n", + "\n", + "Here's a practical example showing the performance difference between pandas and Polars for array conversion:" + ] }, { "cell_type": "code", - "source": "# Demonstrate automatic type preservation\nimport pandas as pd\nimport polars as pl\n\n# Create DataFrames of each type\npandas_input = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})\npolars_input = pl.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})\n\n# Wrangle without specifying backend - type is preserved\npandas_output = dw.wrangle(pandas_input)\npolars_output = dw.wrangle(polars_input)\n\nprint(f\"Pandas input: {type(pandas_input)} -> Output: {type(pandas_output)}\")\nprint(f\"Polars input: {type(polars_input)} -> Output: {type(polars_output)}\")\nprint(\"\u2705 Types automatically preserved!\")", - "metadata": {}, - "outputs": [], - "execution_count": null + "execution_count": 35, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-03T20:54:27.243006Z", + "iopub.status.busy": "2026-07-03T20:54:27.242882Z", + "iopub.status.idle": "2026-07-03T20:54:27.247233Z", + "shell.execute_reply": "2026-07-03T20:54:27.246902Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pandas input: -> Output: \n", + "Polars input: -> Output: \n", + "✅ Types automatically preserved!\n" + ] + } + ], + "source": [ + "# Demonstrate automatic type preservation\n", + "import pandas as pd\n", + "import polars as pl\n", + "\n", + "# Create DataFrames of each type\n", + "pandas_input = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})\n", + "polars_input = pl.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})\n", + "\n", + "# Wrangle without specifying backend - type is preserved\n", + "pandas_output = dw.wrangle(pandas_input)\n", + "polars_output = dw.wrangle(polars_input)\n", + "\n", + "print(f\"Pandas input: {type(pandas_input)} -> Output: {type(pandas_output)}\")\n", + "print(f\"Polars input: {type(polars_input)} -> Output: {type(polars_output)}\")\n", + "print(\"✅ Types automatically preserved!\")" + ] }, { "cell_type": "code", - "source": "import time\nimport numpy as np\n\n# Create a moderately sized array for benchmarking\nlarge_array = np.random.rand(10000, 50)\nprint(f\"Array shape: {large_array.shape}\")\n\n# Benchmark pandas backend\nstart_time = time.time()\npandas_result = dw.wrangle(large_array, backend='pandas')\npandas_time = time.time() - start_time\n\n# Benchmark Polars backend\nstart_time = time.time()\npolars_result = dw.wrangle(large_array, backend='polars')\npolars_time = time.time() - start_time\n\nprint(f\"\\n\ud83d\udcca Performance Comparison:\")\nprint(f\"Pandas backend: {pandas_time:.4f} seconds\")\nprint(f\"Polars backend: {polars_time:.4f} seconds\")\nprint(f\"Speedup: {pandas_time/polars_time:.1f}x faster with Polars\")\n\n# Verify results are equivalent\nprint(f\"\\n\u2705 Results equivalent: {np.allclose(pandas_result.values, polars_result.to_pandas().values)}\")", - "metadata": {}, - "outputs": [], - "execution_count": null + "execution_count": 36, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-03T20:54:27.248559Z", + "iopub.status.busy": "2026-07-03T20:54:27.248475Z", + "iopub.status.idle": "2026-07-03T20:54:27.257243Z", + "shell.execute_reply": "2026-07-03T20:54:27.256890Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Array shape: (10000, 50)\n", + "\n", + "📊 Performance Comparison:\n", + "Pandas backend: 0.0003 seconds\n", + "Polars backend: 0.0009 seconds\n", + "Speedup: 0.4x faster with Polars\n", + "\n", + "✅ Results equivalent: True\n" + ] + } + ], + "source": [ + "import time\n", + "import numpy as np\n", + "\n", + "# Create a moderately sized array for benchmarking\n", + "large_array = np.random.rand(10000, 50)\n", + "print(f\"Array shape: {large_array.shape}\")\n", + "\n", + "# Benchmark pandas backend\n", + "start_time = time.time()\n", + "pandas_result = dw.wrangle(large_array, backend='pandas')\n", + "pandas_time = time.time() - start_time\n", + "\n", + "# Benchmark Polars backend\n", + "start_time = time.time()\n", + "polars_result = dw.wrangle(large_array, backend='polars')\n", + "polars_time = time.time() - start_time\n", + "\n", + "print(f\"\\n📊 Performance Comparison:\")\n", + "print(f\"Pandas backend: {pandas_time:.4f} seconds\")\n", + "print(f\"Polars backend: {polars_time:.4f} seconds\")\n", + "print(f\"Speedup: {pandas_time/polars_time:.1f}x faster with Polars\")\n", + "\n", + "# Verify results are equivalent\n", + "print(f\"\\n✅ Results equivalent: {np.allclose(pandas_result.values, polars_result.to_pandas().values)}\")" + ] }, { "cell_type": "markdown", - "source": "## Summary: Choosing the Right Backend\n\n`data-wrangler` now provides flexible DataFrame backend support:\n\n| Feature | pandas | Polars |\n|---------|--------|--------|\n| **Performance** | Standard | 2-100x faster |\n| **Memory Usage** | Higher | Lower (columnar) |\n| **Ecosystem** | Mature, extensive | Growing rapidly |\n| **Learning Curve** | Familiar to most | Similar API |\n| **Best For** | General use, prototyping | Large data, production |\n\n### Quick Start Guide\n\n```python\n# Basic usage - specify backend per operation\nimport datawrangler as dw\n\n# Use pandas (default)\ndf_pandas = dw.wrangle(data)\n\n# Use Polars for performance \ndf_polars = dw.wrangle(data, backend='polars')\n\n# Set global preference\nfrom datawrangler.core.configurator import set_dataframe_backend\nset_dataframe_backend('polars') # All operations use Polars\n```\n\nBoth backends support all `data-wrangler` functionality including text processing, array conversion, and complex data wrangling pipelines. Choose the backend that best fits your performance requirements and workflow preferences!", - "metadata": {} + "metadata": {}, + "source": [ + "## Summary: Choosing the Right Backend\n", + "\n", + "`data-wrangler` now provides flexible DataFrame backend support:\n", + "\n", + "| Feature | pandas | Polars |\n", + "|---------|--------|--------|\n", + "| **Performance** | Standard | 2-100x faster |\n", + "| **Memory Usage** | Higher | Lower (columnar) |\n", + "| **Ecosystem** | Mature, extensive | Growing rapidly |\n", + "| **Learning Curve** | Familiar to most | Similar API |\n", + "| **Best For** | General use, prototyping | Large data, production |\n", + "\n", + "### Quick Start Guide\n", + "\n", + "```python\n", + "# Basic usage - specify backend per operation\n", + "import datawrangler as dw\n", + "\n", + "# Use pandas (default)\n", + "df_pandas = dw.wrangle(data)\n", + "\n", + "# Use Polars for performance \n", + "df_polars = dw.wrangle(data, backend='polars')\n", + "\n", + "# Set global preference\n", + "from datawrangler.core.configurator import set_dataframe_backend\n", + "set_dataframe_backend('polars') # All operations use Polars\n", + "```\n", + "\n", + "Both backends support all `data-wrangler` functionality including text processing, array conversion, and complex data wrangling pipelines. Choose the backend that best fits your performance requirements and workflow preferences!" + ] } ], "metadata": { "language_info": { "codemirror_mode": { "name": "ipython", - "version": 2 + "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "3.8.10" + "pygments_lexer": "ipython3", + "version": "3.10.12" }, "vscode": { "interpreter": { @@ -2133,4 +3559,4 @@ }, "nbformat": 4, "nbformat_minor": 0 -} \ No newline at end of file +} diff --git a/requirements.txt b/requirements.txt index cb37997..2e55ab5 100644 --- a/requirements.txt +++ b/requirements.txt @@ -2,6 +2,7 @@ scikit-learn importlib-metadata pandas polars>=0.20.0 +pyarrow # required by polars <-> pandas conversion (DataFrame.to_pandas / pl.from_pandas) scipy numpy requests diff --git a/scripts/make_demo_gif.py b/scripts/make_demo_gif.py new file mode 100644 index 0000000..f13c7c7 --- /dev/null +++ b/scripts/make_demo_gif.py @@ -0,0 +1,292 @@ +#!/usr/bin/env python +"""Generate an animated, terminal-style GIF demoing data-wrangler. + +This script actually *runs* real ``datawrangler`` calls (no faked or +hand-typed outputs) and renders the typed commands plus their real +results as a dark, monospace, terminal-style animation using Pillow. + +The resulting GIF is meant to live at ``docs/images/demo.gif`` and be +embedded near the top of ``README.rst`` -- suitable for the README and +for sharing on social media. + +Usage:: + + python scripts/make_demo_gif.py +""" +import os +import time + +import numpy as np +import pandas as pd +from PIL import Image, ImageDraw, ImageFont + +import datawrangler as dw + +# --------------------------------------------------------------------------- +# Layout / style constants +# --------------------------------------------------------------------------- +WIDTH = 900 +HEIGHT = 560 +TITLEBAR_HEIGHT = 36 +PADDING = 16 +FONT_SIZE = 15 +LINE_HEIGHT = 21 +MAX_VISIBLE_LINES = (HEIGHT - TITLEBAR_HEIGHT - 2 * PADDING) // LINE_HEIGHT + +BG_COLOR = (30, 30, 36) +TITLEBAR_COLOR = (48, 48, 56) +TITLE_TEXT_COLOR = (170, 170, 180) +PROMPT_COLOR = (98, 222, 137) +TEXT_COLOR = (225, 225, 230) +OUTPUT_COLOR = (150, 200, 255) +CURSOR_COLOR = PROMPT_COLOR +DOT_RED = (255, 95, 86) +DOT_YELLOW = (255, 189, 46) +DOT_GREEN = (39, 201, 63) + +TYPE_MS = 35 +PAUSE_MS = 350 +REVEAL_MS = 350 +HOLD_MS = 2200 +INTRO_MS = 900 +OUTRO_MS = 2500 + +OUTPUT_PATH = os.path.join( + os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "docs", "images", "demo.gif" +) + + +def find_monospace_font(size): + """Locate a monospace TTF, falling back to Pillow's default font.""" + candidates = [ + "/System/Library/Fonts/Menlo.ttc", + "/System/Library/Fonts/Supplemental/Menlo.ttc", + "/Library/Fonts/Menlo.ttc", + "/System/Library/Fonts/Courier New.ttf", + "/usr/share/fonts/truetype/dejavu/DejaVuSansMono.ttf", + "/usr/share/fonts/truetype/liberation/LiberationMono-Regular.ttf", + ] + for path in candidates: + if os.path.exists(path): + try: + return ImageFont.truetype(path, size) + except OSError: + continue + return ImageFont.load_default() + + +def run_demos(): + """Actually execute real datawrangler calls and capture their real results. + + Every number/shape shown in the GIF is measured live here -- nothing is faked. + """ + from sklearn.metrics.pairwise import cosine_similarity + + demos = [] + + # 1. Large data: wrangle 60 million values, then a real pandas-vs-Polars sort race. + big = np.random.rand(20_000_000, 3) + pdf = dw.wrangle(big) # pandas DataFrame + pldf = dw.wrangle(big, backend="polars") # Polars DataFrame + t0 = time.time() + pdf.sort_values(0) # pandas sort of 20M rows + pandas_ms = (time.time() - t0) * 1000 + t0 = time.time() + pldf.sort("0") # Polars sort of 20M rows + polars_ms = (time.time() - t0) * 1000 + speedup = pandas_ms / max(polars_ms, 1e-6) + demos.append( + { + "command": ( + ">>> big = np.random.rand(20_000_000, 3) # 60 million values\n" + ">>> df = dw.wrangle(big, backend='polars') # -> Polars DataFrame\n" + ">>> df.sort('0') # sort 20M rows" + ), + "output": "pandas: {:.0f} ms polars: {:.0f} ms -> {:.1f}x faster".format( + pandas_ms, polars_ms, speedup + ), + } + ) + + # 2. Real NLP: wrangle raw text into sentence embeddings that capture topic. + news = [ + "stocks rallied on strong quarterly earnings", + "investors cheered better-than-expected profits", + "the chef slowly simmered the tomato sauce", + "a long braise deepens the flavor of the stew", + ] + emb = dw.wrangle(news, text_kwargs={"model": "all-MiniLM-L6-v2"}) + sim = cosine_similarity(emb.values) + demos.append( + { + "command": ( + ">>> news = ['stocks rallied on earnings', 'investors cheered profits',\n" + "... 'the chef simmered the sauce', 'a long braise deepens the stew']\n" + ">>> emb = dw.wrangle(news, text_kwargs={'model': 'all-MiniLM-L6-v2'})\n" + ">>> emb.shape" + ), + "output": ( + "{} # 384-dim sentence embeddings\n" + "cosine similarity -> finance<->finance {:.2f} food<->food {:.2f} " + "finance<->food {:.2f}".format(emb.shape, sim[0, 1], sim[2, 3], sim[0, 2]) + ), + } + ) + + # 3. @funnel: write a function as if the input is a DataFrame -- feed it anything. + @dw.funnel + def zscore(df): + return (df - df.mean()) / df.std() + + z = zscore(np.array([[1, 2], [3, 4], [5, 6]])) # a raw numpy array, not a DataFrame + demos.append( + { + "command": ( + ">>> @dw.funnel\n" + "... def zscore(df):\n" + "... return (df - df.mean()) / df.std()\n" + ">>> zscore(np.array([[1, 2], [3, 4], [5, 6]])) # a raw numpy array" + ), + "output": str(z.round(2)), + } + ) + + # 4. Fill in missing measurements with machine-learning imputation. + raw = pd.DataFrame( + { + "temp": [20.1, 21.3, np.nan, 22.8, 23.1], + "humidity": [45.0, np.nan, 52.0, 55.0, np.nan], + } + ) + + @dw.decorate.interpolate + def clean(x): + return x + + filled = clean(raw, interp_kwargs={"impute_kwargs": {"model": "IterativeImputer"}}) + n_missing = int(raw.isna().sum().sum()) + demos.append( + { + # Only the first line is an f-string; the literal {'impute_kwargs': ...} braces + # below are plain strings, so they don't collide with formatting. + "command": ( + f">>> raw # sensor readings with gaps ({n_missing} missing)\n" + ">>> @dw.decorate.interpolate\n" + "... def clean(x): return x\n" + ">>> clean(raw, interp_kwargs={'impute_kwargs': {'model': 'IterativeImputer'}})" + ), + "output": "{}\n# {} missing values -> 0, filled by IterativeImputer".format( + str(filled.round(1)), n_missing + ), + } + ) + + return demos + + +def draw_terminal_line(draw, font, x, y, text, kind): + """Draw a single terminal line and return the x position after it.""" + prefixes = (">>> ", "... ") + if kind == "prompt" and text[:4] in prefixes: + prefix, rest = text[:4], text[4:] + draw.text((x, y), prefix, font=font, fill=PROMPT_COLOR) + prefix_w = draw.textlength(prefix, font=font) + draw.text((x + prefix_w, y), rest, font=font, fill=TEXT_COLOR) + return x + prefix_w + draw.textlength(rest, font=font) + color = OUTPUT_COLOR if kind == "output" else TEXT_COLOR + draw.text((x, y), text, font=font, fill=color) + return x + draw.textlength(text, font=font) + + +def render_frame(font, title_font, history, current_line=None, cursor=False): + """Render one terminal-window frame from committed history plus an optional in-progress line.""" + img = Image.new("RGB", (WIDTH, HEIGHT), BG_COLOR) + draw = ImageDraw.Draw(img) + + draw.rectangle([0, 0, WIDTH, TITLEBAR_HEIGHT], fill=TITLEBAR_COLOR) + for i, dot_color in enumerate((DOT_RED, DOT_YELLOW, DOT_GREEN)): + cx = 22 + i * 22 + cy = TITLEBAR_HEIGHT // 2 + draw.ellipse([cx - 6, cy - 6, cx + 6, cy + 6], fill=dot_color) + title = "python3 -- data-wrangler demo" + title_w = draw.textlength(title, font=title_font) + draw.text(((WIDTH - title_w) / 2, (TITLEBAR_HEIGHT - FONT_SIZE) / 2), title, font=title_font, fill=TITLE_TEXT_COLOR) + + lines = list(history) + if current_line is not None: + lines.append(current_line) + visible = lines[-MAX_VISIBLE_LINES:] + + y = TITLEBAR_HEIGHT + PADDING + end_x = PADDING + for text, kind in visible: + end_x = draw_terminal_line(draw, font, PADDING, y, text, kind) + y += LINE_HEIGHT + + if cursor and current_line is not None: + cursor_y = y - LINE_HEIGHT + draw.rectangle([end_x + 3, cursor_y + 2, end_x + 11, cursor_y + FONT_SIZE + 2], fill=CURSOR_COLOR) + + return img + + +def build_frames(demos, font, title_font): + frames = [] + durations = [] + history = [] + + def add_frame(current_line=None, cursor=False, duration=TYPE_MS): + frames.append(render_frame(font, title_font, history, current_line, cursor)) + durations.append(duration) + + add_frame(duration=INTRO_MS) + + for demo in demos: + for command_line in demo["command"].split("\n"): + step = max(1, len(command_line) // 10) + for end in range(step, len(command_line), step): + add_frame(current_line=(command_line[:end], "prompt"), cursor=True, duration=TYPE_MS) + add_frame(current_line=(command_line, "prompt"), cursor=True, duration=TYPE_MS) + history.append((command_line, "prompt")) + + add_frame(duration=PAUSE_MS) + + output_lines = demo["output"].split("\n") + for i, output_line in enumerate(output_lines): + history.append((output_line, "output")) + is_last = i == len(output_lines) - 1 + add_frame(duration=HOLD_MS if is_last else REVEAL_MS) + + history.append(("", "output")) + history.append(("# pip install pydata-wrangler", "output")) + add_frame(duration=OUTRO_MS) + + return frames, durations + + +def main(): + demos = run_demos() + + font = find_monospace_font(FONT_SIZE) + title_font = find_monospace_font(FONT_SIZE) + + frames, durations = build_frames(demos, font, title_font) + + palette_frames = [frame.convert("P", palette=Image.ADAPTIVE, colors=96) for frame in frames] + + os.makedirs(os.path.dirname(OUTPUT_PATH), exist_ok=True) + palette_frames[0].save( + OUTPUT_PATH, + save_all=True, + append_images=palette_frames[1:], + duration=durations, + loop=0, + optimize=True, + ) + + size_kb = os.path.getsize(OUTPUT_PATH) / 1024 + print("Wrote {} frames ({:.0f} KB) to {}".format(len(palette_frames), size_kb, OUTPUT_PATH)) + + +if __name__ == "__main__": + main() diff --git a/scripts/verify_functions.py b/scripts/verify_functions.py new file mode 100644 index 0000000..dd6ba4f --- /dev/null +++ b/scripts/verify_functions.py @@ -0,0 +1,146 @@ +"""Comprehensive direct-evidence verification: run every major datawrangler function on real inputs +and print the actual outputs for examination. Run from the repo root.""" +import numpy as np +import pandas as pd +import datawrangler as dw +from datawrangler.io.io import get_local_fname +from sklearn.feature_extraction.text import CountVectorizer + +R = 'tests/resources' +def hdr(s): print("\n" + "=" * 4, s, "=" * 4) + + +print("datawrangler.__version__ =", dw.__version__) + +# ============ ZOO: wrangle every supported datatype ============ +hdr("ZOO / wrangle") +arr = dw.wrangle(np.array([[1, 2, 3], [4, 5, 6]])) +print("array ->", type(arr).__name__, arr.shape, "| values:", arr.values.tolist()) + +df = pd.DataFrame({'a': [1, 2], 'b': [3, 4]}) +print("dataframe ->", type(dw.wrangle(df)).__name__, "| preserved values:", dw.wrangle(df).values.tolist()) + +nul = dw.wrangle(None) +print("null ->", type(nul).__name__, "| empty:", len(nul) == 0) + +polars_df = dw.wrangle(np.arange(6).reshape(3, 2), backend='polars') +print("array (backend=polars) ->", type(polars_df).__name__, polars_df.shape) + +img = dw.io.load(f'{R}/wrangler.jpg') +img_df = dw.wrangle(img) +print("image ->", type(img_df).__name__, img_df.shape, "| pixel mean: %.2f" % img_df.values.mean()) + +# text via sklearn vectorization (CountVectorizer -> LDA) trained on the built-in 'minipedia' corpus +lda = dw.wrangle(['the cat sat on the mat', 'dogs run in the park', 'cats and dogs are pets'], + text_kwargs={'model': ['CountVectorizer', 'LatentDirichletAllocation'], 'corpus': 'minipedia'}) +print("text (sklearn CountVectorizer->LDA) ->", type(lda).__name__, lda.shape) + +# text via sentence-transformers embedding (pre-trained HF model) +emb = dw.wrangle(['hello world', 'data wrangler rocks'], text_kwargs={'model': 'all-MiniLM-L6-v2'}) +print("text (ST embed all-MiniLM-L6-v2) ->", type(emb).__name__, emb.shape, "| mean: %.4f" % emb.values.mean()) + +# mixed list of datatypes, with dtype detection +mixed, dtypes = dw.wrangle([np.array([1, 2, 3]), 'some free text', df], + text_kwargs={'model': 'all-MiniLM-L6-v2'}, return_dtype=True) +print("mixed list -> detected dtypes:", dtypes, "| n results:", len(mixed)) + +# is_ predicates +print("is_array/is_dataframe/is_text/is_null:", + dw.zoo.is_array(np.array([1, 2])), dw.zoo.is_dataframe(df), dw.zoo.is_text('hi'), dw.zoo.is_null([])) + +# text helpers +print("to_str_list:", dw.zoo.to_str_list(['a', 'b'])) +model = dw.zoo.get_text_model('all-MiniLM-L6-v2') +print("get_text_model('all-MiniLM-L6-v2') ->", type(model).__name__ if not isinstance(model, dict) else model) + +# ============ DECORATE ============ +hdr("DECORATE") + + +@dw.funnel +def colmeans(x): + return x.mean(axis=0) + + +print("funnel(np.array) ->", colmeans(np.array([[1, 2], [3, 4]])).values.tolist()) + + +@dw.decorate.list_generalizer +def square(x): + return x ** 2 + + +print("list_generalizer:", square(3), square([2, 3, 4])) + +d1, d2 = df.iloc[:1], df.iloc[1:] +stacked = dw.stack([d1, d2]) +print("stack -> shape", stacked.shape, "| is_multiindex:", dw.zoo.is_multiindex_dataframe(stacked)) +print("unstack -> frame shapes:", [f.shape for f in dw.unstack(stacked)]) + + +@dw.decorate.apply_unstacked +def per_frame_mean(x): + return pd.DataFrame(x.mean(axis=0)).T + + +means = per_frame_mean(stacked) +print("apply_unstacked (per-frame means) -> is_multiindex:", dw.zoo.is_multiindex_dataframe(means)) + +imp = df.copy().astype(float) +imp.loc[0, 'a'] = np.nan + + +@dw.decorate.interpolate +def ident(x): + return x + + +recovered = ident(imp, interp_kwargs={'impute_kwargs': {'model': 'IterativeImputer'}}) +print("interpolate (impute IterativeImputer) -> no NaN:", not recovered.isna().any().any(), + "| values:", recovered.values.round(3).tolist()) + +# ============ IO ============ +hdr("IO") +print("load(csv, index_col=0) ->", dw.io.load(f'{R}/testdata.csv', index_col=0).shape) +print("load(txt) ->", repr(dw.io.load(f'{R}/home_on_the_range.txt')[:40])) +print("load_dataframe(csv) ->", dw.io.load_dataframe(f'{R}/testdata.csv').shape) +# save/load round-trip via the cache +key = 'verify://obj.pkl' +dw.io.save(key, {'x': [1, 2, 3]}, dtype='pickle') +print("save+load(pickle) round-trip ->", dw.io.load(get_local_fname(key), dtype='pickle')) +# remote load +try: + remote = dw.io.load('https://raw.githubusercontent.com/ContextLab/data-wrangler/main/tests/resources/testdata.csv') + print("load(remote URL) ->", type(remote).__name__, remote.shape) +except Exception as e: + print("load(remote URL) -> skipped (network):", e) + +# ============ UTIL ============ +hdr("UTIL") +print("btwn in-range:", dw.util.btwn(np.array([1, 2, 3]), 0, 5), + "| btwn out-of-range:", dw.util.btwn(np.array([1, 9]), 0, 5)) +print("array_like([1,2,3]):", dw.util.array_like([1, 2, 3]), + "| dataframe_like(df):", dw.util.dataframe_like(df)) +print("depth: scalar", dw.util.depth(5), "| [1,2,3]", dw.util.depth([1, 2, 3]), + "| [[1],[2]]", dw.util.depth([[1], [2]])) + +# ============ CORE ============ +hdr("CORE") +opts = dw.core.get_default_options() +print("get_default_options -> has CountVectorizer/text/data:", + all(k in opts for k in ['CountVectorizer', 'text', 'data'])) +cv = dw.core.apply_defaults(CountVectorizer)() +print("apply_defaults(CountVectorizer) -> stop_words:", cv.get_params()['stop_words'], + "| max_df:", cv.get_params()['max_df']) +print("update_dict:", dw.core.update_dict({'a': 1, 'b': 2}, {'b': 9, 'c': 3})) +dw.core.set_dataframe_backend('polars') +print("set/get_dataframe_backend -> ", dw.core.get_dataframe_backend()) +dw.core.reset_dataframe_backend() +print("reset_dataframe_backend -> ", dw.core.get_dataframe_backend()) + +# built-in corpus retrieval (small, cached) +hdr("CORPUS") +sotus = dw.zoo.text.get_corpus('sotus') +print("get_corpus('sotus') -> n docs:", len(sotus), "| first 40 chars:", repr(sotus[0][:40])) + +print("\nALL MAJOR FUNCTIONS EXERCISED SUCCESSFULLY") diff --git a/setup.cfg b/setup.cfg index 7a07014..383c22b 100644 --- a/setup.cfg +++ b/setup.cfg @@ -1,5 +1,5 @@ [bumpversion] -current_version = 0.2.2 +current_version = 0.5.0 commit = True tag = True @@ -7,7 +7,7 @@ tag = True search = version='{current_version}' replace = version='{new_version}' -[bumpversion:file:datawrangler/__init__.py] +[bumpversion:file:datawrangler/core/configurator.py] search = __version__ = '{current_version}' replace = __version__ = '{new_version}' @@ -16,5 +16,7 @@ universal = 1 [flake8] exclude = docs +max-line-length = 120 + [tool:pytest] collect_ignore = ['setup.py'] diff --git a/setup.py b/setup.py index c1e7e57..f183f38 100644 --- a/setup.py +++ b/setup.py @@ -45,6 +45,6 @@ test_suite='tests', tests_require=test_requirements, url='https://github.com/ContextLab/data-wrangler', - version='0.4.0', + version='0.5.0', zip_safe=False, ) diff --git a/tests/AGENTS.md b/tests/AGENTS.md new file mode 100644 index 0000000..42b0a8c --- /dev/null +++ b/tests/AGENTS.md @@ -0,0 +1,42 @@ + + + +# tests + +## Purpose +The pytest test suite for `data-wrangler`, plus sample data resources used by the tests. Tests exercise **real** functionality — real models, real files, real network calls (no mocks) — and are largely parameterized across both the pandas and Polars backends. + +## Key Files +| File | Description | +|-|-| +| `__init__.py` | Marks the test package | + +## Subdirectories +| Directory | Purpose | +|-|-| +| `wrangler/` | The actual test modules and shared fixtures (`conftest.py`) (see `wrangler/AGENTS.md`) | +| `resources/` | Sample data files (CSV, text, image) loaded by fixtures (see `resources/AGENTS.md`) | + +## For AI Agents + +### Working In This Directory +- Run the suite with `make test` or `pytest` from the repo root. +- Run a single test: `pytest tests/wrangler/test_zoo.py::test_function`. +- Never introduce mocks or simplify a failing test to make it pass (per repo `CLAUDE.md`). Fix the code instead; if blocked, take notes and commit before continuing. + +### Testing Requirements +- Some tests download models (sentence-transformers, sklearn corpora) and fetch remote fixtures over HTTP — network access is required for a full run. +- New features must add tests to the matching `test_.py` and, where a DataFrame is produced, cover both backends. + +### Common Patterns +- Shared fixtures live in `wrangler/conftest.py` (local/remote CSV, text, and image resources; a `backend` fixture parameterized over `['pandas', 'polars']`; and `assert_backend_type` / `assert_dataframes_equivalent` helpers). + +## Dependencies + +### Internal +- `datawrangler` (the package under test) + +### External +- pytest, pandas, polars, numpy + + diff --git a/tests/resources/AGENTS.md b/tests/resources/AGENTS.md new file mode 100644 index 0000000..f988b8d --- /dev/null +++ b/tests/resources/AGENTS.md @@ -0,0 +1,30 @@ + + + +# resources (test fixtures) + +## Purpose +Static sample data files used by the test suite. Each is exposed both as a local path and as a raw-GitHub URL via fixtures in `tests/wrangler/conftest.py`, so the same content exercises both local-file and remote-download code paths. + +## Key Files +| File | Description | +|-|-| +| `testdata.csv` | Tabular sample loaded as a pandas DataFrame (`data_file` / `data_url` fixtures; parsed with `index_col=0`). | +| `home_on_the_range.txt` | Plain-text sample for text-loading and text-embedding tests (`text_file` / `text_url`). | +| `wrangler.jpg` | Image sample for image-loading tests (`img_file` / `img_url`). | + +## For AI Agents + +### Working In This Directory +- These files are referenced by URL as `https://raw.githubusercontent.com/ContextLab/data-wrangler/main/tests/resources/`. If you rename or move a file, update `conftest.py` **and** be aware remote tests hit the `main` branch on GitHub — the change only takes effect for URL tests after it is pushed to `main`. +- Keep fixtures small and free of sensitive data (they are public on GitHub). + +### Testing Requirements +- No tests live here; this directory only supplies inputs consumed by `tests/wrangler/`. + +## Dependencies + +### Internal +- Consumed by `tests/wrangler/conftest.py` fixtures + + diff --git a/tests/wrangler/AGENTS.md b/tests/wrangler/AGENTS.md new file mode 100644 index 0000000..6642ecb --- /dev/null +++ b/tests/wrangler/AGENTS.md @@ -0,0 +1,41 @@ + + + +# wrangler (tests) + +## Purpose +The pytest modules for `data-wrangler`, one per package subpackage, plus the shared fixtures in `conftest.py`. Tests run against real models, files, and network resources and are largely parameterized across the pandas and Polars backends. + +## Key Files +| File | Description | +|-|-| +| `conftest.py` | Shared fixtures: `resources` dir, local + remote CSV (`data_file`/`data_url`), image (`img_file`/`img_url`), and text (`text_file`/`text_url`); a parsed `data` DataFrame; a `backend` fixture parameterized over `['pandas','polars']`; and helpers `assert_backend_type` and `assert_dataframes_equivalent`. | +| `test_zoo.py` | Largest module (~21 tests): array/text/dataframe/null detection and wrangling across both backends. | +| `test_decorate.py` | Tests for `funnel`, `interpolate`, stacking, and list generalization (~6 tests). | +| `test_util.py` | Tests for `btwn`, `array_like`, `dataframe_like`, `depth`, and lazy importers (~4 tests). | +| `test_core.py` | Tests for config parsing, defaults injection, and backend state (~3 tests). | +| `test_io.py` | Tests for `load`/`save` with local and remote files (~2 tests). | +| `__init__.py` | Marks the test package. | + +## For AI Agents + +### Working In This Directory +- Run all: `pytest` (or `make test`). Single test: `pytest tests/wrangler/test_zoo.py::test_name`. +- Reuse `conftest.py` fixtures instead of hardcoding paths/URLs. Use the `backend` fixture + `assert_backend_type` / `assert_dataframes_equivalent` to cover both backends. +- Do **not** weaken or mock a failing test to make it pass (repo `CLAUDE.md`). Fix the code; if stuck, note the problem and commit first. + +### Testing Requirements +- Network access is needed for the `*_url` fixtures and for downloading sklearn corpora / sentence-transformers models used by text tests. + +### Common Patterns +- Backend-parameterized tests; equivalence assertions that normalize Polars→pandas before comparing values. + +## Dependencies + +### Internal +- `datawrangler` (the code under test), `tests/resources/` (sample data) + +### External +- pytest, pandas, polars, numpy + + diff --git a/tests/wrangler/conftest.py b/tests/wrangler/conftest.py index c41f870..2c028e5 100644 --- a/tests/wrangler/conftest.py +++ b/tests/wrangler/conftest.py @@ -3,7 +3,6 @@ import pandas as pd import polars as pl import numpy as np -import datawrangler as dw @pytest.fixture @@ -68,18 +67,18 @@ def assert_dataframes_equivalent(df1, df2, check_dtypes=False): df1_pandas = df1.to_pandas() else: df1_pandas = df1 - + if isinstance(df2, pl.DataFrame): df2_pandas = df2.to_pandas() else: df2_pandas = df2 - + # Check shapes assert df1_pandas.shape == df2_pandas.shape, f"Shape mismatch: {df1_pandas.shape} vs {df2_pandas.shape}" - + # Check values (allowing for floating point differences) assert np.allclose(df1_pandas.values, df2_pandas.values, equal_nan=True), "DataFrame values not equivalent" - + if check_dtypes: # Note: dtypes may differ slightly between backends, so this is optional pass diff --git a/tests/wrangler/test_core.py b/tests/wrangler/test_core.py index cb6a344..551eacf 100644 --- a/tests/wrangler/test_core.py +++ b/tests/wrangler/test_core.py @@ -3,9 +3,9 @@ """Tests for `datawrangler` package (core module).""" import datawrangler as dw -import configparser import os +import pytest from sklearn.feature_extraction.text import CountVectorizer @@ -54,3 +54,46 @@ def test_update_dict(): assert d3['a'] == 3 assert d3['b'] == 2 assert d3['c'] == 4 + + +def test_apply_defaults_unknown_name(): + """Regression: apply_defaults must not crash for names absent from config.ini. + + Previously raised KeyError, which broke every sklearn model without a config.ini + section (e.g. TSNE, MDS, Isomap, SpectralEmbedding). + """ + def not_in_config(a, b=2): + return a, b + + wrapped = dw.core.apply_defaults(not_in_config) + # no config section -> nothing injected, call passes through unchanged + assert wrapped(1) == (1, 2) + assert wrapped(1, b=5) == (1, 5) + + +def test_dataframe_backend_config(): + """set/get/reset of the global DataFrame backend, including validation.""" + from datawrangler.core.configurator import ( + set_dataframe_backend, get_dataframe_backend, reset_dataframe_backend) + + try: + assert get_dataframe_backend() == 'pandas' # default + set_dataframe_backend('polars') + assert get_dataframe_backend() == 'polars' + with pytest.raises(ValueError): + set_dataframe_backend('bogus') + # a rejected value must not have mutated the current backend + assert get_dataframe_backend() == 'polars' + finally: + reset_dataframe_backend() + assert get_dataframe_backend() == 'pandas' + + +def test_version_is_single_sourced(): + """Regression for issue #29: __version__ derives from the package metadata (single source of truth), + so it can never drift from setup.py's version.""" + from importlib.metadata import version, PackageNotFoundError + try: + assert dw.__version__ == version('pydata-wrangler') + except PackageNotFoundError: # uninstalled source checkout -> falls back to a literal + assert isinstance(dw.__version__, str) and dw.__version__ diff --git a/tests/wrangler/test_decorate.py b/tests/wrangler/test_decorate.py index 57ea347..784f101 100644 --- a/tests/wrangler/test_decorate.py +++ b/tests/wrangler/test_decorate.py @@ -2,13 +2,12 @@ """Tests for `datawrangler` package (decorate module).""" -import os import datawrangler as dw import pandas as pd import polars as pl import numpy as np import pytest -from .conftest import assert_backend_type, assert_dataframes_equivalent +from .conftest import assert_backend_type # noinspection PyTypeChecker @@ -29,8 +28,9 @@ def test_funnel(data_file, data, img_file, text_file, backend): def g(x): return x.pow(2) - assert int(g(3).values) == 9 - assert list([int(i.values) for i in g([3, 4, 5])]) == [9, 16, 25] + # use .item() to pull the scalar out of the 1x1 result: numpy 2.x forbids int() on an ndim>0 array + assert int(g(3).values.item()) == 9 + assert list([int(i.values.item()) for i in g([3, 4, 5])]) == [9, 16, 25] assert g(np.array([1, 2, 3])).values.tolist() == [[1, 4, 9]] # noinspection PyShadowingNames @@ -55,7 +55,7 @@ def f(x): wrangled_0_values = wrangled[0].to_numpy() if hasattr(wrangled[0], 'to_numpy') else wrangled[0].values wrangled_1_values = wrangled[1].to_numpy() if hasattr(wrangled[1], 'to_numpy') else wrangled[1].values wrangled_2_values = wrangled[2].to_numpy() if hasattr(wrangled[2], 'to_numpy') else wrangled[2].values - + assert np.allclose(wrangled_0_values, wrangled_1_values) assert np.allclose(wrangled_0_values, wrangled_2_values) @@ -68,7 +68,7 @@ def f(x): assert dw.util.btwn(wrangled[4], -1, 1) wrangled_4_values = wrangled[4].to_numpy() if hasattr(wrangled[4], 'to_numpy') else wrangled[4].values assert np.isclose(wrangled_4_values.mean(), -0.0007741971, atol=1e-5) - + # Verify backend types for w in wrangled: if dw.zoo.is_dataframe(w): @@ -79,9 +79,8 @@ def f(x): def test_interpolate(data, backend): # Convert data to appropriate backend for testing if backend == 'polars': - import polars as pl data = pl.from_pandas(data) - + # test imputing if backend == 'pandas': impute_test = data.copy() @@ -93,7 +92,8 @@ def test_interpolate(data, backend): # Polars doesn't have .loc, use different approach impute_test = impute_test.with_columns([ pl.when(pl.int_range(pl.len()) == 4).then(None).otherwise(pl.col('SecondDim')).alias('SecondDim'), - pl.when(pl.int_range(pl.len()) == 6).then(None).otherwise(pl.col('FourthDim')).alias('FourthDim') # Note: polars is 0-indexed + # Note: polars is 0-indexed + pl.when(pl.int_range(pl.len()) == 6).then(None).otherwise(pl.col('FourthDim')).alias('FourthDim') ]) @dw.decorate.interpolate @@ -102,11 +102,11 @@ def f(x): # noinspection PyCallingNonCallable recovered_data1 = f(impute_test, interp_kwargs={'impute_kwargs': {'model': 'IterativeImputer'}}) - + # Convert to numpy for comparison data_values = data.to_numpy() if hasattr(data, 'to_numpy') else data.values recovered_1_values = recovered_data1.to_numpy() if hasattr(recovered_data1, 'to_numpy') else recovered_data1.values - + assert np.allclose(data_values, recovered_1_values) assert dw.zoo.is_dataframe(data) assert dw.zoo.is_dataframe(recovered_data1) @@ -123,13 +123,13 @@ def f(x): pl.when(pl.int_range(pl.len()) == 5).then(None).otherwise(pl.col(col)).alias(col) for col in interp_test.columns ]) - + # noinspection PyCallingNonCallable recovered_data2 = f(interp_test, interp_kwargs={'method': 'linear'}, backend=backend) - + # Convert to numpy for comparison recovered_2_values = recovered_data2.to_numpy() if hasattr(recovered_data2, 'to_numpy') else recovered_data2.values - + assert np.allclose(data_values, recovered_2_values) assert dw.zoo.is_dataframe(data) assert dw.zoo.is_dataframe(recovered_data2) @@ -159,11 +159,12 @@ def f(x): # noinspection PyCallingNonCallable recovered_data3 = f(impute_interp_test, interp_kwargs={'impute_kwargs': {'model': 'IterativeImputer'}, 'method': 'pchip'}, backend=backend) - + # Convert to numpy for comparison recovered_3_values = recovered_data3.to_numpy() if hasattr(recovered_data3, 'to_numpy') else recovered_data3.values - impute_interp_values = impute_interp_test.to_numpy() if hasattr(impute_interp_test, 'to_numpy') else impute_interp_test.values - + impute_interp_values = (impute_interp_test.to_numpy() if hasattr(impute_interp_test, 'to_numpy') + else impute_interp_test.values) + assert np.allclose(recovered_3_values[~np.isnan(impute_interp_values)], data_values[~np.isnan(impute_interp_values)]) assert dw.zoo.is_dataframe(data) @@ -226,3 +227,27 @@ def f(x): # noinspection PyTypeChecker means = f([data1, data2]) assert np.allclose(means, data.mean(axis=0)) + + +def test_apply_stacked_return_model(data): + """Regression: apply_stacked must handle a function that returns (data, model). + + Previously raised ``TypeError: 'tuple' object does not support item assignment`` + when ``return_model=True`` and the input was unstacked. + """ + i = 4 + data1 = data.iloc[:i] + data2 = data.iloc[i:] + + @dw.decorate.apply_stacked + def f(x, return_model=False, **kwargs): + m = x.mean(axis=0) + return (m, {'model': 'mean'}) if return_model else m + + plain = f([data1, data2]) + out, model = f([data1, data2], return_model=True) + + assert model == {'model': 'mean'} + # the data half matches the plain (no-model) result and the true overall mean + assert np.allclose(np.asarray(out), np.asarray(plain)) + assert np.allclose(np.asarray(out), np.asarray(data.mean(axis=0))) diff --git a/tests/wrangler/test_io.py b/tests/wrangler/test_io.py index 6c2b6aa..e62e74e 100644 --- a/tests/wrangler/test_io.py +++ b/tests/wrangler/test_io.py @@ -2,9 +2,16 @@ """Tests for `datawrangler` package (io module).""" +import os +import glob + +import pytest import datawrangler as dw import numpy as np +from datawrangler.io.extension_handler import get_extension +from datawrangler.io.io import get_local_fname + def test_load(data_file, img_file, text_file): data = dw.io.load(data_file) @@ -31,3 +38,119 @@ def test_save(data_file, data_url, img_file, img_url, text_file, text_url): remote = dw.io.load(eval(f'{dtype}_url')) # requires downloading and saving the remote file assert np.all(local == remote) + + +def test_get_extension_strips_url_query_string(): + """URL query strings/fragments must not leak into the detected extension. + + Regression test: Dropbox/Google-Drive style links (e.g. '...file.npz?dl=1') + previously produced the extension 'npz?dl=1', which polluted cache filenames + and made the cached copy unreadable ('Unknown datatype: npz?dl=1'). + """ + # local paths keep working exactly as before + assert get_extension('/some/dir/testdata.csv') == 'csv' + assert get_extension('archive.tar.gz') == 'gz' + assert get_extension('/no/extension/here') == 'dw' + + # remote URLs with query strings / fragments resolve to the TRUE extension + assert get_extension('https://www.dropbox.com/s/abc/minipedia.npz?dl=1') == 'npz' + assert get_extension('https://example.com/data.csv?dl=0') == 'csv' + assert get_extension('https://example.com/data.json?a=1&b=2') == 'json' + assert get_extension('https://example.com/pic.png#section') == 'png' + # a query string that itself contains a dotted path must not fool detection + assert get_extension('https://example.com/data.csv?redirect=/x/y.zip') == 'csv' + + +def test_get_local_fname_query_string_cache_name(): + """Cache filenames derived from query-string URLs use a clean extension.""" + url = 'https://www.dropbox.com/s/abc/minipedia.npz?dl=1' + fname = get_local_fname(url) + assert fname.endswith('.npz'), f'cache filename should end in .npz, got {fname!r}' + assert '?' not in fname and '#' not in fname + + +def _isolated_cache(monkeypatch, tmp_path): + """Point the datawrangler cache at an isolated temp dir and return it.""" + monkeypatch.setenv('HOME', str(tmp_path)) + cache = tmp_path / '.datawrangler' / 'data' + cache.mkdir(parents=True, exist_ok=True) + return cache + + +def test_remote_load_is_cached_once_and_reused(monkeypatch, tmp_path, data_url): + """A remote file is cached exactly once and re-reads hit that same file. + + Regression test for the caching logic: re-loading must NOT re-download or + create additional cache entries under new hashes. + """ + cache = _isolated_cache(monkeypatch, tmp_path) + try: + first = dw.io.load(data_url) + except Exception as e: # pragma: no cover - network unavailable + pytest.skip(f'network unavailable: {e}') + + files_after_first = sorted(glob.glob(str(cache / '*'))) + assert len(files_after_first) == 1, files_after_first + + second = dw.io.load(data_url) + files_after_second = sorted(glob.glob(str(cache / '*'))) + assert files_after_second == files_after_first, 'reload created a duplicate cache entry' + assert np.all(first.values == second.values) + + +def test_query_string_url_round_trips(monkeypatch, tmp_path, data_url): + """A URL with a '?dl=1'-style query string downloads, caches, and reloads. + + Previously this raised 'ValueError: Unknown datatype: csv?dl=1'. + """ + cache = _isolated_cache(monkeypatch, tmp_path) + qs_url = data_url + '?dl=1' + try: + df = dw.io.load(qs_url) + except Exception as e: # pragma: no cover - network unavailable + pytest.skip(f'network unavailable: {e}') + + assert dw.zoo.is_dataframe(df) + cached = sorted(glob.glob(str(cache / '*'))) + assert len(cached) == 1 and cached[0].endswith('.csv'), cached + + +def test_load_values(data_file): + """Deeper than boolean type checks: verify the actual loaded CSV content.""" + data = dw.io.load(data_file, index_col=0) + assert dw.zoo.is_dataframe(data) + assert data.shape == (7, 5) + assert list(data.columns) == ['FirstDim', 'SecondDim', 'ThirdDim', 'FourthDim', 'FifthDim'] + # concrete known values from tests/resources/testdata.csv + assert data['FirstDim'].tolist() == [1, 2, 3, 4, 5, 6, 7] + assert data['FifthDim'].tolist() == [5, 10, 15, 20, 25, 30, 35] + assert data.iloc[0].tolist() == [1, 2, 3, 4, 5] + assert list(data.index) == [0, 2, 4, 5, 6, 8, 10] + + +def test_save_load_roundtrip_pickle(monkeypatch, tmp_path): + """dw.io.save/load round-trips an arbitrary object via the 'pickle' dtype (real files).""" + _isolated_cache(monkeypatch, tmp_path) + obj = {'nested': [1, 2, 3], 'label': 'wrangler', 'arr': np.arange(4).tolist()} + key = 'testkey://obj.pkl' + dw.io.save(key, obj, dtype='pickle') + + cached = get_local_fname(key) + assert os.path.exists(cached), 'save() did not write to the expected cache path' + assert dw.io.load(cached, dtype='pickle') == obj + + +def test_save_load_roundtrip_numpy(monkeypatch, tmp_path): + """dw.io.save/load round-trips an array via the 'numpy' dtype (real files).""" + _isolated_cache(monkeypatch, tmp_path) + arr = np.arange(12).reshape(3, 4) + key = 'testkey://arr.npz' + dw.io.save(key, arr, dtype='numpy') + + cached = get_local_fname(key) + assert os.path.exists(cached) + loaded = dw.io.load(cached, dtype='numpy') + try: + assert np.allclose(loaded['arr_0'], arr) # np.savez stores a positional array as 'arr_0' + finally: + loaded.close() diff --git a/tests/wrangler/test_zoo.py b/tests/wrangler/test_zoo.py index 1c0719f..fa0d634 100644 --- a/tests/wrangler/test_zoo.py +++ b/tests/wrangler/test_zoo.py @@ -48,10 +48,10 @@ def test_wrangle_dataframe(data, data_file, backend): # Test with pandas input and specified backend df1 = dw.zoo.wrangle_dataframe(data, backend=backend) - + # Convert to pandas for detailed assertions (values should be equivalent) df1_pandas = df1.to_pandas() if isinstance(df1, pl.DataFrame) else df1 - + # Backend-specific behavior: pandas preserves index names, Polars does not # This is expected due to fundamental differences in how the libraries handle row indexing if backend == 'pandas': @@ -60,7 +60,7 @@ def test_wrangle_dataframe(data, data_file, backend): # Polars backend: index names are not preserved during conversion # This is documented behavior - Polars uses position-based indexing only pass - + assert np.all(df1_pandas['FirstDim'] == np.arange(1, 8)) assert np.all(df1_pandas['SecondDim'] == np.arange(2, 16, 2)) assert np.all(df1_pandas['ThirdDim'] == np.arange(3, 24, 3)) @@ -70,7 +70,7 @@ def test_wrangle_dataframe(data, data_file, backend): # Test loading from file with backend df2 = dw.zoo.wrangle_dataframe(data_file, load_kwargs={'index_col': 0}, backend=backend) assert_backend_type(df2, backend) - + # Verify equivalence between backends assert_dataframes_equivalent(df1, df2) @@ -79,7 +79,7 @@ def test_wrangle_dataframe_cross_backend_equivalence(data): """Test that pandas and Polars backends produce equivalent results.""" pandas_df = dw.zoo.wrangle_dataframe(data, backend='pandas') polars_df = dw.zoo.wrangle_dataframe(data, backend='polars') - + assert_dataframes_equivalent(pandas_df, polars_df) @@ -103,10 +103,10 @@ def test_wrangle_array(data, img_file, backend): assert df_img.shape == (1400, 5760) assert dw.zoo.is_dataframe(df_img) assert_backend_type(df_img, backend) - + # Convert to numpy for value checks (works for both backends) df_img_values = df_img.to_numpy() if hasattr(df_img, 'to_numpy') else df_img.values - assert np.max(df_img_values) >= 245 # needed for GitHub actions tests + assert np.max(df_img_values) >= 245 # needed for GitHub actions tests assert np.min(df_img_values) == 12 assert np.isclose(np.mean(df_img_values), 152.19, atol=0.1) @@ -115,7 +115,7 @@ def test_wrangle_array_cross_backend_equivalence(data): """Test that array wrangling produces equivalent results across backends.""" pandas_df = dw.zoo.wrangle_array(data.values, backend='pandas') polars_df = dw.zoo.wrangle_array(data.values, backend='polars') - + assert_dataframes_equivalent(pandas_df, polars_df) @@ -149,8 +149,8 @@ def test_get_corpus(): assert sotus[-1].split('\n')[-1] == '' assert len(sotus) == 29 - # test small hugging face corpus: cbt/raw - cbt = dw.zoo.text.get_corpus('cbt', 'raw') + # test small hugging face corpus: cam-cst/cbt (the namespaced Children's Book Test dataset) + cbt = dw.zoo.text.get_corpus('cam-cst/cbt', 'raw') assert cbt[0][:100] == 'CHAPTER I. -LCB- Chapter heading picture : p1.jpg -RCB- How the Fairies were not Invited ' \ 'to Court . ' assert cbt[0][-104:] == "occasionally Rosalind would say , `` I do believe , my dear , that you are really as " \ @@ -169,7 +169,7 @@ def test_wrangle_text_sklearn(text_file, backend): cv = dw.wrangle(text, text_kwargs=text_kwargs, backend=backend) assert cv.shape == (24, 1220) assert_backend_type(cv, backend) - + # Convert to values for numerical checks cv_values = cv.to_numpy() if hasattr(cv, 'to_numpy') else cv.values assert dw.util.btwn(cv_values, 0, 1) @@ -186,7 +186,7 @@ def test_wrangle_text_sklearn(text_file, backend): lda = dw.wrangle(text, text_kwargs=text_kwargs, backend=backend) assert lda.shape == (24, 50) assert_backend_type(lda, backend) - + lda_values = lda.to_numpy() if hasattr(lda, 'to_numpy') else lda.values assert dw.util.btwn(lda_values, 0, 1) assert np.allclose(lda_values.sum(axis=1), 1) @@ -197,7 +197,7 @@ def test_wrangle_text_sklearn(text_file, backend): nmf = dw.wrangle(text, text_kwargs=text_kwargs, backend=backend) assert nmf.shape == (24, 25) assert_backend_type(nmf, backend) - + nmf_values = nmf.to_numpy() if hasattr(nmf, 'to_numpy') else nmf.values assert dw.util.btwn(nmf_values, 0, 1) @@ -205,30 +205,30 @@ def test_wrangle_text_sklearn(text_file, backend): def test_wrangle_text_sklearn_cross_backend_equivalence(text_file): """Test that sklearn text processing produces equivalent results across backends.""" import numpy as np - + text = dw.io.load(text_file).split('\n') - + # Test CountVectorizer equivalence - this should be deterministic text_kwargs = {'model': 'CountVectorizer'} pandas_cv = dw.wrangle(text, text_kwargs=text_kwargs, backend='pandas') polars_cv = dw.wrangle(text, text_kwargs=text_kwargs, backend='polars') assert_dataframes_equivalent(pandas_cv, polars_cv) - + # Test LDA equivalence with fixed random seed for deterministic behavior # Set random seed before each backend test to ensure identical results np.random.seed(42) text_kwargs = { 'model': [ - 'CountVectorizer', + 'CountVectorizer', {'model': 'LatentDirichletAllocation', 'args': [], 'kwargs': {'random_state': 42}} - ], + ], 'corpus': 'sotus' } pandas_lda = dw.wrangle(text, text_kwargs=text_kwargs, backend='pandas') - + np.random.seed(42) # Reset seed for second backend polars_lda = dw.wrangle(text, text_kwargs=text_kwargs, backend='polars') - + assert_dataframes_equivalent(pandas_lda, polars_lda) @@ -243,7 +243,7 @@ def test_wrangle_text_hugging_face(text_file, backend): assert len(sentence_embeddings) == 24 assert all([a == b for a, b in zip([g.shape[0] for g in sentence_embeddings], [len(w) for w in words])]) assert all(g.shape[1] == 384 for g in sentence_embeddings) # all-MiniLM-L6-v2 produces 384-dim embeddings - + # Convert to values for numerical checks embedding_means = [] for g in sentence_embeddings: @@ -260,15 +260,16 @@ def test_wrangle_text_hugging_face(text_file, backend): distilbert_embeddings = dw.wrangle(text, text_kwargs=distilbert_kwargs, backend=backend) assert distilbert_embeddings.shape == (24, 768) # all-mpnet-base-v2 produces 768-dim embeddings assert_backend_type(distilbert_embeddings, backend) - - distilbert_values = distilbert_embeddings.to_numpy() if hasattr(distilbert_embeddings, 'to_numpy') else distilbert_embeddings.values + + distilbert_values = (distilbert_embeddings.to_numpy() if hasattr(distilbert_embeddings, 'to_numpy') + else distilbert_embeddings.values) assert np.isclose(distilbert_values.mean(axis=0).mean(axis=0), -0.000105, atol=0.0001) bert_kwargs = {'model': {'model': 'all-MiniLM-L12-v2', 'args': [], 'kwargs': {}}} bert_embeddings = dw.wrangle(text, text_kwargs=bert_kwargs, backend=backend) assert bert_embeddings.shape == (24, 384) # all-MiniLM-L12-v2 produces 384-dim embeddings assert_backend_type(bert_embeddings, backend) - + bert_values = bert_embeddings.to_numpy() if hasattr(bert_embeddings, 'to_numpy') else bert_embeddings.values assert np.isclose(bert_values.mean(axis=0).mean(axis=0), -0.0001967, atol=0.0001) @@ -276,7 +277,7 @@ def test_wrangle_text_hugging_face(text_file, backend): def test_wrangle_text_hugging_face_cross_backend_equivalence(text_file): """Test that HuggingFace text processing produces equivalent results across backends.""" text = dw.io.load(text_file).split('\n') - + # Test transformer model equivalence model_kwargs = {'model': {'model': 'all-mpnet-base-v2', 'args': [], 'kwargs': {}}} pandas_embeddings = dw.wrangle(text, text_kwargs=model_kwargs, backend='pandas') @@ -288,30 +289,31 @@ def test_wrangle_text_hugging_face_cross_backend_equivalence(text_file): def test_wrangle_text_simplified_api(text_file, backend): """Test simplified text model API with backward compatibility.""" text = dw.io.load(text_file).split('\n') - + # Test 1: String model format (simplified API) simple_string_kwargs = {'model': 'all-MiniLM-L6-v2'} simple_embeddings = dw.wrangle(text, text_kwargs=simple_string_kwargs, backend=backend) assert simple_embeddings.shape == (24, 384) # all-MiniLM-L6-v2 produces 384-dim embeddings assert_backend_type(simple_embeddings, backend) - + # Test 2: Partial dict format (model key only) partial_dict_kwargs = {'model': {'model': 'all-MiniLM-L6-v2'}} partial_embeddings = dw.wrangle(text, text_kwargs=partial_dict_kwargs, backend=backend) assert partial_embeddings.shape == (24, 384) assert_backend_type(partial_embeddings, backend) - + # Test 3: Full dict format (backward compatibility) full_dict_kwargs = {'model': {'model': 'all-MiniLM-L6-v2', 'args': [], 'kwargs': {}}} full_embeddings = dw.wrangle(text, text_kwargs=full_dict_kwargs, backend=backend) assert full_embeddings.shape == (24, 384) assert_backend_type(full_embeddings, backend) - + # Test 4: Verify all formats produce equivalent results simple_values = simple_embeddings.to_numpy() if hasattr(simple_embeddings, 'to_numpy') else simple_embeddings.values - partial_values = partial_embeddings.to_numpy() if hasattr(partial_embeddings, 'to_numpy') else partial_embeddings.values + partial_values = (partial_embeddings.to_numpy() if hasattr(partial_embeddings, 'to_numpy') + else partial_embeddings.values) full_values = full_embeddings.to_numpy() if hasattr(full_embeddings, 'to_numpy') else full_embeddings.values - + # All three formats should produce identical results assert np.allclose(simple_values, partial_values, atol=1e-6) assert np.allclose(simple_values, full_values, atol=1e-6) @@ -321,13 +323,13 @@ def test_wrangle_text_simplified_api(text_file, backend): def test_wrangle_text_simplified_api_cross_backend_equivalence(text_file): """Test that simplified API produces equivalent results across backends.""" text = dw.io.load(text_file).split('\n') - + # Test string format equivalence across backends string_kwargs = {'model': 'all-MiniLM-L6-v2'} pandas_string = dw.wrangle(text, text_kwargs=string_kwargs, backend='pandas') polars_string = dw.wrangle(text, text_kwargs=string_kwargs, backend='polars') assert_dataframes_equivalent(pandas_string, polars_string) - + # Test partial dict format equivalence across backends partial_kwargs = {'model': {'model': 'all-MiniLM-L6-v2'}} pandas_partial = dw.wrangle(text, text_kwargs=partial_kwargs, backend='pandas') @@ -341,22 +343,22 @@ def test_normalize_text_model(): result = dw.zoo.text.normalize_text_model('all-MiniLM-L6-v2') expected = {'model': 'all-MiniLM-L6-v2', 'args': [], 'kwargs': {}} assert result == expected - + # Test partial dict normalization result = dw.zoo.text.normalize_text_model({'model': 'all-MiniLM-L6-v2'}) expected = {'model': 'all-MiniLM-L6-v2', 'args': [], 'kwargs': {}} assert result == expected - + # Test partial dict with some args/kwargs result = dw.zoo.text.normalize_text_model({'model': 'all-MiniLM-L6-v2', 'args': ['arg1']}) expected = {'model': 'all-MiniLM-L6-v2', 'args': ['arg1'], 'kwargs': {}} assert result == expected - + # Test full dict (no change) full_dict = {'model': 'all-MiniLM-L6-v2', 'args': [], 'kwargs': {}} result = dw.zoo.text.normalize_text_model(full_dict) assert result == full_dict - + # Test non-dict/non-string input (passthrough) result = dw.zoo.text.normalize_text_model(None) assert result is None @@ -366,13 +368,13 @@ def test_normalize_text_model(): def test_wrangle_text_list_models_simplified_api(text_file, backend): """Test simplified API with lists of models.""" text = dw.io.load(text_file).split('\n') - + # Test 1: List of string models (sklearn pipeline) sklearn_list_kwargs = {'model': ['CountVectorizer', 'LatentDirichletAllocation'], 'corpus': 'sotus'} sklearn_result = dw.wrangle(text, text_kwargs=sklearn_list_kwargs, backend=backend) assert sklearn_result.shape == (24, 50) # LDA with default 50 topics assert_backend_type(sklearn_result, backend) - + # Test 2: Mixed list with string and dict models mixed_list_kwargs = { 'model': [ @@ -384,7 +386,7 @@ def test_wrangle_text_list_models_simplified_api(text_file, backend): mixed_result = dw.wrangle(text, text_kwargs=mixed_list_kwargs, backend=backend) assert mixed_result.shape == (24, 20) # NMF with 20 components assert_backend_type(mixed_result, backend) - + # Test 3: Verify list processing maintains backward compatibility old_style_kwargs = { 'model': [ @@ -421,8 +423,94 @@ def test_wrangle_null_cross_backend_equivalence(): """Test that null wrangling produces equivalent results across backends.""" pandas_df = dw.wrangle(None, backend='pandas') polars_df = dw.wrangle(None, backend='polars') - + # Both should be empty DataFrames assert len(pandas_df) == 0 assert len(polars_df) == 0 assert_dataframes_equivalent(pandas_df, polars_df) + + +def test_is_multiindex_dataframe_polars(): + """Regression: is_multiindex_dataframe must not crash on Polars (which has no .index).""" + assert dw.zoo.is_multiindex_dataframe(pl.DataFrame({'a': [1, 2, 3]})) is False + assert dw.zoo.is_multiindex_dataframe(pl.DataFrame({'a': [1, 2, 3]}).lazy()) is False + + # pandas behaviour is unchanged + mi = pd.DataFrame({'v': [1, 2]}, + index=pd.MultiIndex.from_tuples([('a', 0), ('a', 1)])) + assert dw.zoo.is_multiindex_dataframe(mi) is True + assert dw.zoo.is_multiindex_dataframe(pd.DataFrame({'v': [1]})) is False + + +def test_return_model_contract(): + """wrangle_* honour the {'model','args','kwargs'} contract, and the returned + model can be re-applied to new data to reproduce equivalent output.""" + from datawrangler.zoo.array import wrangle_array + from datawrangler.zoo.null import wrangle_null + + df, model = wrangle_array(np.array([[1, 2, 3], [4, 5, 6]]), return_model=True) + assert set(model.keys()) == {'model', 'args', 'kwargs'} + assert df.values.tolist() == [[1, 2, 3], [4, 5, 6]] + + # re-applying the returned model to new data reproduces an equivalent DataFrame + df2 = wrangle_array(np.array([[7, 8, 9]]), model=model) + assert df2.values.tolist() == [[7, 8, 9]] + + empty, null_model = wrangle_null(None, return_model=True) + assert set(null_model.keys()) == {'model', 'args', 'kwargs'} + assert len(empty) == 0 + + +def test_create_polars_dataframe(): + """create_polars_dataframe dict / 1D / 2D branches and the 3D ValueError.""" + from datawrangler.zoo.polars_dataframe import create_polars_dataframe + + d = create_polars_dataframe({'a': [1, 2], 'b': [3, 4]}) + assert d.columns == ['a', 'b'] + assert d['a'].to_list() == [1, 2] and d['b'].to_list() == [3, 4] + + one = create_polars_dataframe(np.array([1, 2, 3])) + assert one.shape == (3, 1) + assert one.to_numpy().ravel().tolist() == [1, 2, 3] + + two = create_polars_dataframe(np.array([[1, 2], [3, 4]]), columns=['x', 'y']) + assert two.columns == ['x', 'y'] + assert two.to_numpy().tolist() == [[1, 2], [3, 4]] + + with pytest.raises(ValueError): + create_polars_dataframe(np.zeros((2, 2, 2))) + + +def test_polars_pandas_converters(): + """pandas<->polars conversion round-trips and rejects wrong input types.""" + from datawrangler.zoo.polars_dataframe import ( + pandas_to_polars, polars_to_pandas, is_polars_dataframe) + + pdf = pd.DataFrame({'a': [1, 2, 3], 'b': [4.0, 5.0, 6.0]}) + pol = pandas_to_polars(pdf) + assert is_polars_dataframe(pol) + assert np.allclose(polars_to_pandas(pol).values, pdf.values) + # LazyFrames are collected during conversion + assert np.allclose(polars_to_pandas(pol.lazy()).values, pdf.values) + + with pytest.raises(TypeError): + pandas_to_polars([1, 2, 3]) # not a pandas DataFrame + with pytest.raises(TypeError): + polars_to_pandas(pdf) # not a polars frame + + +def test_issue30_pandas_type_detection(): + """Regression for issue #30: type detection must not depend on pandas' internal ``__module__`` strings. + Under pandas 3.0 those were flattened (e.g. 'pandas.core.frame' -> 'pandas'), which broke is_dataframe / + is_multiindex_dataframe and cascaded into stack/unstack raising 'Unsupported datatype'. The isinstance-based + checks are stable across pandas 2.x and 3.0.""" + df = pd.DataFrame(np.arange(6).reshape(3, 2), columns=['x', 'y']) + assert dw.zoo.is_dataframe(df) is True + assert dw.util.dataframe_like(df) is True + + # the exact funnel -> stack/unstack cascade the issue reported broken + stacked = dw.stack([df, df]) + assert dw.zoo.is_multiindex_dataframe(stacked) is True + frames = dw.unstack(stacked) + assert len(frames) == 2 + assert np.allclose(frames[0].values, df.values)