From 35f8d457ec754518573c9bc91fb0f5afe6e96585 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rian=20=C3=93=20Cuinneag=C3=A1in?= Date: Fri, 24 May 2024 17:08:12 +0100 Subject: [PATCH] PyKX 2.5.0 --- .gitignore | 7 + README.md | 13 +- custom_theme/main.html | 11 + docs/api/pykx-q-data/type_conversions.md | 308 +++-- docs/api/streamlit.md | 10 + docs/api/util.md | 135 +++ docs/beta-features/examples/streamlit.py | 39 + docs/beta-features/index.md | 3 +- docs/beta-features/remote-functions.md | 2 +- docs/beta-features/streamlit.md | 111 ++ docs/blogs.md | 14 +- docs/examples/charting.ipynb | 380 +++++++ docs/examples/db-management.ipynb | 22 +- docs/extras/known_issues.md | 9 +- docs/getting-started/installing.md | 332 ++++-- docs/getting-started/q_magic_command.ipynb | 72 +- docs/getting-started/quickstart.md | 34 +- docs/release-notes/changelog.md | 603 +++++++++- docs/release-notes/underq-changelog.md | 30 + docs/roadmap.md | 58 +- docs/stylesheets/pykx.css | 2 +- docs/troubleshooting.md | 5 +- docs/user-guide/advanced/Pandas_API.ipynb | 1009 +++++++++++------ docs/user-guide/advanced/limitations.md | 3 +- docs/user-guide/configuration.md | 1 - .../fundamentals/conversion_considerations.md | 147 +++ docs/user-guide/fundamentals/creating.md | 18 +- docs/user-guide/fundamentals/types.md | 0 examples/notebooks/interface_overview.ipynb | 39 +- mkdocs.yml | 22 +- pyproject.toml | 5 + setup.py | 2 + src/pykx/__init__.py | 7 +- src/pykx/_ipc.pyx | 22 + src/pykx/config.py | 107 +- src/pykx/core.pyx | 14 +- src/pykx/ctx.py | 3 +- src/pykx/embedded_q.py | 26 +- src/pykx/ipc.py | 76 +- src/pykx/lib/4-1-libs/l64/libq.so | Bin 845160 -> 845384 bytes src/pykx/lib/4-1-libs/l64arm/libq.so | Bin 695776 -> 699880 bytes src/pykx/lib/4-1-libs/m64/libq.dylib | Bin 734976 -> 734976 bytes src/pykx/lib/4-1-libs/m64arm/libq.dylib | Bin 694528 -> 694528 bytes src/pykx/lib/4-1-libs/q.k | 2 +- src/pykx/lib/4-1-libs/w64/q.dll | Bin 700928 -> 700928 bytes src/pykx/lib/4-1-libs/w64/q.lib | Bin 9988 -> 10118 bytes src/pykx/lib/l64/libe.so | Bin 75128 -> 75192 bytes src/pykx/lib/l64/libq.so | Bin 821360 -> 821360 bytes src/pykx/lib/l64arm/libq.so | Bin 687480 -> 687488 bytes src/pykx/lib/m64/libe.so | Bin 71704 -> 71912 bytes src/pykx/lib/m64/libq.dylib | Bin 718432 -> 718432 bytes src/pykx/lib/m64arm/libe.so | Bin 88916 -> 89080 bytes src/pykx/lib/m64arm/libq.dylib | Bin 677712 -> 677712 bytes src/pykx/lib/q.k | 2 +- src/pykx/lib/read.q | 2 +- src/pykx/lib/w64/q.dll | Bin 681984 -> 681984 bytes src/pykx/lib/w64/q.lib | Bin 9988 -> 10118 bytes src/pykx/pandas_api/__init__.py | 4 +- src/pykx/pandas_api/pandas_meta.py | 148 +-- src/pykx/pandas_api/pandas_replace.py | 27 + src/pykx/pykx.q | 34 +- src/pykx/pykx_init.q_ | Bin 3223 -> 4585 bytes src/pykx/query.py | 49 +- src/pykx/read.py | 28 +- src/pykx/reimporter.py | 10 +- src/pykx/streamlit.py | 252 ++++ src/pykx/system.py | 126 +- src/pykx/toq.pyx | 102 +- src/pykx/util.py | 116 +- src/pykx/wrappers.py | 246 +++- tests/test_ipc.py | 56 + tests/test_license.py | 45 +- tests/test_pandas_replace.py | 25 + tests/test_pykx.py | 6 + tests/test_q.py | 13 + tests/test_streamlit.py | 41 + tests/test_system.py | 55 +- tests/test_toq.py | 99 +- tests/test_wrappers.py | 375 +++++- 79 files changed, 4537 insertions(+), 1027 deletions(-) create mode 100644 docs/api/streamlit.md create mode 100644 docs/api/util.md create mode 100644 docs/beta-features/examples/streamlit.py create mode 100644 docs/beta-features/streamlit.md create mode 100644 docs/examples/charting.ipynb create mode 100644 docs/user-guide/fundamentals/conversion_considerations.md delete mode 100644 docs/user-guide/fundamentals/types.md create mode 100644 src/pykx/pandas_api/pandas_replace.py create mode 100644 src/pykx/streamlit.py create mode 100644 tests/test_pandas_replace.py create mode 100644 tests/test_streamlit.py diff --git a/.gitignore b/.gitignore index ff25d76..0b3d7b2 100644 --- a/.gitignore +++ b/.gitignore @@ -65,6 +65,11 @@ __pycache__/ !e.* !libkurl.* !libobjstor.* +**/4-1-libs/*.q +**/4-1-libs/*.q_ +**/4-1-libs/*.k_ +**/4-1-libs/*.k +!**/4-1-libs/q.k # Distribution / packaging .Python @@ -223,6 +228,8 @@ coverage.xml # CCLS files .ccls-cache/* +.ccls +compile_commands.json # HDB Test files HDB/** diff --git a/README.md b/README.md index 564b604..14cc86d 100644 --- a/README.md +++ b/README.md @@ -35,18 +35,19 @@ For more information on using q/kdb+ and getting started with see the following Ensure you have a recent version of pip: +```bash pip install --upgrade pip - +``` Then install the latest version of PyKX with the following command: -``` +```bash pip install pykx ``` To install a specific version of PyKX run the following command replacing with a specific released semver version of the interface -``` +```bash pip install pykx== ``` @@ -68,9 +69,9 @@ The following steps outline the process by which a user can gain access to an in #### Commercial Evaluation License -The following steps outline the process by which a user can gain access to an install a kdb Insights license which provides access to PyKX +The following steps outline the process by which a user can gain access to an install a kdb Insights license which provides access to PyKX -1. Visit https://kx.com/kdb-insights-commercial-evaluation-license-download/ and fill in the attached form following the instructions provided. +1. Contact you KX sales representative or sales@kx.com requesting a trial license for PyKX evaluation. Alternately apply through https://kx.com/book-demo. 2. On receipt of an email from KX providing access to your license download this file and save to a secure location on your computer. 3. Set an environment variable on your computer pointing to the folder containing the license file (instructions for setting environment variables on PyKX supported operating systems can be found [here](https://chlee.co/how-to-setup-environment-variables-for-windows-mac-and-linux/). * Variable Name: `QLIC` @@ -107,6 +108,8 @@ When using PyKX with KX Dashboards users will be required to install `ast2json~= When using PyKX Beta features users will be required to install `dill>=0.2.0` this can be installed using the `beta` extra, e.g. `pip install pykx[beta]` +When using Streamlit users will be required to install `streamlit~=1.28` this can be installed using the `streamlit` extra, e.g. `pip install pykx[streamlit]` + **Warning:** Trying to use the `pa` conversion methods of `pykx.K` objects or the `pykx.toq.from_arrow` method when PyArrow is not installed (or could not be imported without error) will raise a `pykx.PyArrowUnavailable` exception. `pyarrow` is supported Python 3.8-3.10 but remains in Beta for Python 3.11. #### Optional Non-Python Dependencies diff --git a/custom_theme/main.html b/custom_theme/main.html index bffbb07..4c73cdc 100644 --- a/custom_theme/main.html +++ b/custom_theme/main.html @@ -8,4 +8,15 @@ 'https://www.googletagmanager.com/gtm.js?id='+i+dl;f.parentNode.insertBefore(j,f); })(window,document,'script','dataLayer','GTM-PG938LS'); + + + {% endblock %} diff --git a/docs/api/pykx-q-data/type_conversions.md b/docs/api/pykx-q-data/type_conversions.md index 0e4b1d7..7373913 100644 --- a/docs/api/pykx-q-data/type_conversions.md +++ b/docs/api/pykx-q-data/type_conversions.md @@ -1,31 +1,58 @@ # PyKX to Pythonic data type mapping -A breakdown of each of the `pykx.K` types and their analogous `numpy`, `pandas`, and `pyarrow` types. - -??? "Cheat Sheet" - - PyKX type | Python type | Numpy dtype | Pandas dtype | PyArrow type | - ------------------------------- | ----------- | --------------- | --------------- | -------------- | - [List](#pykxlist) | list | object | object | Not Supported | - [Boolean](#pykxbooleanatom) | bool | bool | bool | Not Supported | - [GUID](#pykxguidatom) | uuid4 | uuid4 | uuid4 | uuid4 | - [Byte](#pykxbyteatom) | int | uint8 | uint8 | uint8 | - [Short](#pykxshortatom) | int | int16 | int16 | int16 | - [Int](#pykxintatom) | int | int32 | int32 | int32 | - [Long](#pykxlongatom) | int | int64 | int64 | int64 | - [Real](#pykxrealatom) | float | float32 | float32 | FloatArray | - [Float](#pykxfloatatom) | float | float64 | float64 | DoubleArray | - [Char](#pykxcharatom) | bytes | \|S1 | bytes8 | BinaryArray | - [Symbol](#pykxsymbolatom) | str | object | object | StringArray | - [Timestamp](#pykxtimestampatom) | datetime | datetime64[ns] | datetime64[ns] | TimestampArray | - [Month](#pykxmonthatom) | date | datetime64[M] | datetime64[ns] | Not Supported | - [Date](#pykxdateatom) | date | datetime64[D] | datetime64[ns] | Date32Array | - [Timespan](#pykxtimespanatom) | timedelta | timedelta[ns] | timedelta64[ns] | DurationArray | - [Minute](#pykxminuteatom) | timedelta | timedelta64[m] | timedelta64[ns] | Not Supported | - [Second](#pykxsecondatom) | timedelta | timedelta64[s] | timedelta64[ns] | DurationArray | - [Time](#TimeAtom) | timedelta | timedelta64[ms] | timedelta64[ns] | DurationArray | - [Dictionary](#pykxdictionary) | dict | Not Supported | Not Supported | Not Supported | - [Table](#pykxtable) | dict | records | DataFrame | Table | +A breakdown of each of the `pykx.K` types and their analogous `Python`, `NumPy`, `Pandas`, and `PyArrow` types. + +??? "Cheat Sheet: `Python`, `NumPy`, `PyArrow`" + + | PyKX type | Python type | Numpy dtype | PyArrow type | + | ------------------------------- | ----------- | --------------- | -------------- | + | [List](#pykxlist) | list | object | Not Supported | + | [Boolean](#pykxbooleanatom) | bool | bool | Not Supported | + | [GUID](#pykxguidatom) | uuid4 | uuid4 | uuid4 | + | [Byte](#pykxbyteatom) | int | uint8 | uint8 | + | [Short](#pykxshortatom) | int | int16 | int16 | + | [Int](#pykxintatom) | int | int32 | int32 | + | [Long](#pykxlongatom) | int | int64 | int64 | + | [Real](#pykxrealatom) | float | float32 | FloatArray | + | [Float](#pykxfloatatom) | float | float64 | DoubleArray | + | [Char](#pykxcharatom) | bytes | \\\|S1 | BinaryArray | + | [Symbol](#pykxsymbolatom) | str | object | StringArray | + | [Timestamp](#pykxtimestampatom) | datetime | datetime64[ns] | TimestampArray | + | [Month](#pykxmonthatom) | date | datetime64[M] | Not Supported | + | [Date](#pykxdateatom) | date | datetime64[D] | Date32Array | + | [Timespan](#pykxtimespanatom) | timedelta | timedelta64[ns] | DurationArray | + | [Minute](#pykxminuteatom) | timedelta | timedelta64[m] | Not Supported | + | [Second](#pykxsecondatom) | timedelta | timedelta64[s] | DurationArray | + | [Time](#TimeAtom) | timedelta | timedelta64[ms] | DurationArray | + | [Dictionary](#pykxdictionary) | dict | Not Supported | Not Supported | + | [Table](#pykxtable) | dict | records | Table | + +??? "Cheat Sheet: `Pandas 1.*`, `Pandas 2.*`, `Pandas 2.* PyArrow backed`" + + **Note:** Creating PyArrow backed Pandas objects uses `as_arrow=True` using NumPy arrays as an intermediate data format. + + | PyKX type | Pandas 1.\* dtype | Pandas 2.\* dtype | Pandas 2.\* as_arrow=True dtype | + | ------------------------------- | ----------------- | ----------------- | ------------------------------- | + | [List](#pykxlist) | object | object | object | + | [Boolean](#pykxbooleanatom) | bool | bool | bool[pyarrow] | + | [GUID](#pykxguidatom) | object | object | object | + | [Byte](#pykxbyteatom) | uint8 | uint8 | uint8[pyarrow] | + | [Short](#pykxshortatom) | int16 | int16 | int16[pyarrow] | + | [Int](#pykxintatom) | int32 | int32 | int32[pyarrow] | + | [Long](#pykxlongatom) | int64 | int64 | int64[pyarrow] | + | [Real](#pykxrealatom) | float32 | float32 | float[pyarrow] | + | [Float](#pykxfloatatom) | float64 | float64 | double[pyarrow] | + | [Char](#pykxcharatom) | bytes8 | bytes8 | fixed_size_binary[1][pyarrow] | + | [Symbol](#pykxsymbolatom) | object | object | string[pyarrow] | + | [Timestamp](#pykxtimestampatom) | datetime64[ns] | datetime64[ns] | timestamp[ns][pyarrow] | + | [Month](#pykxmonthatom) | datetime64[ns] | datetime64[s] | timestamp[s][pyarrow] | + | [Date](#pykxdateatom) | datetime64[ns] | datetime64[s] | timestamp[s][pyarrow] | + | [Timespan](#pykxtimespanatom) | timedelta64[ns] | timedelta64[ns] | duration[ns][pyarrow] | + | [Minute](#pykxminuteatom) | timedelta64[ns] | timedelta64[s] | duration[s][pyarrow] | + | [Second](#pykxsecondatom) | timedelta64[ns] | timedelta64[s] | duration[s][pyarrow] | + | [Time](#TimeAtom) | timedelta64[ns] | timedelta64[ms] | duration[ms][pyarrow] | + | [Dictionary](#pykxdictionary) | Not Supported | Not Supported | Not Supported | + | [Table](#pykxtable) | DataFrame | DataFrame | DataFrame | ## `pykx.List` @@ -611,14 +638,25 @@ True ``` === "Pandas" - Calling `.pd()` on a `pykx.TimestampVector` will return a pandas `Series` with `dtype` `datetime64[ns]`. - - ```Python - >>> kx.TimestampVector([datetime(2150, 10, 22, 20, 31, 15, 70713), datetime(2050, 10, 22, 20, 31, 15, 70713)]).pd() - 0 2150-10-22 20:31:15.070713 - 1 2050-10-22 20:31:15.070713 - dtype: datetime64[ns] - ``` + Calling `.pd()` on a `pykx.TimestampVector` will return a pandas `Series` with `dtype`: + + 1. `datetime64[ns]`: + + ```python + >>> kx.TimestampVector([datetime(2150, 10, 22, 20, 31, 15, 70713), datetime(2050, 10, 22, 20, 31, 15, 70713)]).pd() + 0 2150-10-22 20:31:15.070713 + 1 2050-10-22 20:31:15.070713 + dtype: datetime64[ns] + ``` + + 2. `timestamp[ns][pyarrow]` in pandas>=2.0 with `as_arrow=True`: + + ```python + >>> kx.TimestampVector([datetime(2150, 10, 22, 20, 31, 15, 70713), datetime(2050, 10, 22, 20, 31, 15, 70713)]).pd(as_arrow=True) + 0 2150-10-22 20:31:15.070713 + 1 2050-10-22 20:31:15.070713 + dtype: timestamp[ns][pyarrow] + ``` === "PyArrow" Calling `.pa()` on a `pykx.TimestampVector` will return a pyarrow `TimestampArray`. @@ -683,14 +721,34 @@ True ``` === "Pandas" - Calling `.pd()` on a `pykx.MonthVector` will return a pandas `Series` with `dtype` `datetime64[ns]`. - - ```Python - >>> kx.MonthVector([date(1972, 5, 1), date(1999, 5, 1)]).pd() - 0 1972-05-01 - 1 1999-05-01 - dtype: datetime64[ns] - ``` + Calling `.pd()` on a `pykx.MonthVector` will return a pandas `Series` with `dtype`: + + 1. `datetime64[ns]` in `pandas<2.0`: + + ```python + >>> kx.MonthVector([date(1972, 5, 1), date(1999, 5, 1)]).pd() + 0 1972-05-01 + 1 1999-05-01 + dtype: datetime64[ns] + ``` + + 2. `datetime64[s]` in `pandas>=2.0`: + + ```python + >>> kx.MonthVector([date(1972, 5, 1), date(1999, 5, 1)]).pd() + 0 1972-05-01 + 1 1999-05-01 + dtype: datetime64[s] + ``` + + 3. `timestamp[s][pyarrow]` in `pandas>=2.0` with `as_arrow=True`: + + ```python + >>> kx.MonthVector([date(1972, 5, 1), date(1999, 5, 1)]).pd(as_arrow=True) + 0 1972-05-01 00:00:00 + 1 1999-05-01 00:00:00 + dtype: timestamp[s][pyarrow] + ``` ## `pykx.DateAtom` @@ -742,14 +800,35 @@ True ``` === "Pandas" - Calling `.pd()` on a `pykx.DateVector` will return a pandas `Series` with `dtype` `datetime64[ns]`. + Calling `.pd()` on a `pykx.DateVector` will return a pandas `Series` with `dtype`: - ```Python - >>> kx.DateVector([date(1972, 5, 1), date(1999, 5, 1)]).pd() - 0 1972-05-01 - 1 1999-05-01 - dtype: datetime64[ns] - ``` + 1. `datetime64[ns]` in `pandas<2.0`: + + ```python + # pandas<2.0 + >>> kx.DateVector([date(1972, 5, 1), date(1999, 5, 1)]).pd() + 0 1972-05-01 + 1 1999-05-01 + dtype: datetime64[ns] + ``` + + 2. `datetime64[s]` in `pandas>=2.0`: + + ```python + >>> kx.DateVector([date(1972, 5, 1), date(1999, 5, 1)]).pd() + 0 1972-05-01 + 1 1999-05-01 + dtype: datetime64[s] + ``` + + 3. `timestamp[s][pyarrow]` in `pandas>=2.0` with `as_arrow=True`: + + ```python + >>> kx.DateVector([date(1972, 5, 1), date(1999, 5, 1)]).pd(as_arrow=True) + 0 1972-05-01 00:00:00 + 1 1999-05-01 00:00:00 + dtype: timestamp[s][pyarrow] + ``` === "PyArrow" Calling `.pa()` on a `pykx.DateVector` will return a pyarrow `Date32Array`. @@ -830,14 +909,25 @@ True ``` === "Pandas" - Calling `.pd()` on a `pykx.TimespanVector` will return a pandas `Series` with `dtype` `timedelta64[ns]`. + Calling `.pd()` on a `pykx.TimespanVector` will return a pandas `Series` with `dtype`: - ```Python - >>> kx.TimespanVector([timedelta(days=43938, seconds=68851, microseconds=664551), timedelta(days=43938, seconds=68851, microseconds=664551)]).pd() - 0 43938 days 19:07:31.664551 - 1 43938 days 19:07:31.664551 - dtype: timedelta64[ns] - ``` + 1. `timedelta64[ns]`: + + ```python + >>> kx.TimespanVector([timedelta(days=43938, seconds=68851, microseconds=664551), timedelta(days=43938, seconds=68851, microseconds=664551)]).pd() + 0 43938 days 19:07:31.664551 + 1 43938 days 19:07:31.664551 + dtype: timedelta64[ns] + ``` + + 2. `duration[ns][pyarrow]` in `pandas>=2.0` with `as_arrow=True`: + + ```python + >>> kx.TimespanVector([timedelta(days=43938, seconds=68851, microseconds=664551), timedelta(days=43938, seconds=68851, microseconds=664551)]).pd(as_arrow=True) + 0 43938 days 19:07:31.664551 + 1 43938 days 19:07:31.664551 + dtype: duration[ns][pyarrow] + ``` === "PyArrow" Calling `.pa()` on a `pykx.TimespanVector` will return a pyarrow `DurationArray`. @@ -901,14 +991,34 @@ True ``` === "Pandas" - Calling `.pd()` on a `pykx.MinuteVector` will return a pandas `Series` with `dtype` `timedelta64[ns]`. - - ```Python - >>> kx.MinuteVector([timedelta(minutes=216), timedelta(minutes=67)]).pd() - 0 0 days 03:36:00 - 1 0 days 01:07:00 - dtype: timedelta64[ns] - ``` + Calling `.pd()` on a `pykx.MinuteVector` will return a pandas `Series` with `dtype`: + + 1. `timedelta64[ns]` in `pandas<2.0`: + + ```python + >>> kx.MinuteVector([timedelta(minutes=216), timedelta(minutes=67)]).pd() + 0 0 days 03:36:00 + 1 0 days 01:07:00 + dtype: timedelta64[ns] + ``` + + 2. `timedelta64[s]` in `pandas>=2.0`: + + ```python + >>> kx.MinuteVector([timedelta(minutes=216), timedelta(minutes=67)]).pd() + 0 0 days 03:36:00 + 1 0 days 01:07:00 + dtype: timedelta64[s] + ``` + + 3. `duration[s][pyarrow]` in `pandas>=2.0` with `as_arrow=True`: + + ```python + >>> kx.MinuteVector([timedelta(minutes=216), timedelta(minutes=67)]).pd(as_arrow=True) + 0 0 days 03:36:00 + 1 0 days 01:07:00 + dtype: duration[s][pyarrow] + ``` ## `pykx.SecondAtom` @@ -960,14 +1070,34 @@ True ``` === "Pandas" - Calling `.pd()` on a `pykx.SecondVector` will return a pandas `Series` with `dtype` `timedelta64[ns]`. - - ```Python - >>> kx.SecondVector([timedelta(seconds=13019), timedelta(seconds=1019)]).pd() - 0 0 days 03:36:59 - 1 0 days 00:16:59 - dtype: timedelta64[ns] - ``` + Calling `.pd()` on a `pykx.SecondVector` will return a pandas `Series` with `dtype`: + + 1. `timedelta64[ns]` in `pandas<2.0`: + ```python + # pandas<2.0 + >>> kx.SecondVector([timedelta(seconds=13019), timedelta(seconds=1019)]).pd() + 0 0 days 03:36:59 + 1 0 days 00:16:59 + dtype: timedelta64[ns] + ``` + + 2. `timedelta64[s]` in `pandas>=2.0`: + + ```python + >>> kx.SecondVector([timedelta(seconds=13019), timedelta(seconds=1019)]).pd() + 0 0 days 03:36:59 + 1 0 days 00:16:59 + dtype: timedelta64[s] + ``` + + 3. `duration[s][pyarrow]` in `pandas>=2.0` with `as_arrow=True`: + + ```python + >>> kx.SecondVector([timedelta(seconds=13019), timedelta(seconds=1019)]).pd(as_arrow=True) + 0 0 days 03:36:59 + 1 0 days 00:16:59 + dtype: duration[s][pyarrow] + ``` === "PyArrow" Calling `.pa()` on a `pykx.SecondVector` will return a pyarrow `DurationArray`. @@ -1033,14 +1163,34 @@ True === "Pandas" - Calling `.pd()` on a `pykx.TimeVector` will return a pandas `Series` with `dtype` `timedelta64[ns]`. + Calling `.pd()` on a `pykx.TimeVector` will return a pandas `Series` with `dtype`: - ```Python - >>> kx.TimeVector([timedelta(seconds=59789, microseconds=214000), timedelta(seconds=23789, microseconds=214000)]).pd() - 0 0 days 16:36:29.214000 - 1 0 days 06:36:29.214000 - dtype: timedelta64[ns] - ``` + 1. `timedelta64[ns]` in `pandas<2.0`: + + ```python + >>> kx.TimeVector([timedelta(seconds=59789, microseconds=214000), timedelta(seconds=23789, microseconds=214000)]).pd() + 0 0 days 16:36:29.214000 + 1 0 days 06:36:29.214000 + dtype: timedelta64[ns] + ``` + + 2. `timedelta[ms]` in `pandas>=2.0`: + + ```python + >>> kx.TimeVector([timedelta(seconds=59789, microseconds=214000), timedelta(seconds=23789, microseconds=214000)]).pd() + 0 0 days 16:36:29.214000 + 1 0 days 06:36:29.214000 + dtype: timedelta64[ms] + ``` + + 3. `duration[ms][pyarrow]` in `pandas>=2.0` with `as_arrow=True`: + + ```python + >>> kx.TimeVector([timedelta(seconds=59789, microseconds=214000), timedelta(seconds=23789, microseconds=214000)]).pd(as_arrow=True) + 0 0 days 16:36:29.214000 + 1 0 days 06:36:29.214000 + dtype: duration[ms][pyarrow] + ``` === "PyArrow" Calling `.pa()` on a `pykx.TimeVector` will return a pyarrow `DurationArray`. diff --git a/docs/api/streamlit.md b/docs/api/streamlit.md new file mode 100644 index 0000000..0cf146f --- /dev/null +++ b/docs/api/streamlit.md @@ -0,0 +1,10 @@ +# Streamlit Integration + +::: pykx.streamlit + rendering: + show_root_heading: false + options: + show_root_heading: false + members_order: source + members: + - PyKXConnection diff --git a/docs/api/util.md b/docs/api/util.md new file mode 100644 index 0000000..55ffc4f --- /dev/null +++ b/docs/api/util.md @@ -0,0 +1,135 @@ +# PyKX Utilities + +The purpose of this page is to provide users with documentation for utility functions located within various modules within PyKX. + +!!! Note + + This functionality presently is not located in a centralized module but it is expected that with the next major release version of PyKX 3.0.0 they + +## `pykx.ssl_info` + +```python +pykx.ssl_info() +``` + +View information relating to the TLS Settings used by PyKX from your process + +**Returns:** + +| Type | Description | +|-------------------|------------------------------------------------------| +| `pykx.Dictionary` | A dictionary outlining the TLS settings used by PyKX | + +**Example:** + +```python +>>> import pykx as kx +>>> kx.ssl_info() +pykx.Dictionary(pykx.q(' +SSLEAY_VERSION | OpenSSL 1.1.1q 5 Jul 2022 +SSL_CERT_FILE | /usr/local/anaconda3/ssl/server-crt.pem +SSL_CA_CERT_FILE | /usr/local/anaconda3/ssl/cacert.pem +SSL_CA_CERT_PATH | /usr/local/anaconda3/ssl +SSL_KEY_FILE | /usr/local/anaconda3/ssl/server-key.pem +SSL_CIPHER_LIST | ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:.. +SSL_VERIFY_CLIENT| NO +SSL_VERIFY_SERVER| YES +')) +``` + +## `pykx.util.debug_environment` + +```python +pykx.util.debug_environment(detailed=False, return_info=False) +``` + +**Parameters:** + +| Name | Type | Description | Default | +|-------------|------|-----------------------------------------------------------------------------------------------------------|---------| +| detailed | bool | When returning information about a users license print the content of both `QHOME` and `QLIC` directories | `False` | +| return_info | bool | Should the information returned from the function be printed to console (default) or provided as a str | `False` | + + +**Returns:** + +| Type | Description | +|--------------------|-----------------------------------------------------------------------------------------------------| +| `Union[None, str]` | Returns `None` if return information is printed to console otherwise returns a `str` representation | + +**Example:** + +```python +>>> import pykx as kx +>>> kx.util.debug_environment() +**** PyKX information **** +pykx.args: () +pykx.qhome: /usr/local/anaconda3/envs/qenv/q +pykx.qlic: /usr/local/anaconda3/envs/qenv/q +pykx.licensed: True +pykx.__version__: 2.4.3 +pykx.file: /usr/local/anaconda3/lib/python3.8/site-packages/pykx/util.py + +**** Python information **** +sys.version: 3.8.3 (default, Jul 2 2020, 11:26:31) +[Clang 10.0.0 ] +pandas: 2.0.3 +numpy: 1.24.4 +pytz: 2023.3.post1 +which python: /usr/local/bin/python +which python3: /Library/Frameworks/Python.framework/Versions/3.12/bin/python3 +find_libpython: /usr/local/anaconda3/lib/libpython3.8.dylib + +**** Platform information **** +platform.platform: macOS-10.16-x86_64-i386-64bit + +**** PyKX Environment Variables **** +PYKX_IGNORE_QHOME: +PYKX_KEEP_LOCAL_TIMES: +PYKX_ALLOCATOR: +PYKX_GC: +PYKX_LOAD_PYARROW_UNSAFE: +PYKX_MAX_ERROR_LENGTH: +PYKX_NOQCE: +PYKX_Q_LIB_LOCATION: +PYKX_RELEASE_GIL: +PYKX_Q_LOCK: +PYKX_DEFAULT_CONVERSION: +PYKX_SKIP_UNDERQ: +PYKX_UNSET_GLOBALS: +PYKX_DEBUG_INSIGHTS_LIBRARIES: +PYKX_EXECUTABLE: /usr/local/anaconda3/bin/python +PYKX_PYTHON_LIB_PATH: +PYKX_PYTHON_BASE_PATH: +PYKX_PYTHON_HOME_PATH: +PYKX_DIR: /usr/local/anaconda3/lib/python3.8/site-packages/pykx +PYKX_QDEBUG: +PYKX_THREADING: +PYKX_4_1_ENABLED: + +**** PyKX Deprecated Environment Variables **** +SKIP_UNDERQ: +UNSET_PYKX_GLOBALS: +KEEP_LOCAL_TIMES: +IGNORE_QHOME: +UNDER_PYTHON: +PYKX_NO_SIGINT: + +**** q Environment Variables **** +QARGS: +QHOME: /usr/local/anaconda3/lib/python3.8/site-packages/pykx/lib +QLIC: /usr/local/anaconda3/envs/qenv/q +QINIT: + +**** License information **** +pykx.qlic directory: True +pykx.qhome writable: True +pykx.qhome lics: ['k4.lic'] +pykx.qlic lics: ['k4.lic'] + +**** q information **** +which q: /usr/local/anaconda3/envs/qenv/q/q +q info: +(`m64;4f;2020.05.04) +"insights.lib.embedq insights.lib.pykx.. +``` diff --git a/docs/beta-features/examples/streamlit.py b/docs/beta-features/examples/streamlit.py new file mode 100644 index 0000000..5b881da --- /dev/null +++ b/docs/beta-features/examples/streamlit.py @@ -0,0 +1,39 @@ +# Set environment variables needed to run Steamlit integration +import os +os.environ['PYKX_BETA_FEATURES'] = 'true' + +# This is optional but suggested as without it's usage caching +# is not supported within streamlit +os.environ['PYKX_THREADING'] = 'true' + +import streamlit as st +import pykx as kx +import matplotlib.pyplot as plt + + +def main(): + st.header('PyKX Demonstration') + connection = st.connection('pykx', + type=kx.streamlit.PyKXConnection, + port=5050, + username='user', + password='password') + if connection.is_healthy(): + tab = connection.query('select from tab where size<11') + else: + raise kx.QError('Connection object was not deemed to be healthy') + fig, x = plt.subplots() + x.scatter(tab['size'], tab['price']) + + st.write('Queried kdb+ remote table') + st.write(tab) + + st.write('Generated plot') + st.pyplot(fig) + + +if __name__ == "__main__": + try: + main() + finally: + kx.shutdown_thread() diff --git a/docs/beta-features/index.md b/docs/beta-features/index.md index ca6fecc..c23c398 100644 --- a/docs/beta-features/index.md +++ b/docs/beta-features/index.md @@ -15,7 +15,7 @@ Within PyKX beta features are enabled through the use of a configuration/environ >>> os.environ['PYKX_BETA_FEATURES'] = 'True' >>> import pykx as kx >>> kx.beta_features -['Database Management', 'Remote Functions'] +['Streamlit Integration', 'Compression and Encryption', 'Database Management', 'Remote Functions'] ``` Alternatively you can set beta features to be available at all times by adding `PYKX_BETA_FEATURES` to your `.pykx-config` file as outlined [here](../user-guide/configuration.md#configuration-file). An example of a configuration making use of this is as follows: @@ -50,3 +50,4 @@ The following are the currently available beta features: - [Remote Functions](remote-functions.md) let you define functions in Python which interact directly with kdb+ data on a q process. These functions can seamlessly integrate into existing Python infrastructures and also benefit systems that use q processes over Python for performance reasons or as part of legacy applications. - [PyKX Threading](threading.md) provides users with the ability to call into `EmbeddedQ` from multithreaded python programs and allow any thread to modify global state safely. +- [Streamlit Integration](streamlit.md) provides users with the ability to query kdb+ infrastructure through direct integration with Streamlit. diff --git a/docs/beta-features/remote-functions.md b/docs/beta-features/remote-functions.md index 41145f8..c103b77 100644 --- a/docs/beta-features/remote-functions.md +++ b/docs/beta-features/remote-functions.md @@ -8,7 +8,7 @@ Remote Functions let you define Python functions within your Python environment which can interact with kdb+ data on a q process. Once defined, these functions are registered to a [remote session object]() along with any Python dependencies which need to be imported. The [remote session object]() establishes and manages the remote connection to the kdb+/q server. -To execute kdb+/q functions using PyKX, please see [PyKX under q](../pykx-under-q/intro.html) +To execute kdb+/q functions using PyKX, please see [PyKX under q](../pykx-under-q/intro.md) ## Requirements and limitations diff --git a/docs/beta-features/streamlit.md b/docs/beta-features/streamlit.md new file mode 100644 index 0000000..3d03721 --- /dev/null +++ b/docs/beta-features/streamlit.md @@ -0,0 +1,111 @@ +# Streamlit Integration + +!!! Warning + + This module is a Beta Feature and is subject to change. To enable this functionality for testing please follow the configuration instructions [here](../user-guide/configuration.md) setting `PYKX_BETA_FEATURES='true'` + + This functionality is presently not supported on Windows, for full utilisation of this functionality `PYKX_THREADING='true'` nust be set in configuration. + +## Introduction + +[Streamlit](https://streamlit.io) provides an open source framework allowing users to turn Python scripts into sharable web applications. Functionally, Streamlit provides access to external data-sources using the concept of `connections` which allow users to develop conforming APIs which will integrate directly with streamlit applications as extension connection types. + +The integration outlined below makes use of this by generating a new `pykx.streamlit.PyKXConnection` connection type which provides the ability to create synchronous connections to existing q/kdb+ sessions. + +A full breakdown of the API documentation of this class can be found [here](../api/streamlit.md). + +## Requirements and limitations + +To run this functionality, users must have `streamlit>=1.28` installed local to their Python session. + +This can be installed using the following command: + +```bash +pip install pykx[streamlit] +``` + + +## Functional walkthrough + +This walkthrough will demonstrate the following steps: + +1. Initialize a q/kdb+ server on a specified port and populating some data. +1. Generate a `streamlit.py` script which queries the q server and creates a basic streamlit application. +1. Run the streamlit application and view locally + +### Initializing a q/kdb+ server + +This step ensures you have a q process running and a kdb+ table available to query. If you have this already, proceed to the next step. + +Ensure that you have q installed. If you do not have this installed please follow the guide provided [here](https://code.kx.com/q/learn/install/), retrieving your license following the instructions provided [here](https://kx.com/kdb-insights-personal-edition-license-download). + +```bash +q -p 5050 +``` + +Create a table which you will use within your Python analytics defined below. + +```q +q)N:1000 +q)tab:([]sym:N?`AAPL`MSFT`GOOG`FDP;price:100+N?100f;size:10+N?100) +``` + +Set a requirement for users to provide a username/password if you wish to add security to your q process. + +```q +.z.pw:{[u;p]$[(u~`user)&p~`password;1b;0b]} +``` + +### Generate a streamlit script/application + +The following script generates a simple streamlit application which: + +1. Set environment variables and import required libraries +1. Define a function to run for generation of the streamlit application + 1. Name the streamlit application. + 1. Create a connection to the q process initialized on port 5050 above. + 1. Query the q process retrieving a small tabular subset of data using a qsql statement. + 1. Generate a Matplotlib graph directly using the PyKX table. + 1. Display both the table and graph + +This script can additionally be downloaded [here](examples/streamlit.py). + +```python +# Set environment variables needed to run Steamlit integration +import os +os.environ['PYKX_BETA_FEATURES'] = 'true' + +# This is optional but suggested as without it's usage caching +# is not supported within streamlit +os.environ['PYKX_THREADING'] = 'true' + +import streamlit as st +import pykx as kx +import matplotlib.pyplot as plt + +def main(): + st.header('PyKX Demonstration') + connection = st.connection('pykx', + type=kx.streamlit.PyKXConnection, + port=5050, + username='user', + password='password') + if connection.is_healthy(): + tab = connection.query('select from tab where size<11') + else: + raise kx.QError('Connection object was not deemed to be healthy') + fig, x = plt.subplots() + x.scatter(tab['size'], tab['price']) + + st.write('Queried kdb+ remote table') + st.write(tab) + + st.write('Generated plot') + st.pyplot(fig) + +if __name__ == "__main__": + try: + main() + finally: + kx.shutdown_thread() +``` diff --git a/docs/blogs.md b/docs/blogs.md index 4ee878e..fbccacf 100644 --- a/docs/blogs.md +++ b/docs/blogs.md @@ -1,4 +1,4 @@ -# Blogs, Articles and Videos +# Blogs, Articles, Podcasts and Videos KX, Partners and members of the public regularly post articles, blogs and videos relating to their usage of PyKX and how it can be used as part of solutions to real-world problems. The intention of this page is to centralise these blogs and articles and will be kept up to date regularly. @@ -6,7 +6,7 @@ KX, Partners and members of the public regularly post articles, blogs and videos If you would like to contribute content to this site, feel free to raise a pull request [here](https://github.com/KxSystems/pykx/pull). We would love to hear from you. -_Last updated:_ 8th March 2024 +_Last updated:_ 10th May 2024 ## Blogs @@ -17,6 +17,7 @@ _Last updated:_ 8th March 2024 | [PyKX Boosts Trade Analytics](https://www.treliant.com/knowledge-center/pykx-boosts-trade-analytics/) | An introduction to the fundamental features and functionality of PyKX | Paul Douglas, Paul Walsh, and Thomas Smyth | June 26th 2023 | | [PyKX Highlights 2023](https://kx.com/blog/pykx-highlights-2023/) | A breakdown of new features and functionality added from January 2023 to version 2.1.1 in October 2023. | Rian Ó Cuinneagáin | 25th October 2023 | | [Build and Manage Databases using PyKX](https://kx.com/blog/how-to-build-and-manage-databases-using-pykx/) | A breakdown of how PyKX can be used to generate and maintain kdb+ databases using newly released functionality | Conor McCarthy | 24th January 2024 | +| [Contributing to PyKX](https://www.habla.dev/blog/2024/04/10/Contributing-to-PyKX.html) | Outlining how new developers can contribute to PyKX | Oscar Nydza Nicpoñ | 10th April 2024 | ## Articles @@ -29,6 +30,12 @@ _Last updated:_ 8th March 2024 ## Videos +### Using PyKX to Bring the Power of kdb+ to Python + +Conor McCarthy Introduces how PyKX can be used generate data, run analytics and create databases. + + + ### Accelerating Application Development with PyKX Jack Kiernan outlines the fundamentals of PyKX. @@ -48,3 +55,6 @@ Mohammad Noor and Oliver Stewart outline how Citadel make use of PyKX to acceler +## Podcasts + + diff --git a/docs/examples/charting.ipynb b/docs/examples/charting.ipynb new file mode 100644 index 0000000..325c11d --- /dev/null +++ b/docs/examples/charting.ipynb @@ -0,0 +1,380 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "0cee3f27-46b2-4ed8-9199-a6c83968b76d", + "metadata": {}, + "source": [ + "# Charting Data with PyKX\n", + "\n", + "This workbook details example of interfacing PyKX with Python charting libraries.\n", + "\n", + "PyKX supports rich datatype mapping meaning you can convert data from PyKX objects to:\n", + "- Python objects using `.py()`\n", + "- NumPy objects using `.np()`\n", + "- Pandas objects using `.pd()`\n", + "- PyArrow objects using `.pa()`\n", + "\n", + "The full breakdown of how these map is documented [here.](https://code.kx.com/pykx/api/pykx-q-data/type_conversions.html)\n", + "\n", + "These resulting objects will behave as expected with all Python libraries.\n", + "\n", + "For efficiency and exactness the examples below aim to use PyKX objects directly, minimising conversions when possible." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a6c62cd2", + "metadata": { + "tags": [ + "hide_code" + ] + }, + "outputs": [], + "source": [ + "import os\n", + "os.environ['IGNORE_QHOME'] = '1' # Ignore symlinking PyKX q libraries to QHOME\n", + "os.environ['PYKX_Q_LOADED_MARKER'] = '' # Only used here for running Notebook under mkdocs-jupyter during document generation." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "bb0e7404-32f3-4f2d-874b-e596ad14be0a", + "metadata": {}, + "outputs": [ + { + "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", + "
sympricesizequantityin_stock
0a0.9094126451b
1a0.29884775181b
2c0.4540638110b
3b0.1569421361b
4c0.046992654431b
" + ], + "text/plain": [ + "pykx.Table(pykx.q('\n", + "sym price size quantity in_stock\n", + "-------------------------------------\n", + "a 0.9094126 4 5 1 \n", + "a 0.2988477 5 18 1 \n", + "c 0.454063 8 11 0 \n", + "b 0.156942 1 36 1 \n", + "c 0.04699265 4 43 1 \n", + "'))" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import pykx as kx\n", + "tab = kx.Table(data={\n", + " 'sym':kx.random.random(1000, ['a', 'b', 'c']), \n", + " 'price':kx.random.random(1000, 1.0), \n", + " 'size':kx.random.random(1000, 10),\n", + " 'quantity':kx.random.random(1000,100),\n", + " 'in_stock':kx.random.random(1000, [True, False])})\n", + "tab.head()" + ] + }, + { + "cell_type": "markdown", + "id": "c238bc17-98a2-4014-ab38-5c13f8e7c8d1", + "metadata": {}, + "source": [ + "## Matplotlib\n", + "\n", + "Generating a scatter plot using the `price` and `size` columns of our table. \n", + "\n", + "The `scatter(tab['price'], tab['quantity'])` notation is used to access PyKX objects directly. \n", + "\n", + "To use `x=` and `y=` syntax requires conversion to a dataframe using `.pd()` .i.e `scatter(tab.pd(), x='price' ,y='quantity')` \n", + "\n", + "`scatter` fundamentally uses a series of 1D arrays and is therefore one of the only charts where the column values do not need to first be converted in Numpy objects using `.np()`." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "6bd7e251-7b25-432f-8e0e-0e32ac7e95b1", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "plt.scatter(tab['price'], tab['quantity'])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "2e76c5d1-7dd3-482c-90cb-c263d31ad808", + "metadata": {}, + "source": [ + "In order for the column values to be compatible with most of matplotlib charts, they first must be converted to numpy objects using the `.np()` function." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "b62a4a3f-90bb-4f9f-8df6-46fdfb6bc4b9", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.bar(tab['size'].np(), tab['price'].np())\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "3d0e9c66-ef79-4e11-a9c1-6797d608c835", + "metadata": {}, + "source": [ + "## Plotly\n", + "\n", + "Plotly allows `vector` objects to be passed as the `color` argument. This parameter is set using the `sym` column resulting in the scatter chart below.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "4e673c63-fb40-4a22-bee6-01f6fdba7506", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import plotly.express as px\n", + "\n", + "fig = px.scatter(\n", + " x=tab['quantity'],\n", + " y=tab['price'],\n", + " size=tab['size'],\n", + " color=tab['sym'])\n", + "fig.show(renderer=\"png\")" + ] + }, + { + "cell_type": "markdown", + "id": "07595eb5-26ef-45c9-a15d-0edbe2bee955", + "metadata": {}, + "source": [ + "Unlike with Pandas, a PyKX table cannot be passed as the first argument with the following data being passed as column names. Each axis must be explicitly set. \n", + "\n", + "To use this feature, first convert to Pandas using the `.pd()` function" + ] + }, + { + "cell_type": "markdown", + "id": "cdd20942-1a7d-419c-a0ff-3e6e07f3acf9", + "metadata": {}, + "source": [ + "A density heatmap using Plotly. This time the table is converted to a Pandas Dataframe and then the axes are simply assigned the column names as strings." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "47431b0c-091a-436f-9a07-48eefc33c52a", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig = px.density_heatmap(\n", + " tab.pd(),\n", + " x='price', \n", + " y='size')\n", + "fig.show(renderer=\"png\")" + ] + }, + { + "cell_type": "markdown", + "id": "3f9de707-f07a-4ca5-b46a-980abb51c640", + "metadata": {}, + "source": [ + "## Seaborn\n", + "\n", + "Seaborn allows the user to set `data` as a PyKX table name without conversions and then call the `x` and `y` parameters using only the column names of that table.\n", + "\n", + "A bar chart below demonstrates this with the data being set as the table object and all of the parameters being set using the column names, all without conversions." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "82306712-b9cd-480d-9d86-3e241f5717e0", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import seaborn as sns\n", + "\n", + "sns.catplot(\n", + " kind='bar',\n", + " data=tab,\n", + " x='size',\n", + " y='quantity',\n", + " hue='sym'\n", + ")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "c6c63b3f-c8a2-48d3-a63f-334af2c158ab", + "metadata": {}, + "source": [ + "Seaborn supports joining plots together, allowing the user access to another layer of visualisation." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "209a7f8c-94a7-4199-a79b-be21b7c9df6a", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.jointplot(data=tab, x=\"quantity\", y=\"price\", hue=\"sym\")\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/examples/db-management.ipynb b/docs/examples/db-management.ipynb index b58935d..115d747 100644 --- a/docs/examples/db-management.ipynb +++ b/docs/examples/db-management.ipynb @@ -5,14 +5,14 @@ "id": "015ba887", "metadata": {}, "source": [ - "# Introduction\n", + "# Database Creation and Management\n", "\n", "This notebook provides a walkthrough of some of the functionality available for users looking to create and maintain large databases using PyKX.\n", "\n", "In particular, this notebook refers to creating and maintaining [partitioned kdb+ databases](https://code.kx.com/q/kb/partition/). Go to [Q for Mortals](https://code.kx.com/q4m3/14_Introduction_to_Kdb+/#143-partitioned-tables) for more in-depth information about partitioned databases in kdb+.\n", "\n", - "You can download this walkthrough as a `.ipynb` notebook file using the following link.", - "\n", + "You can download this walkthrough as a `.ipynb` notebook file using the following link.\n", + "\n", "This walkthrough provides examples of the following tasks:\n", "\n", "1. Creating a database from a historical dataset\n", @@ -33,6 +33,22 @@ "Import all required libraries and create a temporary directory which will be used to store the database we create for this walkthrough" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "04341da6", + "metadata": { + "tags": [ + "hide_code" + ] + }, + "outputs": [], + "source": [ + "import os\n", + "os.environ['IGNORE_QHOME'] = '1' # Ignore symlinking PyKX q libraries to QHOME\n", + "os.environ['PYKX_Q_LOADED_MARKER'] = '' # Only used here for running Notebook under mkdocs-jupyter during document generation." + ] + }, { "cell_type": "code", "execution_count": 1, diff --git a/docs/extras/known_issues.md b/docs/extras/known_issues.md index b16d656..cc711d0 100644 --- a/docs/extras/known_issues.md +++ b/docs/extras/known_issues.md @@ -1,17 +1,12 @@ # Known Issues -- Enabling the NEP-49 numpy allocators will often segfault when running in a multiprocess setting. +- Enabling the NEP-49 NumPy allocators will often segfault when running in a multiprocess setting. - The timeout value is always set to `0` when using `PYKX_Q_LOCK`. - Enabling `PYKX_ALLOCATOR` and using PyArrow tables can cause segfaults in certain scenarios. - `kurl` functions require their `options` dictionary to have mixed type values. Add a `None` value to bypass: `{'': None, ...}` (See [docs](https://code.kx.com/insights/core/kurl/kurl.html)) -- Pandas 2.0 has deprecated the `datetime64[D/M]` types. - - Due to this change it is not always possible to determine if the resulting q Table should - use a `MonthVector` or a `DayVector`. In the scenario that it is not possible to determine - the expected type a warning will be raised and the `DayVector` type will be used as a - default. - `None` and `pykx.Identity(pykx.q('::'))` do not pass through to single argument Python functions set under q. See [here](../pykx-under-q/known_issues.md#default-parameter). - ``` + ```python >>> def func(n=2): ... return n ... diff --git a/docs/getting-started/installing.md b/docs/getting-started/installing.md index ce7e0db..55127ca 100644 --- a/docs/getting-started/installing.md +++ b/docs/getting-started/installing.md @@ -1,80 +1,114 @@ -# Installing +--- +title: PyKX installation guide +description: Getting started with PyKX +date: April 2024 +author: KX Systems, Inc., +tags: PyKX, setup, install, +--- +# PyKX installation guide -Installation of PyKX is available in using three methods +_This section explains how to install PyKX on your machine._ -1. Installing PyKX from PyPI -2. Installation from source -3. Installation using Anaconda +## Pre-requisites -??? Warning "Anaconda OS support" +Before you start, make sure you have: - PyKX on Anaconda is only supported for Linux x86 and arm based architectures at this time +- **Python** (versions 3.8-3.12) +- **Pip** -!!! Note Python Support +Recommended: a virtual environment with packages such as [venv](https://docs.python.org/3/library/venv.html) from the standard library. - PyKX is only officially supported on Python versions 3.8-3.12, Python 3.7 has reached end of life and is no longer actively supported, please consider upgrading +## Supported environments -=== "Installing PyKX from PyPI" - Ensure you have a recent version of `pip`: - - ``` - pip install --upgrade pip - ``` - - Then install the latest version of PyKX with the following command: +KX only supports versions of PyKX built by KX (installed from wheel files) for: - ``` - pip install pykx - ``` +- **Linux** (`manylinux_2_17_x86_64`, `linux-arm64`) with CPython 3.8-3.12 +- **macOS** (`macosx_10_10_x86_64`, `macosx_10_10_arm`) with CPython 3.8-3.12 +- **Windows** (`win_amd64`) with CPython 3.8-3.12 -=== "Installing PyKX from source" - Installing PyKX from source requires you to have access to a [github](https://github.com) account, once you have access to github you can clone the PyKX repository as follows +??? Note "Special instructions for Windows users." - ``` - git clone https://github.com/kxsystems/pykx - ``` + To run q or PyKX on Windows, you have two options: - Once cloned you can move into the cloned directory and install PyKX using `pip` + - **Install** `#!bash msvcr100.dll`, included in the [Microsoft Visual C++ 2010 Redistributable](https://www.microsoft.com/en-ca/download/details.aspx?id=26999). - ``` + - **Or Execute** `#!bash w64_install.ps1` supplied at the root of the PyKX GitHub [here](https://github.com/KxSystems/pykx) as follows, using PowerShell: + + ```PowerShell + git clone https://github.com/kxsystems/pykx cd pykx - pip install . + .\w64_install.ps1 ``` +We provide assistance to user-built installations of PyKX only on a best-effort basis. -=== "Installing PyKX from Anaconda" - If you use `conda` you can install PyKX from the `kx` channel on Anaconda as follows typing `y` when prompted to accept the installation +## 1. Install PyKX - ``` - conda install -c kx pykx - ``` +You can install PyKX from three sources: + +!!! Note "" + + === "Install PyKX from PyPI" + + Ensure you have a recent version of `#!bash pip`: -!!! Warning + ``` + pip install --upgrade pip + ``` + Then install the latest version of PyKX with the following command: + + ``` + pip install pykx + ``` + + === "Install PyKX from Anaconda" + + For Linux x86 and arm-based architectures, you can install PyKX from the `#!bash kx` channel on Anaconda as follows: + + ``` + conda install -c kx pykx + ``` + Type `#!bash y` when prompted to accept the installation. - Python packages should typically be installed in a virtual environment. [This can be done with the venv package from the standard library](https://docs.python.org/3/library/venv.html). -## PyKX License access and enablement + === "Install PyKX from GitHub" + + Clone the PyKX repository: + + ``` + git clone https://github.com/kxsystems/pykx + ``` + + Enter the cloned repository and install PyKX using `#!bash pip`: + + ``` + cd pykx + pip install . + ``` + +At this point you have [partial access to PyKX](../user-guide/advanced/modes.md#operating-in-the-absence-of-a-kx-license). To gain access to all PyKX features, follow the steps in the next section, otherwise go straight to [3. Verify PyKX Installation](#3-verify-pykx-installation). -Installation of PyKX following the instructions above provides users with access to the library with limited functional scope, full details of these limitations can be found [here](../user-guide/advanced/modes.md). To access the full functionality of PyKX you must first download and install a KX license, this can be achieved either through use of a personal evaluation license or receipt of a commercial license. +## 2. Install a KDB Insights license -!!! Warning "Legacy kdb+/q licenses do not support PyKX by default" +To use all PyKX functionalities, you need to download and install a KDB Insights license. - PyKX will not operate with a vanilla or legacy kdb+ license which does not have access to specific feature flags embedded within the license. In the absence of a license with appropriate feature flags PyKX will fail to initialise with full feature functionality. +!!! Warning "Legacy kdb+/q licenses do not support all PyKX features." -### License installation from a Python session +There are two types of KDB Insights licenses for PyKX: personal and commercial. For either of them, you have two installation options: -The following steps outline the process by which a user can gain access to and install a kdb Insights personal evaluation license for PyKX from a Python session. + - a) from Python + - b) using environment variables -??? Note "Commercial evaluation installation workflow" +### 2.a Install license in Python - The same workflow used for the personal evaluations defined below can be used for commercial evaluations, the only difference being the link used when signing up for your evaluation license. In the case of commercial evaluation this should be https://kx.com/kdb-insights-commercial-evaluation-license-download/ +Follow the steps below to install a KDB Insights license for PyKX from Python: -1. Start your Python session +1. Start your Python session: ```bash $ python ``` -2. Import the PyKX library which will prompt for user input accept this message using `Y` or hitting enter +2. Import the PyKX library. When prompted to accept the installation, type `Y` or press `Enter`: ```python >>> import pykx as kx @@ -85,140 +119,194 @@ The following steps outline the process by which a user can gain access to and i Would you like to continue with license installation? [Y/n]: ``` -3. You will then be prompted asking if you would like to redirect to the kdb Insights personal license installation website +3. Choose whether you wish to install a personal or commercial license, type `Y` or press `Enter` to choose a personal license - ```bash - To apply for a PyKX license, please visit https://kx.com/kdb-insights-personal-edition-license-download. - Once the license application has completed, you will receive a welcome email containing your license information. - Would you like to open this page? [Y/n]: + ```python + Is the intended use of this software for: + [1] Personal use (Default) + [2] Commercial use + Enter your choice here [1/2]: ``` -4. Ensure that you have completed the form for accessing a kdb Insights personal evaluation license and have received your welcome email. -5. Your will be prompted asking if you wish to install your license based on downloaded license file or using the base64 encoded string provided in your email as follows. Enter `1`, `2` or `3` as appropriate. +4. When asked if you would like to apply for a license, type `Y` or press `Enter`: + + === "Personal license" + + ```bash + To apply for a PyKX license, navigate to https://kx.com/kdb-insights-personal-edition-license-download + Shortly after you submit your license application, you will receive a welcome email containing your license information. + Would you like to open this page? [Y/n]: + ``` + + === "Commercial license" + + ```bash + To apply for your PyKX license, contact your KX sales representative or sales@kx.com. + Alternately apply through https://kx.com/book-demo. + Would you like to open this page? [Y/n]: + ``` + +5. For personal use, complete the form to receive your welcome email. For commercial use, the license will be provided over email after the commercial evaluation process has been followed with the support of your sales representative. + +6. Choose the desired method to activate your license by typing `1`, `2`, or `3` as appropriate: ```bash - Please select the method you wish to use to activate your license: - [1] Download the license file provided in your welcome email and input the file path (Default) - [2] Input the activation key (base64 encoded string) provided in your welcome email - [3] Proceed with unlicensed mode: + Select the method you wish to use to activate your license: + [1] Download the license file provided in your welcome email and input the file path (Default) + [2] Input the activation key (base64 encoded string) provided in your welcome email + [3] Proceed with unlicensed mode Enter your choice here [1/2/3]: ``` -6. Once you have decided on decided on your option please finish your installation following the appropriate final step below +7. Depending on your choice (`1`, `2`, or `3`), complete the installation by following the final step as below: === "1" - ```bash - Please provide the download location of your license (E.g., ~/path/to/kc.lic) : - ``` + === "Personal license" + + ```bash + Provide the download location of your license (for example, ~/path/to/kc.lic): + ``` + + === "Commercial license" + + ```bash + Provide the download location of your license (for example, ~/path/to/k4.lic): + ``` === "2" ```bash - Please provide your activation key (base64 encoded string) provided with your welcome email : + Provide your activation key (base64 encoded string) provided with your welcome email: ``` + === "3" -7. Validate that your license has been installed correctly + ```bash + No further actions needed. + ``` + +8. Validate the correct installation of your license: ```python >>> kx.q.til(10) pykx.LongVector(pykx.q('0 1 2 3 4 5 6 7 8 9')) ``` -!!! Note "Troubleshooting and Support" +### 2.b Install license with environment variables - If once you have completed these installation steps you are still seeing issues please visit our [troubleshooting](../troubleshooting.md) guide and [support](../support.md) pages. +For environment-specific flexibility, there are two ways to install your license: by using a file or by copying text. Both are sourced in your welcome email. Click on the tabs below, read the instructions, and choose the method you wish to follow: -### License installation using environment variables +!!! Note "" -To provide environment specific flexibility there are two methods by which users can install a license using environment variables. In both cases this method is flexible to the installation of both `kc.lic` and `k4.lic` versions of a license. + === "Using a file" -#### Using a supplied license file directly + 1. For personal usage, navigate to the [personal license](https://kx.com/kdb-insights-personal-edition-license-download/) and complete the form. For commercial usage, contact your KX sales representative or sales@kx.com or apply through https://kx.com/book-demo. -1. Visit [here](https://kx.com/kdb-insights-personal-edition-license-download/) for a personal edition or [here](https://kx.com/kdb-insights-commercial-evaluation-license-download/) for a commercial evaluation license and fill in the attached form following the instructions provided. -2. On receipt of an email from KX providing access to your license download the license file and save to a secure location on your computer. -3. Set an environment variable on your computer pointing to the folder containing the license file (instructions for setting environment variables on PyKX supported operating systems can be found [here](https://chlee.co/how-to-setup-environment-variables-for-windows-mac-and-linux/). - * Variable Name: `QLIC` - * Variable Value: `/user/path/to/folder` + 2. On receipt of an email from KX, download and save the license file to a secure location on your computer. -#### Using the base64 encoded license content + 3. Set an environment variable pointing to the folder with the license file. (Learn how to set environment variables from [here](https://chlee.co/how-to-setup-environment-variables-for-windows-mac-and-linux/)). + * **Variable Name**: `#!bash QLIC` + * **Variable Value**: `#!bash /user/path/to/folder` -1. Visit [here](https://kx.com/kdb-insights-personal-edition-license-download/) for a personal edition or [here](https://kx.com/kdb-insights-commercial-evaluation-license-download/) for a commercial evaluation license and fill in the attached form following the instructions provided. -2. On receipt of an email from KX providing access to your license copy the base64 encoded contents of your license provided in plain-text within the email -3. Set an environment variable `KDB_LICENSE_B64` on your computer pointing with the value copied in step 2 (instructions for setting environment variables on PyKX supported operating systems can be found [here](https://chlee.co/how-to-setup-environment-variables-for-windows-mac-and-linux/). - * Variable Name: `KDB_LICENSE_B64` - * Variable Value: `` + === "Using text" -If looking to make use of a `k4.lic` you can do so by setting the base64 encoded content of your file as the environment variable `KDB_K4LICENSE_B64`. + 1. For personal usage, navigate to the [personal license](https://kx.com/kdb-insights-personal-edition-license-download/) and complete the form. For commercial usage, contact your KX sales representative or sales@kx.com or apply through https://kx.com/book-demo. -## Supported Environments + 2. On receipt of an email from KX, copy the `#!bash base64` encoded contents of your license provided in plain-text within the email. -KX only officially supports versions of PyKX built by KX, i.e. versions of PyKX installed from wheel files. Support for user-built installations of PyKX (e.g. built from the source distribution) is only provided on a best-effort basis. Currently, PyKX provides wheels for the following environments: + 3. On your computer, set an environment variable `#!bash KDB_LICENSE_B64` when using a personal license or `KDB_K4LICENSE_B64` for a commercial license, pointing with the value copied in step 2. (Learn how to set environment variables from [here](https://chlee.co/how-to-setup-environment-variables-for-windows-mac-and-linux/)). + * **Variable Name**: `KDB_LICENSE_B64` / `KDB_K4LICENSE_B64` + * **Variable Value**: `` -- Linux (`manylinux_2_17_x86_64`, `linux-arm64`) with CPython 3.8-3.12 -- macOS (`macosx_10_10_x86_64`, `macosx_10_10_arm`) with CPython 3.8-3.12 -- Windows (`win_amd64`) with CPython 3.8-3.12 +To validate if you successfully installed your license with environment variables, start Python and import PyKX as follows: -## Dependencies +```bash +$ python +>>> import pykx as kx +>>> kx.q.til(5) +pykx.LongVector(pykx.q('0 1 2 3 4')) +``` -### Python Dependencies +As you approach the expiry date for your license you can have PyKX automatically update your license by updating the environment variable `KDB_LICENSE_B64` or `KDB_K4LICENSE_B64` with your new license information. Once PyKX is initialised with your expired license it will attempt to overwrite your license with the newly supplied value. This is outlined as follows: -#### Required Python dependencies +```python +$python +>>> import pykx as kx +Initialisation failed with error: exp +Your license has been updated using the following information: + Environment variable: 'KDB_K4LICENSE_B64' + License write location: /user/path/to/license/k4.lic +``` -PyKX depends on the following third-party Python packages: +## 3. Verify PyKX installation -- `numpy~=1.20, <2.0; python_version=='3.7'` -- `numpy~=1.22, <2.0; python_version<'3.11', python_version>'3.7'` -- `numpy~=1.23, <2.0; python_version=='3.11'` -- `numpy~=1.26, <2.0; python_version=='3.12'` -- `pandas>=1.2, < 2.2.0` -- `pytz>=2022.1` -- `toml~=0.10.2` +To verify if you successfully installed PyKX on your system, run: -They are installed automatically by `pip` when PyKX is installed. +```bash +python -c"import pykx;print(pykx.__version__)" +``` -The following provides a breakdown of how these libraries are used within PyKX +This command should display the installed version of PyKX. -- [Numpy](https://pypi.org/project/numpy) is used by PyKX when converting data from PyKX objects to numpy equivalent array/recarray style objects, additionally low level integration allowing direct calls to numpy functions such as `numpy.max` with PyKX objects relies on the numpy Python API. -- [Pandas](https://pypi.org/project/pandas) is used by PyKX when converting PyKX data to Pandas Series/DataFrame equivalent objects, additionally when converting data to PyArrow data formats as supported by the optional dependencies below Pandas is used as an intermendiary data format. -- [pytz](https://pypi.org/project/pytz/) is used by PyKX when converting data with timezone information to PyKX objects in order to ensure that the timezone offsets are accurately applied. -- [toml](https://pypi.org/project/toml/) is used by PyKX for configuration parsing, in particular when users make use of `.pykx-config` files for configuration management as outlined [here](../user-guide/configuration.md). +## Dependencies +??? Info "Expand for Required and Optional PyKX dependencies" -#### Optional Python Dependencies + === "Required" -- `pyarrow>=3.0.0`, which can be included by installing the `pyarrow` extra, e.g. `pip install pykx[pyarrow]`. -- `find-libpython~=0.2`, which can be included by installing the `debug` extra, e.g. `pip install pykx[debug]`. -- `ast2json~=0.3`, which is required for KX Dashboards Direct integration and can be installed with the `dashboards` extra, e.g. `pip install pykx[dashboards]` -- `dill>=0.2`, which is required for the Beta feature `Remote Functions` can be installed via pip with the `beta` extra, e.g. `pip install pykx[beta]` + PyKX depends on the following third-party Python packages: -!!! Warning + - `numpy~=1.20, <2.0; python_version=='3.7'` + - `numpy~=1.22, <2.0; python_version<'3.11', python_version>'3.7'` + - `numpy~=1.23, <2.0; python_version=='3.11'` + - `numpy~=1.26, <2.0; python_version=='3.12'` + - `pandas>=1.2, < 2.2.0` + - `pytz>=2022.1` + - `toml~=0.10.2` - Trying to use the `pa` conversion methods of `pykx.K` objects or the `pykx.toq.from_arrow` method when PyArrow is not installed (or could not be imported without error) will raise a `pykx.PyArrowUnavailable` exception. `pyarrow` is supported Python 3.8-3.10 but remains in Beta for Python 3.11-3.12. + **Note**: All are installed automatically by `#!bash pip` when you install PyKX. -The following provides a breakdown of how these libraries are used within PyKX + Here's a breakdown of how PyKX uses these libraries: -- [PyArrow](https://pypi.org/project/pyarrow) is used by PyKX for the conversion of PyKX object to and from their PyArrow equivalent table/array objects. -- [find-libpython](https://pypi.org/project/find-libpython) can be used by developers using PyKX to source the `libpython.{so|dll|dylib}` file required by [PyKX under q](../pykx-under-q/intro.md). + - [NumPy](https://pypi.org/project/numpy): converts data from PyKX objects to NumPy equivalent Array/Recarray style objects; direct calls to NumPy functions such as `numpy.max` with PyKX objects relies on the NumPy Python API. + - [Pandas](https://pypi.org/project/pandas): converts PyKX data to Pandas Series/DataFrame equivalent objects or to PyArrow data formats. Pandas is used as an intermendiary data format. + - [pytz](https://pypi.org/project/pytz/): converts data with timezone information to PyKX objects to ensure that the offsets are accurately applied. + - [toml](https://pypi.org/project/toml/): for configuration parsing and management, with `.pykx-config` as outlined [here](../user-guide/configuration.md). -### Optional Non-Python Dependencies -- `libssl` for TLS on [IPC connections](../api/ipc.md). -- `libpthread` on Linux/MacOS when using the `PYKX_THREADING` environment variable. + === "Optional" -### Windows Dependencies + **Optional Python dependencies:** -To run q or PyKX on Windows, `msvcr100.dll` must be installed. It is included in the [Microsoft Visual C++ 2010 Redistributable](https://www.microsoft.com/en-ca/download/details.aspx?id=26999). + - **`pyarrow >=3.0.0`**: install `pyarrow` extra, for example `pip install pykx[pyarrow]`. + - **`find-libpython ~=0.2`**: install `debug` extra, for example `pip install pykx[debug]`. + - **`ast2json ~=0.3`**: install with `dashboards` extra, for example `pip install pykx[dashboards]` + - **`dill >=0.2`**: install via pip, with`beta` extra, for example `pip install pykx[beta]` -Alternatively installation of all required Windows dependencies can be completed through execution of the `w64_install.ps1` supplied at the root of the PyKX github [here](https://github.com/KxSystems/pykx) as follows using PowerShell: + Here's a breakdown of how PyKX uses these libraries: -```PowerShell -git clone https://github.com/kxsystems/pykx -cd pykx -.\w64_install.ps1 -``` + - [PyArrow](https://pypi.org/project/pyarrow): converts PyKX objects to and from their PyArrow equivalent table/array objects. + - [find-libpython](https://pypi.org/project/find-libpython): provides the `libpython.{so|dll|dylib}` file required by [PyKX under q](../pykx-under-q/intro.md). + - [ast2json](https://pypi.org/project/ast2json/): required for KX Dashboards Direct integration. + - [dill](https://pypi.org/project/dill/): required for the Beta feature `Remote Functions`. + + **Optional non-Python dependencies:** + + - `libssl` for TLS on [IPC connections](../api/ipc.md). + - `libpthread` on Linux/MacOS when using the `PYKX_THREADING` environment variable. + +!!! Note "Troubleshooting and Support" + + If you encounter any issues during the installation process, refer to the following sources for assistance: + + - Visit our [troubleshooting](../troubleshooting.md) guide. + - Ask a question on the KX community at [learninghub.kx.com](https://learninghub.kx.com/forums/forum/pykx/). + - Use Stack Overflow and tag [`pykx`](https://stackoverflow.com/questions/tagged/pykx) or [`kdb`](https://stackoverflow.com/questions/tagged/kdb) depending on the subject. + - Go to [support](../support.md). ## Next steps +That's it! You can now start using PyKX in your Python projects: + - [Quickstart guide](quickstart.md) - [User guide introduction](../user-guide/index.md) diff --git a/docs/getting-started/q_magic_command.ipynb b/docs/getting-started/q_magic_command.ipynb index b0ec902..7a0c430 100644 --- a/docs/getting-started/q_magic_command.ipynb +++ b/docs/getting-started/q_magic_command.ipynb @@ -4,12 +4,15 @@ "cell_type": "code", "execution_count": null, "metadata": { - "tags": ["hide_code"] + "tags": [ + "hide_code" + ] }, "outputs": [], "source": [ - "import os\n", - "os.environ['PYKX_Q_LOADED_MARKER'] = '' # Only used here for running Notebook under mkdocs-jupyter during document generation.\n" + "import os\n", + "os.environ['IGNORE_QHOME'] = '1' # Ignore symlinking PyKX q libraries to QHOME\n", + "os.environ['PYKX_Q_LOADED_MARKER'] = '' # Only used here for running Notebook under mkdocs-jupyter during document generation." ] }, { @@ -44,10 +47,15 @@ "source": [ "import subprocess\n", "import time\n", - "proc = subprocess.Popen(\n", - " ('q', '-p', '5001')\n", - ")\n", - "time.sleep(5)" + "\n", + "try:\n", + " with kx.PyKXReimport():\n", + " proc = subprocess.Popen(\n", + " ('q', '-p', '5000')\n", + " )\n", + " time.sleep(2)\n", + "except:\n", + " raise kx.QError('Unable to create q process on port 5000')" ] }, { @@ -71,24 +79,24 @@ ] }, { - "cell_type": "markdown", - "id": "89ec26e4", - "metadata": {}, - "source": [ - "#### Execution options\n", - "\n", - "Execution options can also be included after `%%q`.\n", - "\n", - "Here is the list of currently supported execution options.\n", - "\n", - "```\n", - "--debug: prints the q backtrace before raising a QError\n", - " if the cell errors\n", - "--display: calls display rather than the default print\n", - " on returned objects\n", - "```\n" - ] - }, + "cell_type": "markdown", + "id": "89ec26e4", + "metadata": {}, + "source": [ + "#### Execution options\n", + "\n", + "Execution options can also be included after `%%q`.\n", + "\n", + "Here is the list of currently supported execution options.\n", + "\n", + "```\n", + "--debug: prints the q backtrace before raising a QError\n", + " if the cell errors\n", + "--display: calls display rather than the default print\n", + " on returned objects\n", + "```\n" + ] + }, { "cell_type": "code", "execution_count": null, @@ -149,7 +157,7 @@ "metadata": {}, "outputs": [], "source": [ - "%%q --host localhost --port 5001 --user user --pass password --noctx\n", + "%%q --host localhost --port 5000 --user user --pass password --noctx\n", "til 10" ] }, @@ -168,7 +176,7 @@ "metadata": {}, "outputs": [], "source": [ - "%%q --port 5001\n", + "%%q --port 5000\n", "tab:([]a:1000?1000; b:1000?500.0; c:1000?`AAPL`MSFT`GOOG);" ] }, @@ -189,7 +197,7 @@ }, "outputs": [], "source": [ - "%%q --port 5001\n", + "%%q --port 5000\n", "afunc: {[x; y]\n", " x + y \n", " };\n", @@ -217,7 +225,7 @@ }, "outputs": [], "source": [ - "%%q --port 5001\n", + "%%q --port 5000\n", "\\l s.k_\n", "s) select * from tab where a>500 and b<250.0 limit 5" ] @@ -240,7 +248,7 @@ "metadata": {}, "outputs": [], "source": [ - "%%q --port 5001\n", + "%%q --port 5000\n", "\\d .example\n", "f: {[x] til x};" ] @@ -252,7 +260,7 @@ "metadata": {}, "outputs": [], "source": [ - "%%q --port 5001\n", + "%%q --port 5000\n", "\\d\n", ".example.f[10]" ] @@ -285,7 +293,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.5" + "version": "3.10.12" } }, "nbformat": 4, diff --git a/docs/getting-started/quickstart.md b/docs/getting-started/quickstart.md index 58c2634..58d4788 100644 --- a/docs/getting-started/quickstart.md +++ b/docs/getting-started/quickstart.md @@ -361,7 +361,39 @@ Objects generated via the PyKX library can be converted where reasonable to `Pyt 3 0.452041 4 4 0.019615 0 ``` - + + If using `pandas>=2.0` it is possible to also use the `as_arrow` keyword argument to convert to + pandas types using pyarrow as the backend instead of the default numpy backed pandas objects. + + ```python + >>> qvec = kx.toq(np.random.randint(5, size=10)) + >>> qvec.pd(as_arrow=True) + 0 1 + 1 2 + 2 3 + 3 4 + 4 2 + 5 3 + 6 0 + 7 0 + 8 2 + 9 0 + dtype: int64[pyarrow] + >>> df = pd.DataFrame(data={'x': [random() for _ in range(5)], 'x1': [randint(0, 4) for _ in range(5)]}) + >>> qtab = kx.toq(df) + >>> qtab.pd(as_arrow=True) + x x1 + 0 0.541059 3 + 1 0.886690 1 + 2 0.674300 4 + 3 0.532791 3 + 4 0.523147 4 + >>> qtab.pd(as_arrow=True).dtypes + x double[pyarrow] + x1 int64[pyarrow] + dtype: object + ``` + * Convert PyKX objects to PyArrow ```python diff --git a/docs/release-notes/changelog.md b/docs/release-notes/changelog.md index a5b8343..e8872cf 100644 --- a/docs/release-notes/changelog.md +++ b/docs/release-notes/changelog.md @@ -8,6 +8,559 @@ Currently PyKX is not compatible with Pandas 2.2.0 or above as it introduced breaking changes which cause data to be cast to the incorrect type. +## PyKX 2.5.0 + +#### Release Date + +2024-05-15 + +### Additions + +- Addition of a method for `pykx.Table` objects to apply `xbar` calculations on specified columns names + + ```python + >>> import pykx as kx + >>> N = 5 + >>> kx.random.seed(42) + >>> tab = kx.Table(data = { + ... 'x': kx.random.random(N, 100.0), + ... 'y': kx.random.random(N, 10.0)}) + >>> tab + pykx.Table(pykx.q(' + x y + ----------------- + 77.42128 8.200469 + 70.49724 9.857311 + 52.12126 4.629496 + 99.96985 8.518719 + 1.196618 9.572477 + ')) + >>> tab.xbar('x', 10) + pykx.Table(pykx.q(' + x y + ----------- + 70 8.200469 + 70 9.857311 + 50 4.629496 + 90 8.518719 + 0 9.572477 + ')) + ``` + +- Addition of the method `window_join` to `pykx.Table` objects allowing Window joins to be applied to specified tables + + ```python + >>> trades = kx.Table(data={ + ... 'sym': ['ibm', 'ibm', 'ibm'], + ... 'time': kx.q('10:01:01 10:01:04 10:01:08'), + ... 'price': [100, 101, 105]}) + >>> quotes = kx.Table(data={ + ... 'sym': 'ibm', + ... 'time': kx.q('10:01:01+til 9'), + ... 'ask': [101, 103, 103, 104, 104, 107, 108, 107, 108], + ... 'bid': [98, 99, 102, 103, 103, 104, 106, 106, 107, 108]}) + >>> windows = kx.q('{-2 1+\:x}', trades['time']) + >>> trades.window_join(quotes, + ... windows, + ... ['sym', 'time'], + ... {'ask_minus_bid': [lambda x, y: x - y, 'ask', 'bid'], + ... 'ask_max': [lambda x: max(x), 'ask']}) + pykx.Table(pykx.q(' + sym time price ask_minus_bid ask_max + ---------------------------------------- + ibm 10:01:01 100 3 4 103 + ibm 10:01:04 101 4 1 1 1 104 + ibm 10:01:08 105 3 2 1 1 108 + ')) + ``` + +- On failure to initialize PyKX with an expiry error PyKX can now install an updated license using the environment variables `KDB_LICENSE_B64` or `KDB_K4LICENSE_B64` for `kc.lic` and `k4.lic` licenses respectively. This allows users to pre-emptively set an environment variable to be used for upgrade prior to expiry. + + === "Successful update of License" + + ```python + >>> import pykx as kx + Initialisation failed with error: exp + Your license has been updated using the following information: + Environment variable: KDB_K4LICENSE_B64 + License write location: /user/path/to/license/k4.lic + >>> kx.q.til(5) + pykx.LongVector(pykx.q('0 1 2 3 4')) + ``` + + === "Error where environment variable matches license content" + + ```python + >>> import pykx as kx + We have been unable to update your license for PyKX using the following information: + Environment variable: KDB_K4LICENSE_B64 + License location: /user/path/to/license/k4.lic + Reason: License content matches supplied Environment variable + + Your PyKX license has now expired. + + Captured output from initialization attempt: + '2024.04.26T12:04:49.514 licence error: exp + + License location used: + /user/path/to/license/k4.lic + + Would you like to renew your license? [Y/n]: + ``` + +- Intialization workflow for PyKX using form based install process now allows users to install Commercial "k4.lic" licenses using this mechanism. The updated workflow provides the following outputs + + === "License initialization" + + ```python + >>> import pykx as kx + Thank you for installing PyKX! + + We have been unable to locate your license for PyKX. Running PyKX in unlicensed mode has reduced functionality. + Would you like to continue with license installation? [Y/n]: Y + + Is the intended use of this software for: + [1] Personal use (Default) + [2] Commercial use + Enter your choice here [1/2]: 2 + + To apply for your PyKX license, contact your KX sales representative or sales@kx.com. + Alternately apply through https://kx.com/book-demo. + Would you like to open this page? [Y/n]: n + + Select the method you wish to use to activate your license: + [1] Download the license file provided in your welcome email and input the file path (Default) + [2] Input the activation key (base64 encoded string) provided in your welcome email + [3] Proceed with unlicensed mode + Enter your choice here [1/2/3]: 1 + + Provide the download location of your license (for example, ~/path/to/k4.lic) : ~/path/to/k4.lic + ``` + + === "Unlicensed initialization" + + ```python + Thank you for installing PyKX! + + We have been unable to locate your license for PyKX. Running PyKX in unlicensed mode has reduced functionality. + Would you like to continue with license installation? [Y/n]: n + + PyKX unlicensed mode enabled. To set this as your default behavior please set the following environment variable PYKX_UNLICENSED='true' + + For more information on PyKX modes of operation, please visit https://code.kx.com/pykx/user-guide/advanced/modes.html. + To apply for a PyKX license please visit + + Personal License: https://kx.com/kdb-insights-personal-edition-license-download + Commercial License: Contact your KX sales representative or sales@kx.com or apply on https://kx.com/book-demo + ``` + +- Addition of `Table.replace()` method allowing users to replace all elements in a table of a given value with a different value. + + ```python + >>> tab = kx.q('([] a:2 2 3; b:4 2 6; c:(1b;0b;1b); d:(`a;`b;`c); e:(1;2;`a))') + >>> tab.replace(2, "test") + pykx.Table(pykx.q(' + a b c d e + --------------------- + `test 4 1 a 1 + `test `test 0 b `test + 3 6 1 c `a + ')) + ``` + +- Added `as_arrow` keyword to the `.pd()` method on PyKX Wrapped objects, using `as_arrow=True` will use PyArrow backed data types instead of the default NumPy backed data types. + +### Fixes and Improvements + +- When importing PyKX from a source file path containing a space initialisation would fail with an `nyi` error message, this has now been resolved + + === "Behaviour prior to change" + + ```python + >>> import pykx as kx + Traceback (most recent call last): + File "", line 1, in + File "C:\Program Files\choco\miniconda\lib\site-packages\pykx\__init__.py", line 285, in + from .embedded_q import EmbeddedQ, EmbeddedQFuture, q + .. + pykx.exceptions.QError: nyi + ``` + + === "Behaviour post change" + + ```python + >>> import pykx as kx + >>> kx.q.til(5) + pykx.LongVector(pykx.q('0 1 2 3 4')) + ``` + +- When using `pykx.q.system.load` users can now load files and splayed tables at folder locations containing spaces. +- Updated libq to 4.0 2024.05.07 and 4.1 to 2024.04.29 for all supported OS's. +- `kx.util.debug_environment()` now uses `PyKXReimport` when running the `q` subprocess and captures `stderr` in case of failure. +- When using debug mode, retrieval of unknown context's would incorrectly present a backtrace to a user, for example: + + === "Behaviour prior to change" + + ```python + >>> import os + >>> os.environ['PYKX_QDEBUG'] = 'true' + >>> import pykx as kx + >>> kx.q.read.csv('/usr/local/anaconda3/data/taxi/yellow_tripdata_2019-12.csv') + backtrace: + [2] k){x:. x;$[99h<@x;:`$"_pykx_fn_marker";99h~@x;if[` in!x;if[(::)~x`;:`$"_pykx_ctx_marker"]]]x} + ^ + [1] (.Q.trp) + + [0] {[pykxquery] .Q.trp[value; pykxquery; {2@"backtrace: + ^ + ",.Q.sbt y;'x}]} + + pykx.Table(pykx.q(' + VendorID tpep_pickup_datetime tpep_dropoff_datetime passenge.. + -----------------------------------------------------------------------------.. + 1 2019.12.01D00:26:58.000000000 2019.12.01D00:41:45.000000000 1 .. + 1 2019.12.01D00:12:08.000000000 2019.12.01D00:12:14.000000000 1 .. + 1 2019.12.01D00:25:53.000000000 2019.12.01D00:26:04.000000000 1 .. + ``` + + === "Behaviour post change" + + ```python + >>> import os + >>> os.environ['PYKX_QDEBUG'] = 'true' + >>> import pykx as kx + >>> kx.q.read.csv('/usr/local/anaconda3/data/taxi/yellow_tripdata_2019-12.csv') + pykx.Table(pykx.q(' + VendorID tpep_pickup_datetime tpep_dropoff_datetime passenge.. + -----------------------------------------------------------------------------.. + 1 2019.12.01D00:26:58.000000000 2019.12.01D00:41:45.000000000 1 .. + 1 2019.12.01D00:12:08.000000000 2019.12.01D00:12:14.000000000 1 .. + 1 2019.12.01D00:25:53.000000000 2019.12.01D00:26:04.000000000 1 .. + ``` + +- When using debug mode, PyKX could run into issues where attempts to compare single character atoms would result in an error. This has now been fixed. + + === "Behaviour prior to change" + + ```python + >>> import os + >>> os.environ['PYKX_QDEBUG'] = 'true' + >>> import pykx as kx + >>> kx.q('"z"') == b'z' + backtrace: + [2] =zz + ^ + [1] (.Q.trp) + + [0] {[pykxquery] .Q.trp[value; pykxquery; {2@"backtrace: + ^ + ",.Q.sbt y;'x}]} + Traceback (most recent call last): + File "", line 1, in + File "/usr/local/anaconda3/lib/python3.8/site-packages/pykx/wrappers.py", line 361, in __eq__ + return self._compare(other, '=') + File "/usr/local/anaconda3/lib/python3.8/site-packages/pykx/wrappers.py", line 338, in _compare + r = q(op_str, self, other) + File "/usr/local/anaconda3/lib/python3.8/site-packages/pykx/embedded_q.py", line 233, in __call__ + return factory(result, False) + File "pykx/_wrappers.pyx", line 493, in pykx._wrappers._factory + File "pykx/_wrappers.pyx", line 486, in pykx._wrappers.factory + pykx.exceptions.QError: = + ``` + + === "Behaviour post change" + + ```python + >>> import os + >>> os.environ['PYKX_QDEBUG'] = 'true' + >>> import pykx as kx + >>> kx.q('"z"') == b'z' + pykx.BooleanAtom(pykx.q('1b')) + ``` +- Update to system functions `tables` and `functions` to allow listing of tables and functions within dictionaries. Previously attempts to list entities within dictionaries would attempt to retrieve items in a namespace. The below example shows this behaviour for tables. + + === "Behaviour prior to change" + + ```python + >>> import pykx as kx + >>> kx.q('.test.table:([]100?1f;100?0b)') + >>> kx.q('test.tab:([]10?1f;10?5)') + >>> kx.q.system.tables('test') + pykx.SymbolVector(pykx.q(',`table')) + >>> kx.q.system.tables('.test') + pykx.SymbolVector(pykx.q(',`table')) + ``` + + === "Behaviour post change" + + ```python + >>> import pykx as kx + >>> kx.q('.test.table:([]100?1f;100?0b)') + >>> kx.q('test.tab:([]10?1f;10?5)') + >>> kx.q.system.tables('test') + pykx.SymbolVector(pykx.q(',`tab')) + >>> kx.q.system.tables('.test') + pykx.SymbolVector(pykx.q(',`table')) + ``` + +- Resolved issue in `PyKXReimport` which caused it to set empty environment variables to `None` rather than leaving them empty. +- The `_PyKX_base_types` attribute assigned to dataframes during `.pd()` conversion included `'>` in the contents. This has been removed: + + === "Behaviour prior to change" + + ```python + >>> kx.q('([] a:1 2)').pd().attrs['_PyKX_base_types'] + {'a': "LongVector'>"} + ``` + + === "Behaviour post change" + + ```python + >>> kx.q('([] a:1 2)').pd().attrs['_PyKX_base_types'] + {'a': "LongVector"} + ``` + +- IPC queries can now pass PyKX Functions like objects as the query parameter. + + === "Behaviour prior to change" + + ```python + >>> import pykx as kx + >>> conn = kx.SyncQConnection(port = 5050) + >>> conn(kx.q.sum, [1, 2]) + .. + ValueError: Cannot send Python function over IPC + >>> conn(kx.q('{x+y}'), 1, 2) + .. + ValueError: Cannot send Python function over IPC + >>> conn(kx.q.floor, 5.2) + .. + ValueError: Cannot send Python function over IPC + ``` + + === "Behaviour post change" + + ```python + >>> import pykx as kx + >>> conn = kx.SyncQConnection(port = 5050) + >>> conn(kx.q.sum, [1, 2]) + pykx.LongAtom(pykx.q('3')) + >>> conn(kx.q('{x+y}'), 1, 2) + pykx.LongAtom(pykx.q('3')) + >>> conn(kx.q.floor, 5.2) + pykx.LongAtom(pykx.q('5')) + ``` + +- When failing to initialise PyKX with an expired or invalid license PyKX will now point a user to the license location: + + === "Behaviour prior to change" + + ```python + Your PyKX license has now expired. + + Captured output from initialization attempt: + '2023.10.18T13:27:59.719 licence error: exp + + Would you like to renew your license? [Y/n]: + ``` + + === "Behaviour post change" + + ```python + Your PyKX license has now expired. + + Captured output from initialization attempt: + '2023.10.18T13:27:59.719 licence error: exp + + License location used: + /usr/local/anaconda3/pykx/kc.lic + + Would you like to renew your license? [Y/n]: + ``` +- Disabled raw conversions for `kx.List` types as the resulting converted object would be unusable, for example: + + === "Behaviour prior to change" + + ```python + >>> kx.q('(1j; 2f; 3i; 4e; 5h)').np(raw=True) + array([418404288, 1, 418403936, 1, 418404000], dtype=np.uintp) + ``` + + === "Behaviour post change" + + ```python + >>> kx.q('(1j; 2f; 3i; 4e; 5h)').np(raw=True) + array([1, 2.0, 3, 4.0, 5], dtype=object) + ``` + + - `handle_nulls` now operates on all of `datetime64[ns|us|ms|s]` and ensures that the contents of the original dataframe are not modified: + + === "Behaviour prior to change" + + ```python + >>> ns = np.array(['', '2020-09-08T07:06:05.123456789'], dtype='datetime64[ns]') + >>> us = np.array(['', '2020-09-08T07:06:05.123456789'], dtype='datetime64[us]') + >>> ms = np.array(['', '2020-09-08T07:06:05.123456789'], dtype='datetime64[ms]') + >>> s = np.array(['', '2020-09-08T07:06:05.123456789'], dtype='datetime64[s]') + >>> df = pd.DataFrame(data= {'ns':ns, 'us':us, 'ms':ms,'s':s}) + + >>> df + ns us ms s + 0 NaT NaT NaT NaT + 1 2020-09-08 07:06:05.123456789 2020-09-08 07:06:05.123456 2020-09-08 07:06:05.123 2020-09-08 07:06:05 + >>> kx.toq(df, handle_nulls=True) + :1: RuntimeWarning: WARN: Type information of column: s is not known falling back to DayVector type + pykx.Table(pykx.q(' + ns us ms s + ---------------------------------------------------------------------------------------------------- + 1970.01.01D00:00:00.000000000 1970.01.01D00:00:00.000000000 + 2020.09.08D07:06:05.123456789 2020.09.08D07:06:05.123456000 2020.09.08D07:06:05.123000000 2020.09.08 + ')) + >>> df + ns us ms s + 0 NaT NaT NaT NaT + 1 1990-09-09 07:06:05.123456789 2020-09-08 07:06:05.123456 2020-09-08 07:06:05.123 2020-09-08 07:06:05 + ``` + + === "Behaviour post change" + + ```python + >>> ns = np.array(['', '2020-09-08T07:06:05.123456789'], dtype='datetime64[ns]') + >>> us = np.array(['', '2020-09-08T07:06:05.123456789'], dtype='datetime64[us]') + >>> ms = np.array(['', '2020-09-08T07:06:05.123456789'], dtype='datetime64[ms]') + >>> s = np.array(['', '2020-09-08T07:06:05.123456789'], dtype='datetime64[s]') + >>> df = pd.DataFrame(data= {'ns':ns, 'us':us, 'ms':ms,'s':s}) + + >>> df + ns us ms s + 0 NaT NaT NaT NaT + 1 2020-09-08 07:06:05.123456789 2020-09-08 07:06:05.123456 2020-09-08 07:06:05.123 2020-09-08 07:06:05 + >>> kx.toq(df, handle_nulls=True) + pykx.Table(pykx.q(' + ns us ms s + ----------------------------------------------------------------------------------------------------------------------- + + 2020.09.08D07:06:05.123456789 2020.09.08D07:06:05.123456000 2020.09.08D07:06:05.123000000 2020.09.08D07:06:05.000000000 + ')) + >>> df + ns us ms s + 0 NaT NaT NaT NaT + 1 2020-09-08 07:06:05.123456789 2020-09-08 07:06:05.123456 2020-09-08 07:06:05.123 2020-09-08 07:06:05 + ``` + + - Fix for error when calling `.pd(raw=True)` on `EnumVector`: + + === "Behaviour prior to change" + + ```python + >>> kx.q('`s?`a`b`c').pd(raw=True) + Traceback (most recent call last): + File "", line 1, in + File "/home/user/.pyenv/versions/3.11.5/lib/python3.11/site-packages/pykx/wrappers.py", line 2601, in pd + return super(self).pd(raw=raw, has_nulls=has_nulls) + ^^^^^^^^^^^ + TypeError: super() argument 1 must be a type, not EnumVector + ``` + + === "Behaviour post change" + + ```python + >>> import pykx as kx + >>> kx.q('`s?`a`b`c').pd(raw=True) + 0 0 + 1 1 + 2 2 + dtype: int64 + ``` + +### Upgrade considerations + + - Since 2.1.0 when using Pandas >= 2.0 dataframe columns of type `datetime64[s]` converted to `DateVector` under `toq`. Now correctly converts to `TimestampVector`. See [conversion condsideratons](../user-guide/fundamentals/conversion_considerations.md#temporal-types) for further details. + + === "Behaviour prior to change" + + ```python + >>> kx.toq(pd.DataFrame(data= {'a':np.array(['2020-09-08T07:06:05'], dtype='datetime64[s]')})) + :1: RuntimeWarning: WARN: Type information of column: a is not known falling back to DayVector type + pykx.Table(pykx.q(' + a + ---------- + 2020.09.08 + ')) + ``` + + === "Behaviour post change" + + ```python + >>> kx.toq(pd.DataFrame(data= {'a':np.array(['2020-09-08T07:06:05'], dtype='datetime64[s]')})) + pykx.Table(pykx.q(' + a + ----------------------------- + 2020.09.08D07:06:05.000000000 + ')) + #Licensed users can pass `ktype` specifying column types if they wish to override the default behaviour + >>> kx.toq(pd.DataFrame(data= {'a':np.array(['2020-09-08T07:06:05'], dtype='datetime64[s]')}), ktype={'a':kx.DateVector}) + pykx.Table(pykx.q(' + a + ---------- + 2020.09.08 + ')) + ``` + + - Configuration option `PYKX_DISABLE_PANDAS_WARNING` has been removed. + - Deprecated `.pd(raw_guids)` keyword. + +### Beta Features + +- Addition of [streamlit](https://streamlit.io/) connection class `pykx.streamlit.Connection` to allow querying of q processes when building a streamlit application. For an example of this functionality and an introduction to it's usage see [here](../beta-features/streamlit.md). + +## PyKX 2.4.2 + +#### Release Date + +2024-04-03 + +### Fixes and Improvements + +- Updated `libq` to 2024.03.28 for all supported OS's. + +## PyKX 2.4.1 + +#### Release Date + +2024-03-27 + +### Fixes and Improvements + +- Previously calls to `qsql.select`, `qsql.exec`, `qsql.update` and `qsql.delete` would require multiple calls to parse the content of `where`, `colums` and `by` clauses. These have now been removed with all parsing now completed within the functional query when called via IPC or local to the Python process. +- Linux x86 and Mac x86/ARM unlicensed mode `e.o` library updated to 2023.11.22. Fixes subnormals issue: + + === "Behavior prior to change" + + ```python + >>> import os + >>> os.environ['PYKX_UNLICENSED']='true' + >>> import pykx as kx + >>> import numpy as np + >>> np.finfo(np.float64).smallest_subnormal + 0. + /usr/local/anaconda3/lib/python3.8/site-packages/numpy/core/getlimits.py:518: UserWarning: The value of the smallest subnormal for type is zero. + setattr(self, word, getattr(machar, word).flat[0]) + /usr/local/anaconda3/lib/python3.8/site-packages/numpy/core/getlimits.py:89: UserWarning: The value of the smallest subnormal for type is zero. + return self._float_to_str(self.smallest_subnormal) + 0.0 + ``` + + === "Behavior post change" + + ```python + >>> import os + >>> os.environ['PYKX_UNLICENSED']='true' + >>> import pykx as kx + >>> import numpy as np + >>> np.finfo(np.float64).smallest_subnormal + 0. + 5e-324 + ``` + ## PyKX 2.4.0 #### Release Date @@ -174,7 +727,6 @@ raise LicenseException("run q code via 'pykx.q'") pykx.exceptions.LicenseException: A valid q license must be in a known location (e.g. `$QLIC`) to run q code via 'pykx.q'. ``` - === "Behavior post change" ```python @@ -222,6 +774,8 @@ === "Behavior post change" ```python + >>> tab = kx.Table(data = {'sym': ['a', 'b', 'c'], 'num': [1, 2, 3]}) + >>> tab.astype({'sym': kx.SymbolAtom}) pykx.Table(pykx.q(' sym num ------- @@ -278,7 +832,6 @@ >>> tab1.merge(tab2_keyed, how='left', q_join=True) ``` - ### Beta Features - Addition of `Compress` and `Encrypt` classes to allow users to set global configuration and for usage within Database partition persistence. @@ -940,29 +1493,29 @@ - Addition of negative slicing to `list` , `vector` and `table` objects - ```python - >>> import pykx as kx - >>> qlist = kx.q('("a";2;3.3;`four)') - >>> qlist[-3:] - pykx.List(pykx.q(' - 2 - 3.3 - `four - ')) + ```python + >>> import pykx as kx + >>> qlist = kx.q('("a";2;3.3;`four)') + >>> qlist[-3:] + pykx.List(pykx.q(' + 2 + 3.3 + `four + ')) - >>> vector = kx.q('til 5') - >>> vector[:-1] - pykx.LongVector(pykx.q('0 1 2 3')) + >>> vector = kx.q('til 5') + >>> vector[:-1] + pykx.LongVector(pykx.q('0 1 2 3')) - >>> table = kx.q('([] a:1 2 3; b:4 5 6; c:7 8 9)') - >>> table[-2:] - pykx.Table(pykx.q(' - a b c - ----- - 2 5 8 - 3 6 9 - ')) - ``` + >>> table = kx.q('([] a:1 2 3; b:4 5 6; c:7 8 9)') + >>> table[-2:] + pykx.Table(pykx.q(' + a b c + ----- + 2 5 8 + 3 6 9 + ')) + ``` ### Fixes and Improvements @@ -1165,8 +1718,8 @@ the following reads a CSV file and specifies the types of the three columns name !!! Warning "Pandas 2.0 has deprecated the `datetime64[D/M]` types." Due to this change it is not always possible to determine if the resulting q Table should - use a `MonthVector` or a `DayVector`. In the scenario that it is not possible to determine - the expected type a warning will be raised and the `DayVector` type will be used as a + use a `MonthVector` or a `DateVector`. In the scenario that it is not possible to determine + the expected type a warning will be raised and the `DateVector` type will be used as a default. ### Fixes and Improvements diff --git a/docs/release-notes/underq-changelog.md b/docs/release-notes/underq-changelog.md index f248ca3..0659ef4 100644 --- a/docs/release-notes/underq-changelog.md +++ b/docs/release-notes/underq-changelog.md @@ -6,6 +6,36 @@ This changelog provides updates from PyKX 2.0.0 and above, for information relat The changelog presented here outlines changes to PyKX when operating within a q environment specifically, if you require changelogs associated with PyKX operating within a Python environment see [here](./changelog.md). +## PyKX 2.5.0 + +#### Release Date + +TBD + +### Fixes and Improvements + +- When loading PyKX under from a source file path containing a space initialisation would fail with an `nyi` error message, this has now been resolved. + +## PyKX 2.4.1 + +#### Release Date + +2024-03-27 + +### Fixes and Improvements + +- When loading PyKX under q users who had previously loaded [embedPy](https://github.com/KxSystems/embedPy) into their process would cause a segfault of unspecified origin. With this release we have added a warning prior to loading of PyKX which specifies that if a value of `.p.e` has been specified which does not match that expected of PyKX a user should consider installing PyKX under q fully: + + ```q + q)\l p.q // Load embedPy + q)\l pykx.q + Warning: Detected invalid '.p.e' function definition expected for PyKX. + Have you loaded another Python integration first? + + Please consider full installation of PyKX under q following instructions at: + https://code.kx.com/pykx/pykx-under-q/intro.html#installation + ``` + ## PyKX 2.3.1 #### Release Date diff --git a/docs/roadmap.md b/docs/roadmap.md index 45e84b3..660fe3b 100644 --- a/docs/roadmap.md +++ b/docs/roadmap.md @@ -1,29 +1,53 @@ # PyKX Roadmap -This page outlines areas of development focus for the PyKX team to provide you with an understanding of the development direction of the library. This is not an exhaustive list of all features/areas of focus but should give you a view on what to expect from the team over the coming months. Additionally this list is subject to change based on the complexity of the features and any customer feature requests raised following the publishing of this list. +This page outlines areas of development focus for the PyKX team to provide you with an understanding of the development direction of the library. This is not an exhaustive list of all features/areas of focus but should give you a view on what to expect from the team over the coming months. Additionally this list is subject to change, particularly for any example code provided based on the complexity of the features and any customer feature requests raised following the publishing of this list. If you need a feature that's not included in this list please let us know by raising a [Github issue](https://github.com/KxSystems/pykx/issues)! -## Nov 2023 - Jan 2024 - -- Support Python 3.12 -- Tighter integration with [Streamlit](https://streamlit.io/) allowing streamlit applications to interact with kdb+ servers and on-disk databases -- User defined Python functions to be supported when operating with local qsql.select functionality -- [JupyterQ](https://github.com/KxSystems/jupyterq) and [ML-Toolkit](https://github.com/KxSystems/ml) updates to allow optional PyKX backend replacing embedPy -- Pythonic data sorting for PyKX Tables - -## Feb - Apr 2024 - -- Database management functionality allowing for Pythonic persistence and management of on-disk kdb+ Databases (Beta) -- Improvements to multi-threaded PyKX efficiency, reducing per-call overhead for running PyKX on separate threads +## Upcoming Changes + +- More Pythonic query syntax when querying PyKX Tables. Syntax for this will be similar to the following: + + ```python + >>> import pykx as kx + >>> N = 10000 + >>> table = kx.Table(data = { + ... 'x' : kx.random.random(N, ['a', 'b', 'c]), + ... 'x1': kx.random.random(N, 100.0), + ... 'x2': kx.random.random(N, 100) + ... }) + >>> table.select(where = kx.col('x') == 'a') + >>> table.select(kx.col('x1').max()) + >>> table.select(kx.col('x1').wavg('x2')) + ``` + +- Addition of support for q primatives as methods off PyKX Vector and Table objects. Syntax for this will be similar to the following + + ```python + >>> import pykx as kx + >>> N = 1000 + >>> vec = kx.random.random(N, 100.0) + >>> vec.mavg(3) + >>> vec.abs() + ``` + +- Performance improvements for conversions from Numpy arrays to PyKX Vector objects and vice-versa through enhanced use of C++ over Cython. +- Additions to the Pandas Like API for PyKX. + - `isnull` + - `idxmax` + - `kurt` + - `sem` + +- Addition of functionality for the development of streaming workflows using PyKX. - Configurable initialisation logic in the absence of a license. Thus allowing users who have their own workflows for license access to modify the instructions for their users. -- Addition of `cast` keyword when inserting/upserting data into a table reducing mismatch issues +- Promotion of Beta functionality currently available in PyKX to full production support + - Database Management + - Compression and Encryption + - Multi-threaded execution + - Remote function execution ## Future - Tighter integration between PyKX/q objects and PyArrow arrays/Tables - Expansion of supported datatypes for translation to/from PyKX -- Continued additions of Pandas-like functionality on PyKX Table objects -- Performance improvements through enhanced usage of Cython -- Real-time/Streaming functionality utilities - Data pre-processing and statistics modules for operation on PyKX tables and vector objects diff --git a/docs/stylesheets/pykx.css b/docs/stylesheets/pykx.css index d3b2872..a726c37 100644 --- a/docs/stylesheets/pykx.css +++ b/docs/stylesheets/pykx.css @@ -1,5 +1,5 @@ .md-grid { - max-width: 75rem; + max-width: 100%; } /* Indentation with bars on the left */ diff --git a/docs/troubleshooting.md b/docs/troubleshooting.md index 7aaf644..3b7eb7d 100644 --- a/docs/troubleshooting.md +++ b/docs/troubleshooting.md @@ -9,7 +9,7 @@ The following section outlines practical information useful when dealing with ge A number of trial and enterprise type licenses exist for q/kdb+. Not all licenses for q/kdb+ however are valid for PyKX. In particular users require access to a license which contains the feature flags `pykx` and `embedq` which provide access to the PyKX functionality. The following locations can be used for the retrieval of evaluation/personal licenses - For non-commercial personal users you can access a 12 month kdb+ license with PyKX enabled [here](https://kx.com/kdb-insights-personal-edition-license-download). -- For commercial evaluation you can download a 30 day PyKX license [here](https://kx.com/kdb-insights-commercial-evaluation-license-download/). +- For commercial evaluation, contact your KX sales representative or sales@kx.com requesting a PyKX trial license. Alternately apply through https://kx.com/book-demo. For non-personal or non-commercial usage please contact sales@kx.com. @@ -20,7 +20,7 @@ Once you have access to your license you can install the license following the w >>> kx.license.install('/path/to/downloaded/kc.lic') ``` -### Initialization failing with a 'embedq' error +### Initialization failing with a 'embedq' error Failure to initialize PyKX while raising an error `embedq` indicates that the license you are attempting to use for PyKX in [licensed modality](user-guide/advanced/modes.md) does not have the sufficient feature flags necessary to run PyKX. To access a license which does allow for running PyKX in this modality please following the instructions [here](#accessing-a-license-valid-for-pykx) to get a new license with appropriate feature flags. @@ -93,7 +93,6 @@ It usually indicates that your license was not correctly written to disk or a li The following section outlines how a user can get access to a verbose set of environment configuration associated with PyKX. This information is helpful when debugging your environment and should be provided if possible with support requests. - ```python >>> import pykx as kx >>> kx.util.debug_environment() # see below for output diff --git a/docs/user-guide/advanced/Pandas_API.ipynb b/docs/user-guide/advanced/Pandas_API.ipynb index 79ead84..28fcebc 100644 --- a/docs/user-guide/advanced/Pandas_API.ipynb +++ b/docs/user-guide/advanced/Pandas_API.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "dfa26ef1", + "id": "d2a3ccf7", "metadata": {}, "source": [ "# Pandas API\n", @@ -22,8 +22,8 @@ }, { "cell_type": "code", - "execution_count": null, - "id": "5b2f27e1", + "execution_count": 2, + "id": "13267c00", "metadata": { "tags": [ "hide_code" @@ -33,13 +33,13 @@ "source": [ "import os\n", "os.environ['IGNORE_QHOME'] = '1' # Ignore symlinking PyKX q libraries to QHOME \n", - "os.environ['PYKX_Q_LOADED_MARKER'] = '' # Only used here for running Notebook under mkdocs-jupyter during document generation.\n" + "os.environ['PYKX_Q_LOADED_MARKER'] = '' # Only used here for running Notebook under mkdocs-jupyter during document generation." ] }, { "cell_type": "code", - "execution_count": null, - "id": "356b337c", + "execution_count": 3, + "id": "44c90043", "metadata": {}, "outputs": [], "source": [ @@ -51,7 +51,7 @@ }, { "cell_type": "markdown", - "id": "b5c9b878", + "id": "06e3f624", "metadata": {}, "source": [ "## Constructing Tables" @@ -59,7 +59,7 @@ }, { "cell_type": "markdown", - "id": "15884a6f", + "id": "31561309", "metadata": {}, "source": [ "### Table\n", @@ -88,7 +88,7 @@ { "cell_type": "code", "execution_count": null, - "id": "a3d8e590", + "id": "170587aa", "metadata": {}, "outputs": [], "source": [ @@ -97,7 +97,7 @@ }, { "cell_type": "markdown", - "id": "1967dbd6", + "id": "273de502", "metadata": {}, "source": [ "Create a Table from an array like object." @@ -106,7 +106,7 @@ { "cell_type": "code", "execution_count": null, - "id": "b8c67d04", + "id": "62b9f5c1", "metadata": {}, "outputs": [], "source": [ @@ -115,7 +115,7 @@ }, { "cell_type": "markdown", - "id": "b59c678b", + "id": "51d82353", "metadata": {}, "source": [ "Create a Table from an array like object and provide names for the columns to use." @@ -124,7 +124,7 @@ { "cell_type": "code", "execution_count": null, - "id": "6469f77e", + "id": "e9751924", "metadata": {}, "outputs": [], "source": [ @@ -133,7 +133,7 @@ }, { "cell_type": "markdown", - "id": "a3074cc5", + "id": "36edf1de", "metadata": {}, "source": [ "### Keyed Table\n", @@ -163,7 +163,7 @@ { "cell_type": "code", "execution_count": null, - "id": "03162ab2", + "id": "0ab1d288", "metadata": {}, "outputs": [], "source": [ @@ -172,7 +172,7 @@ }, { "cell_type": "markdown", - "id": "eda04de8", + "id": "1a2f9b56", "metadata": {}, "source": [ "Create a keyed table from a list of rows." @@ -181,7 +181,7 @@ { "cell_type": "code", "execution_count": null, - "id": "de9fcc81", + "id": "8a0b5ce8", "metadata": {}, "outputs": [], "source": [ @@ -190,7 +190,7 @@ }, { "cell_type": "markdown", - "id": "ab5393c3", + "id": "804183ed", "metadata": {}, "source": [ "Create a keyed table from a list of rows and provide names for the resulting columns." @@ -199,7 +199,7 @@ { "cell_type": "code", "execution_count": null, - "id": "576e4254", + "id": "21b018fe", "metadata": {}, "outputs": [], "source": [ @@ -208,7 +208,7 @@ }, { "cell_type": "markdown", - "id": "cca4e246", + "id": "b91e990b", "metadata": {}, "source": [ "Create a keyed table with a specified index column." @@ -217,7 +217,7 @@ { "cell_type": "code", "execution_count": null, - "id": "a29d1521", + "id": "d2631bad", "metadata": {}, "outputs": [], "source": [ @@ -226,7 +226,7 @@ }, { "cell_type": "markdown", - "id": "73bf284f", + "id": "f1f43263", "metadata": {}, "source": [ "## Metadata" @@ -235,18 +235,23 @@ { "cell_type": "code", "execution_count": null, - "id": "4b363f07", + "id": "15b9c003", "metadata": {}, "outputs": [], "source": [ - "kx.q('N: 1000')\n", - "tab = kx.q('([] x: til N; y: N?`AAPL`GOOG`MSFT; z: N?500f; w: N?1000; v: N?(0N 0 50 100 200 250))')\n", + "N = 1000\n", + "tab = kx.Table(data = {\n", + " 'x': kx.q.til(N),\n", + " 'y': kx.random.random(N, ['AAPL', 'GOOG', 'MSFT']),\n", + " 'z': kx.random.random(N, 500.0),\n", + " 'w': kx.random.random(N, 1000),\n", + " 'v': kx.random.random(N, [kx.LongAtom.null, 0, 50, 100, 200, 250])})\n", "tab" ] }, { "cell_type": "markdown", - "id": "40155b78", + "id": "c2122f58", "metadata": {}, "source": [ "### Table.columns\n", @@ -257,7 +262,7 @@ { "cell_type": "code", "execution_count": null, - "id": "e8a0395e", + "id": "6e35b1b4", "metadata": {}, "outputs": [], "source": [ @@ -266,7 +271,7 @@ }, { "cell_type": "markdown", - "id": "13516f56", + "id": "fc006fd7", "metadata": {}, "source": [ "### Table.dtypes\n", @@ -277,7 +282,7 @@ { "cell_type": "code", "execution_count": null, - "id": "5a312477", + "id": "c8f571f6", "metadata": {}, "outputs": [], "source": [ @@ -286,7 +291,7 @@ }, { "cell_type": "markdown", - "id": "10124c07", + "id": "5b4d25bf", "metadata": {}, "source": [ "### Table.empty\n", @@ -297,7 +302,7 @@ { "cell_type": "code", "execution_count": null, - "id": "751fc442", + "id": "b01c0791", "metadata": {}, "outputs": [], "source": [ @@ -306,7 +311,7 @@ }, { "cell_type": "markdown", - "id": "c973fb82", + "id": "550c1126", "metadata": {}, "source": [ "### Table.ndim\n", @@ -317,7 +322,7 @@ { "cell_type": "code", "execution_count": null, - "id": "ee6b55a0", + "id": "88affa6b", "metadata": {}, "outputs": [], "source": [ @@ -326,7 +331,7 @@ }, { "cell_type": "markdown", - "id": "07ac8e54", + "id": "f479bdcc", "metadata": {}, "source": [ "### Table.shape\n", @@ -337,7 +342,7 @@ { "cell_type": "code", "execution_count": null, - "id": "8d6f890c", + "id": "a0609e97", "metadata": {}, "outputs": [], "source": [ @@ -346,7 +351,7 @@ }, { "cell_type": "markdown", - "id": "654129cc", + "id": "42bc2bc3", "metadata": {}, "source": [ "### Table.size\n", @@ -357,7 +362,7 @@ { "cell_type": "code", "execution_count": null, - "id": "0e621250", + "id": "886296f3", "metadata": {}, "outputs": [], "source": [ @@ -366,7 +371,7 @@ }, { "cell_type": "markdown", - "id": "8e210a91", + "id": "1439bde3", "metadata": {}, "source": [ "## Querying and Data Interrogation" @@ -375,19 +380,24 @@ { "cell_type": "code", "execution_count": null, - "id": "77ab64ab", + "id": "776b5725", "metadata": {}, "outputs": [], "source": [ "# The examples in this section will use this example table filled with random data\n", - "kx.q('N: 1000')\n", - "tab = kx.q('([] x: til N; y: N?`AAPL`GOOG`MSFT; z: N?500f; w: N?1000; v: N?(0N 0 50 100 200 250))')\n", + "N = 1000\n", + "tab = kx.Table(data = {\n", + " 'x': kx.q.til(N),\n", + " 'y': kx.random.random(N, ['AAPL', 'GOOG', 'MSFT']),\n", + " 'z': kx.random.random(N, 500.0),\n", + " 'w': kx.random.random(N, 1000),\n", + " 'v': kx.random.random(N, [kx.LongAtom.null, 0, 50, 100, 200, 250])})\n", "tab" ] }, { "cell_type": "markdown", - "id": "9bd3dada", + "id": "d356c82f", "metadata": {}, "source": [ "### Table.all()\n", @@ -416,7 +426,7 @@ { "cell_type": "code", "execution_count": null, - "id": "95aa447d", + "id": "b1c046de", "metadata": {}, "outputs": [], "source": [ @@ -425,7 +435,7 @@ }, { "cell_type": "markdown", - "id": "4ac12eb0", + "id": "e9c11a2e", "metadata": {}, "source": [ "### Table.any()\n", @@ -454,7 +464,7 @@ { "cell_type": "code", "execution_count": null, - "id": "a43aabc4", + "id": "501721e8", "metadata": {}, "outputs": [], "source": [ @@ -463,7 +473,7 @@ }, { "cell_type": "markdown", - "id": "81a8e19f", + "id": "cb69b61a", "metadata": {}, "source": [ "### Table.at[]\n", @@ -481,7 +491,7 @@ }, { "cell_type": "markdown", - "id": "44a37aff", + "id": "8262b005", "metadata": {}, "source": [ "**Examples:**\n", @@ -492,7 +502,7 @@ { "cell_type": "code", "execution_count": null, - "id": "618fe622", + "id": "3664be9c", "metadata": {}, "outputs": [], "source": [ @@ -501,7 +511,7 @@ }, { "cell_type": "markdown", - "id": "23203909", + "id": "043ed9ca", "metadata": {}, "source": [ "Reassign the value of the `z` column in the 997th row to `3.14159`." @@ -510,7 +520,7 @@ { "cell_type": "code", "execution_count": null, - "id": "978d991d", + "id": "3c7c4bc7", "metadata": {}, "outputs": [], "source": [ @@ -520,7 +530,7 @@ }, { "cell_type": "markdown", - "id": "3d62cbbc", + "id": "903c0aac", "metadata": {}, "source": [ "### Table.get()\n", @@ -547,7 +557,7 @@ }, { "cell_type": "markdown", - "id": "00c06637", + "id": "3d094b7b", "metadata": {}, "source": [ "**Examples:**\n", @@ -558,7 +568,7 @@ { "cell_type": "code", "execution_count": null, - "id": "f950cc1e", + "id": "7809ac4a", "metadata": { "scrolled": true }, @@ -569,7 +579,7 @@ }, { "cell_type": "markdown", - "id": "78608b1c", + "id": "2ddd9659", "metadata": {}, "source": [ "Get the `y` and `z` columns from the table." @@ -578,7 +588,7 @@ { "cell_type": "code", "execution_count": null, - "id": "02d4d586", + "id": "78c9f224", "metadata": { "scrolled": true }, @@ -589,7 +599,7 @@ }, { "cell_type": "markdown", - "id": "2a2186aa", + "id": "379219ef", "metadata": {}, "source": [ "Attempt to get the `q` column from the table and receive none as that column does not exist." @@ -598,7 +608,7 @@ { "cell_type": "code", "execution_count": null, - "id": "a88ef7dc", + "id": "010d9d98", "metadata": {}, "outputs": [], "source": [ @@ -607,7 +617,7 @@ }, { "cell_type": "markdown", - "id": "ea3dc01a", + "id": "3ee99633", "metadata": {}, "source": [ "Attempt to get the `q` column from the table and receive the default value `not found` as that column does not exist." @@ -616,7 +626,7 @@ { "cell_type": "code", "execution_count": null, - "id": "2f3abc92", + "id": "ffd3a851", "metadata": {}, "outputs": [], "source": [ @@ -625,7 +635,7 @@ }, { "cell_type": "markdown", - "id": "b2195cfe", + "id": "34016a3f", "metadata": {}, "source": [ "### Table.head()\n", @@ -651,7 +661,7 @@ }, { "cell_type": "markdown", - "id": "18a0ca1e", + "id": "d823513a", "metadata": {}, "source": [ "**Examples:**\n", @@ -662,7 +672,7 @@ { "cell_type": "code", "execution_count": null, - "id": "5120ce1c", + "id": "5618880c", "metadata": {}, "outputs": [], "source": [ @@ -671,7 +681,7 @@ }, { "cell_type": "markdown", - "id": "08f158a8", + "id": "c5a8b2e8", "metadata": {}, "source": [ "Return the first 10 rows of the table." @@ -680,7 +690,7 @@ { "cell_type": "code", "execution_count": null, - "id": "de9c2842", + "id": "90071dcf", "metadata": {}, "outputs": [], "source": [ @@ -689,7 +699,7 @@ }, { "cell_type": "markdown", - "id": "d1c370e4", + "id": "d97d6bae", "metadata": {}, "source": [ "### Table.iloc[]\n", @@ -719,7 +729,7 @@ }, { "cell_type": "markdown", - "id": "07e31d96", + "id": "a3945130", "metadata": {}, "source": [ "**Examples:**\n", @@ -730,7 +740,7 @@ { "cell_type": "code", "execution_count": null, - "id": "f8108853", + "id": "1f83db52", "metadata": { "scrolled": true }, @@ -741,7 +751,7 @@ }, { "cell_type": "markdown", - "id": "30c429f4", + "id": "72b468a1", "metadata": {}, "source": [ "Get the first 5 rows from a table." @@ -750,7 +760,7 @@ { "cell_type": "code", "execution_count": null, - "id": "2f817967", + "id": "5354ca81", "metadata": {}, "outputs": [], "source": [ @@ -759,7 +769,7 @@ }, { "cell_type": "markdown", - "id": "2eb41e47", + "id": "9295eddc", "metadata": {}, "source": [ "Get all rows of the table where the `y` column is equal to `AAPL`." @@ -768,7 +778,7 @@ { "cell_type": "code", "execution_count": null, - "id": "69e14007", + "id": "6410e870", "metadata": { "scrolled": true }, @@ -779,7 +789,7 @@ }, { "cell_type": "markdown", - "id": "7861f193", + "id": "08792c1d", "metadata": {}, "source": [ "Get all rows of the table where the `y` column is equal to `AAPL`, and only return the `y`, `z` and `w` columns." @@ -788,7 +798,7 @@ { "cell_type": "code", "execution_count": null, - "id": "323cc0f8", + "id": "d61b8396", "metadata": {}, "outputs": [], "source": [ @@ -797,7 +807,7 @@ }, { "cell_type": "markdown", - "id": "9de566f3", + "id": "4525b646", "metadata": {}, "source": [ "Replace all null values in the column `v` with the value `-100`." @@ -806,7 +816,7 @@ { "cell_type": "code", "execution_count": null, - "id": "be66947d", + "id": "b65e7a05", "metadata": {}, "outputs": [], "source": [ @@ -816,7 +826,7 @@ }, { "cell_type": "markdown", - "id": "ed37aa73", + "id": "dc97669c", "metadata": {}, "source": [ "### Table.loc[]\n", @@ -852,7 +862,7 @@ }, { "cell_type": "markdown", - "id": "c68e21f1", + "id": "f90efe27", "metadata": {}, "source": [ "**Examples:**\n", @@ -863,7 +873,7 @@ { "cell_type": "code", "execution_count": null, - "id": "e46092cc", + "id": "20974780", "metadata": { "scrolled": true }, @@ -874,7 +884,7 @@ }, { "cell_type": "markdown", - "id": "9e136f10", + "id": "ceccd5a9", "metadata": {}, "source": [ "Get all rows of the table where the value in the `z` column is greater than `250.0`" @@ -883,7 +893,7 @@ { "cell_type": "code", "execution_count": null, - "id": "52d2f0fe", + "id": "e99478b5", "metadata": {}, "outputs": [], "source": [ @@ -892,7 +902,7 @@ }, { "cell_type": "markdown", - "id": "52c058a6", + "id": "5300666e", "metadata": {}, "source": [ "Replace all null values in the column `v` with the value `-100`." @@ -901,19 +911,19 @@ { "cell_type": "code", "execution_count": null, - "id": "960f1933", + "id": "889ddbd3", "metadata": { "scrolled": true }, "outputs": [], "source": [ - "tab.loc[tab['v'] == kx.q('0N'), 'v'] = -100\n", + "tab.loc[tab['v'] == kx.LongAtom.null, 'v'] = -100\n", "tab" ] }, { "cell_type": "markdown", - "id": "9b262eca", + "id": "e52f569f", "metadata": {}, "source": [ "Replace all locations in column `v` where the value is `-100` with a null." @@ -922,17 +932,17 @@ { "cell_type": "code", "execution_count": null, - "id": "f4c974c7", + "id": "2df5ddff", "metadata": {}, "outputs": [], "source": [ - "tab[tab['v'] == -100, 'v'] = kx.q('0N')\n", + "tab[tab['v'] == -100, 'v'] = kx.LongAtom.null\n", "tab" ] }, { "cell_type": "markdown", - "id": "ddc94e12", + "id": "ca371dea", "metadata": {}, "source": [ "Usage of the `loc` functionality under the hood additionally allows users to set columns within a table for single or multiple columns. Data passed for this can be q/Python." @@ -941,26 +951,26 @@ { "cell_type": "code", "execution_count": null, - "id": "f9d06838", + "id": "2c5b1db2", "metadata": {}, "outputs": [], "source": [ - "tab['new_col'] = kx.q('1000?1f')" + "tab['new_col'] = kx.random.random(1000, 1.0)" ] }, { "cell_type": "code", "execution_count": null, - "id": "1505d9bb", + "id": "87d71574", "metadata": {}, "outputs": [], "source": [ - "tab[['new_col1', 'new_col2']] = [20, kx.q('1000?0Ng')]" + "tab[['new_col1', 'new_col2']] = [20, kx.random.random(1000, kx.GUIDAtom.null)]" ] }, { "cell_type": "markdown", - "id": "05124590", + "id": "53c9631f", "metadata": {}, "source": [ "### Table.sample()\n", @@ -993,21 +1003,26 @@ { "cell_type": "code", "execution_count": null, - "id": "8b4a10be", + "id": "845e22d6", "metadata": { "scrolled": true }, "outputs": [], "source": [ "# The examples in this section will use this example table filled with random data\n", - "kx.q('N: 1000')\n", - "tab = kx.q('([] x: til N; y: N?`AAPL`GOOG`MSFT; z: N?500f; w: N?1000; v: N?(0N 0 50 100 200 250))')\n", + "N = 1000\n", + "tab = kx.Table(data = {\n", + " 'x': kx.q.til(N),\n", + " 'y': kx.random.random(N, ['AAPL', 'GOOG', 'MSFT']),\n", + " 'z': kx.random.random(N, 500.0),\n", + " 'w': kx.random.random(N, 1000),\n", + " 'v': kx.random.random(N, [kx.LongAtom.null, 0, 50, 100, 200, 250])})\n", "tab.head()" ] }, { "cell_type": "markdown", - "id": "970c8ea4", + "id": "c9d84056", "metadata": {}, "source": [ "**Examples:**\n", @@ -1018,7 +1033,7 @@ { "cell_type": "code", "execution_count": null, - "id": "9dde77b1", + "id": "ebfeeec5", "metadata": {}, "outputs": [], "source": [ @@ -1027,7 +1042,7 @@ }, { "cell_type": "markdown", - "id": "1d14afe9", + "id": "d3150483", "metadata": {}, "source": [ "Sample 10% of the rows." @@ -1036,7 +1051,7 @@ { "cell_type": "code", "execution_count": null, - "id": "32772c46", + "id": "67844a62", "metadata": {}, "outputs": [], "source": [ @@ -1045,7 +1060,7 @@ }, { "cell_type": "markdown", - "id": "82a7a79d", + "id": "dce42092", "metadata": {}, "source": [ "Sample 10% of the rows and allow the same row to be sampled twice." @@ -1054,7 +1069,7 @@ { "cell_type": "code", "execution_count": null, - "id": "4c96839b", + "id": "1a2326fd", "metadata": {}, "outputs": [], "source": [ @@ -1063,7 +1078,7 @@ }, { "cell_type": "markdown", - "id": "82b501a6", + "id": "7d42cde9", "metadata": {}, "source": [ "### Table.select_dtypes()\n", @@ -1100,7 +1115,7 @@ }, { "cell_type": "markdown", - "id": "0570165c", + "id": "bb6fc886", "metadata": {}, "source": [ "**Examples:**\n", @@ -1111,16 +1126,21 @@ { "cell_type": "code", "execution_count": null, - "id": "74ade8d1", + "id": "ca9b5532", "metadata": {}, "outputs": [], "source": [ - "df = kx.q('([] c1:`a`b`c; c2:1 2 3h; c3:1 2 3j; c4:1 2 3i)')" + "df = kx.Table(data = {\n", + " 'c1': kx.SymbolVector(['a', 'b', 'c']),\n", + " 'c2': kx.ShortVector([1, 2, 3]),\n", + " 'c3': kx.LongVector([1, 2, 3]),\n", + " 'c4': kx.IntVector([1, 2, 3])\n", + " })" ] }, { "cell_type": "markdown", - "id": "b889d7c7", + "id": "8eb25b29", "metadata": {}, "source": [ "Exclude columns containing symbols" @@ -1129,7 +1149,7 @@ { "cell_type": "code", "execution_count": null, - "id": "e8a792da", + "id": "de81564b", "metadata": {}, "outputs": [], "source": [ @@ -1138,7 +1158,7 @@ }, { "cell_type": "markdown", - "id": "c87f28c4", + "id": "1e842cc3", "metadata": {}, "source": [ "Include a list of column types" @@ -1147,7 +1167,7 @@ { "cell_type": "code", "execution_count": null, - "id": "ac2af334", + "id": "ba874cb6", "metadata": {}, "outputs": [], "source": [ @@ -1156,7 +1176,7 @@ }, { "cell_type": "markdown", - "id": "ede98735", + "id": "5bb4eaa2", "metadata": {}, "source": [ "### Table.tail()\n", @@ -1182,7 +1202,7 @@ }, { "cell_type": "markdown", - "id": "a7b6bd44", + "id": "2c9de3b3", "metadata": {}, "source": [ "**Examples:**\n", @@ -1193,7 +1213,7 @@ { "cell_type": "code", "execution_count": null, - "id": "d1f5f644", + "id": "5c31fc24", "metadata": {}, "outputs": [], "source": [ @@ -1202,7 +1222,7 @@ }, { "cell_type": "markdown", - "id": "181a4d86", + "id": "5ad81954", "metadata": {}, "source": [ "Return the last 10 rows of the table." @@ -1211,7 +1231,7 @@ { "cell_type": "code", "execution_count": null, - "id": "c8a0bb7b", + "id": "02974f05", "metadata": {}, "outputs": [], "source": [ @@ -1220,7 +1240,7 @@ }, { "cell_type": "markdown", - "id": "32d2194b-fe6e-4789-9437-fa8cec5f9287", + "id": "a2edb648", "metadata": {}, "source": [ "## Sorting" @@ -1228,7 +1248,7 @@ }, { "cell_type": "markdown", - "id": "38d04a7b-603d-4ecb-afb0-c7999b6d23ec", + "id": "ee65b6ab", "metadata": {}, "source": [ "### Table.sort_values()\n", @@ -1256,7 +1276,7 @@ }, { "cell_type": "markdown", - "id": "b71e942a-1247-4931-9a0f-edd2fd97b185", + "id": "6b4c5b68", "metadata": {}, "source": [ "**Examples:**" @@ -1265,17 +1285,20 @@ { "cell_type": "code", "execution_count": null, - "id": "2b8e2204-1e4e-4776-8f6a-22589ff66124", + "id": "e996a181", "metadata": {}, "outputs": [], "source": [ - "tab = kx.Table(data={'column_a': [20, 3, 100],'column_b': [56, 15, 42], 'column_c': [45, 80, 8]})\n", + "tab = kx.Table(data={\n", + " 'column_a': [20, 3, 100],\n", + " 'column_b': [56, 15, 42],\n", + " 'column_c': [45, 80, 8]})\n", "tab" ] }, { "cell_type": "markdown", - "id": "9494343e-34d1-4303-8007-38afe9ee6ead", + "id": "5093808f", "metadata": {}, "source": [ "Sort a Table by the second column" @@ -1284,7 +1307,7 @@ { "cell_type": "code", "execution_count": null, - "id": "fce9c74a-ed0b-4d2f-92f4-2b9b42762d4b", + "id": "08eb698c", "metadata": {}, "outputs": [], "source": [ @@ -1293,7 +1316,7 @@ }, { "cell_type": "markdown", - "id": "6ee86878-634f-4383-bb90-af361b785f59", + "id": "4a48687d", "metadata": {}, "source": [ "Sort a Table by the third column in descending order" @@ -1302,7 +1325,7 @@ { "cell_type": "code", "execution_count": null, - "id": "f8edac0a-f6f0-4a70-ae51-7c8599ee4da9", + "id": "4ba2b42f", "metadata": {}, "outputs": [], "source": [ @@ -1311,7 +1334,7 @@ }, { "cell_type": "markdown", - "id": "2b61d8b5-52a1-4c05-9347-c205ba6934d7", + "id": "29930425", "metadata": {}, "source": [ "### Table.nsmallest()\n", @@ -1342,7 +1365,7 @@ }, { "cell_type": "markdown", - "id": "c2430479-e832-4c6a-8cc0-651dd6af57b4", + "id": "64976edc", "metadata": {}, "source": [ "**Examples:**\n", @@ -1353,17 +1376,20 @@ { "cell_type": "code", "execution_count": null, - "id": "768f4e97-79a4-4abb-bced-5fa99f87c4ca", + "id": "302d4b08", "metadata": {}, "outputs": [], "source": [ - "tab = kx.Table(data={'column_a': [2, 3, 2, 2, 1],'column_b': [56, 15, 42, 102, 32], 'column_c': [45, 80, 8, 61, 87]})\n", + "tab = kx.Table(data={\n", + " 'column_a': [2, 3, 2, 2, 1],\n", + " 'column_b': [56, 15, 42, 102, 32],\n", + " 'column_c': [45, 80, 8, 61, 87]})\n", "tab" ] }, { "cell_type": "markdown", - "id": "79600d41-ef99-478e-89e6-5e67eadb6ee7", + "id": "c687bc12", "metadata": {}, "source": [ "Get the row where the first column is the smallest" @@ -1372,7 +1398,7 @@ { "cell_type": "code", "execution_count": null, - "id": "287c6905-d508-441b-887b-b71233e1d133", + "id": "5f2e6e8b", "metadata": {}, "outputs": [], "source": [ @@ -1381,7 +1407,7 @@ }, { "cell_type": "markdown", - "id": "48f5485e-4353-4523-8cc8-8655b1b8a9c3", + "id": "580d8d06", "metadata": {}, "source": [ "Get the 4 rows where the first column is the smallest, then any equal values are sorted based on the second column" @@ -1390,7 +1416,7 @@ { "cell_type": "code", "execution_count": null, - "id": "1772dd9b-389e-4da2-8994-245cfaa6d942", + "id": "039083ba", "metadata": {}, "outputs": [], "source": [ @@ -1399,7 +1425,7 @@ }, { "cell_type": "markdown", - "id": "7869e8c1-a303-466f-8afc-3ebdb59a379d", + "id": "db0280b3", "metadata": {}, "source": [ "Get the 2 rows with the smallest values for the first column and in case of duplicates, take the last entry in the table" @@ -1408,7 +1434,7 @@ { "cell_type": "code", "execution_count": null, - "id": "425a2841-610f-4cb2-9703-105ea14ac900", + "id": "eb02553b", "metadata": {}, "outputs": [], "source": [ @@ -1417,7 +1443,7 @@ }, { "cell_type": "markdown", - "id": "64ee5a21-7234-40f1-b720-e176740f4fc4", + "id": "fbb4e07f", "metadata": {}, "source": [ "### Table.nlargest()\n", @@ -1448,7 +1474,7 @@ }, { "cell_type": "markdown", - "id": "66b7c0a9-3d23-47c9-af79-8020c52d32e2", + "id": "394bdd98", "metadata": {}, "source": [ "**Examples:**\n", @@ -1459,17 +1485,20 @@ { "cell_type": "code", "execution_count": null, - "id": "1fa56308-8ede-448c-9cb6-0c232aac0dee", + "id": "ead5bfc0", "metadata": {}, "outputs": [], "source": [ - "tab = kx.Table(data={'column_a': [2, 3, 2, 2, 1],'column_b': [102, 15, 42, 56, 32], 'column_c': [45, 80, 8, 61, 87]})\n", + "tab = kx.Table(data={\n", + " 'column_a': [2, 3, 2, 2, 1],\n", + " 'column_b': [102, 15, 42, 56, 32],\n", + " 'column_c': [45, 80, 8, 61, 87]})\n", "tab" ] }, { "cell_type": "markdown", - "id": "2d8a45f7-a91a-41d5-854b-4bdfb7f696ef", + "id": "efc9b4c7", "metadata": {}, "source": [ "Get the row with the largest value for the first column" @@ -1478,7 +1507,7 @@ { "cell_type": "code", "execution_count": null, - "id": "88fa3ff8-4e31-4006-aec2-c697390e2b29", + "id": "c7c6363a", "metadata": {}, "outputs": [], "source": [ @@ -1487,7 +1516,7 @@ }, { "cell_type": "markdown", - "id": "68da7ae5-e181-45dd-8fe4-ae078da131a6", + "id": "18b2a6ce", "metadata": {}, "source": [ "Get the 4 rows where the first column is the largest, then any equal values are sorted based on the third column" @@ -1496,7 +1525,7 @@ { "cell_type": "code", "execution_count": null, - "id": "81647d24-282a-48ee-bf75-d08838211e94", + "id": "9162934a", "metadata": {}, "outputs": [], "source": [ @@ -1505,7 +1534,7 @@ }, { "cell_type": "markdown", - "id": "d538d7f0-c9ff-42a0-9dd5-c95792637775", + "id": "65fce7c3", "metadata": {}, "source": [ "Get the 2 rows with the smallest values for the first column and in case of duplicates, take all rows of the same value for that column" @@ -1514,7 +1543,7 @@ { "cell_type": "code", "execution_count": null, - "id": "c898e01e-60ef-4763-9728-2e215962f393", + "id": "f0bc8991", "metadata": {}, "outputs": [], "source": [ @@ -1523,7 +1552,7 @@ }, { "cell_type": "markdown", - "id": "ed1a193f-b02f-4af3-bdf2-acf46d374901", + "id": "ffc7e449", "metadata": {}, "source": [ "## Data Joins/Merging" @@ -1531,7 +1560,7 @@ }, { "cell_type": "markdown", - "id": "ef401426", + "id": "6a4c9fc9", "metadata": {}, "source": [ "### Table.merge()\n", @@ -1583,7 +1612,7 @@ }, { "cell_type": "markdown", - "id": "61d1567a", + "id": "3fbf575d", "metadata": {}, "source": [ "**Examples:**\n", @@ -1594,7 +1623,7 @@ { "cell_type": "code", "execution_count": null, - "id": "8a9acd51", + "id": "0f5f134f", "metadata": { "scrolled": true }, @@ -1607,7 +1636,7 @@ }, { "cell_type": "markdown", - "id": "7350d9db", + "id": "e9a9809e", "metadata": {}, "source": [ "Merge tab1 and tab2 with specified left and right suffixes appended to any overlapping columns." @@ -1616,7 +1645,7 @@ { "cell_type": "code", "execution_count": null, - "id": "23685dcb", + "id": "86b35497", "metadata": {}, "outputs": [], "source": [ @@ -1625,7 +1654,7 @@ }, { "cell_type": "markdown", - "id": "3b2c65d4", + "id": "c2a3ed1a", "metadata": {}, "source": [ "Merge tab1 and tab2 but raise an exception if the Tables have any overlapping columns." @@ -1634,7 +1663,7 @@ { "cell_type": "code", "execution_count": null, - "id": "b5d16312", + "id": "a6326a4c", "metadata": { "scrolled": true }, @@ -1649,7 +1678,7 @@ { "cell_type": "code", "execution_count": null, - "id": "793df3f3", + "id": "9d56ecee", "metadata": {}, "outputs": [], "source": [ @@ -1659,7 +1688,7 @@ }, { "cell_type": "markdown", - "id": "d58a52a3", + "id": "c97d6764", "metadata": {}, "source": [ "Merge tab1 and tab2 on the `a` column using an inner join." @@ -1668,7 +1697,7 @@ { "cell_type": "code", "execution_count": null, - "id": "1180e6f4", + "id": "756423a2", "metadata": { "scrolled": true }, @@ -1679,7 +1708,7 @@ }, { "cell_type": "markdown", - "id": "b14e36da", + "id": "cad8a08e", "metadata": {}, "source": [ "Merge tab1 and tab2 on the `a` column using a left join." @@ -1688,7 +1717,7 @@ { "cell_type": "code", "execution_count": null, - "id": "4b0098da", + "id": "e3511b35", "metadata": {}, "outputs": [], "source": [ @@ -1697,7 +1726,7 @@ }, { "cell_type": "markdown", - "id": "00d0ad6a", + "id": "cba56e88", "metadata": {}, "source": [ "Merge tab1 and tab2 using a cross join." @@ -1706,7 +1735,7 @@ { "cell_type": "code", "execution_count": null, - "id": "b55be868", + "id": "3d8eb680", "metadata": { "scrolled": true }, @@ -1719,7 +1748,7 @@ }, { "cell_type": "markdown", - "id": "d552054e-883a-41ae-96b7-3e4394d6a0d9", + "id": "caa8cb07", "metadata": {}, "source": [ "Merge tab1 and tab2_keyed using a left join with `q_join` set to `True`. Inputs/Outputs will match q [lj](https://code.kx.com/q/ref/lj/) behaviour." @@ -1728,7 +1757,7 @@ { "cell_type": "code", "execution_count": null, - "id": "4d3d70c5-9ad9-45ee-b69f-d855c3f116af", + "id": "1a7fb401", "metadata": {}, "outputs": [], "source": [ @@ -1740,7 +1769,7 @@ }, { "cell_type": "markdown", - "id": "e4e4b882-1fd9-4069-93ae-18848301a5fc", + "id": "b465b9fc", "metadata": {}, "source": [ "Inputs/Outputs will match q [ij](https://code.kx.com/q/ref/ij/) behaviour." @@ -1749,7 +1778,7 @@ { "cell_type": "code", "execution_count": null, - "id": "bf32cdee-0b20-44f9-b0f5-db44be5e8d91", + "id": "bb0c0f70", "metadata": {}, "outputs": [], "source": [ @@ -1760,7 +1789,7 @@ }, { "cell_type": "markdown", - "id": "5e619567-b73d-4821-976e-4b5f9bdddef4", + "id": "125d8479", "metadata": {}, "source": [ "Merge using `q_join` set to `True`, and `how` set to `left`, will fail when `tab2` is not a keyed table." @@ -1769,7 +1798,7 @@ { "cell_type": "code", "execution_count": null, - "id": "03a3e697-8ee8-47ee-9cf9-299e1ebfef61", + "id": "6d71a5e4", "metadata": {}, "outputs": [], "source": [ @@ -1782,7 +1811,7 @@ }, { "cell_type": "markdown", - "id": "7583c015", + "id": "42158c05", "metadata": {}, "source": [ "### Table.merge_asof()\n", @@ -1839,7 +1868,7 @@ }, { "cell_type": "markdown", - "id": "908499df", + "id": "8712f68e", "metadata": {}, "source": [ "**Examples:**\n", @@ -1850,7 +1879,7 @@ { "cell_type": "code", "execution_count": null, - "id": "e660e496", + "id": "16fbf21a", "metadata": {}, "outputs": [], "source": [ @@ -1862,7 +1891,7 @@ { "cell_type": "code", "execution_count": null, - "id": "e456e4ad", + "id": "c8d023aa", "metadata": {}, "outputs": [], "source": [ @@ -1872,7 +1901,7 @@ { "cell_type": "code", "execution_count": null, - "id": "d4616f6d", + "id": "b2f2766b", "metadata": {}, "outputs": [], "source": [ @@ -1881,7 +1910,7 @@ }, { "cell_type": "markdown", - "id": "496d5a72", + "id": "e10eced6", "metadata": {}, "source": [ "Perform a asof join on two tables but first merge them on the by column." @@ -1890,7 +1919,7 @@ { "cell_type": "code", "execution_count": null, - "id": "3f0fcc13", + "id": "943dd5b1", "metadata": {}, "outputs": [], "source": [ @@ -1936,7 +1965,7 @@ { "cell_type": "code", "execution_count": null, - "id": "b7259913", + "id": "20657aed", "metadata": {}, "outputs": [], "source": [ @@ -1946,7 +1975,7 @@ { "cell_type": "code", "execution_count": null, - "id": "32e41b85", + "id": "a858ec29", "metadata": {}, "outputs": [], "source": [ @@ -1955,7 +1984,7 @@ }, { "cell_type": "markdown", - "id": "04e022a9", + "id": "e6280a9a", "metadata": {}, "source": [ "## Analytic functionality" @@ -1964,19 +1993,24 @@ { "cell_type": "code", "execution_count": null, - "id": "c167fdc9", + "id": "b5d4844f", "metadata": {}, "outputs": [], "source": [ "# All the examples in this section will use this example table.\n", - "kx.q('N: 100')\n", - "tab = kx.q('([] sym: N?`AAPL`GOOG`MSFT; price: 250f - N?500f; traded: 100 - N?200; hold: N?0b)')\n", + "N = 100\n", + "kx.Table(data={\n", + " 'sym': kx.random.random(N, ['AAPL', 'GOOG', 'MSFT']),\n", + " 'price': 250 + kx.random.random(N, 500.0),\n", + " 'traded': 100 - kx.random.random(N, 200),\n", + " 'hold': kx.random.random(N, False)\n", + " })\n", "tab" ] }, { "cell_type": "markdown", - "id": "be074715", + "id": "fa9c8fc5", "metadata": {}, "source": [ "### Table.abs()\n", @@ -2003,7 +2037,7 @@ { "cell_type": "code", "execution_count": null, - "id": "52f27400", + "id": "032c6006", "metadata": { "scrolled": true }, @@ -2014,7 +2048,7 @@ }, { "cell_type": "markdown", - "id": "85d42035", + "id": "d644f8ee", "metadata": {}, "source": [ "### Table.count()\n", @@ -2042,7 +2076,7 @@ { "cell_type": "code", "execution_count": null, - "id": "a53125cb", + "id": "cd70f67c", "metadata": {}, "outputs": [], "source": [ @@ -2051,7 +2085,7 @@ }, { "cell_type": "markdown", - "id": "77a5a83f", + "id": "f8554641", "metadata": {}, "source": [ "### Table.max()\n", @@ -2080,7 +2114,7 @@ { "cell_type": "code", "execution_count": null, - "id": "5aea50f5", + "id": "743d7fb5", "metadata": {}, "outputs": [], "source": [ @@ -2089,7 +2123,7 @@ }, { "cell_type": "markdown", - "id": "71dab7ac", + "id": "bc5b6dde", "metadata": {}, "source": [ "### Table.min()\n", @@ -2118,7 +2152,7 @@ { "cell_type": "code", "execution_count": null, - "id": "9f13e8a7", + "id": "d730d7e0", "metadata": {}, "outputs": [], "source": [ @@ -2127,7 +2161,7 @@ }, { "cell_type": "markdown", - "id": "1bf3da2a", + "id": "4aee2790", "metadata": {}, "source": [ "### Table.sum()\n", @@ -2157,7 +2191,7 @@ { "cell_type": "code", "execution_count": null, - "id": "09975a7a", + "id": "4303521e", "metadata": {}, "outputs": [], "source": [ @@ -2166,7 +2200,7 @@ }, { "cell_type": "markdown", - "id": "97920009", + "id": "3fd35bc7", "metadata": {}, "source": [ "### Table.mean()\n", @@ -2193,7 +2227,7 @@ }, { "cell_type": "markdown", - "id": "dee2e8cc", + "id": "4ce8168f", "metadata": {}, "source": [ "**Examples:**\n", @@ -2204,7 +2238,7 @@ { "cell_type": "code", "execution_count": null, - "id": "9d4c8a22", + "id": "50b58aad", "metadata": {}, "outputs": [], "source": [ @@ -2222,7 +2256,7 @@ { "cell_type": "code", "execution_count": null, - "id": "d02c4cfd", + "id": "fc7ab777", "metadata": {}, "outputs": [], "source": [ @@ -2231,7 +2265,7 @@ }, { "cell_type": "markdown", - "id": "c6feb4ea", + "id": "f3b85934", "metadata": {}, "source": [ "Calculate the mean across the rows of a table" @@ -2240,7 +2274,7 @@ { "cell_type": "code", "execution_count": null, - "id": "506a6867", + "id": "8f85e05c", "metadata": {}, "outputs": [], "source": [ @@ -2249,7 +2283,7 @@ }, { "cell_type": "markdown", - "id": "cd714c1b", + "id": "b0eff83a", "metadata": {}, "source": [ "### Table.median()\n", @@ -2276,7 +2310,7 @@ }, { "cell_type": "markdown", - "id": "00d44518", + "id": "80f2f2a1", "metadata": {}, "source": [ "**Examples:**\n", @@ -2287,7 +2321,7 @@ { "cell_type": "code", "execution_count": null, - "id": "df20ecfc", + "id": "46ca7078", "metadata": {}, "outputs": [], "source": [ @@ -2305,7 +2339,7 @@ { "cell_type": "code", "execution_count": null, - "id": "6e9dc5be", + "id": "0bd18f87", "metadata": {}, "outputs": [], "source": [ @@ -2314,7 +2348,7 @@ }, { "cell_type": "markdown", - "id": "585d9d01", + "id": "8312046c", "metadata": {}, "source": [ "Calculate the median across the rows of a table" @@ -2323,7 +2357,7 @@ { "cell_type": "code", "execution_count": null, - "id": "6ccf50df", + "id": "6fd7558c", "metadata": {}, "outputs": [], "source": [ @@ -2332,7 +2366,7 @@ }, { "cell_type": "markdown", - "id": "aeec2045", + "id": "929fe196", "metadata": {}, "source": [ "### Table.mode()\n", @@ -2360,7 +2394,7 @@ }, { "cell_type": "markdown", - "id": "c52ffed8", + "id": "880e64c2", "metadata": {}, "source": [ "**Examples:**\n", @@ -2371,7 +2405,7 @@ { "cell_type": "code", "execution_count": null, - "id": "786fe3b6", + "id": "b0b087e3", "metadata": {}, "outputs": [], "source": [ @@ -2389,7 +2423,7 @@ { "cell_type": "code", "execution_count": null, - "id": "58909ffa", + "id": "19d3a003", "metadata": { "scrolled": true }, @@ -2400,7 +2434,7 @@ }, { "cell_type": "markdown", - "id": "7d437b70", + "id": "85ce92d2", "metadata": {}, "source": [ "Calculate the median across the rows of a table" @@ -2409,7 +2443,7 @@ { "cell_type": "code", "execution_count": null, - "id": "cfa17533", + "id": "3d418ed9", "metadata": {}, "outputs": [], "source": [ @@ -2418,7 +2452,7 @@ }, { "cell_type": "markdown", - "id": "4c270df3", + "id": "097ff9d9", "metadata": {}, "source": [ "Calculate the mode across columns and keep null values." @@ -2427,7 +2461,7 @@ { "cell_type": "code", "execution_count": null, - "id": "80afc141", + "id": "503efd21", "metadata": { "scrolled": true }, @@ -2446,7 +2480,7 @@ { "cell_type": "code", "execution_count": null, - "id": "4e3300f5", + "id": "94f25640", "metadata": {}, "outputs": [], "source": [ @@ -2455,7 +2489,7 @@ }, { "cell_type": "markdown", - "id": "4117c73f", + "id": "7371feb5", "metadata": {}, "source": [ "### Table.prod()\n", @@ -2485,7 +2519,7 @@ { "cell_type": "code", "execution_count": null, - "id": "a6c64b75", + "id": "7852e009", "metadata": { "scrolled": true }, @@ -2493,8 +2527,13 @@ "source": [ "# This example will use a smaller version of the above table\n", "# as the result of calculating the product quickly goes over the integer limits.\n", - "kx.q('N: 10')\n", - "tab = kx.q('([] sym: N?`AAPL`GOOG`MSFT; price: 2.5f - N?5f; traded: 10 - N?20; hold: N?0b)')\n", + "N = 10\n", + "tab = kx.Table(data={\n", + " 'sym': kx.random.random(N, ['AAPL', 'GOOG', 'MSFT']),\n", + " 'price': 2.5 - kx.random.random(N, 5.0),\n", + " 'traded': 10 - kx.random.random(N, 20),\n", + " 'hold': kx.random.random(N, False)\n", + " })\n", "tab[tab['traded'] == 0, 'traded'] = 1\n", "tab[tab['price'] == 0, 'price'] = 1.0\n", "tab" @@ -2503,7 +2542,7 @@ { "cell_type": "code", "execution_count": null, - "id": "540297e2", + "id": "5ced8761", "metadata": {}, "outputs": [], "source": [ @@ -2512,7 +2551,7 @@ }, { "cell_type": "markdown", - "id": "c777923e", + "id": "ff51630f", "metadata": {}, "source": [ "### Table.skew()\n", @@ -2542,7 +2581,7 @@ { "cell_type": "code", "execution_count": null, - "id": "fc109f0f", + "id": "af65b9ab", "metadata": {}, "outputs": [], "source": [ @@ -2551,7 +2590,7 @@ }, { "cell_type": "markdown", - "id": "22940e03", + "id": "b054645b", "metadata": {}, "source": [ "### Table.std()\n", @@ -2581,7 +2620,7 @@ }, { "cell_type": "markdown", - "id": "292f9c39", + "id": "9a0c1a5d", "metadata": {}, "source": [ "**Examples:**\n", @@ -2592,7 +2631,7 @@ { "cell_type": "code", "execution_count": null, - "id": "f2df159e", + "id": "42c3e6bf", "metadata": {}, "outputs": [], "source": [ @@ -2610,7 +2649,7 @@ { "cell_type": "code", "execution_count": null, - "id": "63d45751", + "id": "947435db", "metadata": {}, "outputs": [], "source": [ @@ -2619,7 +2658,7 @@ }, { "cell_type": "markdown", - "id": "2e9705de", + "id": "463894f1", "metadata": {}, "source": [ "Calculate the std across the rows of a table" @@ -2628,7 +2667,7 @@ { "cell_type": "code", "execution_count": null, - "id": "8edf71a4", + "id": "7d918f6a", "metadata": {}, "outputs": [], "source": [ @@ -2637,7 +2676,7 @@ }, { "cell_type": "markdown", - "id": "1ef61cd5", + "id": "ad38071b", "metadata": {}, "source": [ "Calculate std accross columns with ddof=0:" @@ -2646,7 +2685,7 @@ { "cell_type": "code", "execution_count": null, - "id": "0f66fe87", + "id": "77c7aaa3", "metadata": {}, "outputs": [], "source": [ @@ -2655,7 +2694,7 @@ }, { "cell_type": "markdown", - "id": "c80d90ae", + "id": "5f1e5350", "metadata": {}, "source": [ "## Group By" @@ -2663,7 +2702,7 @@ }, { "cell_type": "markdown", - "id": "2e1d05d5", + "id": "57fe61a2", "metadata": {}, "source": [ "### Table.groupby()\n", @@ -2714,7 +2753,7 @@ { "cell_type": "code", "execution_count": null, - "id": "c0454f7d", + "id": "aa82d895", "metadata": { "scrolled": true }, @@ -2731,7 +2770,7 @@ }, { "cell_type": "markdown", - "id": "55b6b4e0", + "id": "0487cfe5", "metadata": {}, "source": [ "Group on the `Animal` column and calculate the mean of the resulting `Max Speed` and `Max Altitude` columns." @@ -2740,7 +2779,7 @@ { "cell_type": "code", "execution_count": null, - "id": "30c55810", + "id": "db5f0dd6", "metadata": { "scrolled": true }, @@ -2751,7 +2790,7 @@ }, { "cell_type": "markdown", - "id": "0e62a99f", + "id": "361019ba", "metadata": {}, "source": [ "Example table with multiple columns to group on." @@ -2760,23 +2799,23 @@ { "cell_type": "code", "execution_count": null, - "id": "0ceddbbf", + "id": "c1985906", "metadata": {}, "outputs": [], "source": [ - "tab = kx.q('2!', kx.Table(\n", + "tab = kx.Table(\n", " data={\n", " 'Animal': ['Falcon', 'Falcon', 'Parrot', 'Parrot', 'Parrot'],\n", " 'Type': ['Captive', 'Wild', 'Captive', 'Wild', 'Wild'],\n", " 'Max Speed': [390., 350., 30., 20., 25.]\n", - " }\n", - "))\n", + " })\n", + "tab = tab.set_index(2)\n", "tab" ] }, { "cell_type": "markdown", - "id": "7e43e1bc", + "id": "ae3d3244", "metadata": {}, "source": [ "Group on multiple columns using thier indexes." @@ -2785,7 +2824,7 @@ { "cell_type": "code", "execution_count": null, - "id": "c281e305", + "id": "bb9dd53b", "metadata": {}, "outputs": [], "source": [ @@ -2794,7 +2833,7 @@ }, { "cell_type": "markdown", - "id": "e5d04220", + "id": "14dfdd2a", "metadata": {}, "source": [ "Example table with Nulls." @@ -2803,14 +2842,14 @@ { "cell_type": "code", "execution_count": null, - "id": "ae67684c", + "id": "8f389591", "metadata": {}, "outputs": [], "source": [ "tab = kx.Table(\n", " [\n", " [\"a\", 12, 12],\n", - " [kx.q('`'), 12.3, 33.],\n", + " [kx.SymbolAtom.null, 12.3, 33.],\n", " [\"b\", 12.3, 123],\n", " [\"a\", 1, 1]\n", " ],\n", @@ -2821,7 +2860,7 @@ }, { "cell_type": "markdown", - "id": "512021d7", + "id": "62e3f5f5", "metadata": {}, "source": [ "Group on column `a` and keep null groups." @@ -2830,7 +2869,7 @@ { "cell_type": "code", "execution_count": null, - "id": "a09a6d3a", + "id": "bcca967d", "metadata": { "scrolled": true }, @@ -2841,7 +2880,7 @@ }, { "cell_type": "markdown", - "id": "4ca2006b", + "id": "2ddc596a", "metadata": {}, "source": [ "Group on column `a` keeping null groups and not using the groups as an index column." @@ -2850,7 +2889,7 @@ { "cell_type": "code", "execution_count": null, - "id": "caa2576e", + "id": "c8f9a0b4", "metadata": {}, "outputs": [], "source": [ @@ -2859,7 +2898,7 @@ }, { "cell_type": "markdown", - "id": "660b3c92", + "id": "56cf152e", "metadata": {}, "source": [ "## Apply\n", @@ -2907,7 +2946,7 @@ { "cell_type": "code", "execution_count": null, - "id": "d746cddb", + "id": "0a85caee", "metadata": {}, "outputs": [], "source": [ @@ -2918,7 +2957,7 @@ }, { "cell_type": "markdown", - "id": "54c09d0c", + "id": "e4cddd7b", "metadata": {}, "source": [ "Apply square root on each item within a column" @@ -2927,7 +2966,7 @@ { "cell_type": "code", "execution_count": null, - "id": "f8bbcac7", + "id": "0895f9c5", "metadata": {}, "outputs": [], "source": [ @@ -2936,7 +2975,7 @@ }, { "cell_type": "markdown", - "id": "09a61483", + "id": "47b6ca70", "metadata": {}, "source": [ "Apply a reducing function sum on either axis" @@ -2945,7 +2984,7 @@ { "cell_type": "code", "execution_count": null, - "id": "84b92b9b", + "id": "901a692b", "metadata": {}, "outputs": [], "source": [ @@ -2955,7 +2994,7 @@ { "cell_type": "code", "execution_count": null, - "id": "169d8ed3", + "id": "43ab33ab", "metadata": {}, "outputs": [], "source": [ @@ -2964,7 +3003,7 @@ }, { "cell_type": "markdown", - "id": "ed4d720c", + "id": "c20acb8a", "metadata": {}, "source": [ "## Aggregate\n", @@ -3008,7 +3047,7 @@ { "cell_type": "code", "execution_count": null, - "id": "2696cf42", + "id": "0fd05e6e", "metadata": {}, "outputs": [], "source": [ @@ -3023,7 +3062,7 @@ }, { "cell_type": "markdown", - "id": "3f90677b", + "id": "cecd45f0", "metadata": {}, "source": [ "Aggregate a list of functions over rows" @@ -3032,7 +3071,7 @@ { "cell_type": "code", "execution_count": null, - "id": "861e5787", + "id": "857ff7cf", "metadata": {}, "outputs": [], "source": [ @@ -3041,7 +3080,7 @@ }, { "cell_type": "markdown", - "id": "ccdaee01", + "id": "8bc17135", "metadata": {}, "source": [ "Perform an aggregation using a user specified function" @@ -3050,7 +3089,7 @@ { "cell_type": "code", "execution_count": null, - "id": "b5f9f25b", + "id": "4108f2e5", "metadata": {}, "outputs": [], "source": [ @@ -3062,7 +3101,7 @@ }, { "cell_type": "markdown", - "id": "667d9961", + "id": "ba013165", "metadata": {}, "source": [ "Apply an aggregation supplying column specification for supplied function" @@ -3071,7 +3110,7 @@ { "cell_type": "code", "execution_count": null, - "id": "60845603", + "id": "1cf2c721", "metadata": {}, "outputs": [], "source": [ @@ -3080,7 +3119,7 @@ }, { "cell_type": "markdown", - "id": "256f5496", + "id": "dc726b75", "metadata": {}, "source": [ "## Data Preprocessing" @@ -3088,7 +3127,7 @@ }, { "cell_type": "markdown", - "id": "976e633c", + "id": "d508891a", "metadata": {}, "source": [ "### Table.add_prefix()\n", @@ -3115,7 +3154,7 @@ }, { "cell_type": "markdown", - "id": "77ff0376", + "id": "4255701a", "metadata": {}, "source": [ "**Examples:**\n", @@ -3126,7 +3165,7 @@ { "cell_type": "code", "execution_count": null, - "id": "c71b39c6", + "id": "905c810d", "metadata": {}, "outputs": [], "source": [ @@ -3135,7 +3174,7 @@ }, { "cell_type": "markdown", - "id": "8b6968da", + "id": "cd6a4005", "metadata": {}, "source": [ "Add \"col_\" to table columns:" @@ -3144,7 +3183,7 @@ { "cell_type": "code", "execution_count": null, - "id": "aa98ca46", + "id": "11296af4", "metadata": {}, "outputs": [], "source": [ @@ -3153,7 +3192,7 @@ }, { "cell_type": "markdown", - "id": "5f87eeba", + "id": "8fb874ba", "metadata": {}, "source": [ "### Table.add_suffix()\n", @@ -3180,7 +3219,7 @@ }, { "cell_type": "markdown", - "id": "dc449e82", + "id": "47618c02", "metadata": {}, "source": [ "**Examples:**\n", @@ -3191,7 +3230,7 @@ { "cell_type": "code", "execution_count": null, - "id": "4471a14b", + "id": "1e5c17b3", "metadata": {}, "outputs": [], "source": [ @@ -3200,7 +3239,7 @@ }, { "cell_type": "markdown", - "id": "b01dfa6c", + "id": "e93f30cb", "metadata": {}, "source": [ "Add \"_col\" to table columns:" @@ -3209,7 +3248,7 @@ { "cell_type": "code", "execution_count": null, - "id": "c7c46631", + "id": "5625768b", "metadata": {}, "outputs": [], "source": [ @@ -3218,7 +3257,7 @@ }, { "cell_type": "markdown", - "id": "d56eeae9", + "id": "a5bb7631", "metadata": {}, "source": [ "### Table.astype()\n", @@ -3247,7 +3286,7 @@ }, { "cell_type": "markdown", - "id": "5d27ccde", + "id": "e0af2087", "metadata": {}, "source": [ "**Examples:**\n", @@ -3258,16 +3297,21 @@ { "cell_type": "code", "execution_count": null, - "id": "63d18dce", + "id": "deb4809e", "metadata": {}, "outputs": [], "source": [ - "df = kx.q('([] c1:1 2 3i; c2:1 2 3j; c3:1 2 3h; c4:1 2 3i)')" + "df = kx.Table(data = {\n", + " 'c1': kx.IntVector([1, 2, 3]),\n", + " 'c2': kx.LongVector([1, 2, 3]),\n", + " 'c3': kx.ShortVector([1, 2, 3]),\n", + " 'c4': kx.IntVector([1, 2, 3])\n", + " })" ] }, { "cell_type": "markdown", - "id": "4e6fad4f", + "id": "9126a84d", "metadata": {}, "source": [ "Cast all columns to dtype LongVector" @@ -3276,7 +3320,7 @@ { "cell_type": "code", "execution_count": null, - "id": "0ef76c1e", + "id": "da1b75cb", "metadata": {}, "outputs": [], "source": [ @@ -3285,7 +3329,7 @@ }, { "cell_type": "markdown", - "id": "1846286e", + "id": "3799183f", "metadata": {}, "source": [ "Casting as specified in the dictionary supplied with given dtype per column" @@ -3294,7 +3338,7 @@ { "cell_type": "code", "execution_count": null, - "id": "a4cc4bb7", + "id": "77de55f5", "metadata": {}, "outputs": [], "source": [ @@ -3303,7 +3347,7 @@ }, { "cell_type": "markdown", - "id": "c77a5800", + "id": "e73a33cd", "metadata": {}, "source": [ "The next example will use this table" @@ -3312,16 +3356,24 @@ { "cell_type": "code", "execution_count": null, - "id": "78b91d9f", + "id": "73e47ecc", "metadata": {}, "outputs": [], "source": [ - "df = kx.q('([] c1:3#.z.p; c2:`abc`def`ghi; c3:1 2 3j; c4:(\"abc\";\"def\";\"ghi\");c5:\"abc\";c6:(1 2 3;4 5 6;7 8 9))')" + "df = kx.Table(data={\n", + " 'c1': kx.TimestampAtom('now'),\n", + " 'c2': ['abc', 'def', 'ghi'],\n", + " 'c3': [1, 2, 3],\n", + " 'c4': [b'abc', b'def', b'ghi'],\n", + " 'c5': b'abc',\n", + " 'c6': [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n", + " })\n", + "df" ] }, { "cell_type": "markdown", - "id": "e89a0596", + "id": "5eb8e9f2", "metadata": {}, "source": [ "Casting char and string columns to symbol columns" @@ -3330,7 +3382,7 @@ { "cell_type": "code", "execution_count": null, - "id": "599dca72", + "id": "b56e61ab", "metadata": {}, "outputs": [], "source": [ @@ -3339,7 +3391,7 @@ }, { "cell_type": "markdown", - "id": "92ab62d2", + "id": "c7422edd", "metadata": {}, "source": [ "### Table.drop()\n", @@ -3366,7 +3418,7 @@ }, { "cell_type": "markdown", - "id": "756e1611", + "id": "6b589694", "metadata": {}, "source": [ "**Examples:**\n", @@ -3377,20 +3429,25 @@ { "cell_type": "code", "execution_count": null, - "id": "60fb2684", + "id": "e0df894a", "metadata": {}, "outputs": [], "source": [ "# The examples in this section will use this example table filled with random data\n", - "kx.q('N: 1000')\n", - "tab = kx.q('([] x: til N; y: N?`AAPL`GOOG`MSFT; z: N?500f; w: N?1000; v: N?(0N 0 50 100 200 250))')\n", + "N = 1000\n", + "tab = kx.Table(data = {\n", + " 'x': kx.q.til(N),\n", + " 'y': kx.random.random(N, ['AAPL', 'GOOG', 'MSFT']),\n", + " 'z': kx.random.random(N, 500.0),\n", + " 'w': kx.random.random(N, 1000),\n", + " 'v': kx.random.random(N, [kx.LongAtom.null, 0, 50, 100, 200, 250])})\n", "tab.head()" ] }, { "cell_type": "code", "execution_count": null, - "id": "bc0db439", + "id": "f7553c97", "metadata": {}, "outputs": [], "source": [ @@ -3399,7 +3456,7 @@ }, { "cell_type": "markdown", - "id": "b6b79c9b", + "id": "3b68fcbf", "metadata": {}, "source": [ "Drop columns from a table." @@ -3408,7 +3465,7 @@ { "cell_type": "code", "execution_count": null, - "id": "41eb79c1", + "id": "1a07c27f", "metadata": {}, "outputs": [], "source": [ @@ -3417,7 +3474,7 @@ }, { "cell_type": "markdown", - "id": "e34706ea", + "id": "d30d870b", "metadata": {}, "source": [ "### Table.drop_duplicates()\n", @@ -3437,7 +3494,7 @@ }, { "cell_type": "markdown", - "id": "e9e064d1", + "id": "3c633610", "metadata": {}, "source": [ "**Examples:**\n", @@ -3448,17 +3505,21 @@ { "cell_type": "code", "execution_count": null, - "id": "7c8be915", + "id": "672ae369", "metadata": {}, "outputs": [], "source": [ - "tab2 = kx.q('([] 100?`AAPL`GOOG`MSFT; 100?3)')\n", + "N = 100\n", + "tab2 = kx.Table(data ={\n", + " 'x': kx.random.random(N, ['AAPL', 'GOOG', 'MSFT']),\n", + " 'x1': kx.random.random(N, 3)\n", + " })\n", "tab2" ] }, { "cell_type": "markdown", - "id": "4af0c99d", + "id": "5912fc4e", "metadata": {}, "source": [ "Drop all duplicate rows from the table." @@ -3467,7 +3528,7 @@ { "cell_type": "code", "execution_count": null, - "id": "5f6ec5c7", + "id": "9cc0d387", "metadata": {}, "outputs": [], "source": [ @@ -3476,7 +3537,7 @@ }, { "cell_type": "markdown", - "id": "77282b77", + "id": "6110d8d9", "metadata": {}, "source": [ "### Table.pop()\n", @@ -3502,7 +3563,7 @@ }, { "cell_type": "markdown", - "id": "6846f6a1", + "id": "70c2c22a", "metadata": {}, "source": [ "**Examples:**\n", @@ -3513,7 +3574,7 @@ { "cell_type": "code", "execution_count": null, - "id": "40ab2931", + "id": "cc1770f6", "metadata": { "scrolled": true }, @@ -3528,7 +3589,7 @@ }, { "cell_type": "markdown", - "id": "45aca79f", + "id": "e4843e47", "metadata": {}, "source": [ "Remove the `z` and `w` columns from the table and return them." @@ -3537,7 +3598,7 @@ { "cell_type": "code", "execution_count": null, - "id": "2f381911", + "id": "3c9dda2a", "metadata": {}, "outputs": [], "source": [ @@ -3550,7 +3611,7 @@ }, { "cell_type": "markdown", - "id": "2f4954bb", + "id": "68e67196", "metadata": {}, "source": [ "### Table.rename()\n", @@ -3584,7 +3645,7 @@ }, { "cell_type": "markdown", - "id": "ddd7f1f2", + "id": "08c8748e", "metadata": {}, "source": [ "**Examples:**\n", @@ -3595,7 +3656,7 @@ { "cell_type": "code", "execution_count": null, - "id": "d844c2c3", + "id": "e131bae9", "metadata": {}, "outputs": [], "source": [ @@ -3605,7 +3666,7 @@ }, { "cell_type": "markdown", - "id": "9b819386", + "id": "b5ef3e3d", "metadata": {}, "source": [ "Rename column `x` to `index` and `y` to `symbol` using the `columns` keyword." @@ -3614,7 +3675,7 @@ { "cell_type": "code", "execution_count": null, - "id": "e352c9ba", + "id": "e03e5b8e", "metadata": {}, "outputs": [], "source": [ @@ -3623,7 +3684,7 @@ }, { "cell_type": "markdown", - "id": "4f9e2895-a82a-4f8e-ae2c-d3f898ece131", + "id": "6d25ea19", "metadata": {}, "source": [ "Rename column `x` to `index` and `y` to `symbol` by setting the `axis` keyword." @@ -3632,7 +3693,7 @@ { "cell_type": "code", "execution_count": null, - "id": "16ae0555-9d92-4642-9671-03a2790216c8", + "id": "4a8da84c", "metadata": {}, "outputs": [], "source": [ @@ -3641,7 +3702,7 @@ }, { "cell_type": "markdown", - "id": "70e2735a-b582-47f7-9557-5f64f2238e89", + "id": "9d887f84", "metadata": {}, "source": [ "Rename index of a keyed table by using literal `index` as the `axis` parameter." @@ -3650,7 +3711,7 @@ { "cell_type": "code", "execution_count": null, - "id": "7b2bcbd6-32ef-4988-ac81-3de73222face", + "id": "4619e64e", "metadata": {}, "outputs": [], "source": [ @@ -3659,7 +3720,274 @@ }, { "cell_type": "markdown", - "id": "b85d53ba", + "id": "fda14bd0-5be3-44f3-a5ba-36ab067eb384", + "metadata": {}, + "source": [ + "### Table.replace()\n", + "``` Table.replace(to_replace, value) ```\n", + "\n", + "Replace all values in a table with another given value.\n", + "\n", + "**Parameters:**\n", + "\n", + "| Name | Type | Description | Default |\n", + "| :-------: | :--- | :------------------------------------------------------------------------------------------| :-----: |\n", + "| to_replace| any | Value of element in table you wish to replace. | None |\n", + "| value | any | New value to perform replace with. | None |\n", + "\n", + "**Returns:**\n", + "\n", + "| Type | Description |\n", + "| :---: | :----------------------------------------------------------------- |\n", + "| Table | A table with the given elements replaced with new value. |" + ] + }, + { + "cell_type": "markdown", + "id": "d211a836-b74c-42df-9da4-b20896c6c1f7", + "metadata": {}, + "source": [ + "**Examples**\n", + "\n", + "Create an unkeyed `Table` and a `KeyedTable` with elements to be replaced." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "bbbec511-0395-4be3-b9b4-e6d3c09a21a7", + "metadata": {}, + "outputs": [ + { + "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", + "
bcde
a
241ba1
220bb2
361bc`a
" + ], + "text/plain": [ + "pykx.KeyedTable(pykx.q('\n", + "a| b c d e \n", + "-| --------\n", + "2| 4 1 a 1 \n", + "2| 2 0 b 2 \n", + "3| 6 1 c `a\n", + "'))" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tab = kx.q('([] a:2 2 3; b:4 2 6; c:(1b;0b;1b); d:(`a;`b;`c); e:(1;2;`a))')\n", + "ktab = kx.q('([a:2 2 3]b:4 2 6; c:(1b;0b;1b); d:(`a;`b;`c); e:(1;2;`a))')\n", + "ktab" + ] + }, + { + "cell_type": "markdown", + "id": "cbfcf189-628d-45fe-ab85-2330b46fdcc9", + "metadata": {}, + "source": [ + "Replace all instances of `2` in the `KeyedTable` with `123`. Note the key column remains unchanged." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "3a36a978-022a-4e49-8191-05a768d5f30e", + "metadata": {}, + "outputs": [ + { + "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", + "
bcde
a
241ba1
21230bb123
361bc`a
" + ], + "text/plain": [ + "pykx.KeyedTable(pykx.q('\n", + "a| b c d e \n", + "-| -----------\n", + "2| 4 1 a 1 \n", + "2| 123 0 b 123\n", + "3| 6 1 c `a \n", + "'))" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ktab.replace(2,123)" + ] + }, + { + "cell_type": "markdown", + "id": "6cc51c70-af14-4061-bdd7-d2fa7d8df20b", + "metadata": {}, + "source": [ + "Replace all `True` values with a list of strings." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "a1b87680-f2aa-4434-bcb6-2f4b384b735c", + "metadata": {}, + "outputs": [ + { + "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", + "
abcde
024`one`two`threea1
1220bb2
236`one`two`threec`a
" + ], + "text/plain": [ + "pykx.Table(pykx.q('\n", + "a b c d e \n", + "-----------------------\n", + "2 4 `one`two`three a 1 \n", + "2 2 0b b 2 \n", + "3 6 `one`two`three c `a\n", + "'))" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tab.replace(True, (\"one\", \"two\", \"three\"))" + ] + }, + { + "cell_type": "markdown", + "id": "73059996", "metadata": {}, "source": [ "### Table.reset_index()\n", @@ -3701,7 +4029,7 @@ { "cell_type": "code", "execution_count": null, - "id": "a723d14d", + "id": "05f5d858", "metadata": {}, "outputs": [], "source": [ @@ -3719,7 +4047,7 @@ }, { "cell_type": "markdown", - "id": "089ad779", + "id": "ac9a7e94", "metadata": {}, "source": [ "Resetting the index of the table will result in original index columns being added to the table directly" @@ -3728,7 +4056,7 @@ { "cell_type": "code", "execution_count": null, - "id": "4662c138", + "id": "35f78f09", "metadata": {}, "outputs": [], "source": [ @@ -3737,7 +4065,7 @@ }, { "cell_type": "markdown", - "id": "4e019e54", + "id": "ea62a377", "metadata": {}, "source": [ "Reset the index adding a specified named column to the table" @@ -3746,7 +4074,7 @@ { "cell_type": "code", "execution_count": null, - "id": "a990ea29", + "id": "c136c0f7", "metadata": {}, "outputs": [], "source": [ @@ -3755,7 +4083,7 @@ }, { "cell_type": "markdown", - "id": "f186c5fb", + "id": "4a4223bb", "metadata": {}, "source": [ "Reset the index using multiple named columns" @@ -3764,7 +4092,7 @@ { "cell_type": "code", "execution_count": null, - "id": "9c62edc4", + "id": "be677606", "metadata": {}, "outputs": [], "source": [ @@ -3773,7 +4101,7 @@ }, { "cell_type": "markdown", - "id": "c6f54a5c", + "id": "535841af", "metadata": {}, "source": [ "Reset the index specifying the column `number` which is to be added to the table" @@ -3782,7 +4110,7 @@ { "cell_type": "code", "execution_count": null, - "id": "c52367f4", + "id": "b3e6bda0", "metadata": {}, "outputs": [], "source": [ @@ -3791,7 +4119,7 @@ }, { "cell_type": "markdown", - "id": "ee76fa24", + "id": "80719030", "metadata": {}, "source": [ "Reset the index specifying multiple numbered columns" @@ -3800,7 +4128,7 @@ { "cell_type": "code", "execution_count": null, - "id": "0cf6b213", + "id": "fab2e4e7", "metadata": {}, "outputs": [], "source": [ @@ -3809,7 +4137,7 @@ }, { "cell_type": "markdown", - "id": "7fc928a5", + "id": "ed82d445", "metadata": {}, "source": [ "Drop index columns from table" @@ -3818,7 +4146,7 @@ { "cell_type": "code", "execution_count": null, - "id": "8596e5a1", + "id": "945b8293", "metadata": {}, "outputs": [], "source": [ @@ -3827,7 +4155,7 @@ }, { "cell_type": "markdown", - "id": "e95b57dd", + "id": "db72bcbb", "metadata": {}, "source": [ "Drop specified key columns from table" @@ -3836,7 +4164,7 @@ { "cell_type": "code", "execution_count": null, - "id": "dde1ee77", + "id": "b9646f1d", "metadata": {}, "outputs": [], "source": [ @@ -3845,7 +4173,7 @@ }, { "cell_type": "markdown", - "id": "8e19ddeb", + "id": "2201d826", "metadata": {}, "source": [ "### Table.set_index()\n", @@ -3886,18 +4214,23 @@ { "cell_type": "code", "execution_count": null, - "id": "6ede4322", + "id": "e2ef05c3", "metadata": {}, "outputs": [], "source": [ - "kx.q('N: 10')\n", - "tab = kx.q('([] sym: N?`AAPL`GOOG`MSFT; price: 2.5f - N?5f; traded: N?0 1; hold: N?01b)')" + "N = 10\n", + "tab = kx.Table(data={\n", + " 'sym': kx.random.random(N, ['AAPL', 'GOOG', 'MSFT']),\n", + " 'price': 2.5 - kx.random.random(N, 5.0),\n", + " 'traded': 10 - kx.random.random(N, 20),\n", + " 'hold': kx.random.random(N, False)\n", + " })" ] }, { "cell_type": "code", "execution_count": null, - "id": "f6708166", + "id": "f561efd4", "metadata": {}, "outputs": [], "source": [ @@ -3908,7 +4241,7 @@ { "cell_type": "code", "execution_count": null, - "id": "abf46438", + "id": "66f9b964", "metadata": {}, "outputs": [], "source": [ @@ -3919,7 +4252,7 @@ { "cell_type": "code", "execution_count": null, - "id": "567ff8e9", + "id": "00dda488", "metadata": {}, "outputs": [], "source": [ @@ -3930,7 +4263,7 @@ }, { "cell_type": "markdown", - "id": "fb24895d", + "id": "965ef63a", "metadata": {}, "source": [ "Appending:" @@ -3939,7 +4272,7 @@ { "cell_type": "code", "execution_count": null, - "id": "d080737f", + "id": "cf53a132", "metadata": {}, "outputs": [], "source": [ @@ -3950,7 +4283,7 @@ { "cell_type": "code", "execution_count": null, - "id": "c33e779e", + "id": "19f88bde", "metadata": {}, "outputs": [], "source": [ @@ -3960,7 +4293,7 @@ }, { "cell_type": "markdown", - "id": "c7eab4a6", + "id": "7d605454", "metadata": {}, "source": [ "Verify Integrity:" @@ -3969,7 +4302,7 @@ { "cell_type": "code", "execution_count": null, - "id": "98fc7587", + "id": "63c810f0", "metadata": {}, "outputs": [], "source": [ @@ -3980,7 +4313,7 @@ { "cell_type": "code", "execution_count": null, - "id": "b17c1a22", + "id": "266dbc68", "metadata": {}, "outputs": [], "source": [ diff --git a/docs/user-guide/advanced/limitations.md b/docs/user-guide/advanced/limitations.md index b55cc5a..eed8a0f 100644 --- a/docs/user-guide/advanced/limitations.md +++ b/docs/user-guide/advanced/limitations.md @@ -2,7 +2,7 @@ When q is run embedded within a Python process (as opposed to over IPC), it is restricted in how it can operate. This is a result of the fact that when running embedded it does not have the main loop or timers that one would expect from a typical q process. The following are a number of examples showing these limitations in action -## IPC Interface +## IPC Interface As a result of the lack of a main loop PyKX cannot be used to respond to q IPC requests as a server. Callback functions such as [`.z.pg`](https://code.kx.com/q/ref/dotz/#zpg-get) defined within a Python process will not operate as expected. @@ -52,4 +52,3 @@ Attempting to use the timer callback function directly using PyKX will raise an >>> kx.q.z.ts AttributeError: ts: .z.ts is not exposed through the context interface because the main loop is inactive in PyKX. ``` - diff --git a/docs/user-guide/configuration.md b/docs/user-guide/configuration.md index 12f1cc3..1f07f44 100644 --- a/docs/user-guide/configuration.md +++ b/docs/user-guide/configuration.md @@ -88,7 +88,6 @@ The following variables can be used to enable or disable advanced features of Py | `PYKX_UNLICENSED` | `False` | `1` or `true` | Set PyKX to make use of the library in `unlicensed` mode at all times. | | | `PYKX_LICENSED` | `False` | `1` or `true` | Set PyKX to make use of the library in `licensed` mode at all times. | | | `PYKX_THREADING` | `False` | `1` or `true` | When importing PyKX start EmbeddedQ within a background thread. This allows calls into q from any thread to modify state, this environment variable is only supported for licensed users. | | -| `PYKX_SKIP_SIGNAL_OVERWRITE` | `False` | `1` or `true` | Skip overwriting of [signal](https://docs.python.org/3/library/signal.html) definitions by PyKX, these are presently overwritten by default to reset Pythonic default definitions with are reset by PyKX on initialisation in licensed modality. | | | `PYKX_NO_SIGNAL` | `False` | `1` or `true` | Skip overwriting of [signal](https://docs.python.org/3/library/signal.html) definitions by PyKX, these are presently overwritten by default to reset Pythonic default definitions with are reset by PyKX on initialisation in licensed modality. | | | `PYKX_4_1_ENABLED` | `False` | `1` or `true` | Load version 4.1 of `libq` when starting `PyKX` in licensed mode, this environment variable does not work without a valid `q` license. | | | `PYKX_NO_SIGINT` | `False` | `1` or `true` | Avoid setting `signal.signal(signal.SIGINT)` once PyKX is loaded, these are presently set to the Python default values once PyKX is loaded to ensure that PyKX licensed modality does not block their use by Python. | `DEPRECATED`, please use `PYKX_NO_SIGNAL` | diff --git a/docs/user-guide/fundamentals/conversion_considerations.md b/docs/user-guide/fundamentals/conversion_considerations.md new file mode 100644 index 0000000..1fa75f4 --- /dev/null +++ b/docs/user-guide/fundamentals/conversion_considerations.md @@ -0,0 +1,147 @@ +# PyKX Conversion Considerations + +PyKX attempts to make conversions between q and Python as seamless as possible. +However due to differences in their underlying implementations there are cases where 1 to 1 mappings are not possible. + +## Data types and conversions + +The key PyKX APIs around data types and conversions are outlined under: + +* [Convert Pythonic data to PyKX](../../api/pykx-q-data/toq.md) +* [PyKX type wrappers](../../api/pykx-q-data/wrappers.md) +* [PyKX to Pythonic data type mapping](../../api/pykx-q-data/type_conversions.md) +* [Registering Custom Conversions](../../api/pykx-q-data/register.md) + +## Text representation in PyKX + +[Text representation in PyKX](../fundamentals/text.md) requires consideration as there are some key differences between the `Symbol` and `Char` data types. + +## Nulls and Infinites + +Most q datatypes have the concepts of null, negative infinity, and infinity. Python does not have the concept of infinites and it's null behaviour differs in implementation. The page [handling nulls and infinities](./nulls_and_infinities.md) details the needed considerations when dealing with these special values. + +## Temporal types + +### Timestamp/Datetime types + +Particular care is needed when converting temporal types as Python and q use different [epoch](https://en.wikipedia.org/wiki/Epoch_(computing)) values: + +* q 2000 +* Python 1970 + +__Note:__ The following details focus on `NumPy` but similar considerations should be taken in to account when converting Python, Pandas, and PyArrow objects. + +The 30 year epoch offset means there are times which are unreachable in one or the other language: + +| | TimestampVector | datetime64[ns] | +|---------------|---------------------------------|---------------------------------| +| Minimum value | `1707.09.22D00:12:43.145224194` | `1677-09-21T00:12:43.145224194` | +| Maximum value | `2292.04.10D23:47:16.854775806` | `2262-04-11T23:47:16.854775807` | + +As such the range of times which can be directly converted should be considered: + +* Minimum value: `1707-09-22T00:12:43.145224194` +* Maximum value: `2262-04-11T23:47:16.854775807` + +As mentioned [above](#nulls-and-infinites) most q data types have null, negative infinity, and infinity values. + +| | q representation | datetime64[ns] | +|-------------------|------------------|---------------------------------| +| Null | `0Np` | `NaT` | +| Negative Infinity | `-0Wp` | `1707-09-22T00:12:43.145224193` | +| Infinity | `0Wp` | Overflow cannot be represented | + +Converting from q to NumPy using `.np()`, `0Np` and `-0Wp` convert to meaningful values but `0Wp` overflows: + +```q +>>> kx.q('0N -0W 0Wp').np() +array(['NaT', '1707-09-22T00:12:43.145224193', '1707-09-22T00:12:43.145224191'], dtype='datetime64[ns]') +``` + +Converting to q using `toq` by default only the NumPy maximum values converts to a meaningful value: + +```q +>>> arr = np.array(['NaT', '1677-09-21T00:12:43.145224194', '2262-04-11T23:47:16.854775807'], dtype='datetime64[ns]') +>>> kx.toq(arr) +pykx.TimestampVector(pykx.q('2262.04.11D23:47:16.854775808 2262.04.11D23:47:16.854775810 2262.04.11D23:47:16.854775807')) +``` + +To additionally handle `NaT` being converted the `handle_nulls` keyword can be used: + +```q +>>> arr = np.array(['NaT', '1677-09-21T00:12:43.145224194', '2262-04-11T23:47:16.854775807'], dtype='datetime64[ns]', handle_nulls=True) +>>> kx.toq(arr) +pykx.TimestampVector(pykx.q('0N 2262.04.11D23:47:16.854775810 2262.04.11D23:47:16.854775807')) +``` + +Using `raw=True` we can request that the epoch offset is not applied. This allows for the underlying numeric values to be accessed directly: + +```python +>>> kx.q('0N -0W 0Wp').np(raw=True) +array([-9223372036854775808, -9223372036854775807, 9223372036854775807]) +``` + +Passing back to q with `toq` these are then presented as the long null, negative infinity, and infinity: + +```python +>>> kx.toq(kx.q('0N -0W 0Wp').np(raw=True)) +pykx.LongVector(pykx.q('0N -0W 0W')) +``` + +`ktype` can be passed during `toq` to specify desired types: + +```python +>>> kx.toq(pd.DataFrame(data= {'d':np.array(['2020-09-08T07:06:05'], dtype='datetime64[s]')}), ktype={'d':kx.DateVector}) +pykx.Table(pykx.q(' +d +---------- +2020.09.08 +')) +``` + +Note that: + +* Dictionary based conversion is only supported when operating in [licensed mode](../../user-guide/advanced/modes.md). +* Data is first converted to the default type and then cast to the desired type. + +Other items of note: + +* In NumPy further data types exist `datetime64[us]`, `datetime64[ms]`, `datetime64[s]` which due to their lower precision have a wider range of dates they can represent. When converted using to q using `toq` these all present as q `Timestamp` type and as such only dates within the range this data type can represent should be converted. +* Pandas 2.* changes behavior and conversions should be reviewed as part of an upgrade of this package. [PyKX to Pythonic data type mapping](../../api/pykx-q-data/type_conversions.md) includes examples showing differences seen when calling `.pd()`. + +### Duration types + +Duration types do not have the issue of epoch offsets but some range limitations exist when converting between Python and PyKX. + +`kx.SecondVector` and `kx.MinuteVector` convert to `timedelta64[s]`: + +| | q representation | timedelta64[s] | +|-------------------------------------|------------------|---------------------------| +| `kx.SecondVector` Null | `0Nv` | `NaT` | +| `kx.SecondVector` Negative Infinity | `-0Wv` | `-24856 days +20:45:53` | +| `kx.SecondVector` Infinity | `0Wv` | `24855 days 03:14:07` | +| `kx.MinuteVector` Null | `0Nu` | `NaT` | +| `kx.MinuteVector` Negative Infinity | `-0Wu` | `-1491309 days +21:53:00` | +| `kx.MinuteVector` Infinity | `0Wu` | `1491308 days 02:07:00` | + +When converting Python to q using `toq` care must be taken as `timedelta64[s]` is 64 bit and converts to `kx.SecondVector` which is 32 bit: + +| | SecondVector | timedelta64[s] | +|---------------|--------------|-----------------------------------| +| Minimum value | `**:14:06` | `106751991167300 days 15:30:07` | +| Maximum value | `-**:14:06` | `-106751991167301 days +08:29:53` | + +As such the range of times which can be directly converted should be considered: + +* Minimum value: `-24856 days +20:45:54` +* Maximum value: `24855 days 03:14:06` + +q does not display values of second type over `99:59:59`, beyond this `**` is displayed in the hour field. +The data is still stored correctly and will display when converted: + +```python +>>> kx.q('99:59:59 +1') +pykx.SecondAtom(pykx.q('**:00:00')) +>>> kx.q('99:59:59 +1').pd() +Timedelta('4 days 04:00:00') +``` diff --git a/docs/user-guide/fundamentals/creating.md b/docs/user-guide/fundamentals/creating.md index 679b5cb..8b6357c 100644 --- a/docs/user-guide/fundamentals/creating.md +++ b/docs/user-guide/fundamentals/creating.md @@ -360,11 +360,13 @@ x1: double Care should be taken in particular when converting q temporal data to Python native data types. As Python temporal data types only support microsecond precision roundtrip conversions will reduce temporal granularity for q data. - ```python - >>> import pykx as kx - >>> qtime = kx.TimestampAtom('now') - >>> qtime - pykx.TimestampAtom(pykx.q('2024.01.05D03:16:23.736627552')) - >>> kx.toq(qtime.py()) - pykx.TimestampAtom(pykx.q('2024.01.05D03:16:23.736627000')) - ``` + ```python + >>> import pykx as kx + >>> qtime = kx.TimestampAtom('now') + >>> qtime + pykx.TimestampAtom(pykx.q('2024.01.05D03:16:23.736627552')) + >>> kx.toq(qtime.py()) + pykx.TimestampAtom(pykx.q('2024.01.05D03:16:23.736627000')) + ``` + + See [here](../fundamentals/conversion_considerations.md#temporal-types) for further details. diff --git a/docs/user-guide/fundamentals/types.md b/docs/user-guide/fundamentals/types.md deleted file mode 100644 index e69de29..0000000 diff --git a/examples/notebooks/interface_overview.ipynb b/examples/notebooks/interface_overview.ipynb index 1623b7e..1f62f6c 100644 --- a/examples/notebooks/interface_overview.ipynb +++ b/examples/notebooks/interface_overview.ipynb @@ -34,23 +34,25 @@ ] }, { - "cell_type": "code", - "execution_count": null, - "metadata": { - "tags": ["hide_code"] - }, - "outputs": [], - "source": [ - "import os\n", - "os.environ['PYKX_Q_LOADED_MARKER'] = '' # Only used here for running Notebook under mkdocs-jupyter during document generation.\n" - ] - }, - { "cell_type": "code", "execution_count": null, "metadata": { + "tags": [ + "hide_code" + ] }, "outputs": [], + "source": [ + "import os\n", + "os.environ['IGNORE_QHOME'] = '1' # Ignore symlinking PyKX q libraries to QHOME\n", + "os.environ['PYKX_Q_LOADED_MARKER'] = '' # Only used here for running Notebook under mkdocs-jupyter during document generation." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "import pykx as kx\n", "kx.q.system.console_size = [10, 80]" @@ -547,12 +549,10 @@ "import time\n", "\n", "try:\n", - " proc = subprocess.Popen(\n", - " ('q', '-p', '5000'),\n", - " stdin=subprocess.PIPE,\n", - " stdout=subprocess.DEVNULL,\n", - " stderr=subprocess.DEVNULL,\n", - " )\n", + " with kx.PyKXReimport():\n", + " proc = subprocess.Popen(\n", + " ('q', '-p', '5000')\n", + " )\n", " time.sleep(2)\n", "except:\n", " raise kx.QError('Unable to create q process on port 5000')" @@ -637,7 +637,6 @@ "metadata": {}, "outputs": [], "source": [ - "proc.stdin.close()\n", "proc.kill()" ] }, @@ -1083,7 +1082,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.3" + "version": "3.10.12" }, "mimetype": "text/x-python", "name": "python", diff --git a/mkdocs.yml b/mkdocs.yml index fe1d2c0..cd5906c 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -52,6 +52,7 @@ markdown_extensions: - pymdownx.arithmatex: generic: true - pymdownx.caret + - pymdownx.inlinehilite - pymdownx.details - pymdownx.emoji: emoji_index: !!python/name:materialx.emoji.twemoji @@ -115,6 +116,12 @@ plugins: - https://pandas.pydata.org/docs/objects.inv - render_swagger - search + - exclude-search: + exclude: + - getting-started/q_magic_command.ipynb + - user-guide/advanced/Pandas_API.ipynb + - getting-started/PyKX Introduction Notebook.ipynb + - examples/db-management.ipynb - spellcheck: known_words: spelling.txt ignore_code: true # Ignore words in tags @@ -129,6 +136,7 @@ plugins: - user-guide/advanced/Pandas_API.ipynb - getting-started/PyKX Introduction Notebook.ipynb - examples/db-management.ipynb + - examples/charting.ipynb theme: @@ -144,8 +152,10 @@ theme: - content.tabs.link # Insiders - header.autohide - navigation.tabs + - navigation.footer - content.code.annotate - content.action.edit + - content.code.copy palette: - media: "(prefers-color-scheme: light)" scheme: kx-light @@ -183,6 +193,7 @@ nav: - Interacting with PyKX objects: user-guide/fundamentals/evaluating.md - Querying data: user-guide/fundamentals/querying.md - Indexing PyKX objects: user-guide/fundamentals/indexing.md + - Conversion considerations: user-guide/fundamentals/conversion_considerations.md - Text Representation in PyKX: user-guide/fundamentals/text.md - Handling nulls and infinities: user-guide/fundamentals/nulls_and_infinities.md - Advanced usage and performance considerations: @@ -190,7 +201,7 @@ nav: - Database interactions: user-guide/advanced/database.md - Using q functions in a Pythonic way: user-guide/advanced/context_interface.md - Modes of operation: user-guide/advanced/modes.md - - Numpy integration: user-guide/advanced/numpy.md + - NumPy integration: user-guide/advanced/numpy.md - Serialization and de-serialization: user-guide/advanced/serialization.md - Performance considerations: user-guide/advanced/performance.md - Interface limitations: user-guide/advanced/limitations.md @@ -217,10 +228,12 @@ nav: - IPC: api/ipc.md - PyKX Exceptions: api/exceptions.md - Schema generation: api/schema.md + - Streamlit Integration: api/streamlit.md - System Command Wrappers: api/system.md + - Utilities: api/util.md - File loading and saving: - - Writing PyKX data to disk: api/pykx-save-load/write.md - - Reading PyKX data from disk: api/pykx-save-load/read.md + - Writing data to disk: api/pykx-save-load/write.md + - Reading data from disk: api/pykx-save-load/read.md - Reimporter module: api/reimporting.md - Serialization: api/serialize.md - Beta Features: @@ -229,6 +242,7 @@ nav: - Compression and Encryption: beta-features/compress-encypt.md - Remote Function Execution: beta-features/remote-functions.md - Multithreading: beta-features/threading.md + - Streamlit: beta-features/streamlit.md - Python interfacing within q: - Overview: pykx-under-q/intro.md - API: pykx-under-q/api.md @@ -237,7 +251,9 @@ nav: - Examples: - Subscriber: examples/subscriber/readme.md - Compression and Encryption: examples/compress_and_encrypt/readme.md + - Database Creation and Management: examples/db-management.ipynb - IPC: examples/ipc/README.md + - Charting Data with PyKX: examples/charting.ipynb - PyKX as a Server: examples/server/server.md - Multithreaded Execution: examples/threaded_execution/threading.md - Extras: diff --git a/pyproject.toml b/pyproject.toml index 35d6aa7..daef722 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -71,6 +71,7 @@ doc = [ "mkdocs-autorefs==0.4.1", "mkdocs-click==0.5.0", "mkdocs-exclude==1.0.2", + "mkdocs-exclude-search==0.6.6", "mkdocs-jupyter~=0.24", "mkdocs-material~=9.4.5", "mkdocs-render-swagger-plugin==0.0.3", @@ -100,6 +101,9 @@ dashboards = [ beta = [ "dill>=0.2.0", ] +streamlit = [ + "streamlit~=1.28; python_version>'3.7'" +] test = [ "coverage[toml]==6.3.2", "Cython~=3.0.0", @@ -213,6 +217,7 @@ ignore = [ "I100", # import statements are in the wrong order "I202", # additional newline in a group of imports (We use three 3: built-in, third-party, local) "W503", # depracated warning - goes against PEP8 + "W605", # Invalid escape character in comments causing issue with q examples ] diff --git a/setup.py b/setup.py index 2696be7..61d2393 100755 --- a/setup.py +++ b/setup.py @@ -177,6 +177,8 @@ def ext(name: str, '-O3', '-Wall', '-Wextra', + '-Wno-error=incompatible-pointer-types', # Warning became an error in GCC 14.x + '-Wno-error=int-conversion', # Warning became an error in GCC 14.x # It'd be nice if we could leave -Wunused-variable enabled, but when Cython's binding # option is True (which it needs to be to generate signatures for its callables) tons of # unused variables are created. This clutters the compiler output, which could hide diff --git a/src/pykx/__init__.py b/src/pykx/__init__.py index c756518..f055f88 100644 --- a/src/pykx/__init__.py +++ b/src/pykx/__init__.py @@ -231,7 +231,7 @@ def _register(self, self._call( f'{"" if name[0] == "." else "."}{name}:(enlist`)!enlist(::);' f'system "d {"" if name[0] == "." else "."}{name}";' - f'system "l {path.as_posix()}"', + f'.pykx.util.loadfile["{path.parent}";"{path.name}"];', wait=True, ) return name[1:] if name[0] == '.' else name @@ -277,6 +277,7 @@ def paths(self, paths: List[Union[str, Path]]): from . import exceptions from . import wrappers from . import schema +from . import streamlit from . import random from ._wrappers import _init as _wrappers_init @@ -360,7 +361,7 @@ def install_into_QHOME(overwrite_embedpy=False, to_local_folder=False) -> None: def activate_numpy_allocator() -> None: - """Sets the allocator used for Numpy array data to one optimzied for use with PyKX. + """Sets the allocator used for Numpy array data to one optimized for use with PyKX. This will only change the default allocator if the environment variable `PYKX_ALLOCATOR` is set to 1 or if the flag `--pykxalloc` is present in the QARGS environment variable. @@ -376,7 +377,7 @@ def activate_numpy_allocator() -> None: Numpy arrays created with this allocator can be converted into a q vector without copying the data. - Because q objects must have their metadata immediately preceeding the data, only a single + Because q objects must have their metadata immediately preceding the data, only a single q vector can be created using this approach. Repeated conversions of the Numpy array into a q vector will yield the same q vector with its reference count incremented by 1 each time. diff --git a/src/pykx/_ipc.pyx b/src/pykx/_ipc.pyx index eb66ef9..ecf5d57 100644 --- a/src/pykx/_ipc.pyx +++ b/src/pykx/_ipc.pyx @@ -74,6 +74,28 @@ def _unlicensed_call(handle: int, query: bytes, parameters: List[K], wait: bool) cpdef ssl_info(): + """View information relating to the TLS settings used by PyKX from your process + + Returns: + A dictionary outlining the TLS settings used by PyKX + + Example: + + ```python + >>> import pykx as kx + >>> kx.ssl_info() + pykx.Dictionary(pykx.q(' + SSLEAY_VERSION | OpenSSL 1.1.1q 5 Jul 2022 + SSL_CERT_FILE | /usr/local/anaconda3/ssl/server-crt.pem + SSL_CA_CERT_FILE | /usr/local/anaconda3/ssl/cacert.pem + SSL_CA_CERT_PATH | /usr/local/anaconda3/ssl + SSL_KEY_FILE | /usr/local/anaconda3/ssl/server-key.pem + SSL_CIPHER_LIST | ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:.. + SSL_VERIFY_CLIENT| NO + SSL_VERIFY_SERVER| YES + ')) + ``` + """ if licensed: return q('-26!0') cdef uintptr_t info = core.sslInfo(0) diff --git a/src/pykx/config.py b/src/pykx/config.py index 8136346..ae89596 100644 --- a/src/pykx/config.py +++ b/src/pykx/config.py @@ -96,6 +96,7 @@ def _is_set(envvar): _qlic = os.getenv('QLIC', '') _pwd = os.getcwd() license_located = False +lic_path = '' for loc in (_pwd, _qlic, qhome): if loc=='': pass @@ -126,15 +127,63 @@ def _license_install_B64(license, license_type): with open(qlic/license_type, 'wb') as binary_file: binary_file.write(lic) + return True + + +def _license_check(lic_type, lic_encoding, lic_variable): + license_content = None + lic_name = lic_type + '.lic' + lic_file = qlic / lic_name + if os.path.exists(lic_file): + with open(lic_file, 'rb') as f: + license_content = base64.encodebytes(f.read()).decode('utf-8') + license_content = license_content.replace('\n', '') + if lic_encoding == license_content: + conflict_message = 'We have been unable to update your license for PyKX using '\ + 'the following information:\n'\ + f" Environment variable: {lic_variable} \n"\ + f' License location: {qlic}/{lic_type}.lic\n'\ + 'Reason: License content matches supplied Environment variable' + print(conflict_message) + return False + else: + return _license_install_B64(lic_encoding, lic_name) + +def _license_install(intro=None, return_value=False, license_check=False, license_error=None): # noqa: + + if license_check: + install_success = False + kc_b64 = _get_config_value('KDB_LICENSE_B64', None) + k4_b64 = _get_config_value('KDB_K4LICENSE_B64', None) + + if kc_b64 is not None: + kx_license_env = 'KDB_LICENSE_B64' + kx_license_file = 'kc' + install_success = _license_check(kx_license_file, kc_b64, kx_license_env) + elif k4_b64 is not None: + kx_license_env = 'KDB_K4LICENSE_B64' + kx_license_file = 'k4' + install_success = _license_check(kx_license_file, k4_b64, kx_license_env) + if install_success: + if license_error is not None: + install_message = f'Initialisation failed with error: {license_error}\n'\ + 'Your license has been updated using the following '\ + 'information:\n'\ + f' Environment variable: {kx_license_env}\n'\ + f' License write location: {qlic}/{kx_license_file}.lic' + print(install_message) + return True - -def _license_install(intro=None, return_value=False): # noqa: modes_url = "https://code.kx.com/pykx/user-guide/advanced/modes.html" - lic_url = "https://kx.com/kdb-insights-personal-edition-license-download" + personal_url = "https://kx.com/kdb-insights-personal-edition-license-download" + commercial_url = "https://kx.com/book-demo" unlicensed_message = '\nPyKX unlicensed mode enabled. To set this as your default behavior '\ - "please set the following environment variable 'PYKX_UNLICENSED='true'"\ - '\n\nFor more information on PyKX modes of operation, please visit '\ - f'{modes_url}.\nTo apply for a PyKX license please visit {lic_url}' + "set the following environment variable PYKX_UNLICENSED='true'"\ + '\n\nFor more information on PyKX modes of operation, visit '\ + f'{modes_url}.\nTo apply for a PyKX license visit '\ + f'\n\n Personal License: {personal_url}'\ + '\n Commercial License: Contact your KX sales representative '\ + f'or sales@kx.com or apply on {commercial_url}' first_user = '\nThank you for installing PyKX!\n\n'\ 'We have been unable to locate your license for PyKX. '\ 'Running PyKX in unlicensed mode has reduced functionality.\n'\ @@ -147,10 +196,28 @@ def _license_install(intro=None, return_value=False): # noqa: return False elif continue_license in ('y', 'Y', ''): - redirect = input(f'\nTo apply for a PyKX license, please visit {lic_url}.\n' - 'Once the license application has completed, you will receive a ' - 'welcome email containing your license information.\n' - 'Would you like to open this page? [Y/n]: ') + commercial = input('\nIs the intended use of this software for:' + '\n [1] Personal use (Default)' + '\n [2] Commercial use' + '\nEnter your choice here [1/2]: ').strip().lower() + if commercial not in ('1', '2', ''): + raise Exception('User provided option was not one of [1/2]') + + personal = commercial in ('1', '') + + lic_url = personal_url if personal else commercial_url + lic_type = 'kc.lic' if personal else 'k4.lic' + + if personal: + redirect = input(f'\nTo apply for your PyKX license, navigate to {lic_url}.\n' + 'Shortly after you submit your application, you will receive a ' + 'welcome email containing your license information.\n' + 'Would you like to open this page? [Y/n]: ') + else: + redirect = input('\nTo apply for your PyKX license, contact your ' + 'KX sales representative or sales@kx.com.\n' + f'Alternately apply through {lic_url}.\n' + 'Would you like to open this page? [Y/n]: ') if redirect.lower() in ('y', ''): try: @@ -164,15 +231,15 @@ def _license_install(intro=None, return_value=False): # noqa: 'input the file path (Default)' '\n [2] Input the activation key (base64 encoded string) provided in ' 'your welcome email' - '\n [3] Proceed with unlicensed mode:' + '\n [3] Proceed with unlicensed mode' '\nEnter your choice here [1/2/3]: ').strip().lower() if install_type not in ('1', '2', '3', ''): raise Exception('User provided option was not one of [1/2/3]') if install_type in ('1', ''): - license = input('\nPlease provide the download location of your license ' - '(E.g., ~/path/to/kc.lic) : ').strip() + license = input('\nProvide the download location of your license ' + f'(for example, ~/path/to/{lic_type}) : ').strip() download_location = os.path.expanduser(Path(license)) if not os.path.exists(download_location): @@ -182,10 +249,10 @@ def _license_install(intro=None, return_value=False): # noqa: print('\nPyKX license successfully installed. Restart Python for this to take effect.\n') # noqa: E501 elif install_type == '2': - license = input('\nPlease provide your activation key (base64 encoded string) ' + license = input('\nProvide your activation key (base64 encoded string) ' 'provided with your welcome email : ').strip() - _license_install_B64(license, 'kc.lic') + _license_install_B64(license, lic_type) print('\nPyKX license successfully installed. Restart Python for this to take effect.\n') # noqa: E501 elif install_type == '3': @@ -202,14 +269,7 @@ def _license_install(intro=None, return_value=False): # noqa: if any(i in qargs for i in _arglist) or _licenvset or not hasattr(sys, 'ps1'): # noqa: C901 pass elif not license_located: - kc_b64 = _get_config_value('KDB_LICENSE_B64', None) - k4_b64 = _get_config_value('KDB_K4LICENSE_B64', None) - if kc_b64 is not None: - _license_install_B64(kc_b64, 'kc.lic') - elif k4_b64 is not None: - _license_install_B64(k4_b64, 'k4.lic') - else: - _license_install() + _license_install() licensed = False @@ -250,7 +310,6 @@ def _license_install(intro=None, return_value=False): # noqa: pykx_qdebug = _is_enabled('PYKX_QDEBUG', '--q-debug') pandas_2 = pd.__version__.split('.')[0] == '2' -disable_pandas_warning = _is_enabled('PYKX_DISABLE_PANDAS_WARNING') def find_core_lib(name: str) -> Path: diff --git a/src/pykx/core.pyx b/src/pykx/core.pyx index 21efe10..546930a 100644 --- a/src/pykx/core.pyx +++ b/src/pykx/core.pyx @@ -9,7 +9,7 @@ import sys from . import beta_features from .util import num_available_cores -from .config import tcore_path_location, _is_enabled, _license_install, pykx_threading, _check_beta, _get_config_value, pykx_lib_dir, ignore_qhome +from .config import tcore_path_location, _is_enabled, _license_install, pykx_threading, _check_beta, _get_config_value, pykx_lib_dir, ignore_qhome, lic_path def _normalize_qargs(user_args: List[str]) -> Tuple[bytes]: @@ -294,17 +294,21 @@ if not pykx_threading: if _qinit_check_proc.returncode: # Fallback to unlicensed mode if _qinit_output != ' ': _capout_msg = f'Captured output from initialization attempt:\n{_qinit_output}' + _lic_location = f'License location used:\n{lic_path}' else: _capout_msg = '' # nocov - this can only occur under extremely weird circumstances. + _lic_location = '' # nocov - this additional line is to ensure this code path is covered. if hasattr(sys, 'ps1'): if re.compile('exp').search(_capout_msg): _exp_license = 'Your PyKX license has now expired.\n\n'\ f'{_capout_msg}\n\n'\ + f'{_lic_location}\n\n'\ 'Would you like to renew your license? [Y/n]: ' - _license_message = _license_install(_exp_license, True) + _license_message = _license_install(_exp_license, True, True, 'exp') elif re.compile('embedq').search(_capout_msg): _ce_license = 'You appear to be using a non kdb Insights license.\n\n'\ f'{_capout_msg}\n\n'\ + f'{_lic_location}\n\n'\ 'Running PyKX in the absence of a kdb Insights license '\ 'has reduced functionality.\nWould you like to install '\ 'a kdb Insights personal license? [Y/n]: ' @@ -313,14 +317,16 @@ if not pykx_threading: _upd_license = 'Your installed license is out of date for this version'\ ' of PyKX and must be updated.\n\n'\ f'{_capout_msg}\n\n'\ + f'{_lic_location}\n\n'\ 'Would you like to install an updated kdb '\ 'Insights personal license? [Y/n]: ' _license_message = _license_install(_upd_license, True) if (not _license_message) and _qinit_check_proc.returncode: if '--licensed' in qargs or _is_enabled('PYKX_LICENSED', '--licensed'): - raise PyKXException(f'Failed to initialize embedded q.{_capout_msg}') + raise PyKXException(f'Failed to initialize embedded q.{_capout_msg}\n\n{_lic_location}') else: - warn(f'Failed to initialize PyKX successfully with the following error: {_capout_msg}', PyKXWarning) + warn('Failed to initialize PyKX successfully with ' + f'the following error: {_capout_msg}\n\n{_lic_location}', PyKXWarning) _libq_path_py = bytes(find_core_lib('e')) _libq_path = _libq_path_py _q_handle = dlopen(_libq_path, RTLD_NOW | RTLD_GLOBAL) diff --git a/src/pykx/ctx.py b/src/pykx/ctx.py index f2c134e..6921c6f 100644 --- a/src/pykx/ctx.py +++ b/src/pykx/ctx.py @@ -132,7 +132,8 @@ def __getattr__(self, key): # noqa attr = self._q._call( 'k){x:. x;$[99h<@x;:`$"_pykx_fn_marker";99h~@x;if[` in!x;if[(::)~x`;:`$"_pykx_ctx_marker"]]]x}', # noqa: E501 fqn_with_key, - wait=True + wait=True, + skip_debug=True ) except QError as err: if '_' in str(key): diff --git a/src/pykx/embedded_q.py b/src/pykx/embedded_q.py index 5101193..f962125 100644 --- a/src/pykx/embedded_q.py +++ b/src/pykx/embedded_q.py @@ -118,12 +118,28 @@ class EmbeddedQ(Q, metaclass=ABCMetaSingleton): def __init__(self): # noqa if licensed: - kxic_path = (pykx_dir/'lib'/'kxic.k').as_posix() + kxic_path = (pykx_dir/'lib').as_posix() + kxic_file = 'kxic.k' pykx_qlib_path = (pykx_dir/'pykx').as_posix() # This q code is run as a single call into q to improve startup performance: code = '' + code += ''' + .pykx.util.loadfile:{[folder;file] + cache:system"cd"; + res:.[{system"cd ",x;res:system"l ",y;(0b;res)}; + (folder;file); + {(1b;x)} + ]; + if[folder~system"cd";system"cd ",cache]; + $[res[0];'res[1];res[1]] + }; + ''' if not no_qce: - code += f'if[not `comkxic in key `;system"l {kxic_path}"];' + code += f''' + if[not `comkxic in key `; + .pykx.util.loadfile["{kxic_path}";"{kxic_file}"] + ]; + ''' if os.getenv('PYKX_UNDER_Q') is None: os.environ['PYKX_UNDER_PYTHON'] = 'true' code += 'setenv[`PYKX_UNDER_PYTHON;"true"];' @@ -165,8 +181,8 @@ def __init__(self): # noqa break else: raise err - pykx_qini_path = (Path(__file__).parent.absolute()/'pykx_init.q_') - self._call(f'\l {pykx_qini_path}', skip_debug=True) # noqa + pykx_qini_path = Path(__file__).parent.absolute().as_posix() + self._call(f'.pykx.util.loadfile["{pykx_qini_path}";"pykx_init.q_"]', skip_debug=True) # noqa pykx_q_path = (Path(__file__).parent.absolute()/'pykx.q') with open(pykx_q_path, 'r') as f: code = f.read() @@ -222,7 +238,7 @@ def __call__(self, query = wrappers.CharVector(query) if (not skip_debug) and (debug or pykx_qdebug): if 0 != len(args): - query = wrappers.List([bytes(query), *[wrappers.K(x) for x in args]]) + query = wrappers.List([query, *[wrappers.K(x) for x in args]]) result = _keval( b'{[pykxquery] .Q.trp[value; pykxquery; {2@"backtrace:\n",.Q.sbt y;\'x}]}', query diff --git a/src/pykx/ipc.py b/src/pykx/ipc.py index b98e1d5..72e1cae 100644 --- a/src/pykx/ipc.py +++ b/src/pykx/ipc.py @@ -638,6 +638,13 @@ def _send(self, ): if self.closed: raise RuntimeError("Attempted to use a closed IPC connection") + tquery = type(query) + debugging = (not skip_debug) and (debug or pykx_qdebug) + if not (issubclass(tquery, K) or isinstance(query, (str, bytes))): + raise ValueError('Cannot send object of passed type over IPC: ' + str(tquery)) + if debugging: + if not issubclass(tquery, Function): + query = CharVector(query) start_time = monotonic_ns() timeout = self._connection_info['timeout'] while True: @@ -646,14 +653,14 @@ def _send(self, events = self._writer.select(timeout) for key, _mask in events: callback = key.data - if (not skip_debug) and (debug or pykx_qdebug): + if debugging: return callback()( key.fileobj, bytes(CharVector( '{[pykxquery] .Q.trp[{[x] (0b; value x)}; pykxquery;' '{(1b;"backtrace:\n",.Q.sbt y;x)}]}' )), - CharVector(query) if len(params) == 0 else List((CharVector(query), *params)), + query if len(params) == 0 else List((query, *params)), wait=wait, error=error, debug=debug @@ -672,13 +679,13 @@ def _ipc_query_builder(self, query, *params): for a, b in zip(prev_types, data): if not issubclass(a, type(None))\ - and (issubclass(type(b), Function) or isinstance(b, Foreign) + and (isinstance(b, Foreign) or (isinstance(b, Composition) and q('{.pykx.util.isw x}', b)) )\ and not issubclass(a, Function)\ or issubclass(type(b), Function) and\ isinstance(b, Composition) and q('{.pykx.util.isw x}', b): - raise ValueError('Cannot send Python function over IPC') + raise ValueError('Cannot send object of passed type over IPC: ' + str(type(b))) return data def _send_sock(self, @@ -1084,6 +1091,18 @@ def __call__(self, # basis: q('{x set y+til z}', 'async_query', 10, 5, wait=True) ``` + + Call a PyKX Operator function with supplied parameters + + ```python + q(kx.q.sum, [1, 2, 3]) + ``` + + Call a PyKX Keyword function with supplied paramters + + ```python + q(kx.q.floor, [5.2, 10.4]) + ``` """ if wait is None: wait = self._connection_info['wait'] @@ -1462,6 +1481,18 @@ def __call__(self, # basis: await q('{x set y+til z}', 'async_query', 10, 5, wait=True) ``` + + Call a PyKX Operator function with supplied parameters + + ```python + await q(kx.q.sum, [1, 2, 3]) + ``` + + Call a PyKX Keyword function with supplied paramters + + ```python + await q(kx.q.floor, [5.2, 10.4]) + ``` """ if not reuse: conn = _DeferredQConnection(self._stored_args['host'], @@ -1532,6 +1563,7 @@ def _call(self, *args: Any, wait: Optional[bool] = None, debug: bool = False, + skip_debug: bool = False ): try: with self._lock if self._lock is not None else nullcontext(): @@ -1666,6 +1698,7 @@ def _call(self, *args: Any, wait: Optional[bool] = None, debug: bool = False, + skip_debug: bool = False ): return self._send(query, *args, wait=wait, debug=debug)._await() @@ -1984,6 +2017,7 @@ def _call(self, *args: Any, wait: Optional[bool] = None, debug: bool = False, + skip_debug: bool = False, ): conn = _DeferredQConnection(self._stored_args['host'], self._stored_args['port'], @@ -2463,11 +2497,11 @@ def _licensed_call(handle: int, query: bytes, parameters: List, wait: bool) -> K # TODO: can we switch over to exclusively using this approach instead of `_licensed_call`? # It would involve making `cls._lib` be either libq or libe depending on if we're licensed. @classmethod - def _unlicensed_call(cls, handle: int, query: bytes, parameters: List, wait: bool) -> K: + def _unlicensed_call(cls, handle: int, query, parameters: List, wait: bool) -> K: return _ipc._unlicensed_call(handle, query, parameters, wait) def __call__(self, - query: Union[str, bytes, CharVector], + query: Union[str, bytes, CharVector, K], *args: Any, wait: Optional[bool] = None, debug: bool = False, @@ -2529,6 +2563,18 @@ def __call__(self, q('{x set y+til z}', 'async_query', 10, 5, wait=True) ``` + Call a PyKX Operator function with supplied parameters + + ```python + q(kx.q.sum, [1, 2, 3]) + ``` + + Call a PyKX Keyword function with supplied paramters + + ```python + q(kx.q.floor, [5.2, 10.4]) + ``` + Automatically reconnect to a q server after a disconnect. ```python @@ -2545,23 +2591,29 @@ def __call__(self, return self._call(query, *args, wait=wait, debug=debug) def _call(self, - query: Union[str, bytes], + query: Union[K, str, bytes], *args: Any, wait: Optional[bool] = None, debug: bool = False, + skip_debug: bool = False ) -> K: if wait is None: wait = self._connection_info['wait'] if self.closed: raise RuntimeError('Attempted to use a closed IPC connection') + tquery = type(query) + if not (issubclass(tquery, K) or isinstance(query, (str, bytes))): + raise ValueError('Cannot send object of passed type over IPC: ' + str(tquery)) + if not issubclass(tquery, Function): + if isinstance(query, CharVector): + query = bytes(query) + else: + query = normalize_to_bytes(query, 'Query') if len(args) > 8: raise TypeError('Too many parameters - q queries cannot have more than 8 parameters') prev_types = [type(x) for x in args] handle = self._handle if wait else -self._handle args = [K(x) for x in args] - for a, b in zip(prev_types, (type(x) for x in args)): - if issubclass(b, Function) and not issubclass(a, Function): - raise ValueError('Cannot send Python function over IPC') handler = self._licensed_call if licensed else self._unlicensed_call try: @@ -2574,7 +2626,7 @@ def _call(self, '{(1b; "backtrace:\n",.Q.sbt y; x)}]}', 'Query' ), - [K(normalize_to_bytes(query, 'Query'))] if len(args) == 0 else [List([K(normalize_to_bytes(query, 'Query')), *args])], + [K(query)] if len(args) == 0 else [List((K(query), *args))], wait, ) if res._unlicensed_getitem(0).py() == True: @@ -2582,7 +2634,7 @@ def _call(self, raise QError(res._unlicensed_getitem(2).py().decode()) else: return res._unlicensed_getitem(1) - return handler(handle, normalize_to_bytes(query, 'Query'), args, wait) + return handler(handle, query, args, wait) except BaseException as e: if isinstance(e, QError) and 'snd handle' not in str(e) and 'write to handle' not in str(e) and 'close handle' not in str(e): raise e diff --git a/src/pykx/lib/4-1-libs/l64/libq.so b/src/pykx/lib/4-1-libs/l64/libq.so index b654f7ead657b46aa2fa739a27edf336937de184..bf837c7b2c3c9395d81b74c3faf06d2f57dc7946 100755 GIT binary patch delta 224936 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

0m-J* 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 delta 224716 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
JcNu})3%I*wE!xmnJv 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%0Ack)8G0F?|To&VSH`p=?Fh zG2OILnm>aAKkyfanxa*qQw5P>;QsBhnp0o@P6&Uf;KQ&3LAvxf+C<-y&Ltii@oX*|GW?>GauGpdn36H>;&$-^mF zjxIeAXgs)9q7m~|*H79BK6qyg826r+gF}5r;P!~$TzO-Ufm$Vf@k(0W)(Dpiv~L+B z)`7q7{i-T&+~L?&q8F)j{EEUPBKZRxv9@%l@I2dNixBT7w4~eV;G-6P<6D0j^fy(V z2fWZ82HxtrNzACqgJ638sVeuX9v?t-5^JY+z_YQ$Dqg72Rjcx5U3=qwyN`BSJdpr! zggo0sXjJH~9vp*JO1qc6%%7rHHzCDDHlEp_IgK{*mEEI2O7!fXPKCx$jo0=TPo*<4 zMwQ-^M9Bi>`LXx&-!P+8*azyWi6hl`)tX;EB#7^u2BRVxND_~$@$iPnj$yU$B1*@< zEK}4OLk^zB!R!=~6ukkt8g!pgBB?s}t#8C@ek5n7O5GFWfo;oa6&+GRy}(Bjh&53x zsm?pYCUdVk4|1%NOSloIPdm9~hCy1U)-gT1a53s5ZEYJysL>DY)G>o6MaDc&NBksy z_Zw|xsY_5oiW1omfW%C_vXzTmn5sr6K%*0T!lJVxTJJv{Ue7{NH@TpGyn+M zAhx>k07uhGP?1I4cEegQ2*(;c0IsE>HF(|1YmSr;yyghevj%VC`sHx6X5&c(O7$i0 z#Md==9bJP@#f}&o3P%2!{J5{feg>Kkk|3=Kh zmr9aYRFj7oJc(Jr(1bnWwBkBJoUF;4IoA6cof;yX+<8mgT{n^F&b_>35`VgL6JEvfsl`8s^Vs*bcuMBv`NY~KQ@th^ zJFXkzZ=Zg+t{2x=u4a-T@+b}Eu&wor>#P12Mz4H;(XOL9Fnywf#731JLkT5CwC`E9 zDhkR23@j|l?je+UNM%xD!^jOeBE2?uv0t`5w>Gb5Z~sF4ScfN9KC+1VB!OK2sxJ3x z;@sV4j-{?_8ZDc2U9L4r(~OWBy8!#c>Qau2E_Hb?ow`D7tjk;Io_{6Oy4*MX<^hHc z1O9*c$_4zSJA}E@H3QK@IRrSn3{NxUT&6T?OBg*c^@~wfqj{%6Vy7RkFXnpi(7>nj zXn7H9Bpd5p`XY_-0Hm^Hyx2N9Cy#uwPm^oB2Tz7EBg_-zgeO-#xo>FN$d4wvD?TJM zReJ$9AJ{x}$FJltU4;EO?yGAwNSyKHZjLWUkSa?%w6Cb*#eMYCX%$(FOGTs?53CfO zD0vTN{tGeMi=Wkn4iK%pf#K0&pf~rZ(s2sBjeI5bK=eU)NZvDU;1b&ux}-_VSMg?I zo#q?+OtqP;JlP;E5iIrMYPSNH=(8Ue&ciBrD3 zZ-v+MQOej)g!@4jKd?k}_k+07Pb~D~9+g_{DxdD(#STB7=)6AHw$&CYF1$N|A_$}bJ6y~W!4ytz&{SX`rOP*_pC%8o%a`4mJC zanKQNvjHFKdOp?0%-|I{51l(KermuQJ0{ZadE!J%% zAb@wSk(om)&n7#3Ie=#SZ-gA_8p!L_8;(ykQDX`OVOe*gz{6@i>I#_59I-Tz|8C!U zdxwVn8+%i0-CKFgW;KS*Mu#S%G$e>ABtd{a3^}koVzNt=+9(%K4lj?9L*7NXbPo(; z{`U)1i|H;J2ZKv*6T^bJU**mqKx#V?e;1$m$6IU<=FV=ZU688zthPYK&QuZRyI|hR zu`>PcBs@cSi0|1#(gzJWJ2i^j1w3J+>1gp&P-#yt3gYZ4gd3gz-6@eiV;-=|#f}i} zTcsO*1K;5@@!9NWMQ~!YanPLns{K5Fg_<3V?;_L z?(4irYw367AXrvbBmSpTli{?63ZV@S3gv|rND^*kv$JPy}yKvqW(L#2G^Kge=+5W=yk&}Cs7aiX(Qwoe*y)o~N@N455 z^A@cpLS)_#OMh8lp)#xkbsu-IV5>LdmJBxWS^jnwl6Gs-T+K#VNH)?hV0VnS~TIa5Ga376EOJ(?ZvAmyovX$EI@Xl zctaF#n4o(>j^0oAaY!iYB04nX&76P9l{ib<44|Q6ep6oGSp`s1uJ95p+R1CmztA;E z6s8D1!Ew|KwD*hHAHf&G*(IeJ)X{5VQ8Vnv53|JCX56#Z#_;l02Y;q)347{qfc?AB zHwUB0ej%cp^EjvRGc{oo?qtoOUEnk;l7Cvyg*wP=9lX<4lD`SJiOBc|$(Or`m66=N z#^111s+TY*DId<7PTj>*!JSK3EjM=)u@B9}1!RR!MTgVHzmeSAu@e2psaO;bac=O7 z#O1XtbZv;}6~%pOADt%Q=+!oI3EDs)9Qib{Gzu$t2Vykxc2Ei4M)3d-dxZCa#(xH# zRNFua+E)?X*3Maj6GZD4ye*iVxdk8XGC7`@oEFv-lQ2c_XdWD%ya6rOK$dN6AO`Dn zcYDRbmgKHN;4a%ohfT5DnNm4k42tG4&ZpWy&wr6Vht6UVx*?i3acnyo!!nD%qIts# zHRyM*1mPWp&ACMkcXh3Y3iQ$sv?pRUKJlV&3=i{q@-v#>-I|)GP*LTr|D>h3zgNz< z%g4L$gem^ovy9?F4Aol%Ci44$q-X)tazQsXvOQf zw+s7JDkh1Z(sPjVY%{;056!xFqM9gD73E6>l+ zgW>0b+K4Nj6lY?2z03}OQ>Sn-94Pf7_}T+3qzK+7Yl^Wk&8V52#Fb6~q(cHhPEwgf;fW8I;a0675mq#cA+326ipJQQ*Ub!wWOiybTRDsKzmu?| z*QIR~c*d$-9z%qmuilV@eyK#^Tm6gtJ}u5;#-r>%m>2+`brX!{gqEI9FfJ3JS)2y~ zp(>0D_&v$?9#dO@fb$pDSwV8HXwruJb*kSE6Bu=eB9vd3f*@+ze~OyvsJWl`g)*p! zkck(!ty8ce98xy7B~)Hk>CzcW?@mYQwpyFB#Sd+GL8VRL{&=~ton9R(Cdcz2=lflN zN(ld$JoTOUHJ&%BoC$f9l92M9P~-XY8bim)^*6p4M-A^8TRrhCf&2Re$~=nLV){rt zI^Kd7Dv*2$FE$z5^4j`bxh#zH#elZl4PJ5?ZMmg(-AK$HYHIZNQT;ojc01mo+H8T| zLBd1#;^}hkB_%^lX~%~np6{)8uytJ&6-?Mpanabsn+HvO0ht!jkInE`#Z$NnqP3EM zM3@PcBy?HrCTEe)5qnMG$+6-OFHDv1YIT6l{LOpmY{n~CO0d~(BmBmC{MrqZz!VbYLDjt)xTm&`7^R4-4J zu&m+?N$>Db&E+IMq>;-s#5ymvPp_9<>R`wX2g=}D)(1e;RPFbEU`n1SAl+AtOy(YB z@xq@LlS3h(TI$~%i2^dVt)>1}s`waGi1azb@S7Mje!uwyzyHK<8c5j+QIsrIEBlVz z+t}fXkg541G>L;9A+bFX#T|LCTJF8E8ps
eb~UJ_R)T zTr5lBi70dXUlTds;qU3g&R9GM5h={Rf@$e$v=arkxs-w8Rm43mT(I5H(pT`8ng z+xc*naC8@*;++;;p77!d8A`KXap;h-hHnb3(=#36uzsxzZxY$B1~5*bG^h3wrEiSX z=4f$s#!u|rxJC~&OEoqWrNQObec~@d|8VdRY2@}6jVkTX0DK`pnGes~9BB?IUk1_a zT#@vI(XSsUzV6CH;kV})bi7s&f)_-(aS!*eno>Pl=XC)L zB(15Yc(Sz{?_PPtYV1H76FVjLcjE)A&%-!LS+`A1DyHTq(X=~HsFyv7%cBalH;Q~P ze~>NA^s-2;9xPUL=fSOe1X6=!{QYYnaf^k1euutqAq5ihWj{$!*@iu-!-BvF0}Bfp5Z=|i&LRsiNR zPMBU^G&xMv7sHr@A@Ik2wPr8?gy1P(V(OOx7^>ART6~(y6I};301#+?Ipd_KB>zmD zNQHn}RaEQ619j{Aik7{g{s-3=gL=V)+fK~yg~O+H;`d%S25=C!d+`WFxODH$$$iY& z8~S@!(VM;?ZuACM!%1>)9tT&Azj}kEJBW&Xcp%QFn)cz|9_~K!KtDH+1dspI$!lUl zA8aK(#Oyvi+{X`eEthqYWvX69Bx71ig&3Z?LGFOOjkwZ>H%ZK_kD*!kCd%>E*fpcy ze`%%c`r-E`E!~gOQ?%bVdMeL1u(o#~@1v@`w1r!HJ;kg3d`SH{J!KwW zHkx*P7d@aJQE>)FgCA|nn=WPz;0Nkn@dQe6MD8b97oAfs>#pfnF7-tJG(OegeBwKC zHI4gvj)k#TZdmzBHL7JXHtiz06-jcPMcsis!s)mNGJpiU`8AOHxP~R73TgiZ6zI4F zZeG@bykW)q{#2?&@$eT12J)a_yDNOEJh)+i(v3-Mheb-v(*?U%3PUlAxFM5D|l+ zgKw)-Dq7;bxawnl-|OJz5uW;pZwGVVK(8KHB<9l{Ex|XH<9MGGf`B|5rgOCLytuLp zHX)-#JQ~a!+1nvpDEE(9<_Ed+M;k-HYvSE#r9p-sKE;qrVo034^ac<~mI-?0=i0am zjg#+@gh*V29)k4|DZU@VV=C>&8qij2pm;C@V#`@k`4iq6@jyC#!kcC;>Po$P4L1?8 z%1;SX-HDby$Y~S)n;)RQ!Z!F(e&_$@>($Hu%@6-iex$k+*&kt7$6W;*%DZOfyO);j z9|}H(Edi%+Uuon~(usN}H-%@gBw;F%ogPcN0>ZT+3*r#}95jSN5sSx+Ox*6TMXmX5yR`kFy69-6H1kjOu1GURV>Dc zj_=3S0+6+F8FFNZ4}=(-l7>c(rikR>+^<$phxZ4p|JczmAPp8N-Mvdi9*i?$&2V0` z(&%KlT#Q~^`*VZ-Wfep?=L zTRyd$Bqof2KS4dQX9OfP@V^n<2tmz#Bm}KHqQyw?UPv(`xu??zAey+%XCh}L?~d2{ zu8ibqO?>`fc0(6JB6!Pf?3eHvQ$yQFX@KpuP7|hI(hGQqPc@3yOj(u&mw{TSmL8n_ z)-kH|}AJ2L3@;R?!5NAH)rfTuPDXk8i zUsi_92IB&bM5c1jh{eD`5<*1M(Z+22R;Oa{Ll=_uV~*T|52?eELdRX$Rfm)QPB%KI z^1(1J-=2y+TZ!^t9Cxv{h~4E-B{Ks(SxEn$9vVvjKKQCxBWnE-3Y7BO1a8)YIUuX> zbJD(m0C#WCg(3n&1seX}injyqGLYecKDt%{x#EK1J(#@yuK1oufe?NIJjD;$m?x`* z9TD}F{A=t)SyKT9bcE;u#>oILAu17-v0IW*+LinrOYv*~7TVv4^3iHK@8kId zOe4w^NsLC760FAi)V-x*$8;X!kP<1?s9M5h2Ip>nqY>MJAzo-QKUbD)5)EhYIt|O3 z)2vQ$Dc*={)g^l666AEe$pkA(MgUn-XnW7T@2-^mF2>COtAvSq2Cv;LZZSDJgXS}m zl!%>Dk=gGJWGF{EV8Sg%HJWyW0_EuakD~73sg@Zq4y!xRgw?qJHt6%A4l`S>tzdJS z$-OgE!EDGGiq4=L9Rn?!;eE7^5%g!kEmA#XYP_FG*+N8RHP*BxxGTEKw5Jp*E6S-2 zr#HiKgF*9C{%az7XN_Scv!j2l4P9#$M9#9dL*0g?h8g`luizO4wYG1^Y*p26(7J$bD$J(5ac9B zm1G=~*C)VJrQZa9r3*oXfyj*a>xm6&HTjXO_h}Hn!E-Tt@m)xqX5fMq; zF1-q|>h%N?HeCRuCh(XL@#=gKx)dDtwL(QI_XlVZeM38=(N6k;UFc$_*pHK<(*3;CTcP~D0+jdA%4_*2DId;(K`0`pW@j0) zNwmy$DXibQhrw-YgNtA*R&$^fLAt6)o1D2=g>r(zxR$1l);gR+L$QnN8P_AOdtA3T zF(LSZ*StUtqoMR zx6I;w@CTZK+hDk#;6gz|-kuWh!#RoySa@q$pg-KSc{?p7lKz-^oXqHT3`Us)%aQ=!+uk6iJk zl2&6dB5&AA4*WkQ5%U_LmDew*Nn?|c_aGy0iJ^0Nkkd381NiSmv0@JQiC8ELN`{iJ zw6Wz$q#^8m{zo^|w^KoLK90UZg2m%G+|OyYOyQRcgr}MJ@HmOpq&y|0$dJ3*s&db$ zPK`|$i_F}uZ9x;Xjm?)zPL&36>gzwlr4-W*sq%inE^IYG1bDE*&j1e)+mxjDrG3i8 z12eCa@QDV?onY0nDsH6BqFzBDnz^vWJP;G+@@h4Y zJd?FLfmkl6;bBj$x)HAyHWfcBH0Z6NSozs=9h5qThU8zsAp*q2vzK13fFj zH6vUR%~Kk@7R%;yFJ1kA#LoHLx83ST)Xo#S=K3x?Z+}Z{>q=z;en4r3Na%o|na=1q zpnR7HyfuKQRBs4d7%JE)D}?U?9;bI{fXRn8C1!zg+{5Bpe}s-xeQ*TG<+%kTErW8d_FzYF0Nam`3*4J48OZ~ zh4LRFcY%npH}xH@&+lsuG?V_nvG9Ipb|Lt_ z@4e4IT<-KabLO-;b0)VHB4_Cj9%EJiF8MBv<^|ofDZjKRH8GhQ%dUk0p28iHWQd;_8W7!(Vq_4zS1GS|eN?U9i!N&J&2WPj8;26uzoYEYcIiycwk!7f>=FBm188k77CM z7f6R36flEjOoMjxKChpDE~5Y&@UCh1|6s%`(t>$`fPfz&f^za+MjZT`#Or%OuDK}= zYhYu$Qz60vc~PD7SKC^+&KxAi^Z^eJRx*yBvG|;|as7ji+`7Is@~~~q%)xU!rU!D1 z{P01zoDjr=D;S?;uOus0xfR7!SqXY{S}4D{h;VX&u#7C2tFM)DaC<#|nxhZIy)ps! z{jMR;ypWF|#vD?;Va3+I^lGSaq%`nM>wyNhk|Bvaq(u zpGojFp5hJ3giK$dI|^i;i_i!ze&G`t#$pL#uXs8ZB2cnHs;`Ez&R<-oI`6t`s zNBQNkihrb-m}N~LjUVImCE!~u5l(_Hqm&2-Az4a<-MCne9`6Co)B9w+XZ=dzpKN^x zE@Z4A4bI~+U^V@%13rgA;?BE~S3TD>-TI~D6~>`9zO)!-NV%qUcff(4Yt!cQD@Msh z`fs+?vtx->yEBg$P(Kyl7{i!tf`2`dsr`I?K<6NCVf;O`0G1|8FiVqAFuCwI`(71j zZQUhD%YVe+lmcGyX>OIJspBD%7oA6Gt^PgQH6O>VSIu;NzP^?*8ZDPIqs`k8j9uTV zZXa&9A~)*BRaH#GQY_IX-Y!{}mjdM%!>&&`r1#Az43nKSW>?Oyg37489kV_le6p1% z@7u~#!$#}T4I6Dpo>gGiUqUj*`47%2@bfJWXaJxo`qN0(X?&CkmgE5l*8fLB@Q1k) zUTe9r$p;t>d-kHR1$r;Py=Ek3>+|p<{UV{L#=-v+RSm&-hd|%iuZbVF1ENwyo=i5` zEx+M5@eDGrZor@iYv#fQI0I5{d`DNl#}Tx*+2IF$HAOi+i~JVr>v_(`T`wFY^2)b{ z*(5Iy%#R^6))DmMlh{s zKk5UORWr!*C;bJyi2d{@c!g{;hb__f)G2;f>FcHX>3DUt(lWh|@4dT>1*}X@kuTn` zORSg{kolnOrJd9q(;63i&n~kB z6De^$X4aKHU9XSEk}X*ePn<~lcRd`l4Q7uG`go;PcN{lM zdu*XLd@GODkuG5*#qqpeyIrMlIWOd_Q%;c7@f8ExUV62|CSseHlX{T*Pez6wOZsHsH zFkc!oSID#?ZJn(Qn@jl^U=PjQq4%%S_c-tWCt45u@?bh0r#(CLpCCS2$WDD9gf*YC zQ@@>WWA1|E#U}c2m)^&Dbz3ygZfAwsV)LY3@G}b!`HT@GkpPg8g|;<4MyaI$?cLZ?bpclxFfPGli;xDaTHILC$h1}^>|vq}Q}6zkwd&5HDa)$PV$a4E)`Ky@D8 zkStI}aM1`XBvdzCU@X!ParQcek@YW5&VHlyqNhdrXy41wkW-sNf42tZuh7CmYIacn zJ3I-V90W=8Aj2Vj)3C^qfYjsz3joOqq)_V;$>WCk9M(^5B@I5L@1~nUdk?{Nr#9&h z!{K%WeRf#CSZ6d>J_2vVe!JZq$_yxlTGa0nJsIUzBAwCcSWgK;v{zf3&1q$;b6~p6 z;By#cMzQS@Hjs}(oNTOFz*XS8QUaYy#*kjU#1E3`Y~L6`R;Z zKF9U`?gfWo7)OZu+7f#hajH(IcE^Erx%Am_eQWR5D8Of}y$AE}J*}JkeS+%%Cywh2 zD^D}>jId+aQ1lfoKLN+JL-fZ9eQRY|FSFlCeUYx(MV>7`MV8qS>QjPoPllou^fbRb zr5|Ij!zt%keN|noIqR(6+rhs1sW-IrqP~W`JN`IwQSToRx*j@r)}u5$b@4*;#K(gy z$q)F`u-+^#=|9&gp)2UC%la+|_H^vB-n(wK-RLo=oq++iFFD%}E=s-i7eD)tGYkf2 z;2;pp8E`-4PyIT?3dsKxho>&&dPQ$is`sRhSM=3lM~?ijQX^FAF5R4NY8f~$w{ofr zR!qsCrTKc;&^sTOoEBdJTHDc;EBaLDDV^jMV1Al0k7BOsV+`NF2H0}y;5~+``Vgq=<( zZG9JCNBA|DadRm4EH>xHEQ8$|jzX??5XHfPQts$y1~%MSKD;5V{^#)Cr{X&pUXz9N z$z2RDl{Vhh`zv*Srwupt0dDISygR<$RC-sR!9IHTFuuMUt>YU@EAQ!>A*S5Td-~^r z@8P0=q`gJjkof<#LybF}PoG$<9a^}<^|lV@{f`bU)(-D;hwI8ayw4q)Z{7$0QXVJF zf2eQS@O!*Kfei;Za`?h;<$DxRw4^|A96AE>uon&5G60?T>-YGjeaF?R^mLJ8qy-Q4 zi|_<>%p;tZXPOs2(m&Ptw%W~2vMA29X`VbMcp@7aLMxu=FE}r$CO0`dCBWJFss6{h zQ-74BU`9Dk{s}J!Xp8yUBe_4UwfB*gFK?&!{(^HDUKaRE-^{C*2RA0YBD%;w(Q%R1 zW{&y%U;1>N?z*}CKYC|H_bYw)OdqEBe?ya>L2^Run`dzKNTw~%^h5BBXZ7d$21?s( zdhfY@pKgq~+6#S>E~8(JBs4hIoCc$Tl-@d&Cp{Flq^9Lbhj5Z9OGT6?tuxq?Jj#<^ z;oM)AQmjcjW9D@1Q0wz?rSha`)z)Qk137WDHKS}`cT%ls0RMxswA1BDxL0Bw?B4Pu#4)latu0TgU)DaZ z29-b{7)0GlARkqyA4~LOlvVY~^Oe3g2e5sm@1xv{rt`1#0}+h1`D;j>HE8~8q!vZd zi`QVu-D%(({Yd3rJv#peb*53Hx44>!mhhvP>yl$Bs&=GLOZC%~qB`_~Kl{wlX{)`M2}Eq|AS&tVwfhQ~ zpVJA16i>?ZK(sn$k^64iYx~EPlqN!2ici8_G!L*sI5hF~O1*He5)om=rL?xTbWi$O zFD6%;SECHnzk-0;@+O&0LL})-K4W>CKenCL6lhNPmOaaRF-hDt_d6xMq?B1hD=9ts zC$aS8fj4m-MSHmNxEMrjc8fEJcqMoYjW>w6*g@y)?e-`@P3(HuE-s9Ix1WRf{$Kh@ zNTWvvk)>-(U#Oyyd(}{OARDJ7>;fv`)CloE?P#|u{GoVVR)vpJ6hbdlk$@Y2aZaM6 zTf-1c75vXi#3FEod7+c2sd#s!0w*!E&gv8Yaf6P`4f=u`EYAfun32mcD!`%po3wPf zCz{dZN@8~9{qa0idAQ_pbu9%ti;tNQIg3~*jJupg6WlX-;VhCB|7c2Z5z+47kK>6! z(6e-xgz%acafhb5h`vhrIMSdWAuyV2Wzhjah5A$$X;svAd`Ny9v@fj^6S9{t=uTzP zLMeVh;YLx95yU7OCe_E&Up%hV+`a}a3?JDrbnMI4_LWrUYpX9_!iglVIHQ`j&>MOC zQqJ5){DcQ9Z0e<)(G!0;9sn9wN?gelAp>oI0`OQcd`^`^O)` z5G(u~z2n^H4AcowG;oU~U#HDSQTYaC5*7#UBB|MUUHh}XsgmhzFRKa6j!{k<;mlQ1mnB|2{0idIOcP$et#P7Cju2aq8WZ7I5HIV zN>7$uWrBMCYKR2245gRxF>hK(2Sr*UUGx*|J`{{6+L!o50jVn#Y5brG zBrzzE+AQ2IV(DQzW%-Ltw_8RQP(L}LQz}?(c2&qqX`zh^R4iC)Nco*`(v)klqG96&L~NJ)aW}!@zT`cM`~e zlr2~sf${3i3b|ISdwq?HjBFr@+UOhXhz6=$q*dZunc4ZkR6pK5c%3#ByAVnteoT2Eq7MWp@dKEc=oe{kuky6= zrS}B`G+;Wa@+gpqfn1Z>QUdyf4uy&kCGZn^94ZD`z1aAc$#@E6)JK0Cj@!!lsyFqG6qUX9bg#G-PW~2gO|n)UXMii_o=D;4TJ0MkG`r<*n~p544c(0tO_f)hDWs;T=ls>zjCg=dAp+F) zt|`Ke3pQ6+^h)p3oSI^(&uRpTKuA7N5#!VYJhohu%k*$Nty4GZP)h`7_)Uk#l9dPA zg^1_K$30RQ*Kt%bXOlga5&mL@;9cj;lESg-@oQH`0@G1U5P2w}Sxi6~+p{+Qm_%p*83ycP+Kfix+0)J9TD!IlM`+?xrrT%mK|{B0XoYZyQSpV zGigR0pjlhmR0o_34=mRa@oXikE28}$m+(_^aMR|E+qqO4tznWXPSxGhPSd!$BHXpo z0R}hA+$jhx*y}^uSXZ>xZK2}2Vx?|9{a6pwvKH;HC$>9Bzm>H$uvpM`P`sgX)jS76sPM;bjfdx*&-yc_VEOF@U71cVJzAN%AmO{p(d2Tpz^M~^3k^m{PgoLGJji{rdV4!XRA+BFbOl%i*} zG)8#Sk_KXsa_1$f4Uwomqojr+!o?Bw*Y zI>yjSs}W&ue@2~q2qE4&1~NhheHtU8@nXc17|1UzyVB7ZG1}BNjSujQS*!_5Uk=z0 zHIIJwjN|&OY6yrj?IyDL3-O^ixTpuCz!99_;A}plk?_(L(1J!{z0+ANGs8t&M4cOB z`bTMUW08sXDnzX4s^q_=p0T2qQmqY5kHyl0v&Dj>G@~1_Vy9cw7rdUP?Gxl4(1PmG zZ*d|VK`{P^6Lot!9g%cc`x+c?Qqxy*Yps)JiE&<9og`j#4)oq`BGIWdXI#aYGMLhgM3vOPa8oLp} z#1Y<;2>|$1f!6a8^0ABg(I~vS&{RY#BU({(GtnHudp>I>f}4JIkXy*N^p=_|F0`?u z3;acfS_j};+d9K%(tL7F%ejU75Q`;x1=6u*qNy&CR1@&Y+nbV1;!E9C+G|2;FugK~ zddlBRsCIKvFY2#&356#`vEIWaj|@Frs_X91-~cuB35~0Px}&tU&9uQ zQKQT}`nfv;{~D8_Y==-bc!6lZ>ZN(3RJrME7rC_*zPPDSr=`?1+O-r7bU#u?OHqxL z#FnDDv*7?^1RF`AeO+&fJwBP5wZg_dM4z-0W0V^fy3$JUb{!%BUf^cd#F6MJFk5ZPg{~j?OK;_ z13RY_!~L>h=omMMVkHU`oc<19C+kj@UI&BXXXE%$YbD<7oFZQ6fDI1q#4`IvecsTT zcEVRlHc??a5vSX|HC243;GykN9mFa~Y~CFKtU_ws5tL#!4euygo4&8dNSZ3$@RD;9 z&@xzS7AG<}FVfmp!E&HCn5a2Eh1PZg#%z_#tH;rkj-r}Zn~Qk5w%FA;a}xl-_pq%; z36sdblW2kWVS06f+>${PJBipX^XqbVX}0cKTf3XgiPr8~yYcE{8z;i|Ee>`ETi=z37-L_ETs|;@W?w8fnh!Jo-C4}iMSp*b$;;-@lUx)kKG>*fYk%;#Xb&EH zrZod|jIzSvzIjtu@tscRX>R?#n5cv#M>7c6m$Ab&ZfRHO611d6+mf-_qH+0I3{~3I zqpm%GuQzF24>7-LyR}>zb_JUuAYc2ELO&2D_ahIi1KPj?;-%8!)|%5l5Z=1V6D3%7 zg>sfQiWYq+@>H)6nOMha2Wdc0@he0}w~s`p`VWHH3yrS^WbcPOHU4`hEaRk#aS~ZJ z6=R;Brzj13U(uY8M2P>Mo=htwjlb;7nb#Nuas`^!rZXRjWuY}#K+iE91xy}vEIrq#?WntPaInECwkjU{2Vm6rWKEXK&H9f z(J;v9f5$l%)rksvLk-zV_j-$!Rb7|K5iIRt9YM7ET1Ku7q5XYe*g>$vz9P8BhKCjK zp#w|LHe2+}Z9s!kHeJNjRgv}(c-A#c3<(aT3CZ| zn$Iyi_7mPp!vGrEPlWloERht03x3Wea!hkjl^IxwBmLSBvJWDG_7lw_{>5|8$vFsv z^A+=`9FyOBTo0~@ z)vaUGziB@=1jptGtOX@hxA(7SiNdPpcK>%uiTxOdX2y)2)-(7fhk0A8@)$mCm0VZ| zfLd4c;r_y)Q=5eH0AX*S8wZsTdix0^m*?a;Ky(Du2MrLTVCk_cn6>3E>XMt@$z33@ zy+QLK`+=}TeE0XDiv+7+69< zgPbC(0v^{Oy3ZJG&%WBgEC)~eelS-32JIRwyq(5WE5ln>bV598qKyhy!*cZfQY-2} zusF9EB0f+Ys?qmD#1v4hfT6G*rO^jNMXd8qcOC$9y^HN>@lfc&=c#b0sO9}@6=eLU z#up^yrb{h;4mk}IwWcl=;ltz!^B8M?@QZ#c%+lO;zeXTr^aIrc&;35uwz0OXlICy3)vxE({m9z>0Q_5MLoqK;utE zXPlK}e=5S1-afS9Q{nETP2tECl9v{0m6(b1?kduveCX<@;A0EOW2C6-7~Pt2Vl0h% z=n&#++2i(~Oz;BXEhmf=p<+`jP&mZi90@)Poqwe03V7A~OoSmw==+}u`1n^YtHm-h zPEtM-9o#OKS*$Lxc$sS&Ob(+&Xjt3J4hVN=*X zDoo>yQ)Qa_g$VRm!XLL#fVpMP zw(H#ezjWvek*LEfcxj?x^P#gr>9X*ei^EzW^O!9!LvIo|0sM zdlX`f-z~d#)4U2zN)zthV^Jph5hA(Du&kKCi}MmXo9MSR(ZzE&Toi3vF?cS6F;;8h zgaas!GfXwpg%iAnV$z|)j-*f1#V5}95hq;I#v(*GyqXRq#dGbWVI1mDAC49clzKC0 z=4er`@>^-Q!X+5q@9^{)Et>kAZ6FEvRuivap|FU` zRkIo@v|5+|c4KPJXRu-D3uw|<5u$#%o&owq>ql$H!qf`e^OwRspct|Ws~n8#-)=@V z<9e7%??U0Rch$yG%P++^rF0YR{ZiC)>tD~FZTJ@Weelx2i=*UAkS?slSE5a|_-`0U z5h=MzVD3`1a@A^oL*IQRLL$zu;{oyBK>P5uK=U53TV2xjYRNUM2(yr5$ zuV8_O06h+xXb=q_CxUvJc~#hkffwLhQ*scz=Ci)qSKHoHeAVxPJ%fN71~LN50COi- z7!>{i#_-PPTGCQ>N!D(L+B|_!7rH-A_*OQvDGhc9i4)&Y)$wAoQoNPsj~D$jx;C*c zkraO<${RCJ$Q~eFKhfrLRYv*(EmA>exuz=Xd4oz(Wza)j)|b)-0In^SgiWw7W9t|* zzmttX`hB8xl>M77tYf$$WxrMjHIb8??TmnAIhU>jp zQpPdWNPkWcu1?lI?C~gd<$=+z=`e^Band_h3=Eb_?iu*_s6TNpF#wGZ;hBhrZinx@;07 zYFggr8SEx&^hXXTeMhUx?fx{2!F>?V>GAJ%&~7U);NbRulka43Wt9>qiw2dljyTxi z!3PkpBlPuTQ4{>}x5?0YLh0sY5$*910m_Yg9HK0NP;papTH-xHms=F^wfNd?+3T0q zD*%`v5Y^s+c7827`m{u{&Da1RpEvwrY7_-=ZM4Lv5E?(z?wUb{+=Ql8ZIJwI1;hKnW9zb&a;s8 z7$5gAKEk6M;pSWg&9yXcO{;@T zN#v9z0@QyQ>>!DYC^}07D=&}G`}lP#;6TkB^=mCn&Jy8OTu=<#K8j}%%k+INZO;;W z>neMOQnGu+DJ@$9l4#MvHi=;x`Td0=t}CVqMRDobi) zUb5~fiiau*Q(mhXb+I}rEyj4f(-rl?{5D%S=#=~I$RS6h z>Rwal9I;Aqe?uiXVk4W(z7-J}3py~r_Wz(ZS8IwlxYOLVxqtH(vByCc6bw#Fe~2P? zBP$dc^}iJ{9f3%hoa=vpe`HH-|JPzNKi7XZiq*B23;AEmU9mQIuDrR|G&xszR2kh~ zb~BQHWH)Cyy{cPo%=%=`G1W-n9}gHMbHQmF)AL+0D8yKTS=o%R`RETvSY4BIpoH^n zhl#F0420&HA$ll(gwmxMBCb~4Q&hm29uv_z*1x4j7=*vyB>^~}pNUfwuLyL@lqMEU z^_?l)eUo3jlmsPRUW%|wZzqW-%zAJUnmJRl<+U?G&3nB>S4BnGj@b4Gv^{_E0`SGK z4NT~8#n+g4f$2*Om&=ATl)iynjaaSgGi=yl*cCj=bN}+lD$q9Vz2`5j4?}TWWF}e; zD2k2U4C#D+1FHrUURQ0zP`L@vsrETy2r>QkqaCw^Pt8fe*jf2<`rC>ja`CtT^xCYo z9Sth45*aT#vFturYU}@8B0FyDXL>r1rfL4`2E9HTL%*AWZ zY=0TF2XgRuv*+oFJ!Zj!TGx>{W1*^gc$ulcaZt`D#%bs$(5Vl)~;A|NCN)he75hs$mx(gSH2 z>D`~uFC?;cUsA&bINV2!xdkHJKB>wZ`hJ0!uk)kmg;0Ecqizc!=1roh3q?r7P0i6S z^Px*{nPt9v+MCg-0Di%h(tH_d61X2+toG%RVOX8-(Upb5OL5#pFBS^+!0G+HXj*yG zZJsq`ErgDF{F3_qD%@%3_o8$7b+2%{gxvSl56@o08ZtAn!EXI9IEj2x=}g9r;5 z@PHeEO`tqlKv$WGm6GFP zh#8kDYO!dfc92t!)vnUW#Uk3zk8y@YQJhsiakhhV4Ztp=A8N2kEEd&WZvY!Atk7wC zuvkR;uSP2BVFZXr^lrToHz@i?5zu19yA^xm6U9^HOVC-d%zE*Nf=@Vt+aN|qD9#q` zjEmrKvFqd{3<1%TXZ#4;Hm35Us9x*ed+!Y54nC!@lag&|pRHNtVq7Xly~Fg+k3e)+ zs_~Qf)=%YvJj^0v<~GAS(>qQleiGID9KZWc%X{(3sxj^em!Cr9x;$KqK(YPzK?KrS zPC_-6{2n)Iay?EU2MaVekHsU)W8}@kv_=6vn4{o1>Gn%R3&(?1uqu^q(3~YO8BL~# zON5_DLa2gFyi}yXUHIfu5h;4Qp}>z+x>S4u8S#^4BFOQCE0U^Q zqi>gCT{G#>GEuYY_GsoKg%&?}(ayp%zPb7rB$kU-uxYhjE`l93BkI(;N?$BT-%IJ} za^WRD>)ep*7vX6SV^)8@7l!TeNaFGn?T-9?0Y8eU6|lpvrw%J%AOD$ZvaJ$Yenrbx;XrgD z{jo~4sPS-x6lS|XENzM9#LXiq9B;Nsccvh&^2tSNvKpjj4h>xmW6wyMu^NX(3AAgq zXe|0Up~MP$xf%*iH>$oycx4QL4dp*{F)s(Y9FpjQ7mjX&d6e@4I4O0;vcT48r(Hh_ z_}~w$i}nZpPQ?>H_;bw_E7%-xYikysU~2QMLVey%7$Bd9Sn{RqN1wXfp#hWz_bAIa z^pw1pMHT$Z(A*GGkVy-}!?@=Qg~ew0Fq=lH7(bqETmw}cFQ5D(T6ry4#v(bO@n9Xo zbZ6ft+~e$O@#9hC znu6%sFQTq!V?bxnkblJ~XHV+#tLW9D7bb{a+GBoL+SrsC|;D+_n_5lMTW-~*hLejys2Z%Y!1KB zoOB0(1NT9G6Jd`3=+SkfKWOl8Kv%r0@SBJbBRFjXJ^D?AXWW4wEEI`;sfcH1%sdBz zgs)o0%*QVBuNub8;UM%#>ub!MiKzDYYZPMK;IbG5c?e}tuIIcaFEh6~&kNPNl3m!&vC zd9NrQZE>ajcwU_yH*L(fu?w)b%3J{}Eu4oIN*mi5$SUp{w~94?l9z zOO(GJyK5o+wO+W_&ww1<%*mMf6aONpRdf8J?M{$Ad8_K|(zcapv7uah&?#0eJt%d9 zaLc#>CdHM{qq`}^Jpnc(!1jhyG&?Q$1aB-vdPi8M&7rf9WXz1K3iwZ&s8kwQlo>h+ zNt}2O%ac+bB>us1fTt-kSRU@74gcdEXg!jfxEpj8oGzgrL=uE&gJH=y;{$rVK?H~Z zDR)!AM$tMh0&Vdgk4GcYM1ZH4j&V|AXfkhYAhk_RIWChQL+4n z^(}sP2o`*TPqI*$%rCsZlrLy&r;#kLeY;6PEzQa56*lYwZ_i!wD2!`yyy8_nETm1s z__Ys@QN!Ow{W=5X7-6a`(0)CK{2VsZt(9=If`fyJ7_;hOeY9U_&hMgb=nqG^oawcK zX=F=-*2S$bOW`Pyq0KGDoufOygLD5u-kU_{jAaW!Df56<$x|!_&@j&_B@@yiY{jSo zqE}%X#V)5BVw7dJz$OB^yjTx0`YIqU$(sH)HeJ&6kxEkbAcw@9C`QmM2W!ctrD2Gv z$S};=X7>%R3Y>8?V6>KT1c{g{kEji+9@pfcJre@yACfb+ZTzS+c;kSy)`q0e4G-%5c}1*&jl<CtBR9DG3P7Lnlg z``a)p4q4R&`@__83q(*m>T8Jf*%o0TqX=Y0npWfK?7M9k{Ca?$zZxlJ@{773I{&H-CM z)FXppT%4Ed5O2>H-4-AQ!G7(2A;xHvb!!8sD-h7?MKp7p2nepul)!2%W)qyN+{~EH zeT4I1TB^OJ6Wg#&=g|Fa@OE&VOOD$GZhTXx?c!tc`%8=kJ9xW@665*rz4Umy=+!8i z6{r5ECpB|p(w1vdIWM({3B(dtfIKyOwS;_*ej0LY?vK@0psh0`8$Ot$cWcY(Gos*J$DM9>NK0twOqP=R^b={Fdt8IcLF~) z&@t3(Ud;Z-Ii?{c7zmci!bktPrpHV91&BhR>0q>F+cYEO<}-czA`COYZPh|tmJZ$} zf-AYc;aMP{MobWO+$Cysy1QRO9%y0A%y)VR^1k_2)`iK~xEEL#re*O1$A)ZFnbqGM z{Q-;z%o_g9QMe#Og}X#lyMYy29SaSy!g~IIED+20(2%WFxqLVQKtEX6AArggp!qE& z>=xDhx6G`ttrd%r=2INoM2E3swZ=$=2!Pb~#pOs6EQ`Xv1aDKuQQVBN({7R zUX&LPcBkg7m5C{crvo`M=02OP%0=m(KzrbbC4jyInvQo|^NV+~HQs?-QVoogD&m43&dQnNQO!LyM+;9{M> zt>8`nnuQ6|*2nn7w723iCU2oWRIgA(7~>H~+%gA1m8#1s8dxYo94|jaqX9d4<3%Jj zyj>9qx&a)PJ6I0%{Y_QoOpmqC5#^iN(nVMqrsR1dk|(-%!NBA`!!q{UMsEtC7K5i0 zfu6RaCPkvU^Bg#0TCq#pMgxkV(w={SetmXOpJUkY>xx88-^N*1em14Jmof7)wj$I$ zNo2GS>7OEaY2KiE2f?Tv4pG~KBG&QdeY6m^ow5(YntGTv9TX`|t7ghJTpz5F_M#mR zd8za*t=Lv(t82QILHHLSWaUh9*UzWMhd@I@>4QU}Wk$a+z7+iB9ag`#9FWR`MY}B< z`|*jKtmRj5U7KfXkrsqdc0e#}^ArH76=;Cv9s>^5N25Bntjv0(MR3-S+>+Excw492 z+Rs61bl#+ry2iPw&>XimbI^uulhDq@3m>H^{lPy>kG^)mEwil+9kdhM<=!`DIU|#U zZ|e}izcJddAgo#iT^s9sSk$XN1{I}(!ZMd)!O=cCvlL?k@E|YJ=EJxXVy5SZVNxlf z21i6guc%vSY>KpnSc&w*dw_Vot(0*@_{8l5L+2v~ZO0}IL{biIq}*qBS>f_obRIV zj++@Nn>il3gAeD;vU_h>7rk@+J4^Zn=l-@%bN6t%PwqBnsi(&s@xZo1Xx+~G2j@m z<_QrUb7Ke6@D|-fHoO2n znjJ@1PKZVxukpqK<`E^MH6`b?!7-}-ABs2$vsO9{J}H9ymT$14-WP14WN#BhY_rO6 zky~lyN!)NCx_eTz4LW+0;f~N`5D^2{L8C&{32A6t4g^WeiNSMjr-Y}HxQ>RN6287| zw!8!QSbVZ%1RR_|OHPT}N+&ZNKLuPoMy{ttLZCg+AtlE%IS$6%ZIYaWQDZdLvGm$Z zqfQI&27j9w6a{4mI63+ow{6%Et8HD&+nt$wh3)RPnRcHRHB7OvzLasGZ$TGuQiZ`Y z@tn9*9%*2305mo&-pj**v#AA8gr^8u?oSFj1DCC-o9N^=P&{Ay_zZjkO0Uu0GvYh- z$Y!}Mw0!#T50T{6>stAMe*c9B1b>r4t?_&^{{g4*f9U=nVxs%QTUJ=|WRn^2IUYJ1 ze-@_EBszE&j@MPjka7;Dx|`JSob-1Zeh!Mw9GZSk*-i21g`d)CHT6C(e7kgA|IV5u;uC{oFyFL-xjs^)rtD|cls%+RMUi&+ zcc^3k#cVIb)~*}r$a(R#OG3JJKs=gT^x*|q^=qx8Pjl-&!m7$qMqB{&ml@*wlPSEDAlR= zC0J(xuuCG;FcP^)JWH!D;oQeWCohS1AvZ3RFG8agJjr~^E_MYzL0Q2)c3- z*k?i5M5~6T-~5?v;|)WZa%YR&m_?lIIniYIsom6%f@culC z;kOJxWouHob|-}$xH7D{CO%R;*O23NsOk5H+YBQ%C!03Z=sFe}NN`=$u9t;eVATVN zov_-v*R=HoCk*Uj%b)m99&X~G=rp?gm$qLQO&ph^l9srHO0J9Q#xsXlVz~yQg1F4k zN+WKFMvj6@r!1iXH$+h7tEcc0v;=_73A=xq=H3tu#Uf6-M#pampTyfIr4)}A(rZCy zn#acGT+@bO=;TXaKhhsmwTG3V$=&_z9 z@m!C=&+%hS#6eTDgNUc=bX)keTph^nX8jE*Qy%KzYB=$e=tt<{J;V!uQGVPBh`YI_ z*LY_5fh+uEa$}kz15#FsG3kX|YAty=4ZJM^q6RNyWP72_;w>hFQ$0*Kqr&n>JTM@I zCYEDU_`xjBr$mQn^KB9AyzV$glr3#yN9g8l5#{;KTGpj;;XJn!TyDnOBe>c*ZNLhO zyaS9MOkM7X?ubP3%N<-#$u}RqBgPwa)y!=ki_yWjf4#@mF-aF^c5p+K65ZG4S00Y` zm2oY+G{jL;!g`S<)Nvf%0vizKI9zvxPKP;ur(10v5boGXQM&gqnd?F0~wg%;@(%=HQHtjm2tT7t7Fz6JGJwhyMU4wBQ81y1)rdIiW5mT(l-c zbAmr79JD6X=LBa?Kx{9r;>8KCFa`^vi*kZ5C*0?Rd2oZTS=(_w!vF58?RZA<>O%AD zI37{jb*BDx9e3kuKu|r$(TYbWT38Rs$sK866n@8bpa#*7E0PCv#KM3+C4&HJvE9+& zCKg3MW!t;w{dG#+V9MpaBp z?1onGfIIgv5+@~ES6i;^Kb&(xp3rBJ=G~3-4IJxMRx8&3)11)2F+`^%w=)lH=-A&L zi+;GVV-F4`7VBtoIocNe=b9=7qvew{BG$2U{HL6hl{eOtT@VwaPs9DBXS59gy%agIHdR>^cE&M^Qk z1oz_{2W1?=2*Jd)Gp`X0^-+42=tJn{>Rt|-jm^Fr4WpBgKylmi)KXEGM&hT1P}BsA0c@V$RLN%k7wo`Lg3 zOOwAZwBh*WS#M@klB?i~iE_6equc)pzEm`imVXF9%bosfnXeWFwWl{t9sMd-wHCRK z2emZMBy){sjx}|LUl9Qr#O;9j1C!%52PMs9Zqm}x$wL_&POZB;j@R8c=XZD1$EzPz z4@2Z4SC`@DQ{=eJLATMIw#e}hqwY_0%38;t9CXdhmJN<`B6Wc@;gVyJ^0tS0$tA~6 z>~$y2`m2ty^>s7N&0P&g^)5;QJ6tvkh0gtA8F^MSG}i4gcdTZJ)+x0Io4@unD3x@b z%vr$(ldumCwWstxhEUyS=KB$bNPFFGvwLmBk3y;MLkA)Zp-RJn=1cVrUJmwud)U)T zy&7uvZfw|YZ(pT~J!OqU#op$UCI&CPa@v_Igqh>w4Qup@;%Kez(ADhJ+K}y_GnwbM zHB1!tr(Y>lfQHR+oedWq?N9$x_W6M!PS}6`NPdRs(##9{7*h21ie^nv92%OP1{jJ} z`ao<7rH)`*Y4iiYN!n|IeDugSU1GHVyoeRj&BcaGju@UjBVQtVM@L0=4;yw z2Nh+&8_GUo2!(x@o48{BXQ$ykol@|MB2OZ9#BQw2IP-VA4F!s_rI_N*B5^_<5{H?W z<#FQ5XOx0Ml$(#lp61{4IdR_K^Z^Rd;zBgq?zB0-(6GW$S$W@9^td6kYR|*i1pN(vldg$ey0H$I2fgzF*H}Q?$8hnn|=cTDm8_@ z%~~qO{3jB0u$Jh~8XDQ3y=Chaw}>%)U5@$dvxY1OMSqPfHw+;NeNg9;A&9reB}0UR zGVhXY?pJy4JIwj`wO7KFmA#@202G=qG5of2?deF~4Hd6RFQrpxH~>{M67}_r1C5 zUxwNOkqqNs82l8w>D2p$L32Ns{en3)yImfc#eY6wZL`=At-Rbtxy6QB!I{%}cJY{# ze%~%RI9HbaLA0*!#laGug`i6)@30+%qrSz40IKuS;8Z(oDpzAR1Tk*xe2kAhF!`=5 z^A2m6J!zQ;)OJw+mxdt!SXl@X5_@HGAy1Z!tWv~yTKdxPzA|tI6~8ph*CBdkiJ=Z$ zlXjOFe0-nP2T~c=Ysopzp((k;>$!r7IKxRlRI5aPml&4laB}*}kl;OQhuj0ogYytR zq4v$djc2TgeysV?D?@9YQW?Sf-WWd8wWIIe7%srvG3>3Op{@=sd25KovZ;$MrFzBNQB|J0--Zw)>=NAq(*fiyzD`dEg&L+@!|Q88y`@x1vJ$}ARN|=S>x{I=pw?BcL-01JA&Dhcr3C;n~4q z_|UE_*d82rV&LwCjGLNwE-j zK6+<3a6GS!;j}&ae>4;MjdeH;1IpT|IIRTDk2V@HoJ)uQk9I(zT``;ker3&698Q9^ zmV(^W$st1z{U6PwOrrufK<7Q*vUVyCCr)cdv#Y3+m69SlP+1M6hE>%Kiso&;TU8Cv zDF?mG!UKOmGYG4uR@dpKo0B|MUmXsb`gy6Py5Z)2-fEBzfj_4BsI_(ew82LWgh+nM zNA+%Vv&u`n~_BpL2e(<~XFK@fX1E zt9F6cXQr>(N(V*HSM9D`aibtVHPL^Nn`~A|`?jnZ%QBm03oGl_e(FcM0J`Rw3miByj%h>B~jt!C=% z_mvh?^SWxbPH#R~S3RY3{^A#%9Xo%(vNf1iMyaippuzMgN^R~nc`E1=J9y#ot9)JQ zDNr-^`?^G}qSXkueqV>!J=jx5sB>K0XneH#6p;r<)K{Azg7WJ6*lN#9=t6zfq)qp;yDmyP)>EQmjUd8U`QP_AzQ_j`kd*F1KG+t!z&=Qg`Uq zm_r-$dS{yxW7QCyZh(1koZ6*|t_$sKr-tg<)Ae?0fKs{r{8aT5D53*W)hs1=IPGeO zZSKE-+}f-D96+GGI)Eufd*uE-ROTYOQhWzs)H>?ZLG8sPu!EYb>>pyy+)bZ#L?+zp zJE{Ye3s>lQM?fx@CUsIhb?N2>oz(qKe&771D-XIE2RiUIF2XP!_}=ugbdG<%uX%P) z^^m>aH;>*ernuUQ#g!H7Ba2!7KZ?ba73;4KvG==w=iOpAy{xU3MB9o*4^mU?aSl6f zDBv}Nei{n+bgWBzhpO$By!}*pn7T;$xIK*@ss=*|KQRp1)$7ocVQMPE88jQNPE@+2 zT5~(lwc*G$)~3?oYFphDYCA$*3O@L7gzBw0)*{DG)vE{;araX!Pz@3z)qp^b;}51B z(X&_nEWUV`oZHHki6|Z~0nya3iX+v2I%QBY-TM^q9YlqnsR2O|5&yrn4(&4QN2!x_ z-ctwvH+MV?5i^zF%>lqarJp`m!`;v46_<4`tryp{f;_tTIr{OS;?LDk#r1Ov_ySNl zVs80`8e^}_Ye_FZ$2VR~AC2sG!RGwY>I8>?;SMiged!C)0xZ-41b;XPK7uMAU|D88 z^&ST#AoJ*PDk8}TDU>?_w5Bnwo1l6sZG6o|6V(2S-wu%HGA6;uQ9s4HPKUj0>(pG1C_gI{)Jjfiz%&qbS!X~fmqldX_AMDK3 z8LEdaYUkh2xgnN-HoW9NpJ=P`+p`w}^d)?h-xIytg@@S5$4B50y4E~1w zwFV9+gJ-MteS46tGhEWbs~;HaW2{)xt zzf%stUGO?P+~QptDQzVLV$SeERO$5(|N_r_lr_SQ+RG%YINV>o^L>V)YAMCG+2l)jEpDu^Z2!K7&~9m-c6z zKWk3iso@eV8YI9afKXNQjwP6?>eLD>GN;b1YE)~PTC4li=f$Xa7dJ(;S{$gLEMiB8 zPAr5!sYlD?Hh&6`UIC-hN)n*qJ0n?Md|8GPP?}XEcrodakKC z!@OhwqzCY8U9Q#wF>JA1jltrkFIShkR7)UNYhw1@)X2ZJyGWzXt(0(@^fQob5iR{$ZR9=xk)P4j*x}YUI1^!x=t2*E zR$D5@PE>D|I?ym^Dv!q{kQT2}8yPR2$DE;F#LGF?qMNHg?;Zal$JJ^((7vv#0sXo3 zYr88LBruCZGkEcP zFrOLV0JUe0+E`a)e!fPXr0f6KNy@+ok-~FiXBHHdCaaH-AdhO;#?(>f;$E)5iwo~O zoO@lBL;ixK9cVpXY>)M2YfRD=y7;Ra z)9&@EkCJrJd~rQ?HHUrQs3s^r=P7Zc+7gGy(>8+Eb)!`q)w)Ld7Sa|o33;vxsRoHk z+hgSZyBZmCjjyxDJ>t;#XBj*Ot-X#n32@E&88DUl{;sMRYKK7@rMOan zv#A-st8wkqn{s{uyHMjoX9`UY{;+QX>@g4(T_mot17!sK;jYmACg& zhA?h<%BxES$@}g(Bxk#7%2FD>MSbAt@+KH2wIkGft6D8^$=hH#w5THtX`rdTH?mPY zUlRJxGT>u1cft2*?M=<;ryXjTy5Q4d zynv?Re#fyLYMP60g%UHV!%nqT-CB+L{xc3%;thyqu^;OIs;YS)mES-2NeBRRBU1}rWWebb>jaNK8W0+gZF2m(PXB(=# zoI`hZAu!4(D6rQq5TGrxvx7?};Hh;Y|J~{!9fE`IR@X$<-DjOb50<5aY#*KYP}|-1 z5zEZOaUXTxqgJof4M4TVY50gH?@@dDX)kQ6u%A~!E_B#)YZ4+9?ok_dkIJjiLx}A| z_E63CA$w5qA+ISFW8yX&Gk7f<%X=4b3kbP^p84_9u|UKRY06$T%76QOD>g%4NDB>= zjsoYCv!fWR;Z%HbuX+bU;MP3#Q?F$3Q^~;I#rtS#whz$QNGtZK_1xDy1A4Qsf>Ux_ zN7wY5&_b%wy?yGNj0?M;mzqj(c`PH6kEq|CoFr0@id0 zn!FHG@)YKy?dKGi7TO{3Vme6FSibA6eOOj$l>CDuBQvglZh$F{t*5ilY0HC3>5Jaxel9jq3aE%_{TdC}woHP~_ABi;hL=$8U$ zGo#5^2t_gF3ArUYRR?M9Rj76cGHoeTqeIWZnrQ1MM?d>9!*Xntr4<`uU{8YYxE(te z7O6fC#Xv5;h#OEP9%i+e==tFIcr5%MlvqhUiqzOJzim8Myvbow5>%zI#q z=>frLAGse?!*z)Q7gP^BAujl|u)lI=L z$~$FxrrpDcLAtqH?4_4E9Ebu=9K4>dDd-TiZ7}jf5HB9nPlq7W+@?c^)S98&w>-CA zSGIa6{(?{2eP;HEj?RORz*h1+490~=YMT_1?x-)>8xvqy$ot zHhwD;x$*T}wU)R##@QgX1=>osQ8I7Ao9o;Q)aaDBtLaPefFwxKM+G(>Hc=LXFju5C zKtnX?s_L!`+eKd-Q9r;N!9+yYypnf2C&QX-7#kzBnI2Ay;y zzJ}+q;?JmY)i$BBREm=9(!O9a2T;TEGV=_KPq=w^MvV%MY9tQ~lNkcJD56#8rkHys zXZMhhsJw+-|4@BBKe!>cuR$|lf|6!3B44JKf2hGBW8tgt;J9^xaO@{vX}?`x`eWOM zG?1qKq1F)l?qIK_(B?nXxO%HF@#LI{v=38r2BE9R9LwqdA?`iEqb$1r?-T;NLrH)H zLJtri^e&;SB+`~9K>>q+QWPU91WhD@uwW8MTmwOY35p7+7{!8$5X&tW8ao?9F_Q)I>7d^K_ zShRljD`#Y{8*R^7jjoW<$@Z9e<=xT$qNM2%{o_~8HsQZ~QK{9}&KA`-o`jUwbl0z$ zBg}e9kNcWIbB7^%)z{8hp3CF?tVQ!YgA0){x0C*AY$76aI*Je>n3I^BNaY{EDE`nf zks@xrcYDKSqfUz#DN~xkIN{_Y#Zth=zQ(oovyA;@#xC@%iKD!C#3z~6UY;V?3(K7? zJSpRNA!vb>slu1uUs8W?n&64oFS#HcJRn!%*L(nzhNM zhJrb09TO64`>EI3@5A0)x}HLFVs?z_CP$q;8hXb00|m7XP$VH{FD;$b7bmSo`i`Th zR$8&yfWe7OOqRV)yz~^i^fO1DO4+wyB%ex`?}e3eu-aN;qOf zX2%fgx95!2nEPcy95GO=zOk)p*jBy7s?@eRy2SWuFIHP^t1h;$=3=$MwyJGg)fcPf zSal%Dr|ggpv0Gq!J9ExZaVZ0l_o6yi54P_?;f*$VO_XTn`rJW9B`<~1q*KG@<`i_hF4?F>?2w=--G`QF*M{d0IYlU*n(g`!Vo zQ-IxnGS=T~RoHs~-1%Ivuv1U}-q|C}aYV2A-Z?yM;d=eU_s%9N$w+a;lCN6n8=G)3 zLGz6|?znRy$10yW?i|r*-4WA>@l5-FTq5b(phHhM?{8Yyc8>C;BXyj}&6p9qkJ4)K ztX^?~xy|Q#=Lvf3m-M$M823+qM*n-lc}J~(pN1iJNBWt*_Xj*I)&)N}8+Yivj2$Fq zU5ssWUr5@MWp>XiZBoIgpY%4_`xAWkJ*z+a!FgkcX2@S~9qp_Yx7b#_h=i6}kF*Z< zJksnQ*(Ci~Gd=T1r%V0txyh7+SBGEy(b*|J{0{MHB+fb{#!~BW&0w=tC^Jv5t6X3D z(K)owOV5~IH8_AQaNRyXl*hPdm?FxEwBwlMn?WSZEGHot{qf-2r|19V>>3unPH+Cn z*{RR@;go+iH>l_AqgEO<&X2ZLSjJ@Y`Gx&S`_y4+RlcCi2S(`A@!qMzlHSrwWKY74fF7{qmyHBKsnr&bM*eQZdZEQ@ZebDM4 zHfC&?rVCCwTZDyV>(@>?Zw#ASwC(aqXU)*Ww+>10-$j>`He0S6kIb3M{(i=lcdwCj znR-A4iVADu33x~sg~aZ&zSYT=Gp_m0_2Q@eOoQOqgh$4O9N84KyXb;GQHBQT13NyPHqj8Mu_tT$rp z$0iZpUn#l}@bwSc6LFy)?Q=GX+iF6T`)V1NBndK{d`ecl-K^@zb)L`Jy!BTb>@f)n zju0AlMkM^l0cHI2NcIPeN*Iy)oN-P2AC|Be4ChD5L*}0w`sH@M6diHe*{1HF2-5KE z*)jmREE#-L_do4Sh^{;>`P?VVuQ_j-?f((q>v^Z0&Bn!EFHJQA|Tj3b&*Jc5vKP{O)dAu5YkjMc4%+^s8xt>B|DAm>4lMn7!Hn7_&zNgkmNbG zf=<$$hfwev&N!p1zg`M^{?t3qIGYb2`KhqyWRN{+vDS~AyO*h_H)1N%Afur_uNkx* zVXLD|p=&|P@NAU!FpV+zS?eR+>Q`rclLk*vrrk+bwnRGlfP+4{(UZl!X}>xfcln{G zaP@#M$JFJ8A!kYu`cWbhXfp>tZ0f+<J#tfdLzOQiok}r`zB;eVysYuC&0ZCOdWqm4OjmO z-SKy4$Hq%Pt-4lJq@tX2Xar{P%+w+McjpkE)qLl7=ObOmbrRW-`yTD;vz2cKK3NPe zSiF(GzsKX!c5sgWl-2HWeb-s%>h6UduLh#?_=8U~w!4)I;`a738`|z&DXgY`p0cK` z)Sb^c2S?q*AuQ3W%8-D2u~z6M=bR~?W6Q;3)d*k4;#QVe$zT8hHcE$s))6=xEa}G7 zQg?rpyQA~FX08`bI>g5Ge*barM%7}#N~B8$ZY?F+|MW4lP^bLitQDQ|KZ*EFr~lz> zUU#`B(A6_)U03U8|8PDQI#zf3)7kR+hI=TjTUSWDC8=g;n}0Aery*wnhnsssy%BGd zIP43GGjotp=K2Du?H_9IpUyV*?xit9fp%rO(J4#s{nI&U*o%)zu3Y6)IwE_6UL$dl%GWZbXQN3!XtlP(4Bjn?nnSJA^r*j_&APs|nji(Pd%qGkUa;;U z2r;~hut^N#?av8&?a!e+UHg~wrZ#)M2=N6Z+@3qX#U~{~fZ&)EO&<3&NB+%1E|uwT zXZ^6)0{!6M&X&=+tAs*1yo?wnnL_JxU^zVN= zRqEi-f2+DAIl+8DgvjgqYEs7#$=#Yl^SN!8P3AV#IA%UnYSpqiGWvbPY#H6m%3y&< zbo8>3^AnwN-r02MxqQjMWohyxX2UZk>(VHQev6bYyeAR-V>KYO1Z6;b&^pTX6~V6R zpfw;JezL;4`t7e_%d@}{(>u>fi z_ik{f(KDUeL#xG=G=67?2GKi29ed#Fo_~0sQm8-mJDbLAJZePYuUimsc#VGX0GpZv zerKGg*`?r1zmV?4MSLEOq+hf}uSL9$&`V~2dvo=Xh zl{F1o>sTbgI$v&DZZ79LXnl|?4?H^}c*p18e;eVKOwqLH#|Kl7JRz6-2y~uL&1A5j)=M4?Y zw~G+a#4R(48Tp@Fp!Z&M_E3e!EzwHK)t4_id$vA9E}@f|!0*=akEGtBqARujeiR}^ z49@a&@VI}SU7CJ)CuN?`ov;)OO|JE%oNTvOWj*?tf1R!BPZow1xW*HU5rvcN>-ged z=g`(7yS^VNSbMBw4eBnPOd-m9>B;Cg>fNaaTyiF~EurpRF$IG4LGS}~dhIzPmk(ruyd$m&Uy2OYg*{i?1+bn57UGd_Ah_f47Z zsw$c1HdpFV0f>0Qc8Scp+jP!05wme!5xxvOmPs`rj5x3CLOol9pm3vK_v>)}fC$P+ORsP}OYVGX0u}%**1_v{OjILXtG1 zi1&I{3aL^*`o3et-a_B^U8ovayO)Hpr!LN1-8)RhP3pr|Q@hP;UuSO=@n(s~NGU zEz)0wsrJ=B-a%_nt|P)#R}|U3!&Ud56B?Njov*$b4n{;)1$p1(kl~YXawR$R4WRHu zvVPWU!&TeR_w?>?wUnnuhE-F&swWf9Vxgp(YT3C%2!h}Z;gsAAQ!*JD!W~EVWA5xy z2bb(HVDTmnFF>Oj!d0k;s;N#q&G#>{&~tTJ`j+cMHPpCfzUz&M zQzBByO0B+arHW=o3tKMfBnRP%*r7UCU$-AlZ`4mY)bM*#N#xAds(I7`MsmMfy=wad zXVxR<1+Hl?!@B43!*c)14@A$zWPy8JN|HF(Zh8AjgHmeEc<@4CG&5^z9#6`NI&qJE zX@6GJE1J1yH&p5rr)m@4@L^_XbHbbJHBQyP*3JdO2L|G&SP}cqsggry>lRAg-D(xm zW#%PDt2serPv#N~Bj=0UdD$`k!@98Mx=g9a$RY74LO(Gb*l{Z>L!VR>2x}ZQRiB1C zi=_n2M29Cs+}<$hT&rj3)S7B&^OG+HrEqno5oTf5ETjw3x27-D@77dtoG$pTrs~b5 z{Pk-=UY;IbOSxh{yx$gn_G{51RNabR?E(FAEtQ`*R??KZ7?L60%pB+lIrYsHIrY|V z4_n<{o_?t7?wb-7nJX@H(gjqbwL(()ln@*z9zaZ`u!QdSr4RR^w!QGMYDf``OyHM_3EvD zxiur6JBf1lh*HrT^SPn9pR_x>CQ7-okN7xe?%GExSInAPcKdl%)0**ArCtyTn{U(4 zMyi(e2UL@GHX-vlGldPkEKNxQr^?@~tKws?AJ~yw zrFcv+;Nx90$VUo!d}5ydy{_uzoF!M+_m9|lz3x~~b>w}HTk5H)?N@&rti$Z5`a?zx z{hKwuUWWCP<5TSyjiql$Wu@UnJ=Lz!dG72s5^{thydoiobfu1~uZD7^;$8Kr_3!8v z^;MG&_aouHixol6$}sPkb(`2#vZa&;AgGQ)W2V2XuM%pW8$fqm+uc9r>;PROS~c(4 z=N=KNeQbi7M;(F;R6N$>aaYC=UyH1JUH$ArrXRV*^mP*V(=*s;r$#aFgn7z-n;!e6zX2fovhyTzz`5*++ll{vLg*4~`$${@n z8QAoX>EEAH%#lrXd|YQf`q&@cy4w%~(Ntx|QBF zDztI!oV2S;seb)S1Jyme`u!L5?q%T(o000+XM#;p2%(Y0EA1KDrG_fD@iyo`^J1`C zMC7j%-~5xiQ9TXS$hwXD3Z(0a3q^QJ!5P_>8+s}__Ir>W-he(XW(yT>bay;wS0 z7LsCBYsWUzNYJEywksl5=fAJE|GZ~MM8tFzpvzS z=0NSiBtY{meY$<*RP6VV48v~D_fG2rWG8ic{5Pn}AdtFLdYnma@86vmZW zMf%RhYEI29PX-x!`%HbjvAQX&=5@Mf6E%>d3J)}))Qa_iCaPbn+O}2#j%P3`=H9P* z(r-rQuH?c8iM`pKY~xms4mw&S(Ir~>cStHUqpo&q=^Pu6y3$sTxmR2)pTiIr9F;|E zFyT;5rtm6hQ#G@$V>*>i-V&lokbcIm?`%eNc5xL($~nyb>->RUNRLg)U2)Wbw;8Nx24GKz1ZZisHWN+=yC6UI|UM!H!( z{dWs>drJEwa^TRl_eI26I^Dh2Fi{fQi#NaCMl1!c)vt=9(d>2*M`>nhj{33B%+0-y zaR^y5W+{~U`nfpOCM|lMRG;H`v-0gYZZHX$I7;0n4q3j+*^8o+kynijgeqdGp%T9I zo+{MK`q6Nn8K^-mk)9xjhiFWKj*yH=lGu&2bhnmjPzUFirlAgcf9fs*lUKGCnz7S8 zyJP}n##M{;(=AoQT8ZnVg)(~i`}FRXYDk0QU8G6n4#dcuNU0R2Nxfe;X{Fl6?yNLD zOJtsTP$wwdYw{}f#8#@=tOmFm#Q+LUqZ%LoizFxHTaV6!61n|Y8d70$A<_|XyYMvT zPxji5%Kt&g2o9ZojT63?TKgxc{oen0N)x+$9Z_!3IY2A1wQiYH`IY=l! zE>&@b7`?7Saw?yT^^`WMalaT&joacNNAmRyq`kVF8}>&0wL%1wBHt*ai|EP#J`*1j z@qIJ&8*NllYwsZ=r12YrQ`x=NOQeGU`5t6kAU^Nb(QWB8S#NKvTS^s2#V1r8 zu!=;w&A5Oq0ECOV7YpA9+)P_FaU(-ToB&mQc*^fmf_l8&dx^qfR^ZUJmRc>o4bH^& zTNy}`?+c?AKF%wt@3dDvYljb#B~_XIAG9j;h4yNqr}lU|Nv22ptq?x`Q|ojaA_o`6 zv8R-Ssq0lLsbu505BWWmNB-*FBB2pnHtn#UU*aZ%*3(NRchoTk-f@cXTZn}Vru+6S?>bCkh^!8E+{3Pns!!@EwTD)+aH7N(CmZcTRi13sQW5qHaj zV^H#0_xOWuuy8Q#w_}K0k9t}*bUxjz;F3Yz$3?gvfmE@gQFjf15gzXyx$gw5osKOL!R4 z{evOqiY4l&(YBwp?&dBt(=i>i>f9>bDC}B<*TLw9nhufN{b`arWu2t}X_TVmHd$_1 zkR;yC5f1V%(W(nE@39b z197ZnWaUp0O0V%^oz6CEL9)N~b`qBh+;a{Iue=dmNqIEtc02JUV}uhj9FSLsdg2#} zm{E;8Vyo*RLcqdtGjkNt)#-Y0rbhs8%fbNO_MEag;H{0V^5f@V*SO zme6{@j(k%PC=U{)7;NQ1Z9~Q>D?^HS_2k z>a^WXmVQWk)OtZ%r4j;u*P@H(;iT1)R*(0gJh({P{7qfMQ6o7vtpoI9bV0pyL0 ze*)LbdS$@q{1!{ZP<)gkH$!8Jj+lK7rHk@L^n2urM6DQY*UH`h=oh=Ik)CgSrZ!M~ z@mVo4tV{@z#YrA3ks0(T5rOQ|(9wM>GIz>W;{+ovtEE|ncfWNt>sY21A7HOhRi>=x zCrDwjVr%e%Zv;82y3H*X3M4rh_$7GGtb)Gp4Sk8$@*By$k6AEw9~wIr+aD6kFU7LJ zHM{^`l#9Hh&|6{`YGrQS? zA#n)H;9!Vv1mUad>GHruoz+XldzJ^eo%*sk^0Exnj>7DgYIr~#y%DPxn`}n;AagK-Mj>}4lTGclw1W9g~yKxGo>wBC>6pRvDH*Rh7U57 zqX|Qk&GPwFD}!S)!8T?hK@3|*7_mBKCG7UdH0n5X1s8zl9g=JsRb?krTIIgyMIS=W zKW0l9TSg`4%)z~xQC5d1aFHf$U&f8WwXnPBrD?RKf&X}yjNnBG_FIK!JJ~7uN(2&{g@A3tjH9n3XrK=IG1UsqRsihKkIy z04Ik

    lKU>~#&zv`8JSTIT$s}J^3Q|iBTzJfibJkm(PXMQZqF4fm1s=*DzXpl_q z4_dd_BOVdb$$Dj?O03zF8{KSe$V>XmL^Y3t6QlaFBJj7)@2j%Ix1?9<$bPC#owUEu z6YzBSyswyqdbi!sPt^#m(>jacUy6zIthGts(qGM%!?yiVsy(jH^jCcn)gUCZFZzM- zOg8w7GKmY0s3>OLkauoBlu|JAw$FM7v8A1oCuX0}w+>KKd2nUt0M%#A^em}Ali6Uz z#=AJ`yKMhU@P!YS@n48_57WDAoVmKz)Jg8~$J3&Y<|u)5Yw`e3#ujb>NOq}4ZT>8i z@t!qO&UJZR8S|@>Kx|AZ61a=@xKz_lE0ft9Z`Cv>z)FR8hc`%yvSad~wTgI*uuJ`I zH&U0nRI`R|LR>>qeyO45O?}a&8n^8uAC`UZ(BhJ%J9F(-}Kh`%5aV)&q8eyn`$bD8DxTshP_m(moX0SyFcSjlZWrE4tmBwCd6Izih-&@_^{!&R#ER7h<^S_{nJ2| zfP~aaQY|{}`Oz;Y1{OHZ?7cc8VCB3K>ruWbX3U(#qjmXzSug4dNosBVODNtTh?*Ul zGnU4~`t^VgOIA0tZ+1emijVo`0n<#zTKNNoDGV-3t=sg9WYw~I&Rm)`rm4xQSKAR{ zF2IW!s>)O{OIo*kQ1O{on>oa9Jlqp?gGwIn6_q8m{bg#PQJW))$E{!JWl(v&NgCEe zQndC;`tbx2I#WkcNz! zjZ{WtS|5!Sp+v zmOg;NG{9$3+07V2seLjh7~{kJB}RnmfHhXH8=^Y4y-%Xpg0;~aAmk<@Yx#XaC7;w7 zj%5EfL|s>VTCCwg}@ra=`A?14fP?Sf_ll0=DYE1Pz?tgodglt}SjbO!W$@ z=hdTzsit8+&(*VrslJ`xAVJeS$mOBdq`nX&(<3uVJ!Ew>m68df^z6-(_2FTxzAi8q z7@H?O4(n!a)wo%1rfCtLk$h3VXBzbyof%Cws?>3A)wN-JM9?R1nwp72J_pn!y_@xu zZq@9r2*RH!5NTtsB(0Uh>ahk{=vyASVjt|2_oj1?Wlj`f8-Cpdrc_wK+#y(|OWXgq zh#Q;67?fYLr-nY}sTjkfc5~s;>$>@Hh957BUvETBcoS?FuYCpTl|Hx@xIVcX&P64P zPgJ=yH*y!Yw?qy`SZnX9(zuF>Z4%M>Zj}c8s`NJ`AkCAI$h~c2%zgk7&4G(6&FHUi zwqcYk;k?>HdKyMfvgy`3{(u=Y5YDP*YEZfFFX>m|{@+v{y0?jZiqG?_#M&rUN6=Rz zMbgS1!qb)1K4)(L?R0CCm{A8Ok(f>zq3*7Avk7kW7jFIb2-ULgbt}yjJhzSvYe=B2 zJ~cwc*ZM=o8ltT(wT9}3BUMLLZMwA6Sy==;`mt7oltW{m)KVplufzSxVuXXShaROq08Uc!(;RPCQ@ z8?mi6i|D!JC`H{ET3Z*UsODWK<1()%1Bx-m%YZ0zB*a=KVoO9TDk=;u57}e2Zu+|v z)ojB3z3d%eqr{f7{c)Ln5mw_aHaWepXP&Pjb9tv;a>qT10qd2QkaMr=2)UM8eP2T} zLiDj{Xd-z}r;Js7I=$UZZh_DI!8e~WA(Cp5a*wX@(Sd@K;pQ+|79-ga`mM35hi6-m z3DfXK=jT2q#QYBNvpd=3aLJP3MI2Y zn55p?ZU?<2b4b3Q+bU=}`FeR`Hobgg&LBv$=IIA-Qt9jjJav;AG9)V1oL+9<(I%$8 z#NdsnH{D2inzg61Z7++t5_8Mz?e_!D$hS9BbpLYZYVOS{y6-aH;}OZ&6ZG51Wq-fH zHw-QtV1I55I=hd<2@cDKbkXnM%pfZ4MGBz6HEE8dbkN!tZ5O~4lTyUwX+n|x=(VG> zu0Bq6YyJHlV%PLDv-|vMnHeJd8*BwB#*B&F5Ik|5O6}W`!{ujQu;Kw}kbPV6>s?sQ zdZN9ZJ9c51+}-?#o#uVP?=SS}acXEvCl-DrV-14VwO+Tst5WE#JN!A*RY^i6oaHC7_QT(t%xb=mf0lopsrG)y%W(y9#^z z=|L=CrkF%;VP=sFO_<{{Nc+*$Z`oO2rCeX!%}%p}&_Ly5rWR^#?qFNSU}=k!|8HBI zlK0y#7x|WQ?tZ(?i8Bd7i#`9?9*$Lg@3Fr>s`}QCO;9byCR4Q~t4{^3>ppJ_us8U< zq11L?5d41QJNx^ds&9wA4QrBodm}!dtpA;$ZtV4AJM!%vA4_W*`Of|H&wH&FTkVkM zNfIdbw6(vF{$=N&t6p@AYR_6r@hxgXoy$vuvltnD%+2XYzY3K!OOQg->5kyH=LvI&hPV|kG z&b7ehfD+$8Y54i*45c$?x~jQ(&^tB^*!vrqh$y*o1am=iClOjL2s%jcwlD&@-c z(ut~h+grY1(pUz^rOBEfZ^tu^cp&*^A`x9&cspJ5R+Sv)n53hAcQy)rL8slyg8yh; zbgSwYJ8KRRdLtIxDxR}qeX}Kl-iUkj>08x}snImb+yXIv3i}divFul)t=V>Aa%c6_ zFqnGv$>?8bj}T`X*nQUa)+ieCD@W&_bLSsLB+&numrg0JIvsW4B-K-WHdzwoP{&mL z$s{$X?#G8K&UdlL3mbWlIMLU)l|DaN`RlZRELtBK55`)5Zo4=|S)rb&1s$2_n=9Si z*{(+}ny>vL9@(yk?XP$2uLtcfwx5Vwh#k%hud`jB&o|-ZI1g@L+Fy(8uTSNREr!{y zt;RG9QxAzNW2!rQoGZ^*PQbFQu^fdd-k5H{)XJF1hbzvQx?pNh<^8J_l1$V)_@$1E@pm)s$@Gk$yH=>R8 zV?k@z;L9l3FIctfFj~rXz4wsNTazmg@d^8*!_0VBEnrrNg80@8EHk zX>3WmMK7Pm_QW1~=QK5<@oFMvk+i!sw)cD{;v6iEPj!pw>K1OupEq5_cle>H6x4x0 zOiGsQ;pQO9AP4Hd5qym*7#vP6M@bn5c%A9Mbk%-X7aYjR-b+_wUx36&NLiQq#rm#| zDS7LNLCaSSF{;``)BYwS{!wf@?LC9F;CJTf)ETNpv!~~EhR*KL zA&x-Iqx1Bt87eKzdQe}Uq1v^&rHRx&=sox#6nbk9tT1E?nanN%F}ohr!|qV=@o(S^ zos<5RLvFAj^bpsG<)4+45i_a4(!4WkzC+y}w)}!VcZX^nJ@-P8h@lWc`hl2=Ox^BI zZhL5}husOaIhlIaohrjqM`YW(AYI-}kFY}QuQdDX&sO5LbFq}SasI)!FfT4)(abs_ z^{Zf~h_;o{65j|ih3!PZ}i=Oqc|-5C-Z0t-#ddA1h^LSkFY6N~)g zlYG3sI#Vred>46-eCKnvkQxr8eJnz776u>zcd7KLF5G?dO!3%D7PK^fR11}7^)8H< z5xvD7dN^>xUi5h&c2_kaaz{fU*laO&7o>BI)Q^Ff3-=4(Sm`m^(fqTc^JlWF^*kpA z&fdig{5~C(h9c=Hd@*LcS*Ck5q#`QA5iE!GavYPXugxrRu)chkYM=_TM3G7BxI)iP zQ*nbDTohS5Z8GuWhf<8JdhWA^5s--Fjh6uuhwLY>8n{!sS&e0!ZKgZT;`C=}s+H$x zV`N8;qB(qVc($ki+~yU`+$>6fZSyl3}An{>56`0x}LVtg@NrHKkY3yWc-H{ryD_tD6iklip|DgZE$trb@^H8N7L` zLPZ2aNubX@(68RDp007)&1|G|Lp^quY8>-MBU9YgS{6>|9v6O3`EV)XEY-5{zLBj$ zyrbnQ;oLHcZFv3(Hw%LW5f9APJ7=klt>)}D?SZ8~0+;NUyXRyMEp3h6B{bKbdr*YU z(eK}*Zt13xIt0l*BYLGf^s~SZ!{LgN2QFiASi|cJ9s5d?jINeq%hE&cRq+YorFJ6s zFotDXPa~7jT2z|pZf^=qt?s(z?jzi_X5Av!FU$Yh|-S@hpCzm^+w z=jhw+W5-P1pX878Pxq-#%?|%&s%qxm;ofx|ER-d5i8p&+lr_4p{^340=1$R3vsHA1 zGK$={-AG2raMB!J@KBW1Q}>&##?=1lR|+~`P8|ng2I@7l)u6EKU-hxsYDnlf-Et0* z#ORbcs&&2XKXl+#4l>!xzmHAY5ik9qbLXfwVUJAHugqbySVD~cYL03Z+Dli?Q9VOL zbmw%{JTf^-_`)1k_Ac?3#I5P7ci7WY^~!V=%_BjZ(&=;4^>^t^^j7Llb5&eeNVL9j zt{Tk-_;qv9Am-@gl%ktC?(8DY#!fTdn*YS28Ra6CTZ7OG6$&%TuA3KA__2 z_5BV0Osg$wBqQ|K#psd;RKKu(HTB=Phb7k44Kld(?k#<5hH4U8svpcyoolU4ZWVIo zs9kOJ?HQ^8uZ$nWq28Wr971l+zi7F2M5by{KhbejlZM*zqE(~5?vtsSw_n!z%7xL% zYXyb|6yU(Dv^;tuJS)rW1~ymJZeRjetB+Xsu+#3v`ewSPJd7}@#NZZ z-+d+SI6H0;BhtJNd-JG3Wlfpu=I>jSjO~{~@UR=$G8%37c1%#F9vmD!HN@(Utvt9e zbw?6(FgrUe?3i&l_jAutzNRySf@JUXjv>CDkl&)JU1~O#jCbEX*jrO}F64G(MV)&l zs_FLg)C`e^dF&mFsH3;fV>i|9`tm%L#_q+tveaV@@+C@H;jpWkv|k6TJGAp5)h)K? z4$~1@nD@04Y##y6u-TA8b z^-G!3`od|mf+v$3@a+xv?Pukpsu?bDbw2}J))^I*YkYsou~5tfuIV~wzPgF?TVKyt z{bT3*q>-Z5^X#bg^zY36sMCz!b%zCNUD&2=x@-aCn-qO%f%@3fv#&iK-CRuws>RdW zt{27_F<`eCwX^>zKDZq$a_~7~JHS(Sc5F`#p(&^bbvA#kNt8l%Vy)rcHS0-?v@@C! zRc}i+J6OxF1iM3m%_10%#YEi?*SS|*hl%TGT&tqt4a1WrHW`sLjkktg@yb;wk1XV% z$~%dz*pE`5{WqBtC{Nnhg(|h~gjeBS{WI&T&Utek?;_RO^ZDl;=r%LD;PJ)Y^!(ZV zLo!lmW9ylZ#E{67^BpT4{qfKi|47V-iYPILHN4}LR77Bd_^3$ zA@~ws=9XX#-HD(|_9EWs#RRRu6Y(-$MR=nKw&TZ;s{MJ~6*O5U;0z6+<`P*Fa~$SB zuCvVvnC}akk+F!eK|hI@dkgjWPr_U`=*NwD2#Jcl&B7ijtAEgmty5VAu zOO4UjFIEF1Zx55!`UEW_6X%T+^<#@wt0=B(7E#lwv|tykZUO!NV%4?&JUBMk+eEbA zcX5FL#CKk^M9sXp`pZUayoil#oU|tJeP%oDu7lE?vTx>9jVW<%=uQRvIdDFZy}0P9 zkdRQE|HFNWxbN57m#6`a=TH>1piCRNAcSEAv5P*uAfmaBd_>)JGu$=l?<7=t2BErM9`eBO%!j^>S#?$BxCA-rpPI2q}%o$Ca;;WV>qeUhN|)hAX2F zJfgaDBW1-SYDDvnTNpoh2O%R_j3-aJ+h3+uFRDK(w4(dxjNNa~Rzt$_#_LVl^o=KU z?HrXfa0NusBA4b5a!2NMqq!y=w@{K{dEsWd-F{E{4nEz<(SspuPs;rrD!dEaJW0su z;Ky=QbMBGcoTHj_to|a++XBtR=k6^(}Gzs{hDQF`k2XFsgfo z2r$H&05QIQ@NM!a;^?sM$B!8S`=&t*=~{9A^H5nKguWeeAz;Nx@g&xwv}PhZ@Y_Wa z?#Lm2q3}7ht7etXPT_Ad;R}}@Z&x5t6J#fy)$KqF zMfBYOL6YvH`iorED`rYJMvCDwnB9yI8I2Zjhj`Pa>dCqdUO<%A%23u8txdXgsah8u z+7-e0z+0c@Ynlvi3Sze1tmiGGOL|-%TgGhZbA54{a<^#NMU)wTcmF&&|FSnTM0RaW zxFSR!-=wGKsT8h=e=AR|2<@N;<*P~2--}F1ZzR=+CEP(%WjK(phStw9(zbxQUFC4U zuKB21(EZ>)1To`9IGFi`+|=F^zh@2w>qFZO6v|ImOYt4O?NK$P{$e=CR_<%!o2?_g zjCi?p%d1+1?HaA;c-7;c1%C-eHQ zu1qTWN(^>r--FQM_CB%R#MJxsZ|te*@KRQMx%MJb1a6D023+wnW(m{OWcNaX6y2D`{ORaW#=t?!C-E&ejB0H#zf6qJ&{dG}Z%Q2wEcnnJY<+b|oO4Y!z zbgh(l1gFVXs#wPw^A&T8uJgExov?{7-vwCrew3s@?N18CO#HxBC*)KbJJ%t(PUKyo z)%%v2v*Rt%nsi1i#I%I8#T1+To)L$+`r*e_^A^oNk{Emc^(Bp^abVLcLz}~9Hhf^c z-u}3necb`!tc108Vmg>D9h!aD%YP&``?N`2T3${lcGFXyP>o?{|?LFk!u0Y|I9#(&qFO>NlOSit}zO^}1Cu3;J6hT%{&)qQ2E?HLS)* z&G1s^SDn6^*~XLlvDGvUbM-5$Rfp&Y&jyn;lRPTzDW1VRy;>~_i$ASrt>IAb@pXE| z8r9?aoz{8TP$;?w(;RH(`-)^^lV+_Io6A)J*wCgl{ydP(r z+544+j_9uaK~2xn2;qdQA>Z!&%~C25GD557P5vc=OMa1yPX~KD$|Lu=sYoY{-R40$ zTdV0P+fHi6q(AB=Mf4dr>wZPb<9ULMtC>UlzM+Q7iYSwcxN~%e`KOZKHHG@f&rr*q zz=uewEp+*0V{xIo@0rM@SP{SLSQ$=}STvEqfAL7BDH}GrdGP5=BjTBb-iXuNWLOxP zb1OvA=Wae|7IK|AS(2e_SACtlmdS4oNlo^8BS7^yOl)MPp1xeG0~PvT~D_PvLa z_TZqZaPM0E?phV^cz2~#nwTNlT8rjnFJHb~B-|Tu@f|zquELLO*RVYu(N?n6$n|QH znCf79N=%WtU$BgGHS3Wk!P@6`!|NbTwMf^{R9`BPbgZWJxAy-c+27|&!)Eb?mxo_b?UwPWSL`ZbvvV8t(Umj=CUbNQ$(6)%d*o4=BG8IiyUcRsI+?9uN&#o}1D zNx?44msucVf1!!ptBL&?B!;NRNCX{B)U|?9&lJ8f;SrZ4iTbE?8wIX-u?Wyqcq4w< zYE!Y!_Nv4sM!d?F1iV&qWYy~QrSbb_(65~8!0EU+ohCuwCMdR2_OqQYV(C_$vrdh# zk<1PctIN;%>(XWG9`wTivr#8rXp@)7goZ%ige>K;$41W(vCt~15eRtMHxLl(K! z0%B^PdQS%55pIZNDE@}|l5@!n8R8)52^Jb;2TB57=NYr~Km`%E1nu415omlcE3sA` zmcjZBZ*?$(RA1lA9+Sc%I|a!aDY*YTg#fv#O5rDCwo^C|w7)imo+gD~-VCM?ZunXI zX<~+?w!};V74OQI$%4nugX5Y!e0EI=w@EnimPFpZ4%&AkqMgB%Q?`c(^X9g89Fn}< zQI+!Bl+M*k`tC$(nFu}g2W716R-IMpG8&dA(iBVaK%=rbEsV%#6N`D&91qjN3j z?du@o$9*2Ax3`|ugEp$uVPn44U7u53hORIz%UMf5Q9-T)$-7LeEXO!#BD=Di2gRci zy9+B2taH>IGxim!;I4Qc4Wmi)_R-Hhr&@Ka!KbgYDY)L_+W$wYQs-q%9YWQn>9|9m zdk&pno{o54?F-$iKX_gZ>~Y6(VMy|lpQV$rPA-+W-;>FtT;G{nDB0ih4W&`=UXVR+ z>3%P$X5HWZx{5o;WP-%~M64Y8qh#W|FMA=am9mHH%}k6Dn|kZK7ue;JpkH`F&4|i4 zDg_)fhX;)ob&~#Q~!?skXH%9}}LtzS)Y^tGo-LT01{5Rxzh*=~p(X z!5-71q0+2YXfrYUP{1lbWms6b_bLnTB$SU8^nlm(CXvbT@hAAveRpZZGkjBuAy#s> zWZO001mj50_lVhj?CbMw$EWP_DwMX3w2CN?V1dQboXoP5yXTtZD!h8xiz=?pZ+oti z@PSvq{i13YR_N8=zlfeSMRzV%vCej0QGr!(o#~CmjQP*$f?{>C&hxt^;89cjR=!^I z66<<56p)8^W%mFyM7%3iC6Fxn&HqA*ruWMxj4d*2cy-QKh+l6+ix;Kck*3RJx#93OdpBAyU#J|2 zjo!LR(#p(0GBb&nT7P+qX+91C()cCe|Cep(A?!9_9M9Vp#Jq%sY3uNRodn|snW@;n z9<)!v{)uh9#M3xYqlhb&AkBJwpEMr>NK^`tsOJhP4}V8PA4O&IMzqwwzN|V&5Bl6N zXzMj~3hr-aqg6w3@zxG8d zLCa&ZjiSIcL6YfiXsK`0G8tB-nm`fT$v=&CEAwS@+sP_+us5-}&D8!1w?~zkk8$x# zK7(AHYDMf7uD%}3>eBSoAw#9VqoMNXyH~0FEmyC6RW*#+ zDn1H&*EbBZGq5LDzxS$Y6`kvld1APnsmom{g6D14Pyh9*dNA|}J?k|#PMv&M6k)#G z;8xZAO@zeivJehDfGs+k94xTftlxZ1wP`s16&C5ok1FU~{u*bT;vZK1KbnanFp)or1->egFSVvVC=%#E6Url)UF@r_Q-Hdd#Ek_49A2nVv7UFtjYV<8XrI zmQb zk?$<1W*z%TB6~Q#21*!?S$?Vu-&AcqH;DHQSG}*nyUZh(2YnmQdq_LGf9QjqA*PiC zNWU83PKp2h1rgTdYeTFc1TAveF=~vxelj55I!&8wj?Mza z&6L_AJ?1S`nOXYIw^Y0M;y}v~>x{4<+Z0|%MoXE+3_oHR^e2riw~cOjOZBZjQhYAg zXWvr2!n=ps_nOGd2V2z`9!^-XRVByWaTzZ!N)~uWN^UN2drOK%B4qFSkJdtcZmVk0 z*BR)>`++`f7eio@J)ddk-xXOsUOu(ORt&-)27u7aG0IT}bTD zdRrxS-E*lW!Zd`dOcNt>wu<=BF_UGPbW%O#bM{3U|{QUoTHSFR))TiH3Lu*&(V^l%!W1F!%tX zhH!EwFO$NOlv{{U7W94tH`7gDS|B5!<087T)>PA$WAZh&tNUP+$Cp~t2IU}eD4W(w zBYNe`*a~rZlA7gv$dn@fsTSF;MbC8%85fcixw_PP?*m*vHm*73nh3oy6LE%!`Luv+ z=v)8^wn{eJ3S)PPxgvV$wVPhL8&;w;JfS<6sD2GL6xr>gPxhHu+YVBJ3VN^63rkdN zWJBVXg(Dus3B;V;jcmZ-T@;x!cZFD# zU2!|QL9Os^B!Py@9B4?W3&>{z5>Cb`>Vycp&4eMdq0iX2WKk8 zn>(LFl$VYA)0bi@_|@;jl%HHOFAF03w)Nei>eSGq_Nd|8iuS0(4$qyekEOF#D!&^s z-_DX?)%X8ZObo`+{+hV|H*tCXBe6pSeCrwl3Ne=#UkFU)SL22MH-4V~^O3d=5+M&3 z{O^cKzs7CMrvK?L^1tl{{a3E6|N5><$a_u1RRpZX?>v6nx_zutsy*?1Xw(zCL#u7e zIjq(>Jui3g2X5%>4|MP353FzP5A5f7TQ`1rJ^X>Q+@$H?cc_&=;P2)SB=ftQ1I~N# z|6_Z9pb0hB z3V+}nFDLBg7m`ong8b48{DG<4-up%!cX-Z!=nuqy;t%}%u|FW@$ATzk`3?TB?<)H$ z{FSqnj?ajfUm-s+rw38Y@=N)z?<#w+hVhW_*|t_ctNTMI{@S@R@I1fC{A%%gw^L=H zQ@TopoyV3h&&# z<+i`;)ZErjZy8=Q&2xa)B2&ix6Ijnr%vKP^EWd6y*;w`c-*^r`{l5Mu&>q#P?<*TO zf&KWN3P$sL=Ey&R?)=2huV30IW_})H8T|PF!R+}DYW}|`z+!*H;&)K{GJyx_A*wf`eV=(B6EKRd)qv>*BoBk^XNa9 z0}20L4wPKH97y9A$1k04XGkEB8Q>k?us}fZ%i;HaXdn>UB)tE(%sS^2MOm}+0Y7F( z^Yek&P9Y&_EzSqJfh8@^2Nr_~tO+IH6$dp+xb8e7~A7~APp=5*9-PO zA1D+1BnV^_RF-@`FcnN4M0{ZJAP*5@@MCcfEE!CZ^+GaPIklqYs2VKnB3F z3=$B05DtNkEI14%&L^XZ#0w@SauY!@hE%awcs@`FmMkIwn3_$_`oi*DA_5bZ;SO3W zD8qh4Sa?2=1(vLW05EYi1oS7ICSouTOaT*$2oDymB|Mn;Bpd>Z!NdJM2CRECCUP0eTSOCa@hj4=iWLZMoR9QQt9y_&H#Z1ZFkE zA80kd;0Y9BaIg)3w|D^0fyHev1X73Mq5XwGF__9Js>6aD>k1i01Yj&^^+M+Y=5h8k z3oHYRz;bX47|UtlGSCnDK}Vkpfhac_029E(evEswFl6;3AehI-&@!+DJONr@$Z!I1 ztUD3(vt=<4EMp&M379q(j({aM<354}CgTofaZg}5n0FiDM`C|F2@1|6V_+hf4rX~U zbvhLlJlaEGxw07(A?@Ou>XAJc3zZG3W;m%lDJ` zOQEQqBIjW0I?7b=X|8?%)1HAtVB)iIU@Y;jhXY{V268UQK)!4&^*@2>goQ=oOL(}6 zfG^`ga5El2|0~$vOvGDYoggRAc7s`*ceB9Q9S|@Me_)>AP6z~3--RP!8t52L2EjP6 z7)%7qz?AVG5`K>yVvzE&I6^oTOa!yQEU*wP14}>)JPgL}B_c2lbfgj< zOaNo|5f7LEP8EBw5X{<7c+dh*fMo{=H<5G>QvbVQD8k?di@~X23Ah+c_<$UMZm(q&VA-b#FPM4=0zvCA!YlTl!Kq33J3@S5F}NNq`3iqv*;mwm3qv^; zA(M&VYZ?g9U5+q;_&Y`!f>~f1SOn&QC15dF4(z)`MkW5m*jx0WGi$^n)kB#2?7n?fCzRoC%(UFfhwU z&cUKHaAqn+^ee&)W`TuZ9#{+(fxE#H4~B9KWuPDQgHhAKKOqQo|3#62Y2ae894rP? z|0Y4u51s=P&l7Gs_Fw{-cmd9UMPNEu>_-Mb>mr<0+WARSByuL$IcdyR^~7O)sRC+@W?0!epL1a&F` zsbFILia_z5)c@G%iojtkvKmwb;${*cmWaT##ub4gu&62SVh>tiRx|wF1uMZsunbHC zQ=3-=3PCHbB2XgOx+3661LG?K-N4i~6@e762uuh4U}2gE5A7=gC$LE9P!aHhiD1;- zPSE^wi7u7vpD6j1uW|VVe;LbaI+u`OaP0(B(Mxj1)KgEK0`XY#eUDBbWxJfmz^U&;qxBd4q{~ z4ulMWwO|^U2Ihf_!K|V90~6hF1}p;|=@2*)PJks~5$GOOLH)7KX*3;|-}6Q2Hj-5=?uG94#i`Rsw*DZ^KG3 z;T>`WW`SG4GO!FR*$K;+;J%lfgXN|81Ix;Y7mWRY41sB&wL}v56iOc^w zH8x>`i3+Ww2ZL1yP2f@->Y}{^^T1-T3@j7m5{h%66+=YJU^&%S`qMP99KGs#K`!Gw2d46NNz!A4>+kmj zreY}OHrOIT7YTuWFrN(v|hgR@C27M>! zPw@v9gVqE%3MTNlMp7Y!PJ&>te6ojt7!s#&{0q#xodj0$J)MAH7FYxp@qAM`n3e{I z9w&jjaTlBofuK8`gr6Xxx!8k#o;|ZbcLtnVg*})87GPUJn@5Bn;{VNgNMcb6$pKb`d{=KEM12*zm7*R6-)(--y$I}aVG=`mh$~H z{yv3ru;dV&dj|ZR9D+q(!U-_(DDGey=m*Qdgl8!N&<)0Z1LweUu<%)_|Hlz7Ec_>^ z1?yqW&y*opbP7T?kl<+&+6X~sNC+%HOHRR(zab3tgO2A&xDx+h(Ip5469VKEObe+D zggg%cU;;sTfm|gl>rO%gHbQSQQisZ1{Q-UU>TSOrnTfgsv-=Dt%w-R z0#C?yYn0-}1mK#TBrug5KNo`uDEYg+L2L=0b3xV# z!3Xj8Dga6R#Xp7ITNd>fC?!E&%1oC@YW55-{C3s5Td;0Z8+ zd%XN$8QAR|2!9a{fknk63_4zd1KWs?{puEIy^6mQ{J%!Vz~a{-K)&CEb0yUOw6_Vc z9ST_ja)W6s_ayBgAj>?3p#MD*1|7SIXeai2AP{uyqfEh~GQz*h_aO)Yiw+YG^nV56 zV*hnz;4l~qT3`Yg@*V_&vF}m;-59!IkqWxOG;k`I1!jSHU?Erp7K3HrZqQLq4!}h4 z9O(X$qS!?a!D7$?cY_H(;ZN+rb7BuVc0(W-=fRNpGpq;8P7whZYf+Y99=HW80?R-P zJR$a6;OyALH<$p%^5$?7=>L-(@5TRl5(3No*zdz1m75k@cp%mdw^XFY~A3?+j9 zP`2XXA_VP+Bme%dy3PhJsxtlG12Q-=CmWP zEcX|>6jdQj=NZ%5|9n3B zz0Q5^=l$h8=M_2)T85UO0kjHDGfDVu66EWNIjEPnYt8_qanR-lDb51HQgh~P|0t~8a1(RQ>6Z9a>FwBSFDa7w3h%Lomk4QLvF zg)@lyGAQW#)OazF2XtR>$Sgx07m^{=jXFLcLez%_d?bYW=1?PO5N$>q<`N-VHjkS5 zkOJ_LH$Uo~Pli$dC1eb3;PzuiEAeJi^=R5v*wNy&9CEy!gceYhXy95RMjd&FO!r45 zh^C-bi^wSIT|x$w{SP$B$7CFJqlLHPhc^F_1W<%)9HWX4L zZH)g0KC;}6A#fKFeL{q23hKL?h|pjuj%Xo&bHVW`B`Txp(K56Eb#OB_fcns8vW+&>XCBDyz2hAx43ZEk)G=Mgv zjyfVjbN)$=JIEkfjk+7KqdEVgEx(`!&^$EfP4=Tfv>EliMFw^e4oyQF{!KincME+8 z^`Ui2-#*0pA8@}zfG;s@C1N!29yvzSwo?OWJKBqS+la6eKQs$TajXcN1lMkDG`j0c7!)Dzc0xl#&-(tUs0BGSY z1VG(ODFNzRcGz@$M~(c6{b+X~`%!-p;g#}t{94g={;GQ~nzr(=nbt!_?El^M*?a;-*xx?K%1gI)WO&5 z3(x@CgjPLCyg#yydeLsw_ao!qTSHZ2NJC3dA6lgx(I(XK6itLyJww1=0tTpZv}_}O zYWq3%qyASY;a)PbjoN;qfT$ZyYo+FXDkfqe3xk(G(B((nJBS!9 z?4&Bus{c|_G`NSFLId9(Ha$PHjb@c(jFlI>Ufd_(E!?s z26++AbC8T|Bq6jLtw4il04>|pZ+4?qs4YlB|LQk0P;XTBd0xd)XN}~tNZqyMoV0w?RJrqB*8?8Wt#Xvy8FdWgclW{cJ z9)%<7AB`hghz8K+Q}9F6JOieScOQJH7tI+vVCJCSqye)`DX&mApnmUw*^5@4F<`p+ zn@0gO1$Cb_U>2ao!D$0#72r5~z^qd{&LsdEJdXf;YtV5%0nosO1VGC!#viRh>(I10 z17VXa!nW zNs0LjkKJe)8bqtnswxtSA^tTagu2l>w0Z4-X>*c+M`*fYzz1X~1D|XSpaHZMZ9u!x z=Era}DB)HHCVVzB9mcuRzYbR1xY&>(I2VRM9X>gnH2iGy`qlMwO$%_h<^#_db1L zI3@jnra~Lg5;TXuZWKU+Xe-*>N?$+&+etW%8u*C5fcihC6BGcxHZp*EKcO$6j!!8G z+KsyShfcF*QQznE9n{-F#!qJd7i1g_?4m}|_Al{A9lMDi zP5X)rq5k5pDZvPUPweNRf&Y>brF+OZ+Wj3>#+Tl`KTrcof1*m29-t=B=02(x^$$=Z zXw?xq??}R%B#buLj+kX=d&Cj5PT3=mnB8aOegzBFnek@)#Ts=i{N5XeKD(Gt{m z4gt{yv=jBG(^g|?Gt`4RW>O+Fhd+(mi>6(SeH;m(X=uBTHdotdH5x=4P{$lfjJnZo z)Qc9|l869sqdqhR%|U%=A?in~&=NF&R-p}-5&`PV;@QFRl=uotjs~*nGpP4UGLE*R zjtRtb6-|fwa_~dT&??k>4R2F-svWsx;8b#q`q8p$kC*|p>N=_nZMdF{dC57S%JHM! zXcZddJ3g+7`2U`gqwP0QV$`>ojGzrS6JG7Vl^U9a{g3#eel!bh_+v3u33Ov9Lvsq~ z9B5!EC7Vpm+=e6CfcjC#GD@cG|3`$$M2z~-Kq2ALX0#f0tf0-+b_q3b8h$G&0NRfF zP~SbIi#8PV$?{&cqnv=JQ^NbHi8CnK!z74S33k+9g&$hBhW#n{qiJXm%|X3ui4aXg z%g}DLPVHYuMwIW&F`YKN>_UQ2(dIm#U8c?NrfORMid~ z(Xubd5SsHnRgI?o!2W4uexp(vK=<7^`B~* z3w`GifEP=vP{&M@Cl}ERa6sG9jPuFREHZ$m%_ai0f!CGlP{+lT5OvQnOJ zs1Nm_d9tI*c`6^Mj9BA5C8Apr*EmN+ru-~3);KSTOxZ8@u5q3oS+HMTQ`-dxC1$O2 zLPSuetaY9m>FJZJ*E+AV=N#I{&8lB`CE^iwXAQ`tNAPZ!%N}u_&AZ#H z9&w%#nPJLnk2uFfW|^{6?F~r8I_HRpIvKf+y{-tEyDns1y3Toaq-&6DRGZzheVy}C z(oKBSd2wW3tla#l^AbL+`0Ar%x>a@{k+$J-=uvzNCGjyLtd{AIg?27L)b~19JjTv; zSS7ZqHQ+M$@1-EWIE+!iFq6?I9Vp45lu4Z zapxHnZTaI=VwtReoPw6f4z|YnM(#I9tGH$kb=?zruS_g3E)F+-kEWlxkzPmoZ9T*f9d24NSP)pl={z>CzRTz%eE&~b556U)wXwr46AWYJ1rx9zsWRX zv(3FH>aT<54fT{qM*cBosAIO%ia!@AhjY%|Z~iRrf8`t{|EO`!Brl)so09x@4G-2J>{H6Rjhf6rlB7_ z<-94h~JA6SipJu6nE}^^K|XK7;n{wmYry`rC@(h+4WB~WI6T*SsHMjI?{ICe)Dm)D{|>j z*HuFuYIh5}%VZO~Rc8)3h41Sv-9TFv%IXcYa!@uSkvTWWPa7yquT0#i+Vv)xyOGgp zyH!?fbUsY`#y+dO3gm)k86AXu)_Fe7z5Q9@?Ug=u+HE}U{UDLjmaH|%-dfdAt7O!3q}D5opHr1{zdZ1q^Dc%$?DIG^ z%arHop6#;odAfMo)ggbKuvs*=@p z&Jm+}aXUk~-Czx{WUzzXj*sN6I_K$A(|8+K1yQY^soOKjP42KKXnPL!R5%^G?_(Le z$vJIg29JA>SNks>TH(2Ns6%zla`xxQ(oIwWsc#BRUAs5YlC;r_6tO_&yhv?1+U2$v z88lftWbKQzWX3MphB77ez399t+Q)Cqd#SD z!|uU;zOqsuD+r=u@4@cF{<*S;hUDc#>mqK58S0uf)N!#haw){{yGRXk6;FJ;ZImrY z0Or=CKeZ#3eD_M?Kb^y)GeP%{GUK1lx%PE%gRJ_ebF{q?Y?lrHbWTp_QP!XKo0C-( zs+MoCYB`E#X_dXoI|=NR*q5DWM(2W#pJndL#8(UZWzEaZ$$*9+y zE9|v!yR3Q5d5*mYY?d8hbTad;W15Wmmvd}PHtgYH{G1_j0L6RwsM^MH!R91{vAtoMm4I=E=fFidzF#%j!lPTEJ#`6^z~o zdgjPijn1j|Wa9D5$k%bs4dEPx+7VE#86C;*f+3df>kp8 z4d<-rO3;-hcfaAh+};B>$c{JYHO2(4)JfkPlsXf1{7z=P>Ab*R3HQp%H=S45d%!B$ z@uu?{d*-PspVOPjMG+X3#ZAr|>|J1mY;Phx!>eZTz9!YHz;>ClS@kNAF1Xn_Yy3XY z!wUqzQ?;cht3Pqbn#phpHPb{@KM`-yd6K~#T&a+wKjktTdx1<*F1er|m)N5Yw$K<| z7IInmma1j2PFCY>Zv>lV!&{WP0}RSma7;hw=2eF9!sAliN8=`uQ@=$1+c`EN9WKOY zh)RcktVCrc8+(Dw{5O#=0n02b1*=1tunue>pk0N~KSr{RuaA+d_5XH`9^VGK79TKY zsNJ)NdakE7<~!$vCMcE0KK7@`ZqkT082#SGa)>P1Q{g;G+~OR5ZYG#R46{@Wp&2Ps z9sff=6~hwtm$9FAJo;1iQtWgcI@z z{I=@TV1w*Y7z2@d`KXzh zWgpxr5nCyek-`Wfm~l*z(%~fRtukdRLpC3D{aJ3?N{=X4?y_bp1*r$ALn5)afIiuw ztouN+yp1U$orcblIol}dGLVtJjs8^*I_{FS+nl4KYb|~azOg052Tax}q3*9br)v2w z?5?|x_6Uz!8Yp`|b~pAI<*$Fr9>+3O`5$XnZIq0ibZ5Nh9F>p>2k$&!o)8X*rt&Wz zd#@~gj~uT9(`3VYv`r)EmEG@A&^FK$!m&M|o7X0et+-6$h&q$>v8x5ek2KEo7U#H_ zY>YNuLAonac2ycla&HThehtPH-bXUEaVN$h`!II?^?+F~_V;;5HlA!1%Eb4b^P-o4 zzWZdw`!qu(+$-zfCwKK=r)+*-H3QggVHe0D8*6mGvfdXecw+on42}B^m~_X`Jm9A? z>HoG=?48&T%7q^|PqpW>Stm=#4F)_W{}Y0eRU6)8ZdGN1qor zjkq4vBb+HrO*0odRa(|mmdbt)`%h8^_NzALkYdZk?&VMSen@o7;7(adbkUW{y;7d| zkYhy$+%0=PREM6kmB*A;JZ6KgHF9~Yb8Pey*uO?rv~p0Zf$L-wF7_>8uWWCnuXljm zYj|bGO5Sq?$*ZohFXR%j-8uTIxHPuc>Jo$&au+jO;>RzJf2r*Eu>aVeqwJa3-Pl!h z;h(D5{E)xgw%s`?p%N~5?0|Vr*a20guf<*^uWo1bw1E|}dpj$IIL@2vB=I8-ZTVoe zEd7WkE&>CxN?BXLGTHGF-D@A1@jT0iNO{9)jFX8U(?+wI?6d0R@{gT!qbuQ*7v+hM zso+MqS+;&mC*KD)NkkhF8{~@RL!0x=F|)y}mk*djkIAPhOD=Zb%W`v@b5e9Uob$4* zZ6m^ZxJfp*k!AyLsQD5{yymb$jFOh zhRS`PI%5+maVp>yG?r>df1&2ZUM8=8s+t#UlHH$D^~QOsc1C{Y99NtQ=Do|uL5>Eq za+!%e=YQDqv1eib^_ry!yC3_p>i|{SN*({NkB7BZ{PM5QoD=OGY?R4m?aqrOrQI2o zkbFL4rTO^CRQ=D!-l_cNjjseVwjMCos(jD=>!5q0GDDXi?xD4EG1ar5e$no{W17jtM(^=Y*5Zy zK-QT%nQ-GSAWlv`KWB1DhYLTJxu4^`1ZHjgIZKUlF!=HD3j)<)YOr(e@wszyOdFWe zcEEfjLLIE*C9;Dkl2}HOr4Ekq*|o%PgF)U6j6J3-q1dq7K9v_$$TpZRgnP6x zoAKB#qrPyCvM0l=SH56gC<2>h)fXJO8$tKyvh54!+yvu7dK2&e1&)baRbUeKUYW9s zBSkvs_(JCHV)T~7WwK_M^PGehF!1H^qbQY-UD&H-?=G?ue-W+IDU-e=hnX-du`e-~ zf+@S@fiInl>^&iKALb!R7t?{iI$)kGkM44gmaI-^a?CPp9^NACwaH_nLq%j?E+Mxs1Wl`;i$+nOG zG7d@Pf5^e?`JsXQA9_qBSR(8H!y&R3EHwGsL&wCfLTzsF1y^1F4;BV&U7VLiPNh+xR zsi0lhOJpxWhooLgliKOIYDmeb|%_Ov9V6+ro|gUZ?tUdc8(g;0sEp4nx}@N zLRHNBu;)cf5Q;vU!l75!XDBr z0{tm+Zx7Q<4Q!htFZMX6Mt8uzDe^6LdsH?hmg(O+Pmz@Gol()rZ0GPdyS`^%He4bL zzbA!quvyl8&pcKSR>nMK<`ri}0D-aTMY`o5>p)2~z+oAU#{`5>+G1O2rg%(zJ2 z`oTGNS_ka7_@GHu9sR{Y`;-rM8sz9twUBWYwREwJ`jG`kF6_;en}1}TTMDPlKWKh1 zM8=e}I(e04vAqpro$UUR88C`tJy(8usf%RLeT~fMbuNmjgj0Cma8-o0sM*@fjMk4a zXOYD0rS{WvNMo_g-Aj7qu>V$ByO;Fp;jDs#=6FNyde)dAJ$s#=^P(0I8!rQ1qq1zB zzb>#=71qHviTwraAAPh)Eb8EN?1e=#_a`-I;h?PfiQ4M`1G48QvJ`(ceZ5pB{me{K z3YW<0pD9&6*eaWUrq)})cG>YWZP5eL06$X$ab%@c68AaBC8UGR_y2Y*WMglVh5LwO z3D_XZ_Yp@q$mF(fcZtzbeASjOjvhaXdbWH^fBYlXz_=TMXiX04_{Bjl1wW4zq5 z-#I;c9mcc=WaECi(iXT*w(ob&n-+I1^;O9`k;g=*8b2Ak7yI~Q>}o*G#-33rmmeUS zC2&BNA8_7c?*Li0A8?L4E9yFi+`|X0Ys0@A>f%CbXfYO#y%2k7h+guGJr#R}%sfcp zGeHh12c0)W*Mlil^439)G+i(!IR~BR#3Wr$(bgU`{~o0-ppBCSL0YC9W8q`6Hpn^i z7C7apgXX|sby}7v2ZPS>_P9LN@e});^CskjF5bmltY-UA{}_}Pp*u(_rc(Cjy&wHW zoe$Xa^FzaUKn-Ki_MW^oK+qo8(ISTiIN>&a&z#aCqmDQ)h|Y$yK9EI6=-D+e=SxSZ z>qf9$wjSX))(}$Iu%aolnWw^8TMsxg{+J) z&Wx^AF1zJ5<m9rSsZE1ORNRG z-3O0b533=)1-l3P#WMe8XOi?q8snnlZpQYlj2&dmwdcc3hl4PegTC)%?I44T6|nz1 zc@4I=z+BrLWXy_=yM@;1k+D(6SbI9m@-oUebHXw(>j&P9RT&NSr>yXF6FOX1hW5)7 zQN|?u7MN31f<^a({$7c(8;k7uOH|idYBy+4Fz;u1i^EB@@dt`^SZGWx(7{{P=zw#M$hXl{cl@pDP%&|^@#NqwU>38|$AgW_?D2mL z*&W8@giO%y2%5`P5%f>>t9~$RvXX$%Lz9fnjiAE`-Y!mV*IVV;JLN>cNb2g67>(a^4!In>`rqQOiQd zu@k^#uv?~|VBBu60h?sg3C73KMSr3#E|PnP8c)O|{U7Dzb=@@)a@Pb7iVIF8+GQBC z<^;_NQS!kF#=}OL9!Og<-?5Iq8nlFBH1>~7#q_CXYj)Cdrs>BK5{rU zle$7x$IRhmyA*7d)x(XGXWSAq)J>n^iZVC1X0yS?q0olv4UPD9^P=#ma9+?<{;BH%s6B8dD)<6dGP;x&3YO8v)DiSn26OOvmATQa#|C}=)wljnIL zK>mJ`af-bLW2&uT0Rd*ocNij7TGb(r~dx)G~O9$I=vT=(& z{VwJ?nKOa}@Hxore3R}Qo48$p|I0aG54k47-Uql#5c$GVMK_DnD+3)~Eab)dgS zHo6J81@4sXZiZP0*e-kA#$>xuqHyF$RhJ;si^5!xW&GJ*AHvO}Xz-}Jl{I#>svt0@Rc4GfrrPsiuDXsUqqQLSsPKqs z18uy^ygou6ds>}0$J4!*+(Xiz$clKT=|;Frw#FOhOzQ`|yMn(tmxwE+17LR(mAdVr zF8HaIO2+QpB{LGJglxD#7A8=}B9ObH3Tr^x2P|#@-MkZhqKZWSRJZKH?o#hchmEMR z_hWZpxBto>_ZJMr`T{N>v*lsxLMYJ!YC#h7WeWERfX-YeUvo$1)B&KyC~vYt+3eiP&+*@aTBZ+bfgC z(Q&ik3RyS~k0P*JR*f_6vm5t?=AtAuM}t9`o@9I;ZImi=I$1cLqAmdo zW%+of(R$EzP~K7={cyJonP5zgPX0U9*e^3Cu(DbLJC4YT3C2$``S;VeBlu)22aq)e z)5@vF8TNXNSrY3tCdqfF8i_Gc{~*pmeddV~a%4A8H=N@&67AU-TVj(b!-8-;5?DZr5@z@uD2!{V~acBv{8M(xemS$d&>W?8>^|d z|6xzU?)e|~bnNc`Vb8|y8r65vZxUX@4#)opP>S95KkVzU2PI+>ZBP&PhVb$huzO^m zIZ1alC8~3F=~$*JL+((Qy0xb4{n%BplC@o}V9FWaaSt$kV|T`c&Ng1Tc(U>P2z$+g zs?%;troXg+Jcg5O3_q(2^o;8>&r)&dUnp+uKI|+Sj{cNAu2S`$#M2D!UW4tp96QRD z%WUkeav3i6T##;lnlbCF8ZhJ3KJx+<-EG$07vV7u(~Z#ynP7vLm!pqyUq-d$V{d(B>FLJp5z!qF(}Pmv z+cOwQaiWehi7E8Ae6U28rjYd_u*||rup)#BwP4j*eb%jX9ly%$7VKQ1QUN(U z5XM(A+f0*5Q#c^z!riiXiZOXwxx%yi%!$WjP(@OMoex+XH=QyRZH?F+X|ipKac^|y z8hD0WJ=K_$Py|<<+jrchcr`s$VrKz9l^nEzc^Ar8Q^`TxT6F+SJkuC{ZZg>J>oXbA z{8{j!73!c6&%fE&v*z@fs>4~!=s80@k$(v-hg2`iXFrSYGmXhHm7r~2pLx(8T3^{K z1`YZqO7=eIJW2j>hhZP08mkK*9uPT`0iOB@L-R_xAk~Dda*c(F*Tc^=wIzaEDzT+-D#*?Fc*s~^Z-(r(<7+y+l@?ZJZNR4|;yzXV&X` zXnW3P#g+LuV^9{PQSu^?%j#)rkqxr)NTcLkplh-Gl*U0WwOUok%;|V61M_6%bYtF_ zEuiZUedaWh<9L^{l&V%qcVJKZgM2%kc|CqTe5*{F!Ab5CICxv%ahF%sP%Fi5yImfb z!BDG(bL7<-#tmcQo*?==_zVbp!#@>$GIqxuGUFV&-4d9C%sCuS8eB0 z!(Jh~&*2Ey1G08KbPkOf|D-wwPE6-`nGI&iLWSiZhuL)6wI1X$V>%Vo1#&weoi$&6 zjcVQu>-6B5 z^ruPd?|OEm`qYA3je~6LuKQ)t`7D-8;S|0+QqBcNb#3RB^NsQLHjD+b`+U`Zp9%Hf z3}(!9uz4-6$CO`HS9Zu{VFqni31-Rq43*=Mb+5wIK&WwNlKE0Fh3|&+%J(ykaYIz& z)MM(E&1~8`z@Y4zN!g7Js>_VLfOF||u#8WF%=mS>*jWl(pwb0fW&Hv)Aw$@%uZ1pgA8!_9XUQii|_2HZhvI6sAEdmQ=6*!~? zY~J2yPLS6hagMO}ut|5rKPIk@s%+yxXSbf-m@~(?!d{87Q`XO6&Q*U`-m|06oTF!n zzBww;CXAmm#CaY^owi>**BCz`AERrRo?=7SL$2h8=UnGSdi69cEE+QCzIsj>O<4+ zd}CHZF4+BZ-_fVD)L}y%)N}^vkcCVm6xfK zfLXHnGGguk+hvc!s8^Lk?B&Fq4OYv-%dr-LoH;6M3&;Re)_q`}L|j2hjMr!=KAtj0 zl|=vI&?M{?G6ffVx^j^@R~YkVmV?15d_6zxipKM=2D^<@!7G>tbbtXq*OH*p zqVCm$`YI3mu-8e%mBbg<7#jFjQd!v{TzI9b3y^W99M*w6TYM$$6#u%K3nyM>ycE+0 zrd-9hIug~zv&6ykhW17bx^swRoNTz|k~AaQp7e$~EKm6zEtw5g$im;zW<{WTrQG{F zW~dgJRmSgFL?pk-lp@n}NIDzjeu=^&uuN9vFnrs>j^gb$wu4d51y`|bG@frqQCYU1&t|6mKK))=% zhHO-V6|(*sV(S7KFbY%ut!is#E)i#fg|Z-51p}*OIharmHq;;b%@v6n>|FI%0UN=9 z?9DY!2_4V6*d+E`YTejEt^ZR-T}zE*!hTtBEg38YIdfFl2zJZXYsrf7wyMdI*D*Ke zg5G!J=IdBSl*47R2D7~bY?eLOaZEJcp?<&MyFRMU^e;3fu+#e2vr0|}8*sTQydRC{ zUp98zu0v+FvWMP$2|apJL>~<;XO^*_VN4YEautQFxt;_Y!NUI>GA|#jf>}S6U>kOB zkm5bI2W;MlOJvxA+Y4aSyUdLT51BPK8B=78mMM8u@obDGa+$(>uuhid(G`k7|KUUC zmEj#jT-M`auLW7Z<H=+Tves{mO)x&7G;P0iPr}am+D)nmAa_!3B2(p{ zgKxV0CUWdH>=)auOnr0{cSE``x_0SgKBTwqIzC_$VUn<_Eb1eW-i7f6J*9)j7K>b+;4f*!x^$!d9;9OvO{?o z+o`BSIu1BRX5LI!%mleLcJJ~LA!eo4j3JR8u4hLm}G?%C} zLDEz%MjHv8V!4b-Wy8bga9qdq!DKiSyW1mI|ACX6A~=}XZ*Gl{>;7O&u-CH9)1rS+ za|h^`J%3=d#eEVwblgfON(T#1??3KhxSGPULoN$%rL>hGCuPdJ5zOJkJI7{0dADKD zlHGVm$9+mJ&ygo?rOTzm?diXD&&J*=3;(Dh2UBGIA64XF_w3`nRnKX|&O!_qdq0>X zLkdVI{WDt6CvyuJv!!r~tS-Q#77WO%3fsUE*z1?y#p)UxM9zr4_Ui?v?cfwbz2(^6FA@(xW`CmP1Qv-sBx>%9wr|$!CL| zvQS|Wm?Ntc)_}dTNns1fiWiLD2YPOj$lJ+Z{7%(Q6K}_3HdrT@DO>{b7@@*Skn=5t zjUd;)6?TCcviElK)(@u1kY!YF`sb=T=77;fpu0%!UBQh2GhvpYSe;NvS2xtwG3>PmCB(!Xd*t=GCDmJ>P zzDH!#ood#Bn`ObBge(VHUEQfxS73we0TYtHA$u?NTQ_mJ_m#)mNVUvt>`ijnU3gc5 z1+xAwHB!Nbe;(g5p?1X1+F5xg{YUkxDaCkaf`zaA);k|N2h3u;>p|via7fgD>0tcz z@(U!Ph=bmg67FhbE8A+U{r5)8F}_=sdE!d;&IVa} zDO>`k$@-PXa4BDDxa^f|Go;n7Mlc{-6?TDnvR9$8hhZZ#?o>Yz1UVLsR?OaDT;|Y6&4suIb z;WCi?g3-00_rLPmUyZRt+F(yN#~(TOZ^kJS^*3tF_(3Hx@^37BlR<73{f$uhAkWZ@ z`WuUyQke5g%=Si*bIQMQ!0G|3qz@b%|0A>CUPkve=g7h7$86Yh)rKrCBl4nOa9s#D zC~IQ~w<_!iVZ%PlntJ#_v@PKJi{oBlE#LS$Z!6 zq#O)Js!x;s@{0p&uyd@qm;5$@oHeO{Q9p&|>-&r=5^}+SbHF_JmvEsIo@LmX-tHsC z%3rYl7i_J&mt~wRiE1MN|fK{?bVbne~t;GJFp`Q(M#`1Rxxdh}%z`xV>>%cPE@ONYM;6||f zSgJM_jaWyZ+C{d(hBHtg~HRSiwNpR?q2&^tor-fv7gcM0qsIdI%fuXwUpirs}> z6*YWu#B;|`*KC?R6;loSGi1~Kbjc2|O!nNb@_j&6Z0tX1v}7=c@6DyC2(Gm5OsmLd zW9Qz*Kh%r~R>=B)a6u#Ppla>J3eGEMgRZ0j^GOwO_Rze@$E>HFbFl|xaRmWuL7!}| zpiZ`coQf&z0Mjho2c}qP1SzbANubBVbkH5bG1;JN{J?KsLtKL0FYplPqZM}BYA&uAeW4@l1M0{Ix+lxk53s~o2Rlxejc`H_+RXOBlv2KOkYcy*mp-AE4f#aSo z3so5QI$8gysxXixzlx&`Op)DSbU)}`A~BCq2T68ip7Iz8E(3dIChSUQZ48fE+s4GbWRV@JXR3 zWyTYDWW&t0Ptaa%V5{tYf}R`|qjDYlB$bv7dK+ZMliaP&h1(kjj(eIXnM^Ii&cWqL zLe_vhqVOagzY#2K957jc9{s6~--bQwbv^Vi9@-iic`bD|+o=w%Dz<&>XNg=xY)MYl zG*c92gRQc#hT2;O7RbsP>U14gC>wByZUNoz$j%yd0%NFfu}>Mp6XQX?k9gc2_FPg) z#cty>iRJRe@3?Gy?Ni42(<-s0@M*+j=Qh=|YO#B<4~N4)HRo*!`O8O7(O_{WsH#qU znkLN$D`e@@bi^XCN;W-BR%<}6!GO^%p!Yr5`7{l%FXSBY481RzPeOX%ml@Bfc7gL` z;WMhZAWfvO5^R$73hO}@77E+IPT8%ZFixZce;}g*^pr><3k>NAbMUUZd)Tvk74oE_7;%Bq`+ zRS&L@7&GgIrkK$7wXa)RueX1%w;S~K8(QDe`mWaZn_?b}wU00UL~sA?O)H+q=Q~63 zKJvb`y+iNcrS)^Yze{g-Yc0{?pVsPav%+U-E!0}Awb@d6=6PdNWYcGI`3u}kFL}Xm zPqvE55op+u5LRDmXTZmf9q-&N!vmR&E7L z`J1J-8?D`WS6f=Q!m<|((e_1Jud}q^EK9@LOS#qZcja4JeVwHlIa;$U?OhTIXN1Gq zJZBCe-zOIjK0dyT^DTed3`;%JEOlLIY3CG6dr#GN^?|Tsew|lY+bLRGuh84Sv$QVL z(yR+DEiO@i*O?!kH}t#RvLD^P^HFs>IU7#B@W4YBaQnIXc>a?HV^1IqrpaW#+9a(EE z$C78PfK57rigDVmx4X5!l`WQ$VbEG4OY4mhvkGi?VdMl3T25&8xEP#jV?{>L^%bb%u-;)^_V|D+3MT4CxqyzuL~Lv;3-Ctb|*m zba?HTRb&;=cBhrFj>eYpL#RHAZMJc`q#afblyq3zIpG{}PX)?3>J3$2Q74rPFr$T-PLuxXCfnLQurPHwjxv$C!IuIH?b zHtURZo}(wO;nseS&Pc1S5!)kH_|8kM{q5Rb-Dbs;_Xhh(-&Wz*8F)h9f=5_Jysjx3v%Kp>pc)@0_( zlP0@fwCv%SJr7$oW?N?2t98wk)rI^=P0+{FX<9GRdR5UYi(WIXQrUWCXOr<)qd56m zYfblS4cF+KA6UI?<7<|V()w?0Z`S&O);6s>wSKq2ivJ3|Htf{)Z!9ggy{;Wr=*4M| zcKAuFZH^T|P;Z-IyRM6dn6oU>TBy~n)uXjQYl+kHFAFJgm+2jxcYnZyKY0c7_qqS3Ox246lUTyGet=4MO8Fy)QYxQXLY7J=rCauj{ zTeUj0y0rRqxU7)M{T~=H#eQwe(^{dmN^7;&fYvzHQWI<$uS?W3Pty{J}eqt^Ge zwp&_k`;RsZXpQZ#0w!qvFB7T32fgXx*gsO|74Wlv$xm8-CP! zSZmZ5R>CJ}9ijC!tru#&R_kJ|cWQlDYpvFowYF*fuTnKD9n=QrE-S&&T9dTS(0ZxX z-)mi=wOs4tTK}o_4Xy8J{ZQ);t$WY})n0qG;gD7}WsT?GY0OBc6uSnjnJ0X7@?2>h zMDp~}CcHxR=h zo+86*%7PQMeW<0?hNZoFifz*2@`hRV@Z8?JQ%}iyXYk}50tyx+#w5Dhcm$dUftE5>+tQz;o!ZzcS$(_2K zDc4)+XWe0G${#HapYyQbQU}#}CA!=NI+|8pFX4q##u-+))>KO~bXUw9WNo{mEG_7c zA-)l>jQzwI6M4>S+pY2XqSiOHM(6`zl-BV6!Fqeo2i8TG@PRl++lOfl+i%dv%MsfC zjUJwk53O_)w0*4Bn=-BAr&n*Ep>?{}tFO2ApKoo)^I3PxuqW5j%k=iF`Oa6CZZ^J& zI44J2uF-m(R>nl=m#?>9dc(@nV!d53-x<2D^pW1aL+krmi?o(#E!FyhUUQV`?SE)} zP-|w3l}`Bj(;98B()yUzM=edZJ*f>(XnjWO^IBij`Z5`&r`&Sa>sA7d+Wv2?&01-@ zP{BL8EN#*D?OH$8x>M_yTK}W zuF>bcdfTD5U0U5*JzBk%7TZ#^Ax&$JjvzyC@4U|H8{ccS=}t6E>jbScw9eOhz1G{c z-lMfi>-`~3x7pTcLqO|GTHn_CiPk+@f6{v7dO6f#?Swii)UdS^5C8JQ^fI=;fk%+r`KWShT~Vp z8N#l4M#@wWca^m-tm|Y0L1G*96}N_3Bb15w2RB8Gc=&6>9TUD**H$ZI zzc!}DhPT_br$c#439hl>%XXc|?P^lHx^?{B$L@N#%Ww~|J*VqY61%wg%{fmf17&rx zsLPlZ6L`_u4)E#_+efeG6})O?lsn{Is+#pBE2{Y$8pESc@jM-tmqQj~9unTX`N2&* lSJU{7ku>Pu4&%Y=?I%6hWJF0nhM2WFh%-XI{n8lo{{XS!&5!^9 diff --git a/src/pykx/lib/4-1-libs/l64arm/libq.so b/src/pykx/lib/4-1-libs/l64arm/libq.so index 8eaf7eaa8e62029c89b8ff4854cccff7f3390657..bcc4b108df8d39b29ba3f8218d6a92b57268f727 100755 GIT binary patch delta 206474 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%0Ay-bz1Nas0j2lDJg9eD9`R>DW#lj91u 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