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 3ad3bd9..ed3e281 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": [ @@ -857,7 +867,7 @@ }, { "cell_type": "markdown", - "id": "07e31d96", + "id": "a3945130", "metadata": {}, "source": [ "**Examples:**\n", @@ -868,7 +878,7 @@ { "cell_type": "code", "execution_count": null, - "id": "f8108853", + "id": "1f83db52", "metadata": { "scrolled": true }, @@ -879,7 +889,7 @@ }, { "cell_type": "markdown", - "id": "30c429f4", + "id": "72b468a1", "metadata": {}, "source": [ "Get the first 5 rows from a table." @@ -888,7 +898,7 @@ { "cell_type": "code", "execution_count": null, - "id": "2f817967", + "id": "5354ca81", "metadata": {}, "outputs": [], "source": [ @@ -897,7 +907,7 @@ }, { "cell_type": "markdown", - "id": "2eb41e47", + "id": "9295eddc", "metadata": {}, "source": [ "Get all rows of the table where the `y` column is equal to `AAPL`." @@ -906,7 +916,7 @@ { "cell_type": "code", "execution_count": null, - "id": "69e14007", + "id": "6410e870", "metadata": { "scrolled": true }, @@ -917,7 +927,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." @@ -926,7 +936,7 @@ { "cell_type": "code", "execution_count": null, - "id": "323cc0f8", + "id": "d61b8396", "metadata": {}, "outputs": [], "source": [ @@ -935,7 +945,7 @@ }, { "cell_type": "markdown", - "id": "9de566f3", + "id": "4525b646", "metadata": {}, "source": [ "Replace all null values in the column `v` with the value `-100`." @@ -944,7 +954,7 @@ { "cell_type": "code", "execution_count": null, - "id": "be66947d", + "id": "b65e7a05", "metadata": {}, "outputs": [], "source": [ @@ -954,7 +964,7 @@ }, { "cell_type": "markdown", - "id": "ed37aa73", + "id": "dc97669c", "metadata": {}, "source": [ "### Table.loc[]\n", @@ -990,7 +1000,7 @@ }, { "cell_type": "markdown", - "id": "c68e21f1", + "id": "f90efe27", "metadata": {}, "source": [ "**Examples:**\n", @@ -1001,7 +1011,7 @@ { "cell_type": "code", "execution_count": null, - "id": "e46092cc", + "id": "20974780", "metadata": { "scrolled": true }, @@ -1012,7 +1022,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`" @@ -1021,7 +1031,7 @@ { "cell_type": "code", "execution_count": null, - "id": "52d2f0fe", + "id": "e99478b5", "metadata": {}, "outputs": [], "source": [ @@ -1030,7 +1040,7 @@ }, { "cell_type": "markdown", - "id": "52c058a6", + "id": "5300666e", "metadata": {}, "source": [ "Replace all null values in the column `v` with the value `-100`." @@ -1039,19 +1049,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." @@ -1060,17 +1070,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." @@ -1079,26 +1089,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", @@ -1131,21 +1141,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", @@ -1156,7 +1171,7 @@ { "cell_type": "code", "execution_count": null, - "id": "9dde77b1", + "id": "ebfeeec5", "metadata": {}, "outputs": [], "source": [ @@ -1165,7 +1180,7 @@ }, { "cell_type": "markdown", - "id": "1d14afe9", + "id": "d3150483", "metadata": {}, "source": [ "Sample 10% of the rows." @@ -1174,7 +1189,7 @@ { "cell_type": "code", "execution_count": null, - "id": "32772c46", + "id": "67844a62", "metadata": {}, "outputs": [], "source": [ @@ -1183,7 +1198,7 @@ }, { "cell_type": "markdown", - "id": "82a7a79d", + "id": "dce42092", "metadata": {}, "source": [ "Sample 10% of the rows and allow the same row to be sampled twice." @@ -1192,7 +1207,7 @@ { "cell_type": "code", "execution_count": null, - "id": "4c96839b", + "id": "1a2326fd", "metadata": {}, "outputs": [], "source": [ @@ -1201,7 +1216,7 @@ }, { "cell_type": "markdown", - "id": "82b501a6", + "id": "7d42cde9", "metadata": {}, "source": [ "### Table.select_dtypes()\n", @@ -1238,7 +1253,7 @@ }, { "cell_type": "markdown", - "id": "0570165c", + "id": "bb6fc886", "metadata": {}, "source": [ "**Examples:**\n", @@ -1249,16 +1264,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" @@ -1267,7 +1287,7 @@ { "cell_type": "code", "execution_count": null, - "id": "e8a792da", + "id": "de81564b", "metadata": {}, "outputs": [], "source": [ @@ -1276,7 +1296,7 @@ }, { "cell_type": "markdown", - "id": "c87f28c4", + "id": "1e842cc3", "metadata": {}, "source": [ "Include a list of column types" @@ -1285,7 +1305,7 @@ { "cell_type": "code", "execution_count": null, - "id": "ac2af334", + "id": "ba874cb6", "metadata": {}, "outputs": [], "source": [ @@ -1294,7 +1314,7 @@ }, { "cell_type": "markdown", - "id": "ede98735", + "id": "5bb4eaa2", "metadata": {}, "source": [ "### Table.tail()\n", @@ -1320,7 +1340,7 @@ }, { "cell_type": "markdown", - "id": "a7b6bd44", + "id": "2c9de3b3", "metadata": {}, "source": [ "**Examples:**\n", @@ -1331,7 +1351,7 @@ { "cell_type": "code", "execution_count": null, - "id": "d1f5f644", + "id": "5c31fc24", "metadata": {}, "outputs": [], "source": [ @@ -1340,7 +1360,7 @@ }, { "cell_type": "markdown", - "id": "181a4d86", + "id": "5ad81954", "metadata": {}, "source": [ "Return the last 10 rows of the table." @@ -1349,7 +1369,7 @@ { "cell_type": "code", "execution_count": null, - "id": "c8a0bb7b", + "id": "02974f05", "metadata": {}, "outputs": [], "source": [ @@ -1358,7 +1378,7 @@ }, { "cell_type": "markdown", - "id": "32d2194b-fe6e-4789-9437-fa8cec5f9287", + "id": "a2edb648", "metadata": {}, "source": [ "## Sorting" @@ -1366,7 +1386,7 @@ }, { "cell_type": "markdown", - "id": "38d04a7b-603d-4ecb-afb0-c7999b6d23ec", + "id": "ee65b6ab", "metadata": {}, "source": [ "### Table.sort_values()\n", @@ -1394,7 +1414,7 @@ }, { "cell_type": "markdown", - "id": "b71e942a-1247-4931-9a0f-edd2fd97b185", + "id": "6b4c5b68", "metadata": {}, "source": [ "**Examples:**" @@ -1403,17 +1423,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" @@ -1422,7 +1445,7 @@ { "cell_type": "code", "execution_count": null, - "id": "fce9c74a-ed0b-4d2f-92f4-2b9b42762d4b", + "id": "08eb698c", "metadata": {}, "outputs": [], "source": [ @@ -1431,7 +1454,7 @@ }, { "cell_type": "markdown", - "id": "6ee86878-634f-4383-bb90-af361b785f59", + "id": "4a48687d", "metadata": {}, "source": [ "Sort a Table by the third column in descending order" @@ -1440,7 +1463,7 @@ { "cell_type": "code", "execution_count": null, - "id": "f8edac0a-f6f0-4a70-ae51-7c8599ee4da9", + "id": "4ba2b42f", "metadata": {}, "outputs": [], "source": [ @@ -1449,7 +1472,7 @@ }, { "cell_type": "markdown", - "id": "2b61d8b5-52a1-4c05-9347-c205ba6934d7", + "id": "29930425", "metadata": {}, "source": [ "### Table.nsmallest()\n", @@ -1480,7 +1503,7 @@ }, { "cell_type": "markdown", - "id": "c2430479-e832-4c6a-8cc0-651dd6af57b4", + "id": "64976edc", "metadata": {}, "source": [ "**Examples:**\n", @@ -1491,17 +1514,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" @@ -1510,7 +1536,7 @@ { "cell_type": "code", "execution_count": null, - "id": "287c6905-d508-441b-887b-b71233e1d133", + "id": "5f2e6e8b", "metadata": {}, "outputs": [], "source": [ @@ -1519,7 +1545,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" @@ -1528,7 +1554,7 @@ { "cell_type": "code", "execution_count": null, - "id": "1772dd9b-389e-4da2-8994-245cfaa6d942", + "id": "039083ba", "metadata": {}, "outputs": [], "source": [ @@ -1537,7 +1563,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" @@ -1546,7 +1572,7 @@ { "cell_type": "code", "execution_count": null, - "id": "425a2841-610f-4cb2-9703-105ea14ac900", + "id": "eb02553b", "metadata": {}, "outputs": [], "source": [ @@ -1555,7 +1581,7 @@ }, { "cell_type": "markdown", - "id": "64ee5a21-7234-40f1-b720-e176740f4fc4", + "id": "fbb4e07f", "metadata": {}, "source": [ "### Table.nlargest()\n", @@ -1586,7 +1612,7 @@ }, { "cell_type": "markdown", - "id": "66b7c0a9-3d23-47c9-af79-8020c52d32e2", + "id": "394bdd98", "metadata": {}, "source": [ "**Examples:**\n", @@ -1597,17 +1623,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" @@ -1616,7 +1645,7 @@ { "cell_type": "code", "execution_count": null, - "id": "88fa3ff8-4e31-4006-aec2-c697390e2b29", + "id": "c7c6363a", "metadata": {}, "outputs": [], "source": [ @@ -1625,7 +1654,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" @@ -1634,7 +1663,7 @@ { "cell_type": "code", "execution_count": null, - "id": "81647d24-282a-48ee-bf75-d08838211e94", + "id": "9162934a", "metadata": {}, "outputs": [], "source": [ @@ -1643,7 +1672,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" @@ -1652,7 +1681,7 @@ { "cell_type": "code", "execution_count": null, - "id": "c898e01e-60ef-4763-9728-2e215962f393", + "id": "f0bc8991", "metadata": {}, "outputs": [], "source": [ @@ -1661,7 +1690,7 @@ }, { "cell_type": "markdown", - "id": "ed1a193f-b02f-4af3-bdf2-acf46d374901", + "id": "ffc7e449", "metadata": {}, "source": [ "## Data Joins/Merging" @@ -1669,7 +1698,7 @@ }, { "cell_type": "markdown", - "id": "ef401426", + "id": "6a4c9fc9", "metadata": {}, "source": [ "### Table.merge()\n", @@ -1721,7 +1750,7 @@ }, { "cell_type": "markdown", - "id": "61d1567a", + "id": "3fbf575d", "metadata": {}, "source": [ "**Examples:**\n", @@ -1732,7 +1761,7 @@ { "cell_type": "code", "execution_count": null, - "id": "8a9acd51", + "id": "0f5f134f", "metadata": { "scrolled": true }, @@ -1745,7 +1774,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." @@ -1754,7 +1783,7 @@ { "cell_type": "code", "execution_count": null, - "id": "23685dcb", + "id": "86b35497", "metadata": {}, "outputs": [], "source": [ @@ -1763,7 +1792,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." @@ -1772,7 +1801,7 @@ { "cell_type": "code", "execution_count": null, - "id": "b5d16312", + "id": "a6326a4c", "metadata": { "scrolled": true }, @@ -1787,7 +1816,7 @@ { "cell_type": "code", "execution_count": null, - "id": "793df3f3", + "id": "9d56ecee", "metadata": {}, "outputs": [], "source": [ @@ -1797,7 +1826,7 @@ }, { "cell_type": "markdown", - "id": "d58a52a3", + "id": "c97d6764", "metadata": {}, "source": [ "Merge tab1 and tab2 on the `a` column using an inner join." @@ -1806,7 +1835,7 @@ { "cell_type": "code", "execution_count": null, - "id": "1180e6f4", + "id": "756423a2", "metadata": { "scrolled": true }, @@ -1817,7 +1846,7 @@ }, { "cell_type": "markdown", - "id": "b14e36da", + "id": "cad8a08e", "metadata": {}, "source": [ "Merge tab1 and tab2 on the `a` column using a left join." @@ -1826,7 +1855,7 @@ { "cell_type": "code", "execution_count": null, - "id": "4b0098da", + "id": "e3511b35", "metadata": {}, "outputs": [], "source": [ @@ -1835,7 +1864,7 @@ }, { "cell_type": "markdown", - "id": "00d0ad6a", + "id": "cba56e88", "metadata": {}, "source": [ "Merge tab1 and tab2 using a cross join." @@ -1844,7 +1873,7 @@ { "cell_type": "code", "execution_count": null, - "id": "b55be868", + "id": "3d8eb680", "metadata": { "scrolled": true }, @@ -1857,7 +1886,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." @@ -1866,7 +1895,7 @@ { "cell_type": "code", "execution_count": null, - "id": "4d3d70c5-9ad9-45ee-b69f-d855c3f116af", + "id": "1a7fb401", "metadata": {}, "outputs": [], "source": [ @@ -1878,7 +1907,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." @@ -1887,7 +1916,7 @@ { "cell_type": "code", "execution_count": null, - "id": "bf32cdee-0b20-44f9-b0f5-db44be5e8d91", + "id": "bb0c0f70", "metadata": {}, "outputs": [], "source": [ @@ -1898,7 +1927,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." @@ -1907,7 +1936,7 @@ { "cell_type": "code", "execution_count": null, - "id": "03a3e697-8ee8-47ee-9cf9-299e1ebfef61", + "id": "6d71a5e4", "metadata": {}, "outputs": [], "source": [ @@ -1920,7 +1949,7 @@ }, { "cell_type": "markdown", - "id": "7583c015", + "id": "42158c05", "metadata": {}, "source": [ "### Table.merge_asof()\n", @@ -1977,7 +2006,7 @@ }, { "cell_type": "markdown", - "id": "908499df", + "id": "8712f68e", "metadata": {}, "source": [ "**Examples:**\n", @@ -1988,7 +2017,7 @@ { "cell_type": "code", "execution_count": null, - "id": "e660e496", + "id": "16fbf21a", "metadata": {}, "outputs": [], "source": [ @@ -2000,7 +2029,7 @@ { "cell_type": "code", "execution_count": null, - "id": "e456e4ad", + "id": "c8d023aa", "metadata": {}, "outputs": [], "source": [ @@ -2010,7 +2039,7 @@ { "cell_type": "code", "execution_count": null, - "id": "d4616f6d", + "id": "b2f2766b", "metadata": {}, "outputs": [], "source": [ @@ -2019,7 +2048,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." @@ -2028,7 +2057,7 @@ { "cell_type": "code", "execution_count": null, - "id": "3f0fcc13", + "id": "943dd5b1", "metadata": {}, "outputs": [], "source": [ @@ -2074,7 +2103,7 @@ { "cell_type": "code", "execution_count": null, - "id": "b7259913", + "id": "20657aed", "metadata": {}, "outputs": [], "source": [ @@ -2084,7 +2113,7 @@ { "cell_type": "code", "execution_count": null, - "id": "32e41b85", + "id": "a858ec29", "metadata": {}, "outputs": [], "source": [ @@ -2093,7 +2122,7 @@ }, { "cell_type": "markdown", - "id": "04e022a9", + "id": "e6280a9a", "metadata": {}, "source": [ "## Analytic functionality" @@ -2102,19 +2131,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", @@ -2141,7 +2175,7 @@ { "cell_type": "code", "execution_count": null, - "id": "52f27400", + "id": "032c6006", "metadata": { "scrolled": true }, @@ -2152,7 +2186,7 @@ }, { "cell_type": "markdown", - "id": "85d42035", + "id": "d644f8ee", "metadata": {}, "source": [ "### Table.count()\n", @@ -2180,7 +2214,7 @@ { "cell_type": "code", "execution_count": null, - "id": "a53125cb", + "id": "cd70f67c", "metadata": {}, "outputs": [], "source": [ @@ -2189,7 +2223,7 @@ }, { "cell_type": "markdown", - "id": "77a5a83f", + "id": "f8554641", "metadata": {}, "source": [ "### Table.max()\n", @@ -2218,7 +2252,7 @@ { "cell_type": "code", "execution_count": null, - "id": "5aea50f5", + "id": "743d7fb5", "metadata": {}, "outputs": [], "source": [ @@ -2256,7 +2290,7 @@ { "cell_type": "code", "execution_count": null, - "id": "9f13e8a7", + "id": "d730d7e0", "metadata": {}, "outputs": [], "source": [ @@ -2427,7 +2461,7 @@ { "cell_type": "code", "execution_count": null, - "id": "09975a7a", + "id": "4303521e", "metadata": {}, "outputs": [], "source": [ @@ -2436,7 +2470,7 @@ }, { "cell_type": "markdown", - "id": "97920009", + "id": "3fd35bc7", "metadata": {}, "source": [ "### Table.mean()\n", @@ -2463,7 +2497,7 @@ }, { "cell_type": "markdown", - "id": "dee2e8cc", + "id": "4ce8168f", "metadata": {}, "source": [ "**Examples:**\n", @@ -2474,7 +2508,7 @@ { "cell_type": "code", "execution_count": null, - "id": "9d4c8a22", + "id": "50b58aad", "metadata": {}, "outputs": [], "source": [ @@ -2492,7 +2526,7 @@ { "cell_type": "code", "execution_count": null, - "id": "d02c4cfd", + "id": "fc7ab777", "metadata": {}, "outputs": [], "source": [ @@ -2501,7 +2535,7 @@ }, { "cell_type": "markdown", - "id": "c6feb4ea", + "id": "f3b85934", "metadata": {}, "source": [ "Calculate the mean across the rows of a table" @@ -2510,7 +2544,7 @@ { "cell_type": "code", "execution_count": null, - "id": "506a6867", + "id": "8f85e05c", "metadata": {}, "outputs": [], "source": [ @@ -2519,7 +2553,7 @@ }, { "cell_type": "markdown", - "id": "cd714c1b", + "id": "b0eff83a", "metadata": {}, "source": [ "### Table.median()\n", @@ -2546,7 +2580,7 @@ }, { "cell_type": "markdown", - "id": "00d44518", + "id": "80f2f2a1", "metadata": {}, "source": [ "**Examples:**\n", @@ -2557,7 +2591,7 @@ { "cell_type": "code", "execution_count": null, - "id": "df20ecfc", + "id": "46ca7078", "metadata": {}, "outputs": [], "source": [ @@ -2575,7 +2609,7 @@ { "cell_type": "code", "execution_count": null, - "id": "6e9dc5be", + "id": "0bd18f87", "metadata": {}, "outputs": [], "source": [ @@ -2584,7 +2618,7 @@ }, { "cell_type": "markdown", - "id": "585d9d01", + "id": "8312046c", "metadata": {}, "source": [ "Calculate the median across the rows of a table" @@ -2593,7 +2627,7 @@ { "cell_type": "code", "execution_count": null, - "id": "6ccf50df", + "id": "6fd7558c", "metadata": {}, "outputs": [], "source": [ @@ -2602,7 +2636,7 @@ }, { "cell_type": "markdown", - "id": "aeec2045", + "id": "929fe196", "metadata": {}, "source": [ "### Table.mode()\n", @@ -2630,7 +2664,7 @@ }, { "cell_type": "markdown", - "id": "c52ffed8", + "id": "880e64c2", "metadata": {}, "source": [ "**Examples:**\n", @@ -2641,7 +2675,7 @@ { "cell_type": "code", "execution_count": null, - "id": "786fe3b6", + "id": "b0b087e3", "metadata": {}, "outputs": [], "source": [ @@ -2659,7 +2693,7 @@ { "cell_type": "code", "execution_count": null, - "id": "58909ffa", + "id": "19d3a003", "metadata": { "scrolled": true }, @@ -2670,7 +2704,7 @@ }, { "cell_type": "markdown", - "id": "7d437b70", + "id": "85ce92d2", "metadata": {}, "source": [ "Calculate the median across the rows of a table" @@ -2679,7 +2713,7 @@ { "cell_type": "code", "execution_count": null, - "id": "cfa17533", + "id": "3d418ed9", "metadata": {}, "outputs": [], "source": [ @@ -2688,7 +2722,7 @@ }, { "cell_type": "markdown", - "id": "4c270df3", + "id": "097ff9d9", "metadata": {}, "source": [ "Calculate the mode across columns and keep null values." @@ -2697,7 +2731,7 @@ { "cell_type": "code", "execution_count": null, - "id": "80afc141", + "id": "503efd21", "metadata": { "scrolled": true }, @@ -2716,7 +2750,7 @@ { "cell_type": "code", "execution_count": null, - "id": "4e3300f5", + "id": "94f25640", "metadata": {}, "outputs": [], "source": [ @@ -2725,7 +2759,7 @@ }, { "cell_type": "markdown", - "id": "4117c73f", + "id": "7371feb5", "metadata": {}, "source": [ "### Table.prod()\n", @@ -2755,7 +2789,7 @@ { "cell_type": "code", "execution_count": null, - "id": "a6c64b75", + "id": "7852e009", "metadata": { "scrolled": true }, @@ -2763,8 +2797,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" @@ -2773,7 +2812,7 @@ { "cell_type": "code", "execution_count": null, - "id": "540297e2", + "id": "5ced8761", "metadata": {}, "outputs": [], "source": [ @@ -2999,7 +3038,7 @@ { "cell_type": "code", "execution_count": null, - "id": "fc109f0f", + "id": "af65b9ab", "metadata": {}, "outputs": [], "source": [ @@ -3008,7 +3047,7 @@ }, { "cell_type": "markdown", - "id": "22940e03", + "id": "b054645b", "metadata": {}, "source": [ "### Table.std()\n", @@ -3038,7 +3077,7 @@ }, { "cell_type": "markdown", - "id": "292f9c39", + "id": "9a0c1a5d", "metadata": {}, "source": [ "**Examples:**\n", @@ -3049,7 +3088,7 @@ { "cell_type": "code", "execution_count": null, - "id": "f2df159e", + "id": "42c3e6bf", "metadata": {}, "outputs": [], "source": [ @@ -3067,7 +3106,7 @@ { "cell_type": "code", "execution_count": null, - "id": "63d45751", + "id": "947435db", "metadata": {}, "outputs": [], "source": [ @@ -3076,7 +3115,7 @@ }, { "cell_type": "markdown", - "id": "2e9705de", + "id": "463894f1", "metadata": {}, "source": [ "Calculate the std across the rows of a table" @@ -3085,7 +3124,7 @@ { "cell_type": "code", "execution_count": null, - "id": "8edf71a4", + "id": "7d918f6a", "metadata": {}, "outputs": [], "source": [ @@ -3094,7 +3133,7 @@ }, { "cell_type": "markdown", - "id": "1ef61cd5", + "id": "ad38071b", "metadata": {}, "source": [ "Calculate std accross columns with ddof=0:" @@ -3103,7 +3142,7 @@ { "cell_type": "code", "execution_count": null, - "id": "0f66fe87", + "id": "77c7aaa3", "metadata": {}, "outputs": [], "source": [ @@ -3112,7 +3151,7 @@ }, { "cell_type": "markdown", - "id": "c80d90ae", + "id": "5f1e5350", "metadata": {}, "source": [ "## Group By" @@ -3120,7 +3159,7 @@ }, { "cell_type": "markdown", - "id": "2e1d05d5", + "id": "57fe61a2", "metadata": {}, "source": [ "### Table.groupby()\n", @@ -3171,7 +3210,7 @@ { "cell_type": "code", "execution_count": null, - "id": "c0454f7d", + "id": "aa82d895", "metadata": { "scrolled": true }, @@ -3188,7 +3227,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." @@ -3197,7 +3236,7 @@ { "cell_type": "code", "execution_count": null, - "id": "30c55810", + "id": "db5f0dd6", "metadata": { "scrolled": true }, @@ -3208,7 +3247,7 @@ }, { "cell_type": "markdown", - "id": "0e62a99f", + "id": "361019ba", "metadata": {}, "source": [ "Example table with multiple columns to group on." @@ -3217,23 +3256,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." @@ -3242,7 +3281,7 @@ { "cell_type": "code", "execution_count": null, - "id": "c281e305", + "id": "bb9dd53b", "metadata": {}, "outputs": [], "source": [ @@ -3251,7 +3290,7 @@ }, { "cell_type": "markdown", - "id": "e5d04220", + "id": "14dfdd2a", "metadata": {}, "source": [ "Example table with Nulls." @@ -3260,14 +3299,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", @@ -3278,7 +3317,7 @@ }, { "cell_type": "markdown", - "id": "512021d7", + "id": "62e3f5f5", "metadata": {}, "source": [ "Group on column `a` and keep null groups." @@ -3287,7 +3326,7 @@ { "cell_type": "code", "execution_count": null, - "id": "a09a6d3a", + "id": "bcca967d", "metadata": { "scrolled": true }, @@ -3298,7 +3337,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." @@ -3307,7 +3346,7 @@ { "cell_type": "code", "execution_count": null, - "id": "caa2576e", + "id": "c8f9a0b4", "metadata": {}, "outputs": [], "source": [ @@ -3316,7 +3355,7 @@ }, { "cell_type": "markdown", - "id": "660b3c92", + "id": "56cf152e", "metadata": {}, "source": [ "## Apply\n", @@ -3364,7 +3403,7 @@ { "cell_type": "code", "execution_count": null, - "id": "d746cddb", + "id": "0a85caee", "metadata": {}, "outputs": [], "source": [ @@ -3375,7 +3414,7 @@ }, { "cell_type": "markdown", - "id": "54c09d0c", + "id": "e4cddd7b", "metadata": {}, "source": [ "Apply square root on each item within a column" @@ -3384,7 +3423,7 @@ { "cell_type": "code", "execution_count": null, - "id": "f8bbcac7", + "id": "0895f9c5", "metadata": {}, "outputs": [], "source": [ @@ -3393,7 +3432,7 @@ }, { "cell_type": "markdown", - "id": "09a61483", + "id": "47b6ca70", "metadata": {}, "source": [ "Apply a reducing function sum on either axis" @@ -3402,7 +3441,7 @@ { "cell_type": "code", "execution_count": null, - "id": "84b92b9b", + "id": "901a692b", "metadata": {}, "outputs": [], "source": [ @@ -3412,7 +3451,7 @@ { "cell_type": "code", "execution_count": null, - "id": "169d8ed3", + "id": "43ab33ab", "metadata": {}, "outputs": [], "source": [ @@ -3421,7 +3460,7 @@ }, { "cell_type": "markdown", - "id": "ed4d720c", + "id": "c20acb8a", "metadata": {}, "source": [ "## Aggregate\n", @@ -3465,7 +3504,7 @@ { "cell_type": "code", "execution_count": null, - "id": "2696cf42", + "id": "0fd05e6e", "metadata": {}, "outputs": [], "source": [ @@ -3480,7 +3519,7 @@ }, { "cell_type": "markdown", - "id": "3f90677b", + "id": "cecd45f0", "metadata": {}, "source": [ "Aggregate a list of functions over rows" @@ -3489,7 +3528,7 @@ { "cell_type": "code", "execution_count": null, - "id": "861e5787", + "id": "857ff7cf", "metadata": {}, "outputs": [], "source": [ @@ -3498,7 +3537,7 @@ }, { "cell_type": "markdown", - "id": "ccdaee01", + "id": "8bc17135", "metadata": {}, "source": [ "Perform an aggregation using a user specified function" @@ -3507,7 +3546,7 @@ { "cell_type": "code", "execution_count": null, - "id": "b5f9f25b", + "id": "4108f2e5", "metadata": {}, "outputs": [], "source": [ @@ -3519,7 +3558,7 @@ }, { "cell_type": "markdown", - "id": "667d9961", + "id": "ba013165", "metadata": {}, "source": [ "Apply an aggregation supplying column specification for supplied function" @@ -3528,7 +3567,7 @@ { "cell_type": "code", "execution_count": null, - "id": "60845603", + "id": "1cf2c721", "metadata": {}, "outputs": [], "source": [ @@ -3537,7 +3576,7 @@ }, { "cell_type": "markdown", - "id": "256f5496", + "id": "dc726b75", "metadata": {}, "source": [ "## Data Preprocessing" @@ -3545,7 +3584,7 @@ }, { "cell_type": "markdown", - "id": "976e633c", + "id": "d508891a", "metadata": {}, "source": [ "### Table.add_prefix()\n", @@ -3572,7 +3611,7 @@ }, { "cell_type": "markdown", - "id": "77ff0376", + "id": "4255701a", "metadata": {}, "source": [ "**Examples:**\n", @@ -3583,7 +3622,7 @@ { "cell_type": "code", "execution_count": null, - "id": "c71b39c6", + "id": "905c810d", "metadata": {}, "outputs": [], "source": [ @@ -3592,7 +3631,7 @@ }, { "cell_type": "markdown", - "id": "8b6968da", + "id": "cd6a4005", "metadata": {}, "source": [ "Add \"col_\" to table columns:" @@ -3601,7 +3640,7 @@ { "cell_type": "code", "execution_count": null, - "id": "aa98ca46", + "id": "11296af4", "metadata": {}, "outputs": [], "source": [ @@ -3610,7 +3649,7 @@ }, { "cell_type": "markdown", - "id": "5f87eeba", + "id": "8fb874ba", "metadata": {}, "source": [ "### Table.add_suffix()\n", @@ -3637,7 +3676,7 @@ }, { "cell_type": "markdown", - "id": "dc449e82", + "id": "47618c02", "metadata": {}, "source": [ "**Examples:**\n", @@ -3648,7 +3687,7 @@ { "cell_type": "code", "execution_count": null, - "id": "4471a14b", + "id": "1e5c17b3", "metadata": {}, "outputs": [], "source": [ @@ -3657,7 +3696,7 @@ }, { "cell_type": "markdown", - "id": "b01dfa6c", + "id": "e93f30cb", "metadata": {}, "source": [ "Add \"_col\" to table columns:" @@ -3666,7 +3705,7 @@ { "cell_type": "code", "execution_count": null, - "id": "c7c46631", + "id": "5625768b", "metadata": {}, "outputs": [], "source": [ @@ -3675,7 +3714,7 @@ }, { "cell_type": "markdown", - "id": "d56eeae9", + "id": "a5bb7631", "metadata": {}, "source": [ "### Table.astype()\n", @@ -3704,7 +3743,7 @@ }, { "cell_type": "markdown", - "id": "5d27ccde", + "id": "e0af2087", "metadata": {}, "source": [ "**Examples:**\n", @@ -3715,16 +3754,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" @@ -3733,7 +3777,7 @@ { "cell_type": "code", "execution_count": null, - "id": "0ef76c1e", + "id": "da1b75cb", "metadata": {}, "outputs": [], "source": [ @@ -3742,7 +3786,7 @@ }, { "cell_type": "markdown", - "id": "1846286e", + "id": "3799183f", "metadata": {}, "source": [ "Casting as specified in the dictionary supplied with given dtype per column" @@ -3751,7 +3795,7 @@ { "cell_type": "code", "execution_count": null, - "id": "a4cc4bb7", + "id": "77de55f5", "metadata": {}, "outputs": [], "source": [ @@ -3760,7 +3804,7 @@ }, { "cell_type": "markdown", - "id": "c77a5800", + "id": "e73a33cd", "metadata": {}, "source": [ "The next example will use this table" @@ -3769,16 +3813,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" @@ -3787,7 +3839,7 @@ { "cell_type": "code", "execution_count": null, - "id": "599dca72", + "id": "b56e61ab", "metadata": {}, "outputs": [], "source": [ @@ -3796,7 +3848,7 @@ }, { "cell_type": "markdown", - "id": "92ab62d2", + "id": "c7422edd", "metadata": {}, "source": [ "### Table.drop()\n", @@ -3823,7 +3875,7 @@ }, { "cell_type": "markdown", - "id": "756e1611", + "id": "6b589694", "metadata": {}, "source": [ "**Examples:**\n", @@ -3834,20 +3886,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": [ @@ -3856,7 +3913,7 @@ }, { "cell_type": "markdown", - "id": "b6b79c9b", + "id": "3b68fcbf", "metadata": {}, "source": [ "Drop columns from a table." @@ -3865,7 +3922,7 @@ { "cell_type": "code", "execution_count": null, - "id": "41eb79c1", + "id": "1a07c27f", "metadata": {}, "outputs": [], "source": [ @@ -3874,7 +3931,7 @@ }, { "cell_type": "markdown", - "id": "e34706ea", + "id": "d30d870b", "metadata": {}, "source": [ "### Table.drop_duplicates()\n", @@ -3894,7 +3951,7 @@ }, { "cell_type": "markdown", - "id": "e9e064d1", + "id": "3c633610", "metadata": {}, "source": [ "**Examples:**\n", @@ -3905,17 +3962,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." @@ -3924,7 +3985,7 @@ { "cell_type": "code", "execution_count": null, - "id": "5f6ec5c7", + "id": "9cc0d387", "metadata": {}, "outputs": [], "source": [ @@ -3933,7 +3994,7 @@ }, { "cell_type": "markdown", - "id": "77282b77", + "id": "6110d8d9", "metadata": {}, "source": [ "### Table.pop()\n", @@ -3959,7 +4020,7 @@ }, { "cell_type": "markdown", - "id": "6846f6a1", + "id": "70c2c22a", "metadata": {}, "source": [ "**Examples:**\n", @@ -3970,7 +4031,7 @@ { "cell_type": "code", "execution_count": null, - "id": "40ab2931", + "id": "cc1770f6", "metadata": { "scrolled": true }, @@ -3985,7 +4046,7 @@ }, { "cell_type": "markdown", - "id": "45aca79f", + "id": "e4843e47", "metadata": {}, "source": [ "Remove the `z` and `w` columns from the table and return them." @@ -3994,7 +4055,7 @@ { "cell_type": "code", "execution_count": null, - "id": "2f381911", + "id": "3c9dda2a", "metadata": {}, "outputs": [], "source": [ @@ -4007,7 +4068,7 @@ }, { "cell_type": "markdown", - "id": "2f4954bb", + "id": "68e67196", "metadata": {}, "source": [ "### Table.rename()\n", @@ -4041,7 +4102,7 @@ }, { "cell_type": "markdown", - "id": "ddd7f1f2", + "id": "08c8748e", "metadata": {}, "source": [ "**Examples:**\n", @@ -4052,7 +4113,7 @@ { "cell_type": "code", "execution_count": null, - "id": "d844c2c3", + "id": "e131bae9", "metadata": {}, "outputs": [], "source": [ @@ -4062,7 +4123,7 @@ }, { "cell_type": "markdown", - "id": "9b819386", + "id": "b5ef3e3d", "metadata": {}, "source": [ "Rename column `x` to `index` and `y` to `symbol` using the `columns` keyword." @@ -4071,7 +4132,7 @@ { "cell_type": "code", "execution_count": null, - "id": "e352c9ba", + "id": "e03e5b8e", "metadata": {}, "outputs": [], "source": [ @@ -4080,7 +4141,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." @@ -4089,7 +4150,7 @@ { "cell_type": "code", "execution_count": null, - "id": "16ae0555-9d92-4642-9671-03a2790216c8", + "id": "4a8da84c", "metadata": {}, "outputs": [], "source": [ @@ -4098,7 +4159,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." @@ -4107,7 +4168,7 @@ { "cell_type": "code", "execution_count": null, - "id": "7b2bcbd6-32ef-4988-ac81-3de73222face", + "id": "4619e64e", "metadata": {}, "outputs": [], "source": [ @@ -4116,7 +4177,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", @@ -4158,7 +4486,7 @@ { "cell_type": "code", "execution_count": null, - "id": "a723d14d", + "id": "05f5d858", "metadata": {}, "outputs": [], "source": [ @@ -4176,7 +4504,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" @@ -4185,7 +4513,7 @@ { "cell_type": "code", "execution_count": null, - "id": "4662c138", + "id": "35f78f09", "metadata": {}, "outputs": [], "source": [ @@ -4194,7 +4522,7 @@ }, { "cell_type": "markdown", - "id": "4e019e54", + "id": "ea62a377", "metadata": {}, "source": [ "Reset the index adding a specified named column to the table" @@ -4203,7 +4531,7 @@ { "cell_type": "code", "execution_count": null, - "id": "a990ea29", + "id": "c136c0f7", "metadata": {}, "outputs": [], "source": [ @@ -4212,7 +4540,7 @@ }, { "cell_type": "markdown", - "id": "f186c5fb", + "id": "4a4223bb", "metadata": {}, "source": [ "Reset the index using multiple named columns" @@ -4221,7 +4549,7 @@ { "cell_type": "code", "execution_count": null, - "id": "9c62edc4", + "id": "be677606", "metadata": {}, "outputs": [], "source": [ @@ -4230,7 +4558,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" @@ -4239,7 +4567,7 @@ { "cell_type": "code", "execution_count": null, - "id": "c52367f4", + "id": "b3e6bda0", "metadata": {}, "outputs": [], "source": [ @@ -4248,7 +4576,7 @@ }, { "cell_type": "markdown", - "id": "ee76fa24", + "id": "80719030", "metadata": {}, "source": [ "Reset the index specifying multiple numbered columns" @@ -4257,7 +4585,7 @@ { "cell_type": "code", "execution_count": null, - "id": "0cf6b213", + "id": "fab2e4e7", "metadata": {}, "outputs": [], "source": [ @@ -4266,7 +4594,7 @@ }, { "cell_type": "markdown", - "id": "7fc928a5", + "id": "ed82d445", "metadata": {}, "source": [ "Drop index columns from table" @@ -4275,7 +4603,7 @@ { "cell_type": "code", "execution_count": null, - "id": "8596e5a1", + "id": "945b8293", "metadata": {}, "outputs": [], "source": [ @@ -4284,7 +4612,7 @@ }, { "cell_type": "markdown", - "id": "e95b57dd", + "id": "db72bcbb", "metadata": {}, "source": [ "Drop specified key columns from table" @@ -4293,7 +4621,7 @@ { "cell_type": "code", "execution_count": null, - "id": "dde1ee77", + "id": "b9646f1d", "metadata": {}, "outputs": [], "source": [ @@ -4302,7 +4630,7 @@ }, { "cell_type": "markdown", - "id": "8e19ddeb", + "id": "2201d826", "metadata": {}, "source": [ "### Table.set_index()\n", @@ -4343,18 +4671,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": [ @@ -4365,7 +4698,7 @@ { "cell_type": "code", "execution_count": null, - "id": "abf46438", + "id": "66f9b964", "metadata": {}, "outputs": [], "source": [ @@ -4376,7 +4709,7 @@ { "cell_type": "code", "execution_count": null, - "id": "567ff8e9", + "id": "00dda488", "metadata": {}, "outputs": [], "source": [ @@ -4387,7 +4720,7 @@ }, { "cell_type": "markdown", - "id": "fb24895d", + "id": "965ef63a", "metadata": {}, "source": [ "Appending:" @@ -4396,7 +4729,7 @@ { "cell_type": "code", "execution_count": null, - "id": "d080737f", + "id": "cf53a132", "metadata": {}, "outputs": [], "source": [ @@ -4407,7 +4740,7 @@ { "cell_type": "code", "execution_count": null, - "id": "c33e779e", + "id": "19f88bde", "metadata": {}, "outputs": [], "source": [ @@ -4417,7 +4750,7 @@ }, { "cell_type": "markdown", - "id": "c7eab4a6", + "id": "7d605454", "metadata": {}, "source": [ "Verify Integrity:" @@ -4426,7 +4759,7 @@ { "cell_type": "code", "execution_count": null, - "id": "98fc7587", + "id": "63c810f0", "metadata": {}, "outputs": [], "source": [ @@ -4437,7 +4770,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 b654f7e..bf837c7 100755 Binary files a/src/pykx/lib/4-1-libs/l64/libq.so and b/src/pykx/lib/4-1-libs/l64/libq.so differ diff --git a/src/pykx/lib/4-1-libs/l64arm/libq.so b/src/pykx/lib/4-1-libs/l64arm/libq.so index 8eaf7ea..bcc4b10 100755 Binary files a/src/pykx/lib/4-1-libs/l64arm/libq.so and b/src/pykx/lib/4-1-libs/l64arm/libq.so differ diff --git a/src/pykx/lib/4-1-libs/m64/libq.dylib b/src/pykx/lib/4-1-libs/m64/libq.dylib index 7d1505c..7864911 100755 Binary files a/src/pykx/lib/4-1-libs/m64/libq.dylib and b/src/pykx/lib/4-1-libs/m64/libq.dylib differ diff --git a/src/pykx/lib/4-1-libs/m64arm/libq.dylib b/src/pykx/lib/4-1-libs/m64arm/libq.dylib index ef9b5dc..953bfc2 100755 Binary files a/src/pykx/lib/4-1-libs/m64arm/libq.dylib and b/src/pykx/lib/4-1-libs/m64arm/libq.dylib differ diff --git a/src/pykx/lib/4-1-libs/q.k b/src/pykx/lib/4-1-libs/q.k index 593a7d5..06ad989 100644 --- a/src/pykx/lib/4-1-libs/q.k +++ b/src/pykx/lib/4-1-libs/q.k @@ -117,7 +117,7 @@ IN:{$[99h<@x;x in y;0]};qa:{$[qb x;0;IN[*x;a0];1;|/qa'1_x]};qb:{(2>#x)|(@x)&~11= / CAN EXIT HERE FOR SMALL Q / pt(tables) pf(date/month/year/int) pd(dirs) pv(values) pn(count) pt::0#pf::` vt:(,`)!,()!(); -bv:{g:$[(::)~x;max;min];x:`:.;d:{`/:'x,'d@&(d:!x)like"[0-9]*"}'P:$[`par.txt in!x;-1!'`$0:`/:x,`par.txt;,x]; +bv:{g:$[(::)~x;max;min];x:.Q.d;d:{`/:'x,'d@&(d:!x)like"[0-9]*"}'P:$[`par.txt in!x;jp[x]'`$0:`/:x,`par.txt;,x]; t:?,/!:'.Q.vt:{(&#:'x)(=,/. x)}'{({("DMJJ"`date`month`year`int?.Q.pf)$$last@x:`\:x}'x)!!:'x}'d; d:{`/:'x[(. y)[;0]],'(`$$(. y)[;1]),'!y}[P]@{i:y@&:x=y x:@[x;&x~\:();:;*0#`. pf];(i;x i)}[;g]'+:t#/:g''.Q.vt:t#/:.Q.vt;.Q.vt:P!.q.except[. .Q.pf]''.Q.vt; .Q.vp:t!{(+(,.Q.pf)!,0#. .Q.pf),'+(-2!'.+x)#'+|0#x:?[x;();0b;()]}'d;.Q.pt,:{.[x;();:;+.q.except[!+.Q.vp x;.Q.pf]!x];x}'.q.except[t;.Q.pt];} diff --git a/src/pykx/lib/4-1-libs/w64/q.dll b/src/pykx/lib/4-1-libs/w64/q.dll index 3c53506..c1b7ff9 100644 Binary files a/src/pykx/lib/4-1-libs/w64/q.dll and b/src/pykx/lib/4-1-libs/w64/q.dll differ diff --git a/src/pykx/lib/4-1-libs/w64/q.lib b/src/pykx/lib/4-1-libs/w64/q.lib index ea82b4b..bc1bfa3 100644 Binary files a/src/pykx/lib/4-1-libs/w64/q.lib and b/src/pykx/lib/4-1-libs/w64/q.lib differ diff --git a/src/pykx/lib/l64/libe.so b/src/pykx/lib/l64/libe.so index ebf16db..11818e9 100755 Binary files a/src/pykx/lib/l64/libe.so and b/src/pykx/lib/l64/libe.so differ diff --git a/src/pykx/lib/l64/libq.so b/src/pykx/lib/l64/libq.so index 2a8c586..5a5f383 100755 Binary files a/src/pykx/lib/l64/libq.so and b/src/pykx/lib/l64/libq.so differ diff --git a/src/pykx/lib/l64arm/libq.so b/src/pykx/lib/l64arm/libq.so index 9eb8f21..c148bd6 100755 Binary files a/src/pykx/lib/l64arm/libq.so and b/src/pykx/lib/l64arm/libq.so differ diff --git a/src/pykx/lib/m64/libe.so b/src/pykx/lib/m64/libe.so index 9c997a4..89c1542 100755 Binary files a/src/pykx/lib/m64/libe.so and b/src/pykx/lib/m64/libe.so differ diff --git a/src/pykx/lib/m64/libq.dylib b/src/pykx/lib/m64/libq.dylib index b28aac5..74353fa 100755 Binary files a/src/pykx/lib/m64/libq.dylib and b/src/pykx/lib/m64/libq.dylib differ diff --git a/src/pykx/lib/m64arm/libe.so b/src/pykx/lib/m64arm/libe.so index 75a51fc..7c95d93 100755 Binary files a/src/pykx/lib/m64arm/libe.so and b/src/pykx/lib/m64arm/libe.so differ diff --git a/src/pykx/lib/m64arm/libq.dylib b/src/pykx/lib/m64arm/libq.dylib index 5c4b079..52604ce 100755 Binary files a/src/pykx/lib/m64arm/libq.dylib and b/src/pykx/lib/m64arm/libq.dylib differ diff --git a/src/pykx/lib/q.k b/src/pykx/lib/q.k index 274f4c1..782f4c6 100644 --- a/src/pykx/lib/q.k +++ b/src/pykx/lib/q.k @@ -117,7 +117,7 @@ IN:{$[99h<@x;x in y;0]};qa:{$[qb x;0;IN[*x;a0];1;|/qa'1_x]};qb:{(2>#x)|(@x)&~11= / CAN EXIT HERE FOR SMALL Q / pt(tables) pf(date/month/year/int) pd(dirs) pv(values) pn(count) pt::0#pf::` vt:(,`)!,()!(); -bv:{g:$[(::)~x;max;min];x:`:.;d:{`/:'x,'d@&(d:!x)like"[0-9]*"}'P:$[`par.txt in!x;-1!'`$0:`/:x,`par.txt;,x]; +bv:{g:$[(::)~x;max;min];x:.Q.d;d:{`/:'x,'d@&(d:!x)like"[0-9]*"}'P:$[`par.txt in!x;jp[x]'`$0:`/:x,`par.txt;,x]; t:?,/!:'.Q.vt:{(&#:'x)(=,/. x)}'{({("DMJJ"`date`month`year`int?.Q.pf)$$last@x:`\:x}'x)!!:'x}'d; d:{`/:'x[(. y)[;0]],'(`$$(. y)[;1]),'!y}[P]@{i:y@&:x=y x:@[x;&x~\:();:;*0#`. pf];(i;x i)}[;g]'+:t#/:g''.Q.vt:t#/:.Q.vt;.Q.vt:P!.q.except[. .Q.pf]''.Q.vt; .Q.vp:t!{(+(,.Q.pf)!,0#. .Q.pf),'+(-2!'.+x)#'+|0#x:?[x;();0b;()]}'d;.Q.pt,:{.[x;();:;+.q.except[!+.Q.vp x;.Q.pf]!x];x}'.q.except[t;.Q.pt];} diff --git a/src/pykx/lib/read.q b/src/pykx/lib/read.q index 41bfd1a..398b992 100644 --- a/src/pykx/lib/read.q +++ b/src/pykx/lib/read.q @@ -1,4 +1,4 @@ -system"l ", {x sv (-1 _ x vs y),enlist "csvutil.q"}[$[.z.o~`w64;"\\";"/"]; (value{})6]; +.pykx.util.loadfile[;"csvutil.q"]{x sv (-1 _ x vs y)}[$[.z.o~`w64;"\\";"/"]; (value{})6]; system"d .read"; diff --git a/src/pykx/lib/w64/q.dll b/src/pykx/lib/w64/q.dll index 312318e..442727f 100644 Binary files a/src/pykx/lib/w64/q.dll and b/src/pykx/lib/w64/q.dll differ diff --git a/src/pykx/lib/w64/q.lib b/src/pykx/lib/w64/q.lib index 2857d79..efe485c 100644 Binary files a/src/pykx/lib/w64/q.lib and b/src/pykx/lib/w64/q.lib differ diff --git a/src/pykx/pandas_api/__init__.py b/src/pykx/pandas_api/__init__.py index c884675..e8f755d 100644 --- a/src/pykx/pandas_api/__init__.py +++ b/src/pykx/pandas_api/__init__.py @@ -74,6 +74,7 @@ def return_val(*args, **kwargs): from .pandas_reset_index import _init as _reset_index_init, PandasResetIndex from .pandas_apply import _init as _apply_init, PandasApply from .pandas_sorting import _init as _sorting_init, PandasSorting +from .pandas_replace import _init as _replace_init, PandasReplace def _init(_q): @@ -87,11 +88,12 @@ def _init(_q): _apply_init(q) _sorting_init(q) _reset_index_init(q) + _replace_init(q) class PandasAPI(PandasApply, PandasMeta, PandasIndexing, PandasReindexing, PandasConversions, PandasMerge, PandasSetIndex, PandasGroupBy, - PandasSorting, PandasResetIndex): + PandasSorting, PandasReplace, PandasResetIndex): """PandasAPI mixin class""" replace_self = False prev_locs = {} diff --git a/src/pykx/pandas_api/pandas_meta.py b/src/pykx/pandas_api/pandas_meta.py index b74798b1..66724af 100644 --- a/src/pykx/pandas_api/pandas_meta.py +++ b/src/pykx/pandas_api/pandas_meta.py @@ -60,11 +60,13 @@ def preparse_computations(tab, axis=0, skipna=True, numeric_only=False, bool_onl if bool_only: (tab, cols) = _get_bool_only_subtable(tab) res = q( - '{[tab;skipna;axis]' - 'r:value flip tab;' - 'if[not axis~0;r:flip r];' - 'if[skipna;r:{x where not null x} each r];' - 'r}', + ''' + {[tab;skipna;axis] + r:value flip tab; + if[not axis~0;r:flip r]; + if[skipna;r:{x where not null x} each r]; + r} + ''', tab, skipna, axis @@ -149,15 +151,18 @@ def mean(self, axis: int = 0, numeric_only: bool = False): if numeric_only: tab = _get_numeric_only_subtable(tab) - key_str = '' if axis == 0 else '`$string ' - val_str = '' if axis == 0 else '"f"$value ' - query_str = 'cols tab' if axis == 0 else 'til count tab' - where_str = ' where not (::)~/:r[;1]' return q( - '{[tab]' - f'r:{{[tab; x] ({key_str}x; avg {val_str}tab[x])}}[tab;] each {query_str};' - f'(,/) {{(enlist x 0)!(enlist x 1)}} each r{where_str}}}', - tab + ''' + {[tab;axis] + idx:$[axis;til count tab;cols tab]; + r:{[tab;axis;idx] + ( + $[axis;`$string@;]idx; + avg $[axis;"f"$value@;]tab idx + ) + }[tab;axis]each idx; + {x[;0]!x[;1]} r where not (::)~/:r[;1]} + ''', tab, axis ) @api_return @@ -199,15 +204,14 @@ def std(self, axis: int = 0, ddof: int = 1, numeric_only: bool = False): if ddof == len(tab): return q('{x!count[x]#0n}', axis_keys) - return q( - '''{[tab;axis;ddof;axis_keys] - tab:$[0~axis;(::);flip] value flip tab; - d:$[0~ddof;dev; - 1~ddof;sdev; - {[ddof;x] avg sqrt (sum xexp[x-avg x;2]) % count[x]-ddof}ddof]; - axis_keys!d each tab - }''', tab, axis, ddof, axis_keys - ) + return q(''' + {[tab;axis;ddof;axis_keys] + tab:$[0~axis;(::);flip] value flip tab; + d:$[0~ddof;dev; + 1~ddof;sdev; + {[ddof;x] avg sqrt (sum xexp[x-avg x;2]) % count[x]-ddof}ddof]; + axis_keys!d each tab + }''', tab, axis, ddof, axis_keys) @api_return def median(self, axis: int = 0, numeric_only: bool = False): @@ -217,16 +221,17 @@ def median(self, axis: int = 0, numeric_only: bool = False): if numeric_only: tab = _get_numeric_only_subtable(tab) - key_str = '' if axis == 0 else '`$string ' - val_str = '' if axis == 0 else '"f"$value ' - query_str = 'cols tab' if axis == 0 else 'til count tab' - where_str = ' where not (::)~/:r[;1]' - return q( - '{[tab]' - f'r:{{[tab; x] ({key_str}x; med {val_str}tab[x])}}[tab;] each {query_str};' - f'(,/) {{(enlist x 0)!(enlist x 1)}} each r{where_str}}}', - tab - ) + return q(''' + {[tab;axis] + idx:$[axis;til count tab;cols tab]; + r:{[tab;axis;idx] + ( + $[axis;`$string@;]idx; + med $[axis;"f"$value@;]tab idx + ) + }[tab;axis]each idx; + raze{(enlist x 0)!enlist x 1}each r where not (::)~/:r[;1]} + ''', tab, axis) @convert_result def skew(self, axis=0, skipna=True, numeric_only=False): @@ -245,27 +250,26 @@ def mode(self, axis: int = 0, numeric_only: bool = False, dropna: bool = True): tab = q('{(keys x) _ 0!x}', tab) if numeric_only: tab = _get_numeric_only_subtable(tab) - x_str = 'x: x where not null x; ' if dropna else '' - query_str = 'cols tab' if axis == 0 else 'til count tab' - cols_str = 'tab[x]' if axis == 0 else 'value tab[x]' - maxc_str = 'x[1]' if axis ==0 else 'raze x _ 0' - cs_str = 'cols tab' if axis == 0 else '`idx,`$string each til count r[0][1]' - m_str = '{1 _ raze x}' if axis == 0 else '{x: raze x; x iasc null x}' - flip_m = 'flip ' if axis == 0 else '' - mode_query = f'{{{x_str}(x l) where d=max d:1_deltas (l:where differ x),count x:asc x}}' \ - if numeric_only else f'{{{x_str}x where f=max f:@[0*i;i:x?x;+;1]}}' - return q( - '{[tab]' - f'r:{{[tab; x] (x; {mode_query}' - f'[{cols_str}])}}[tab;] each {query_str};' - f'maxc: max {{count {maxc_str}}} each r;' - 'r:{[x; y] $[not y=t:count x 1;' - '[qq: x 1; (x 0;(y - t){[z; t]z,z[t]}[;t]/qq)];' - '(x 0; x 1)]}[;maxc] each r;' - f'cs: {cs_str};' - f'm: {m_str} each r;' - f'cs !/: {flip_m}m}}', - tab + + return q(''' + {[tab; axis; numeric; drop] + idx:$[axis;til count tab;cols tab]; + modeQuery:$[numeric; + {x[l] where d=max d:1_deltas (l:where differ x),count x:asc x}; + {x where f=max f:@[0*i;i:x?x;+;1]} + ]; + r:{[tab; axis; modeQuery; drop; x] + (x; modeQuery $[drop;{x where not null x};] $[axis;value;]tab x) + }[tab;axis;modeQuery;drop]each idx; + maxc: max{count x y}[$[axis;{raze x _ 0};{x 1}]]each r; + r:{[x; y] + $[not y=t:count x 1; + [qq: x 1; (x 0;(y - t){[z; t]z,z[t]}[;t]/qq)]; + (x 0; x 1)]}[;maxc] each r; + cs:$[axis;`idx,`$string each til count r[0][1];cols tab]; + m:$[axis;{x: raze x; x iasc null x};{1 _ raze x}] each r; + cs!/:$[axis;;flip]m + }''', tab, axis, numeric_only, dropna ) @api_return diff --git a/src/pykx/pandas_api/pandas_replace.py b/src/pykx/pandas_api/pandas_replace.py new file mode 100644 index 0000000..afe1b1d --- /dev/null +++ b/src/pykx/pandas_api/pandas_replace.py @@ -0,0 +1,27 @@ +from . import api_return + + +def _init(_q): + global q + q = _q + + +class PandasReplace: + + @api_return + def replace(self, to_replace, value): + return q(''' + {[t;s;r] + gt:$[-11h~type t;get;(::)] t; + cs:cols $[99h~type gt;value;(::)]gt; + map:([] c:cs; cT:type each value ?[t;();();cs!cs]); + map:update s:count[map]#enlist s,sT:type s,r:count[map]#enlist r,rT:type r from map; + map:select from map where (cT=0) or neg[sT]=cT; + map:update sOp:?[(sT>=0) or cT=0;count[map]#(~/:);count[map]#(=)] from map; + map:update rI:{[t;c;s;sOp] where sOp[s;t c]}[0!gt]'[c;s;sOp] from map; + map:delete from map where 0=count each rI; + map:update atF:?[(0=cT) or neg[cT]=rT;count[map]#(@[;;:;]);count[map]#({1_ @[(::),x;1+y;:;z]})] from map; + map:update r:(count each rI)#'enlist each r from map; + ![t;();0b;map[`c]!exec {[atF;c;rI;r](atF[;rI;r];c)}'[atF;c;rI;r] from map] + } + ''', self, to_replace, value) # noqa: E501 diff --git a/src/pykx/pykx.q b/src/pykx/pykx.q index 2edd4bb..45593a5 100644 --- a/src/pykx/pykx.q +++ b/src/pykx/pykx.q @@ -8,6 +8,17 @@ // @desc Process context prior to PyKX initialization .pykx.util.prevCtx:system"d"; +@[ + {if[not"{.pykx.pyexec x}"~string get x; + -1"Warning: Detected invalid '.p.e' function definition expected for PyKX.\n", + "Have you loaded another Python integration first?\n\n", + "Please consider full installation of PyKX under q following instructions at:\n", + "https://code.kx.com/pykx/pykx-under-q/intro.html#installation.\n" + ] + }; + `.p.e; + {::}] + \d .pykx // @private @@ -29,6 +40,18 @@ util.os:first string .z.o; // @type {dict} util.startup:.Q.opt .z.x + +// @private +// @overview +// @desc Load a file at an associated folder location, this is used +// to allow loading of files at folder locations containing spaces +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]] + } + // @private // @desc Retrieval of PyKX initialization directory on first initialization if[not "true"~lower getenv`PYKX_LOADED_UNDER_Q; @@ -72,7 +95,10 @@ if["true"~getenv`PYKX_UNDER_PYTHON; if[not "true"~lower getenv`PYKX_LOADED_UNDER_Q; util.pyEnvInfo:("None"; "None"; ""); if[0=count getenv`PYKX_Q_LOADED_MARKER; - @[system"l ",;"pykx_init.q_";{system"l ",pykxDir,"/pykx_init.q_"}]; + @[system"l ",; + "pykx_init.q_"; + {[x;y] util.loadfile[x;"pykx_init.q_"]}[pykxDir] + ] ]; ]; @@ -1632,7 +1658,7 @@ console:{pyexec"from code import InteractiveConsole\n__pykx_console__ = Interact // @desc // Set the execution function used when loading files with the extension `*.p` // or when using the following syntax `p)` within a q session -.p.e:{.pykx.pyexec x} +.p.e:{.pykx.pyexec x} // If changing this line please ensure you have updated the check used at the beginning of this file to warn users about PyKX being loaded with other Python libraries // @private // @desc @@ -1708,8 +1734,8 @@ listExtensions:{-2 _/:lst where like[;"*.q"]lst:string key hsym`$pykxDir,"/exten loadExtension:{[ext] if[not 10h=type ext;'"Extension provided must be of type string"]; if[not ext in listExtensions[];'"Extension provided '",ext,"' not available"]; - @[system"l ",; - pykxDir,"/extensions/",ext,".q"; + .[util.loadfile; + (pykxDir,"/extensions/";ext,".q"); {'x," raised when attempting to load extension"} ]; } diff --git a/src/pykx/pykx_init.q_ b/src/pykx/pykx_init.q_ index 7db2989..c9f992f 100644 Binary files a/src/pykx/pykx_init.q_ and b/src/pykx/pykx_init.q_ differ diff --git a/src/pykx/query.py b/src/pykx/query.py index ede1b32..661fa6c 100644 --- a/src/pykx/query.py +++ b/src/pykx/query.py @@ -22,9 +22,6 @@ def __dir__(): return __all__ -consolidate = '{$[0>type x;x;(0h>v 0)&1~count v:distinct type each x;raze x;x]}' - - class QSQL: """Generates and submits functional q SQL queries. @@ -399,7 +396,7 @@ def _seud(self, table, query_type, columns=None, where=None, by=None, modify=Fal query_char = '!' if query_type in ('delete', 'update') else '?' try: res = self._q( - f'{{{query_char}[{table_code};x;y;z]}}', + f'{{{query_char}[{table_code};value x;value y;value z]}}', where_clause, by_clause, select_clause, @@ -422,9 +419,9 @@ def _generate_clause(self, clause_value, clause_name, query_type): if clause_value is None: if clause_name in ('columns', 'where'): b = query_type == 'delete' and clause_name == 'columns' - return self._q._call('`symbol$()', wait=True) if b else [] + return [b'{`symbol$()}', None] if b else [b'{x}', []] elif clause_name == 'by': - return [] if query_type == 'exec' else False + return [b'{x}', []] if query_type == 'exec' else [b'{x}', False] else: if clause_name in ('columns', 'by'): return self._generate_clause_columns_by(clause_value, clause_name, query_type) @@ -439,23 +436,18 @@ def _generate_clause_columns_by(self, clause_value, clause_name, query_type): if isinstance(clause_value, str): if clause_value == '': raise ValueError('q query specifying column cannot be empty') - clause_value = [clause_value] - return self._q._call('raze', - [self._q._call('parse', - k.CharVector(x), - wait=True) for x in clause_value], - wait=True, - ) + clause_value = [k.CharVector(clause_value)] + else: + clause_value = [k.CharVector(x) for x in clause_value] + return [b'{parse each x}', clause_value] elif (query_type in ['select', 'exec']) and (clause_name in ['columns', 'by']): if isinstance(clause_value, list): - return self._q._call('{x!x}', - self._q._call(consolidate, clause_value, wait=True), - wait=True) + return [b'{v!v:{$[0>type x;x;(0h>v 0)&1~count v:distinct type each x;raze x;x]}x}', clause_value] # noqa: E501 elif isinstance(clause_value, str) and query_type == 'select': - return self._q._call('{x!x}enlist@', clause_value, wait=True) - return k.K(clause_value) + return [b'{x!x}enlist@', clause_value] + return [b'{x}', k.K(clause_value)] elif isinstance(clause_value, k.K): - return clause_value + return [b'{x}', clause_value] raise TypeError(f"Unsupported type for '{clause_name}' clause") def _generate_clause_columns_by_dict(self, clause_value): @@ -464,22 +456,21 @@ def _generate_clause_columns_by_dict(self, clause_value): if isinstance(val, str): if val == '': raise ValueError(f'q query specifying column for key {key!r} cannot be empty') - clause_dict[key] = self._q._call('parse', k.CharVector(val), wait=True) + clause_dict[key] = [True, k.CharVector(val)] else: - clause_dict[key] = self._q._call(consolidate, val, wait=True) - return k.K(clause_dict) + clause_dict[key] = [False, val] + return [b'{key[x]!{$[x 0;parse;{$[0>type x;x;(0h>v 0)&1~count v:distinct type each x;raze x;x]}]x 1}each value x}', clause_dict] # noqa: E501 def _generate_clause_where(self, clause_value) -> k.List: if isinstance(clause_value, k.List): - return clause_value # clause value is a parse tree + return [b'{x}', clause_value] if isinstance(clause_value, k.BooleanVector): - return self._q._call('enlist', clause_value, wait=True) + return [b'{enlist x}', clause_value] if isinstance(clause_value, str): - clause_value = [clause_value] - try: - return k.K([self._q._call('parse', k.CharVector(x), wait=True) for x in clause_value]) - except Exception as ex: - raise TypeError("Unsupported type for 'where' clause") from ex + clause_value = [k.CharVector(clause_value)] + else: + clause_value = [k.CharVector(x) for x in clause_value] + return [b'{parse each x}', clause_value] class SQL: diff --git a/src/pykx/read.py b/src/pykx/read.py index 0fd5f25..3196a02 100644 --- a/src/pykx/read.py +++ b/src/pykx/read.py @@ -80,7 +80,8 @@ def csv(self, path: The path to the CSV file. types: Can be a dictionary of columns and their types or a `str`-like object of uppercase characters representing the types. Space is used to drop a column. - If `None`, the types will be guessed using `.csvutil.info`. + If `None`, the types will be guessed using [csvutil.q](https://github.com/KxSystems/kdb/blob/master/utils/csvutil.q). + A breakdown of this process is illustrated in the table below. delimiter: A single character representing the delimiter between values. as_table: `True` if the first line of the CSV file should be treated as column names, in which case a `pykx.Table` is returned. If `False` a `pykx.List` of @@ -92,6 +93,29 @@ def csv(self, See Also: [`q.write.csv`][pykx.write.QWriter.csv] + + CSV Type Guessing Table: + | Type Character | Type | Condition(s) | + |---|---|---| + | * | List |- Any type of width greater than 30.
- Remaining unknown types. | + | B | BooleanAtom |- Matching Byte or Char, maxwidth 1, no decimal points, at least 1 of `[0fFnN]` and 1 of `[1tTyY]` in columns.
- Matching Byte or Char, maxwidth 1, no decimal points, all elements in `[01tTfFyYnN]`. | + | G | GUIDAtom |- Matches GUID-like structure.
- Matches structure wrapped in `{ }`. | + | X | ByteAtom |- Maxwidth of 2, comprised of `[0-9]` AND `[abcdefABCDEF]`. | + | H | ShortAtom |- Matches Integer with maxwidth less than 7. | + | I | IntAtom |- Numerical of size between 7 and 15 with exactly 3 decimal points (IP Address).
- Matches Long with maxwidth less than 12. | + | J | LongAtom |- Numerical, no decimal points, all elements `+-` or `0-9`. | + | E | RealAtom |- Matches float with maxwidth less than 9. | + | F | FloatAtom |- Numerical, maxwidth greater than 2, fewer than 2 decimal points, `/` present.
- Numerical, fewer than 2 decimal points, maxwidth greater than 1. | + | C | CharAtom |- Empty columns. Remaining unknown types of size 1. | + | S | SymbolAtom |- Remaining unknown types of maxwidth 2-11 and granularity of less than 10. | + | P | TimestampAtom |- Numerical, maxwidth 11-29, fewer than 4 decimals matching `YYYY[./-]MM[./-]DD` | + | M | MonthAtom |- Matching either numerical, Int, Byte, Real or Float, fewer than 2 decimal points, maxwidth 4-7 | + | D | DateAtom |- Matching Integer, maxwidth 6 or 8.
- Numerical, 0 decimal points, maxwidth 8-10.
- Numerical, 2 decimal points, maxwidth 8-10.
- No decimal points maxwidth 5-9, matching date with 3 letter month code eg.(9nov1989). | + | N | TimespanAtom |- Numerical, maxwidth 15, no decimal points, all values `0-9`.
- Numerical, maxwidth 3-29, 1 decimal point, matching `*[0-9]D[0-9]*`.
- Numerical, maxwidth 3-28, 1 decimal point. | + | U | MinuteAtom |- Matching Byte, maxwidth 4, matching `[012][0-9][0-5][0-9]`.
- Numerical, maxwidth 4 or 5, no decimal points, matching `*[0-9]:[0-5][0-9]`. | + | V | SecondAtom |- Matching Integer, maxwidth 6, matching `[012][0-9][0-5][0-9][0-5][0-9]`.
- Matching Time, maxwidth 7 or 8, no decimal points. | + | T | TimeAtom |- Numerical, maxwidth 9, no decimal points, all values numeric.
- Numerical, maxwidth 7 - 12, fewer than 2 decimal points, matching `[0-9]:[0-5][0-9]:[0-5][0-9]`.
- Matching Real or Float, maxwidth 7-12, 1 decimal point, matching `[0-9][0-5][0-9][0-5][0-9]`. | + Examples: Read a comma seperated CSV file into a `pykx.Table` guessing the datatypes of each @@ -121,7 +145,7 @@ def csv(self, ```python table = q.read.csv('example.csv', {'x1':kx.IntAtom,'x2':kx.GUIDAtom,'x3':kx.TimestampAtom}) ``` - """ + """ # noqa: E501 as_table = 'enlist' if as_table else '' dict_conversion = None if types is None or isinstance(types, dict): diff --git a/src/pykx/reimporter.py b/src/pykx/reimporter.py index e7d710a..629e952 100644 --- a/src/pykx/reimporter.py +++ b/src/pykx/reimporter.py @@ -42,7 +42,7 @@ def __init__(self): 'QHOME', 'PYKX_EXECUTABLE', 'PYKX_DIR') - self.envvals = [str(os.getenv(x)) for x in self.envlist] + self.envvals = [os.getenv(x) for x in self.envlist] def __enter__(self): self.reset() @@ -54,7 +54,10 @@ def reset(self): Note: It is not recommended to use this function directly instead use the `with` syntax. This will automatically manage setting and restoring the environment variables for you. """ - [os.unsetenv(x) for x in self.envlist] + for x, y in zip(self.envlist, self.envvals): + os.unsetenv(x) + if y is not None: + del os.environ[x] os.environ['QHOME'] = original_qhome def restore(self): @@ -64,7 +67,8 @@ def restore(self): This will automatically manage setting and restoring the environment variables for you. """ for x, y in zip(self.envlist, self.envvals): - os.environ[x] = y + if y is not None: + os.environ[x] = y def __exit__(self, exc_type, exc_value, exc_tb): self.restore() diff --git a/src/pykx/streamlit.py b/src/pykx/streamlit.py new file mode 100644 index 0000000..0636bc5 --- /dev/null +++ b/src/pykx/streamlit.py @@ -0,0 +1,252 @@ +import warnings + +from . import beta_features +from .config import _check_beta, pykx_threading, system +from .exceptions import QError +from .ipc import SyncQConnection + +beta_features.append('Streamlit Integration') + + +# This class is required to ensure that in the absence +# of the streamlit dependency PyKX can be imported +class _dummy_class(object): + def __getattr__(self, item): + return self + + def __call__(self, *args, **kwargs): + return self + + +try: + from streamlit.connections import BaseConnection + _streamlit_unavailable = False +except ImportError: + # This base connection object is to ensure the streamlit + # class can be initialized correctly + BaseConnection = {SyncQConnection: _dummy_class} + _streamlit_unavailable = True + + +def _check_streamlit(): + if _streamlit_unavailable: + raise QError('Use of streamlit functionality requires access to ' + 'of streamlit as a dependency, this can be installed ' + ' using:\n\npip install pykx[streamlit]') + + +class PyKXConnection(BaseConnection[SyncQConnection]): + """ + A connection to q/kdb+ processes from streamlit. Initialize using: + + ```python + st.connection("", type = pykx.streamlit.PyKXConnection, *args) + ``` + + PyKX Connection supports the application of queries using Syncronous IPC + connections to q/kdb+ processes or Python processes running PyKX as a + server. + + This is supported through the ``query()`` method, this method allows + users to run `sql`, `qsql` or `q` queries against these processes returning + PyKX data. + + !!! Warning + Streamlit integration is not presently supported for Windows as for + full utilization it requires use of `PYKX_THREADING` functionality + + Parameters: + host: The host name to which a connection is to be established. + port: The port to which a connection is to be established. + username: Username for q connection authorization. + password: Password for q connection authorization. + timeout: Timeout for blocking socket operations in seconds. If set to `0`, the socket + will be non-blocking. + large_messages: Whether support for messages >2GB should be enabled. + tls: Whether TLS should be used. + unix: Whether a Unix domain socket should be used instead of TCP. If set to `True`, the + host parameter is ignored. Does not work on Windows. + wait: Whether the q server should send a response to the query (which this connection + will wait to receive). Can be overridden on a per-call basis. If `True`, Python will + wait for the q server to execute the query, and respond with the results. If + `False`, the q server will respond immediately to every query with generic null + (`::`), then execute them at some point in the future. + + Note: The `username` and `password` parameters are not required. + The `username` and `password` parameters are only required if the q server requires + authorization. Refer to [ssl documentation](https://code.kx.com/q/kb/ssl/) for more + information. + + Note: The `timeout` argument may not always be enforced when making succesive querys. + When making successive queries if one query times out the next query will wait until a + response has been recieved from the previous query before starting the timer for its own + timeout. This can be avioded by using a seperate `SyncQConnection` instance for each + query. + + Examples: + + Connect to a q process at `localhost` on port `5050` as a streamlit connection, + querying using q + + ```python + >>> import streamlit as st + >>> import pykx as kx + >>> conn = st.connection('pykx', type=kx.streamlit.PyKXConnection, + ... host = 'localhost', port = 5050) + >>> df = conn.query('select from tab').pd() + >>> st.dataframe(df) + ``` + """ + _connection = None + _connection_kwargs = {} + + def _connect(self, **kwargs) -> None: + _check_beta('Streamlit Integration') + _check_streamlit() + if system == 'Windows': + raise QError('Streamlit integration currently unsupported for Windows') + if not pykx_threading: + warnings.warn("Streamlit caching requires execution on secondary threads, " + "to utilize this fully please consider setting PYKX_THREADING " + "= 'True'") + self._connection = SyncQConnection(no_ctx=True, **kwargs) + self._connection_kwargs = kwargs + + def reset(self, **kwargs) -> None: + """ + Reset an existing Streamlit Connection object, this can be used to manually + reconnect to a datasource which was disconnected. This will use the connection + details provided at initialisation of the original class. + + Example: + + Reset a connection if deemed to no longer be valid + + ```python + >>> import streamlit as st + >>> import pykx as kx + >>> conn = st.connection('pykx', type=kx.streamlit.PyKXConnection, + ... host = 'localhost', port = 5050) + >>> if not conn.is_healthy(): + ... conn.reset() + >>> + ``` + """ + _check_beta('Streamlit Integration') + _check_streamlit() + if not isinstance(self._connection, SyncQConnection): + raise QError('Unable to reset uninitialized connection') + self._connection.close() + self._connect(**self._connection_kwargs) + + def is_healthy(self) -> bool: + """ + Check if an existing streamlit connection is 'healthy' and + available for query. + + Returns: + A boolean indicating if the connection being used is in a + 'healthy' state + + Example: + + ```python + >>> import streamlit as st + >>> import pykx as kx + >>> conn = st.connection('pykx', type=kx.streamlit.PyKXConnection, + ... host = 'localhost', port = 5050) + >>> conn.is_healthy() + True + ``` + """ + _check_beta('Streamlit Integration') + _check_streamlit() + if not isinstance(self._connection, SyncQConnection): + raise QError('Unable to validate uninitialized connection') + if self._connection.closed: + warnings.warn('Connection closed') + return False + try: + self.query('::') + return True + except BaseException as err: + warnings.warn('Unhealthy connection detected with error: ' + str(err)) + return False + + def query(self, query: str, *args, format='q', **kwargs): + """ + Evaluate a query on the connected q process over IPC. + + Parameters: + query: A q expression to be evaluated. + *args: Arguments to the q query. Each argument will be converted into a `pykx.K` + object. Up to 8 arguments can be provided, as that is the maximum + supported by q. + format: What execution format is to be used, should the function use the `qsql` + interface, execute a `sql` query or run `q` code. + + Raises: + RuntimeError: A closed IPC connection was used. + QError: Query timed out, may be raised if the time taken to make or receive a query + goes over the timeout limit. + TypeError: Too many arguments were provided - q queries cannot have more than 8 + parameters. + ValueError: Attempted to send a Python function over IPC. + + Examples: + + Connect to a q process at `localhost` on port `5050` as a streamlit connection, + querying using q + + ```python + >>> import streamlit as st + >>> import pykx as kx + >>> conn = st.connection('pykx', type=kx.streamlit.PyKXConnection, + ... host = 'localhost', port = 5050) + >>> df = conn.query('select from tab').pd() + >>> st.dataframe(df) + ``` + + Connect to a q process at `localhost` on port `5050` as a streamlit connection, + querying using qsql + + ```python + >>> import streamlit as st + >>> import pykx as kx + >>> conn = st.connection('pykx', type=kx.streamlit.PyKXConnection, + ... host = 'localhost', port = 5050) + >>> df = conn.query('tab', where='x>0.5', format='qsql').pd() + >>> st.dataframe(df) + ``` + + Connect to a q process at `localhost` on port `5050` as a streamlit connection, + querying using sql + + ```python + >>> import streamlit as st + >>> import pykx as kx + >>> conn = st.connection('pykx', type=kx.streamlit.PyKXConnection, + ... host = 'localhost', port = 5050) + >>> df = conn.query('select * from tab where x>0.5', format='sql').pd() + >>> st.dataframe(df) + ``` + """ + _check_beta('Streamlit Integration') + _check_streamlit() + + def _query(query: str, format, args, kwargs): + if format == 'sql': + try: + res = self._connection.sql(query, *args) + except QError as err: + if '.s.sp' in str(err): + raise QError('SQL functionality not loaded on connected server, error: ' + str(err)) # noqa: E501 + raise QError(err) + return res + elif format == 'q': + return self._connection(query, *args, **kwargs) + if format == 'qsql': + return self._connection.qsql.select(query, *args, **kwargs) + else: + raise QError("Unsupported format provided for query, must be one of 'q', 'qsql' or 'sql'") # noqa: E501 + return _query(query, format, args, kwargs) diff --git a/src/pykx/system.py b/src/pykx/system.py index bdef11b..5bfcbfd 100644 --- a/src/pykx/system.py +++ b/src/pykx/system.py @@ -1,7 +1,10 @@ """System command wrappers for PyKX.""" +import os +from pathlib import Path +from warnings import warn from . import Q, wrappers as k -from .exceptions import QError +from .exceptions import PyKXWarning, QError __all__ = ['SystemCommands'] @@ -25,11 +28,24 @@ def __call__(self, x): return self._q('{system x}', k.CharVector(x)) def tables(self, namespace=None): - """Lists the tables in the current namespace or in the provided namespace.""" + """Lists the tables associated with a namespace/dictionary + + Examples: + + Retrieve the tables within a provided namespace: + + ```python + kx.system.tables('.foo') + ``` + + Retrieve the tables within a provided dictionary: + + ```python + kx.system.tables('foo') + ``` + """ if namespace is not None: namespace = str(namespace) - if namespace[0] != '.': - namespace = '.' + namespace return self._q._call(f'\\a {namespace}', wait=True) return self._q._call('\\a', wait=True) @@ -47,13 +63,13 @@ def console_size(self): Get the maximum console_size size of output for EmbeddedQ to 10 columns and 10 rows. - ``` + ```python kx.q.system.console_size ``` Set the maximum console size of output for EmbeddedQ to 10 columns and 10 rows. - ``` + ```python kx.q.system.console_size = [10, 10] ``` """ @@ -81,13 +97,13 @@ def display_size(self): Get the maximum display size of output for EmbeddedQ to 10 columns and 10 rows. - ``` + ```python kx.q.system.display_size ``` Set the maximum display size of output for EmbeddedQ to 10 columns and 10 rows. - ``` + ```python kx.q.system.display_size = [10, 10] ``` """ @@ -108,13 +124,13 @@ def cd(self, directory=None): Get the current working directory. - ``` + ```python kx.q.system.cd() ``` Change the current working directory to the root directory on a `UNIX` like machine. - ``` + ```python kx.q.system.cd('/') ``` """ @@ -129,19 +145,19 @@ def namespace(self, ns=None): Get the current namespace. - ``` + ```python kx.q.system.namespace() ``` Change the current namespace to `.foo`, note the leading `.` may be ommited. - ``` + ```python kx.q.system.namespace('foo') ``` Return to the default namespace. - ``` + ```python kx.q.system.namespace('') ``` """ @@ -159,26 +175,30 @@ def namespace(self, ns=None): def functions(self, ns=None): """Get the functions available in the current namespace or functions in a - provided namespace. + provided namespace or dictionary. Examples: Get the functions within the current namespace. - ``` + ```python kx.q.system.functions() ``` - Get the functions within the `.foo` namespace, note the leading `.` may be ommited. + Get the functions within the `.foo` namespace. + ```python + kx.q.system.functions('.foo') ``` - kx.q.system.functions('foo') + + Get the functions within a dictionary. + + ```python + kx.q.system.function('foo') ``` """ if ns is not None: ns = str(ns) - if ns[0] != '.': - ns = '.' + ns return self._q._call(f'\\f {ns}', wait=True) return self._q._call('\\f', wait=True) @@ -193,13 +213,13 @@ def garbage_collection(self): Get the current garbage collection mode. - ``` + ```python kx.q.system.garbage_collection ``` Set the current garbage collection mode to immediate collection. - ``` + ```python kx.q.system.garbage_collection = 1 ``` """ @@ -212,18 +232,43 @@ def garbage_collection(self, value): return self._q._call(f'\\g {value}', wait=True) raise ValueError('Garbage collection mode can only be set to either 0 or 1.') - def load(self, fd): + def load(self, path): """Loads a q script or a directory of a splayed table. Examples: Load a q script named `foo.q`. - ``` + ```python kx.q.system.load('foo.q') ``` """ - return self._q._call(f'\\l {fd}', wait=True) + if isinstance(path, k.CharAtom) or isinstance(path, k.CharVector): + path = path.py().decode() + elif isinstance(path, k.SymbolAtom): + path = path.py() + if path[0] == ':': + path = path[1:] + elif isinstance(path, Path): + path = str(path) + if ' ' not in path: + if path[-1] == '/': + path = path[:-1] + print(path) + return self._q._call(f'\\l {path}', wait=True) + warn('Detected a space in supplied path\n' + f' Path: \'{path}\'\n' + 'q system loading does not support spaces, attempting load ' + 'using alternative load operation', PyKXWarning) + full_path = os.path.abspath(path) + load_path = Path(full_path) + folder = load_path.parent.as_posix() + file = load_path.name + + if not (load_path.is_dir() or load_path.is_file()): + raise ValueError(f'Provided user path \'{str(load_path)} \'is not a file/directory') + return self._q._call('.pykx.util.loadfile', k.CharVector(folder), + k.CharVector(file), wait=True) @property def utc_offset(self): @@ -235,13 +280,13 @@ def utc_offset(self): Get the current local time offset. - ``` + ```python kx.q.system.utc_offset ``` Set the current local time offset to be -4:00 from UTC. - ``` + ```python kx.q.system.utc_offset = -4 ``` """ @@ -262,13 +307,13 @@ def precision(self): Get the current level of float precision. - ``` + ```python kx.q.system.precision ``` Set the Level of float precision to 2. - ``` + ```python kx.q.system.precision = 2 ``` """ @@ -292,7 +337,7 @@ def rename(self, src, dest): Rename a file `foo.q` to `bar.q`. - ``` + ```python kx.q.system.rename('foo.q', 'bar.q') ``` """ @@ -326,13 +371,13 @@ def num_threads(self): Set the number of threads for embedded q to use to 8. - ``` + ```python kx.q.num_threads = 8 ``` Set the number of threads for a q process being connected to over IPC to 8. - ``` + ```python q = kx.SyncQConnection('localhost', 5001) q.num_threads = 8 ``` @@ -356,13 +401,13 @@ def random_seed(self): Get the current seed value. - ``` + ```python kx.q.system.random_seed ``` Set the random seed value to 23. - ``` + ```python kx.q.system.random_seed = 23 ``` """ @@ -379,13 +424,13 @@ def variables(self, ns=None): Get the variables defined in the current namespace. - ``` + ```python kx.q.system.variables() ``` Get the variables associated with a q namespace/dictionary - ``` + ```python kx.q.system.variables('.foo') kx.q.system.variables('foo') ``` @@ -403,7 +448,7 @@ def workspace(self): Get the memory usage of `EmbeddedQ`. - ``` + ```python kx.q.system.workspace ``` """ @@ -417,14 +462,15 @@ def week_offset(self): Get the current week offset. - ``` + ```python kx.q.system.week_offset ``` Set the current week offset so Monday is the first day of the week. - ``` + ```python kx.q.system.week_offset = 2 + ``` """ return self._q._call('\\W', wait=True) @@ -443,13 +489,13 @@ def date_parsing(self): Get the current value for date parsing. - ``` + ```python kx.q.system.date_parsing ``` Get the current value for date parsing so the format is `dd/mm/yyyy`. - ``` + ```python kx.q.system.date_parsing = 1 ``` """ diff --git a/src/pykx/toq.pyx b/src/pykx/toq.pyx index c436fb2..8db005a 100644 --- a/src/pykx/toq.pyx +++ b/src/pykx/toq.pyx @@ -104,7 +104,7 @@ from . import wrappers as k from ._pyarrow import pyarrow as pa from .cast import * from . import config -from .config import disable_pandas_warning, find_core_lib, k_allocator, licensed, pandas_2, system +from .config import find_core_lib, k_allocator, licensed, pandas_2, system from .constants import INF_INT16, INF_INT32, INF_INT64, NULL_INT16, NULL_INT32, NULL_INT64 from .exceptions import LicenseException, PyArrowUnavailable, PyKXException, QError from .util import df_from_arrays, slice_to_range @@ -1303,20 +1303,28 @@ def from_numpy_ndarray(x: np.ndarray, elif ktype in supported_np_temporal_types: if ktype is k.TimestampVector or ktype is k.TimespanVector: offset = TIMESTAMP_OFFSET if ktype is k.TimestampVector else 0 - if x.dtype == np.dtype('kx, False) +_timedelta_resolution_str_map = { + 'timedelta64[ns]': k.TimespanAtom, + 'timedelta64[ms]': k.TimeAtom, + 'timedelta64[s]': k.SecondAtom, +} + +def from_pandas_timedelta( + x: Any, + ktype: Optional[KType] = None, + *, + cast: bool = False, + handle_nulls: bool = False, +) -> k.K: + x = x.to_numpy() + if ktype is None: + ktype = _timedelta_resolution_str_map[str(x.dtype)] + return from_numpy_timedelta64(x, ktype=ktype, cast=cast, handle_nulls=handle_nulls) + def from_arrow(x: Union['pa.Array', 'pa.Table'], ktype: Optional[KType] = None, @@ -2601,7 +2626,8 @@ _converter_from_python_type = { if not pandas_2: _converter_from_python_type[pd.core.indexes.numeric.Int64Index] = from_pandas_index _converter_from_python_type[pd.core.indexes.numeric.Float64Index] = from_pandas_index - +else: + _converter_from_python_type[pd._libs.tslibs.timedeltas.Timedelta] = from_pandas_timedelta class ToqModule(ModuleType): # TODO: `cast` should be set to False at the next major release (KXI-12945) diff --git a/src/pykx/util.py b/src/pykx/util.py index da99cb7..9234a76 100644 --- a/src/pykx/util.py +++ b/src/pykx/util.py @@ -11,6 +11,7 @@ from .config import qargs, qhome, qlic from ._version import version as __version__ from .exceptions import PyKXException +from .reimporter import PyKXReimport __all__ = [ @@ -256,8 +257,101 @@ def get_default_args(f: Callable) -> Dict[str, Any]: } -def debug_environment(detailed=False, return_info=False): - """Displays information about your environment to help debug issues.""" +def debug_environment(detailed: bool = False, return_info: bool = False) -> Union[str, None]: + """ + Functionality for the retrieval of information about a users environment + + Parameters: + detailed: When returning information about a users license print the content of both + `QHOME` and `QLIC` directories + return_info: Should the information returned from the function be printed to console + (default) or provided as a str + + Returns: + Returns `None` if return information is printed to console otherwise + returns a `str` representation + + Examples: + + ```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.. + ``` + + + + + """ debug_info = "" debug_info += pykx_information() debug_info += python_information() @@ -376,10 +470,16 @@ def q_information(): q_info += f"which q: {whichq}\n" if whichq is not None: q_info += ('q info: \n') - if platform.system() == 'Windows': # nocov: - q_info += subprocess.check_output("powershell -NoProfile -ExecutionPolicy ByPass \"echo \\\"-1 .Q.s1 (.z.o;.z.K;.z.k);-1 .Q.s1 .z.l 4;\\\" | q -c 200 200\"", shell=True).decode(encoding='utf-8') # noqa: E501 - else: # nocov: - q_info += subprocess.check_output("echo \"-1 .Q.s1 (.z.o;.z.K;.z.k);-1 .Q.s1 .z.l 4;\" | q -c 200 200", shell=True).decode(encoding='utf-8') # noqa: E501 - except Exception: - pass + if platform.system() == 'Windows': + cmd = "powershell -NoProfile -ExecutionPolicy ByPass \"echo \\\"-1 .Q.s1 (.z.o;.z.K;.z.k);-1 .Q.s1 .z.l 4;\\\" | q -c 200 200\"" # noqa: E501 + else: + cmd = "echo \"-1 .Q.s1 (.z.o;.z.K;.z.k);-1 .Q.s1 .z.l 4;\" | q -c 200 200" + with PyKXReimport(): + out = subprocess.run(cmd, shell=True, capture_output=True) + if out.returncode == 0: + q_info += (out.stdout).decode(encoding='utf-8') + else: + q_info += "Failed to gather q information: " + (out.stderr).decode(encoding='utf-8') + except Exception as e: + q_info += f"Failed to gather q information: {e}" return q_info diff --git a/src/pykx/wrappers.py b/src/pykx/wrappers.py index d10df40..af4e55e 100644 --- a/src/pykx/wrappers.py +++ b/src/pykx/wrappers.py @@ -502,7 +502,8 @@ def pd( self, *, raw: bool = False, - has_nulls: Optional[bool] = None + has_nulls: Optional[bool] = None, + as_arrow: Optional[bool] = False, ): return self.np(raw=raw) @@ -639,6 +640,7 @@ def pd(self, *, raw: bool = False, has_nulls: Optional[bool] = None, + as_arrow: Optional[bool] = False, ) -> Union[pd.Timedelta, int]: if raw: return self.np(raw=True) @@ -673,6 +675,7 @@ def pd( *, raw: bool = False, has_nulls: Optional[bool] = None, + as_arrow: Optional[bool] = False, ): if raw: return self.np(raw=True) @@ -1476,6 +1479,51 @@ def __getitem__(self, key): return q('@', self, _idx_to_k(key, _wrappers.k_n(self))) +if pandas_2 and pa is not None: + _as_arrow_map = { + 'List': 'object', + 'BooleanVector': 'bool[pyarrow]', + 'GUIDVector': 'object', + 'ByteVector': 'uint8[pyarrow]', + 'ShortVector': 'int16[pyarrow]', + 'IntVector': 'int32[pyarrow]', + 'LongVector': 'int64[pyarrow]', + 'RealVector': 'float[pyarrow]', + 'FloatVector': 'double[pyarrow]', + 'CharVector': pd.ArrowDtype(pa.binary(1)), + 'SymbolVector': 'string[pyarrow]', + 'TimestampVector': 'timestamp[ns][pyarrow]', + 'MonthVector': 'timestamp[s][pyarrow]', + 'DateVector': 'timestamp[s][pyarrow]', + 'TimespanVector': 'duration[ns][pyarrow]', + 'MinuteVector': 'duration[s][pyarrow]', + 'SecondVector': 'duration[s][pyarrow]', + 'TimeVector': 'duration[ms][pyarrow]' + } + + _as_arrow_raw_map = { + 'List': 'object', + 'BooleanVector': 'bool[pyarrow]', + 'GUIDVector': 'object', + 'ByteVector': 'uint8[pyarrow]', + 'ShortVector': 'int16[pyarrow]', + 'IntVector': 'int32[pyarrow]', + 'LongVector': 'int64[pyarrow]', + 'RealVector': 'float[pyarrow]', + 'FloatVector': 'double[pyarrow]', + 'CharVector': pd.ArrowDtype(pa.binary(1)), + 'SymbolVector': pd.ArrowDtype(pa.binary()), + 'TimestampVector': 'int64[pyarrow]', + 'DatetimeVector': 'double[pyarrow]', + 'MonthVector': 'int32[pyarrow]', + 'DateVector': 'int32[pyarrow]', + 'TimespanVector': 'int64[pyarrow]', + 'MinuteVector': 'int32[pyarrow]', + 'SecondVector': 'int32[pyarrow]', + 'TimeVector': 'int32[pyarrow]', + } + + class Vector(Collection, abc.Sequence): """Base type for all q vectors, which are ordered collections of a particular type.""" @property @@ -1490,7 +1538,7 @@ def has_infs(self) -> bool: type_char = ' bg xhijefcspmdznuvts'[self.t] except IndexError: return False - return q(f'{{any any -0W 0W{type_char}=\\:x}}')(self).py() + return q(f'{{any -0W 0W{type_char}=\\:x}}')(self).py() def __len__(self): return _wrappers.k_n(self) @@ -1535,8 +1583,19 @@ def pd( *, raw: bool = False, has_nulls: Optional[bool] = None, + as_arrow: Optional[bool] = False, ): res = pd.Series(self.np(raw=raw, has_nulls=has_nulls), copy=False) + if as_arrow: + if not pandas_2: + raise RuntimeError('Pandas Version must be at least 2.0 to use as_arrow=True') + if pa is None: + raise PyArrowUnavailable # nocov + if raw: + if type(self).__name__ != 'GUIDVector': + res = res.astype(_as_arrow_raw_map[type(self).__name__]) + else: + res = res.astype(_as_arrow_map[type(self).__name__]) return res def pa(self, *, raw: bool = False, has_nulls: Optional[bool] = None): @@ -1959,7 +2018,7 @@ def py(self, *, raw: bool = False, has_nulls: Optional[bool] = None, stdlib: boo def np(self, *, raw: bool = False, has_nulls: Optional[bool] = None): """Provides a Numpy representation of the list.""" - return _wrappers.list_np(self, raw, has_nulls) + return _wrappers.list_np(self, False, has_nulls) class NumericVector(Vector): @@ -2006,11 +2065,24 @@ def pd( *, raw: bool = False, has_nulls: Optional[bool] = None, + as_arrow: Optional[bool] = False, ): + if as_arrow: + if not pandas_2: + raise RuntimeError('Pandas Version must be at least 2.0 to use as_arrow=True') + if pa is None: + raise PyArrowUnavailable # nocov arr = self.np(raw=raw, has_nulls=has_nulls) - if isinstance(arr, np.ma.MaskedArray): - arr = pd.arrays.IntegerArray(arr, mask=arr.mask, copy=False) - res = pd.Series(arr, copy=False) + if as_arrow: + arr = pa.array(arr) + if raw: + res = pd.Series(arr, copy=False, dtype=_as_arrow_raw_map[type(self).__name__]) + else: + res = pd.Series(arr, copy=False, dtype=_as_arrow_map[type(self).__name__]) + else: + if isinstance(arr, np.ma.MaskedArray): + arr = pd.arrays.IntegerArray(arr, mask=arr.mask, copy=False) + res = pd.Series(arr, copy=False) return res @@ -2172,6 +2244,7 @@ def pd( *, raw: bool = False, has_nulls: Optional[bool] = None, + as_arrow: Optional[bool] = False, ): if raw: return PandasUUIDArray(self.np(raw=raw)) @@ -2596,9 +2669,17 @@ def pd( *, raw: bool = False, has_nulls: Optional[bool] = None, + as_arrow: Optional[bool] = False, ): if raw: - return super(self).pd(raw=raw, has_nulls=has_nulls) + res = super().pd(raw=raw, has_nulls=has_nulls) + if as_arrow: + if not pandas_2: + raise RuntimeError('Pandas Version must be at least 2.0 to use as_arrow=True') + if pa is None: + raise PyArrowUnavailable # nocov + res = res.astype('int64[pyarrow]') + return res res = pd.Series(self.np(raw=raw, has_nulls=has_nulls), dtype='category') return res @@ -2621,8 +2702,9 @@ def pd( *, raw: bool = False, has_nulls: Optional[bool] = None, + as_arrow: Optional[bool] = False, ): - res = self._as_list().pd(raw=raw, has_nulls=has_nulls) + res = self._as_list().pd(raw=raw, has_nulls=has_nulls, as_arrow=as_arrow) return res def pa(self, *, raw: bool = False, has_nulls: Optional[bool] = None): @@ -2786,7 +2868,10 @@ def pd( raw: bool = False, has_nulls: Optional[bool] = None, raw_guids=False, + as_arrow: Optional[bool] = False, ): + if raw_guids: + warnings.warn("Keyword 'raw_guids' is deprecated", DeprecationWarning) if raw_guids and not raw: v = [x.np(raw=isinstance(x, GUIDVector), has_nulls=has_nulls) for x in self._values] v = [PandasUUIDArray(x) if x.dtype == complex else x for x in v] @@ -2805,8 +2890,19 @@ def pd( for i, v in enumerate(self._values): if not raw and isinstance(v, EnumVector): df = df.astype({self._keys.py()[i]: 'category'}) - _pykx_base_types[self._keys.py()[i]] = str(type(v)).split('.')[-1] + _pykx_base_types[self._keys.py()[i]] = str(type(v).__name__) df.attrs['_PyKX_base_types'] = _pykx_base_types + if as_arrow: + if not pandas_2: + raise RuntimeError('Pandas Version must be at least 2.0 to use as_arrow=True') + if pa is None: + raise PyArrowUnavailable # nocov + if raw: + t_dict = dict(filter(lambda i: i[1] != 'GUIDVector', _pykx_base_types.items())) + df = df.astype(dict([(k, _as_arrow_raw_map[v]) + for k, v in t_dict.items()])) + else: + df = df.astype(dict([(k, _as_arrow_map[v]) for k, v in _pykx_base_types.items()])) return df def pa(self, *, raw: bool = False, has_nulls: Optional[bool] = None): @@ -2988,6 +3084,116 @@ def grouped(self, cols: Union[List, str] = ''): else: raise e + def xbar(self, values): + """ + Apply `xbar` round down operations on the column(s) of a table to a specified + value + + Parameters: + values: Provide a dictionary mapping the column to apply rounding to with + the rounding value as follows `{column: value}`. + + Returns: + A table with rounding applied to the specified columns. + + Example: + + ```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 + ')) + >>> tab.xbar({'x': 10, 'y': 2}) + pykx.Table(pykx.q(' + x y + ---- + 70 8 + 70 8 + 50 4 + 90 8 + 0 8 + ')) + ``` + """ + return q("{if[11h<>type key y;" + " '\"Column(s) supplied must convert to type pykx.SymbolAtom\"];" + " ![x;();0b;key[y]!{(xbar;x;y)}'[value y;key y]]}", self, values) + + def window_join(self, table, windows, cols, aggs): + """ + Window joins provide the ability to analyse the behaviour of data + in one table in the neighborhood of another. + + Parameters: + table: A `pykx.Table` or Python table equivalent containing a `['sym' and 'time']` + column (or equivalent) with a `parted` attribute on `'sym'`. + windows: A pair of lists containing times/timestamps denoting the beginning and + end of the windows + cols: The names of the common columns `['sym' and 'time']` within each table + aggs: A dictionary mapping the name of a new derived column to a list + specifying the function to be applied as the first element and the columns + which should be passed from the `table` to this function. These are mapped + {'new_col0': [f0, 'c0'], 'new_col1': [f1, 'c0', 'c1']}. + + Returns: + For each record of the original table, a record with additional columns + denoted by the `new_col0` entries in the `aggs` argument are added which is + the result of applying the function `f0` with the content of column `c0` over + the matching intervals in the `table`. + + Example: + + ```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]}) + >>> windows = kx.q('{-2 1+\:x}', trades['time']) + >>> trades.window_join(quotes, + ... windows, + ... ['sym', 'time'], + ... {'ask_max': [lambda x: max(x), 'ask'], + ... 'ask_minus_bid': [lambda x, y: x - y, 'ask', 'bid']}) + 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 + ')) + ``` + """ + return q("{[t;q;w;c;a]" + "(cols[t], key a) xcol wj[w; c; t;enlist[q],value a]}", + self, table, windows, cols, aggs) + def _repr_html_(self): if not licensed: return self.__repr__() @@ -3417,6 +3623,7 @@ def pd( *, raw: bool = False, has_nulls: Optional[bool] = None, + as_arrow: Optional[bool] = False, ): kk = self._keys._keys vk = self._values._keys @@ -3425,6 +3632,12 @@ def pd( if len(self) == 0: df = pd.DataFrame(columns=kk.py() + vk.py()) df = df.set_index(kk.py()) + if as_arrow: + if not pandas_2: + raise RuntimeError('Pandas Version must be at least 2.0 to use as_arrow=True') + if pa is None: + raise PyArrowUnavailable # nocov + df = df.convert_dtypes(dtype_backend='pyarrow') return df idx = [kvg(i).np(raw=raw, has_nulls=has_nulls).reshape(-1) for i in range(len(kk))] @@ -3439,11 +3652,22 @@ def pd( for i, col in enumerate(kk.py()): if not raw and isinstance(kvg(i), EnumVector): df[col] = df[col].astype('category') - _pykx_base_types[col] = str(type(kvg(i))).split('.')[-1] + _pykx_base_types[col] = str(type(kvg(i)).__name__) for i, col in enumerate(vk.py()): if not raw and isinstance(vvg(i), EnumVector): df[col] = df[col].astype('category') - _pykx_base_types[col] = str(type(vvg(i))).split('.')[-1] + _pykx_base_types[col] = str(type(vvg(i)).__name__) + if as_arrow: + if not pandas_2: + raise RuntimeError('Pandas Version must be at least 2.0 to use as_arrow=True') + if pa is None: + raise PyArrowUnavailable # nocov + if raw: + t_dict = dict(filter(lambda i: i[1] != 'GUIDVector', _pykx_base_types.items())) + df = df.astype(dict([(k, _as_arrow_raw_map[v]) + for k, v in t_dict.items()])) + else: + df = df.astype(dict([(k, _as_arrow_map[v]) for k, v in _pykx_base_types.items()])) df.set_index(kk.py(), inplace=True) df.attrs['_PyKX_base_types'] = _pykx_base_types return df diff --git a/tests/test_ipc.py b/tests/test_ipc.py index 2c4685c..ef563d4 100644 --- a/tests/test_ipc.py +++ b/tests/test_ipc.py @@ -657,6 +657,60 @@ def test_large_IPC(kx, q_port): assert size == len(res) +@pytest.mark.unlicensed +def test_func_parameter(kx, q_port): + # The below tests are formatted as follows + # to allow operation both in licensed and + # unlicensed mode, the initial call retrieves + # the function and the assertion passes the + # tested functions to the server as the query arg + with kx.SyncQConnection(port=q_port) as q: + fn = q('{sum}', None) + assert q(fn, [1, 2, 3]).py() == 6 + + fn = q('{floor}', None) + assert q(fn, 5.2).py() == 5 + + fn = q('{mins}', None) + assert q(fn, [1, 2, 3]).py() == [1, 1, 1] + + fn = q('{cut}', None) + assert q(fn, 2, [1, 2, 3]).py() == [[1, 2], [3]] + + fn = q('{min x}') + assert q(fn, [1, 2, 3]).py() == 1 + + if kx.licensed: + with kx.SecureQConnection(port=q_port) as q: + fn = q('{sum}', None) + assert q(fn, [1, 2, 3]).py() == 6 + + fn = q('{floor}', None) + assert q(fn, 5.2).py() == 5 + + fn = q('{mins}', None) + assert q(fn, [1, 2, 3]).py() == [1, 1, 1] + + fn = q('{cut}', None) + assert q(fn, 2, [1, 2, 3]).py() == [[1, 2], [3]] + + fn = q('{min x}') + assert q(fn, [1, 2, 3]).py() == 1 + + +@pytest.mark.unlicensed +def test_func_errors(kx, q_port): + with kx.SyncQConnection(port=q_port) as q: + with pytest.raises(ValueError) as err: + q(sum, [1, 2, 3]) + assert 'builtin_function_or_method' in str(err) + + with kx.SecureQConnection(port=q_port) as q: + with pytest.raises(ValueError) as err: + q(sum, [1, 2, 3]) + assert 'builtin_function_or_method' in str(err) + + @pytest.mark.unlicensed def test_debug_kwarg(kx, q_port): with kx.SyncQConnection(port=q_port) as q: @@ -712,6 +766,7 @@ def test_debug_kwarg_global(q_port): with kx.SyncQConnection(port=q_port) as q: q('.pykx_test.cache_sbt:.Q.sbt') q('.Q.sbt:{.pykx_test.cache:y;x y}[.Q.sbt]') + assert q('=', b'z', b'z').py() assert q('til 10').py() == list(range(10)) with pytest.raises(kx.QError) as e: q('til "asd"') @@ -857,6 +912,7 @@ def test_SyncQConnection_reconnect(kx): @pytest.mark.unlicensed +@pytest.mark.xfail(reason='Flaky on several platforms') def test_SecureQConnection_reconnect(kx): q_exe_path = subprocess.run(['which', 'q'], stdout=subprocess.PIPE).stdout.decode().strip() proc = subprocess.Popen( diff --git a/tests/test_license.py b/tests/test_license.py index d57d930..7399b33 100644 --- a/tests/test_license.py +++ b/tests/test_license.py @@ -1,7 +1,6 @@ import base64 from io import StringIO import os -import shutil import re # Do not import pykx here - use the `kx` fixture instead! @@ -56,13 +55,27 @@ def test_invalid_lic_continue(tmp_path, monkeypatch): assert str(e) == 'Invalid input provided please try again' +@pytest.mark.skipif( + os.getenv('PYKX_THREADING') is not None, + reason='Not supported with PYKX_THREADING' +) +def test_invalid_commercial_input(tmp_path, monkeypatch): + os.environ['QLIC'] = os.environ['QHOME'] = str(tmp_path.absolute()) + inputs = iter(['Y', 'F']) + monkeypatch.setattr('builtins.input', lambda _: next(inputs)) + try: + import pykx as kx # noqa: F401 + except Exception as e: + assert str(e) == 'User provided option was not one of [1/2]' + + @pytest.mark.skipif( os.getenv('PYKX_THREADING') is not None, reason='Not supported with PYKX_THREADING' ) def test_licensed_signup_no_file(tmp_path, monkeypatch): os.environ['QLIC'] = os.environ['QHOME'] = str(tmp_path.absolute()) - inputs = iter(['Y', 'n', '1', '/test/test.blah']) + inputs = iter(['Y', '1', 'n', '1', '/test/test.blah']) monkeypatch.setattr('builtins.input', lambda _: next(inputs)) try: import pykx as kx # noqa: F401 @@ -76,7 +89,7 @@ def test_licensed_signup_no_file(tmp_path, monkeypatch): ) def test_licensed_signup_invalid_b64(tmp_path, monkeypatch): os.environ['QLIC'] = os.environ['QHOME'] = str(tmp_path.absolute()) - inputs = iter(['Y', 'n', '2', 'data:image/png;test']) + inputs = iter(['Y', '1', 'n', '2', 'data:image/png;test']) monkeypatch.setattr('builtins.input', lambda _: next(inputs)) try: import pykx as kx # noqa: F401 @@ -94,7 +107,7 @@ def test_licensed_success_file(monkeypatch): qhome_path = os.environ['QHOME'] os.unsetenv('QLIC') os.unsetenv('QHOME') - inputs = iter(['Y', 'n', '1', qhome_path + '/kc.lic']) + inputs = iter(['Y', '1', 'n', '1', qhome_path + '/kc.lic']) monkeypatch.setattr('builtins.input', lambda _: next(inputs)) import pykx as kx @@ -112,7 +125,7 @@ def test_licensed_success_b64(monkeypatch): os.unsetenv('QHOME') with open(qhome_path + '/kc.lic', 'rb') as f: license_content = base64.encodebytes(f.read()) - inputs = iter(['Y', 'n', '2', str(license_content)]) + inputs = iter(['Y', '1', 'n', '2', str(license_content)]) monkeypatch.setattr('builtins.input', lambda _: next(inputs)) import pykx as kx @@ -195,28 +208,6 @@ def test_check_license_success_b64(kx): assert kx.license.check(license, format='STRING') -@pytest.mark.xfail(reason="Manual testing works correctly, seems to be a persistance issue") -@pytest.mark.skipif('KDB_LICENSE_EXPIRED' not in os.environ, - reason='Test required KDB_LICENSE_EXPIRED environment variable to be set') -def test_exp_license(kx): - exp_lic = os.environ['KDB_LICENSE_EXPIRED'] - lic_folder = '/tmp/license' - os.makedirs(lic_folder, exist_ok=True) - with open(lic_folder + '/k4.lic', 'wb') as binary_file: - binary_file.write(base64.b64decode(exp_lic)) - qhome_loc = os.environ['QHOME'] - os.environ['QLIC'] = os.environ['QHOME'] = lic_folder - pattern = re.compile('Your PyKX license has now.*') - with patch('sys.stdout', new=StringIO()) as test_out: - try: - import pykx # noqa: F401 - except Exception as e: - assert str(e) == "EOF when reading a line" - shutil.rmtree(lic_folder) - os.environ['QLIC'] = os.environ['QHOME'] = qhome_loc - assert pattern.match(test_out.getvalue()) - - def test_check_license_invalid(kx): pattern = re.compile("Supplied license information does not match.*") with patch('sys.stdout', new=StringIO()) as test_out: diff --git a/tests/test_pandas_replace.py b/tests/test_pandas_replace.py new file mode 100644 index 0000000..b2bcc37 --- /dev/null +++ b/tests/test_pandas_replace.py @@ -0,0 +1,25 @@ +# Do not import pykx here - use the `kx` fixture instead! + + +def test_unkeyed_replace(kx, q): + tab = kx.q('([] a:2 2 3; b:4 2 6; c:7 2 9; d:(`a;`b;`c); e:(1;2;`a))') + assert all((tab.replace(2, 10).pd() == tab.pd().replace(2, 10))) + assert all((tab.replace(1000, 1).pd() == tab.pd().replace(1000, 1))) + assert all((tab.replace('a', 100).pd() == tab.pd().replace('a', 100))) + assert all((tab.replace(2, 'a').pd() == tab.pd().replace(2, 'a'))) + assert all((tab.replace(3, "test").pd() == tab.pd().replace(3, "test"))) + + replaced_tab = kx.q('([] a:2 2 3; b:((`a,2);2;6); c:7 2 9; d:(`a;`b;`c); e:(1;2;`a))') + assert all((tab.replace(4, ('a', 2)) == replaced_tab)) + + +def test_keyed_replace(kx, q): + ktab = kx.q('([a:2 2 3]b:4 2 6; c:7 2 9; d:(`a;`b;`c); e:(1;2;`a))') + assert all((ktab.replace(2, 10).pd() == ktab.pd().replace(2, 10))) + assert all((ktab.replace(1000, 1).pd() == ktab.pd().replace(1000, 1))) + assert all((ktab.replace('a', 100).pd() == ktab.pd().replace('a', 100))) + assert all((ktab.replace(2, 'a').pd() == ktab.pd().replace(2, 'a'))) + assert all((ktab.replace(3, "test").pd() == ktab.pd().replace(3, "test"))) + + replaced_ktab = kx.q('([a:2 2 3]b:((`a,2);2;6); c:7 2 9; d:(`a;`b;`c); e:(1;2;`a))') + assert all(ktab.replace(4, ('a', 2)).values() == replaced_ktab.values()) diff --git a/tests/test_pykx.py b/tests/test_pykx.py index 22738b8..271eec1 100644 --- a/tests/test_pykx.py +++ b/tests/test_pykx.py @@ -357,3 +357,9 @@ def test_PYKX_Q_LIB_LOCATION(): import pykx as kx kx.q('\\l PYKX_Q_LIB_LOCATION.q') assert 42 == kx.q('.pytest.a').py() + + +@pytest.mark.unlicensed +def test_subnormals(kx): + import numpy as np + assert '5e-324' == str(np.finfo(np.float64).smallest_subnormal + 0.) diff --git a/tests/test_q.py b/tests/test_q.py index 288aef7..20fa8be 100644 --- a/tests/test_q.py +++ b/tests/test_q.py @@ -244,6 +244,8 @@ def test_debug_global(): assert kx.q('til 10').py() == list(range(10)) cache_sbt = kx.q('.Q.sbt') kx.q('.Q.sbt:{.pykx_test.cache:x}') + + assert kx.q('=', kx.q('"z"'), b'z').py() try: kx.q('til "asd"') except Exception as e: @@ -276,3 +278,14 @@ def test_41(): kx.q('(`a;):(`b;1.2)') assert 'match' in str(err) os.unsetenv('PYKX_4_1_ENABLED') + + +@pytest.mark.isolate +def test_load_spacefile(tmp_path): + test_location = tmp_path/'test directory' + os.makedirs(test_location, exist_ok=True) + with open(test_location/'file.q', 'w') as f: + f.write('.pykx_test.tmp.variable:1b') + import pykx as kx + kx.q('{.pykx.util.loadfile[1_string x;y]}', test_location, b'file.q') + assert kx.q('.pykx_test.tmp.variable') diff --git a/tests/test_streamlit.py b/tests/test_streamlit.py new file mode 100644 index 0000000..b4f9448 --- /dev/null +++ b/tests/test_streamlit.py @@ -0,0 +1,41 @@ +import os +import sys + +# Do not import pykx here - use the `kx` fixture instead! +import pytest + +if not sys.version_info < (3, 8): + import streamlit as st + + +@pytest.mark.skipif(sys.version_info < (3, 8), reason="requires python3.8 or higher") +def test_streamlit(kx, q_port): + conn = st.connection('pykx', type=kx.streamlit.PyKXConnection, + host='localhost', port=q_port) + assert kx.q('~', conn.query('til 5'), [0, 1, 2, 3, 4]) + + conn.query('tab:([]10?1f;10?1f)') + sql_loaded = conn.query('@[{system"l ",x;1b};"s.k_";{0b}]') + if sql_loaded: + assert kx.q('~', conn.query('tab'), conn.query('select * from tab', format='sql')) + assert kx.q('~', conn.query('select from tab where x>0.5'), conn.query('tab', where='x>0.5', format='qsql')) # noqa: E501 + assert conn.is_healthy() + + with pytest.raises(kx.QError) as err: + conn.query('tab', format='unsupported') + assert 'Unsupported format provided for query' in str(err.value) + + +@pytest.mark.isolate +@pytest.mark.skipif( + os.getenv('PYKX_THREADING') is not None, + reason='Threading only works when beta features enabled so this will pass in threading tests' +) +@pytest.mark.skipif(sys.version_info < (3, 8), reason="requires python3.8 or higher") +def test_beta(): + import pykx as kx + + with pytest.raises(kx.QError) as err: + st.connection('pykx', type=kx.streamlit.PyKXConnection, + host='localhost', port=5050) + assert 'Attempting to use a beta feature "Streamlit' in str(err.value) diff --git a/tests/test_system.py b/tests/test_system.py index b9d47cb..620d583 100644 --- a/tests/test_system.py +++ b/tests/test_system.py @@ -76,6 +76,10 @@ def test_system_tables(): kx.q('qtab: ([] til 10; 2 + til 10)') kx.q('r: ([] til 10; 2 + til 10)') assert kx.q.system.tables().py() == ['qtab', 'r'] + kx.q('.foo.tab:([]10?1f;10?1f)') + kx.q('foo.bar:([]10?1f)') + assert kx.q.system.tables('.foo').py() == ['tab'] + assert kx.q.system.tables('foo').py() == ['bar'] @pytest.mark.isolate @@ -95,7 +99,8 @@ def test_system_functions(): kx.q('\\d .foo') kx.q('func: {x + 3}') kx.q('\\d .') - assert all(kx.q.system.functions('foo') == kx.q('enlist `func')) + kx.q('foo.bar: {x+1}') + assert all(kx.q.system.functions('foo') == kx.q('enlist `bar')) assert all(kx.q.system.functions('.foo') == kx.q('enlist `func')) @@ -201,6 +206,51 @@ def test_system_load(): pass +@pytest.mark.isolate +def test_system_space_load(tmp_path): + test_location = tmp_path/'test directory' + os.makedirs(test_location, exist_ok=True) + cache_dir = os.getcwd() + file_location = test_location/'load_file.q' + with open(file_location, 'w') as f: + f.write('.pykx_test.system.variable:1b') + import pykx as kx + kx.q.system.load(file_location) + assert kx.q('.pykx_test.system.variable') + assert cache_dir == os.getcwd() + + test_splay = test_location/'splay/' + kx.q('{x set ([]10?1f;10?1f)}', test_splay) + + def test_load_splay(test_splay): + loaded = kx.q.system.load(test_splay) + assert loaded.py() == 'splay' + assert isinstance(kx.q['splay'], kx.Table) + kx.q('delete splay from `.') + assert cache_dir == os.getcwd() + + test_load_splay(test_splay) # Path + test_load_splay(str(test_splay)) # String + test_load_splay(kx.toq(test_splay)) # Symbol with leading : + test_load_splay(kx.toq(str(test_splay))) # Symbol without leading : + test_load_splay(kx.CharVector(str(test_splay))) # CharVector + test_load_splay(str(test_splay) + '/') # String with trailing / + # Symbol with leading : with trailing / + test_load_splay(kx.q('{`$string[x],"/"}', kx.toq(test_splay))) + # Symbol without leading : with trailing / + test_load_splay(kx.q('{`$string[x],"/"}', kx.toq(str(test_splay)))) + # CharVector with trailing / + test_load_splay(kx.q('{x,"/"}', kx.CharVector(str(test_splay)))) + + file_move_location = test_location/'move_file.q' + with open(file_move_location, 'w') as f: + f.write('.pykx_test.move.variable:1b;system"cd .."') + kx.q.system.load(file_move_location) + assert kx.q('.pykx_test.move.variable') + assert cache_dir != os.getcwd() + os.chdir(cache_dir) + + @pytest.mark.isolate def test_system_namespace(): import pykx as kx @@ -287,7 +337,8 @@ def test_system_functions_ipc(q_port): q('print: {til x}') assert all(q.system.functions() == q('enlist `print')) q('.foo.func: {x + 3}') - assert all(q.system.functions('foo') == q('enlist `func')) + q('foo.bar:{x+2}') + assert all(q.system.functions('foo') == q('enlist `bar')) assert all(q.system.functions('.foo') == q('enlist `func')) diff --git a/tests/test_toq.py b/tests/test_toq.py index 51b6e68..a90b52a 100644 --- a/tests/test_toq.py +++ b/tests/test_toq.py @@ -384,24 +384,94 @@ def test_from_datetime64(kx): @pytest.mark.unlicensed @pytest.mark.nep49 -def test_from_datetime64_smsus(kx): - d = np.array(['2020-09-08T07:06:05.000004'], dtype='datetime64[us]') +def test_from_datetime64_smsusns(kx): + d = np.array(['2020-09-08T07:06:05.000004', '2020-09-08T07:06:05.000004'], + dtype='datetime64[ns]') + dn = np.array(['', ''], dtype='datetime64[ns]') + dnm = np.array(['', '2020-09-08T07:06:05.000004'], dtype='datetime64[ns]') + df = pd.DataFrame(data={'d': d, 'dn': dn, 'dnm': dnm}) kd = kx.K(d) - assert isinstance(kd, kx.TimestampVector) + kd_hn = kx.K(d, handle_nulls=True) + kdn = kx.K(dn) + kdn_hn = kx.K(dn, handle_nulls=True) + assert all([isinstance(x, kx.TimestampVector) for x in [kd, kd_hn, kdn, kdn_hn]]) assert (kd.np() == d.astype(np.dtype('datetime64[ns]'))).all() - - d = np.array(['2020-09-08T07:06:05.004'], dtype='datetime64[ms]') + if kx.licensed: + assert (kx.toq(df) == kx.toq(kx.toq(df).pd())).all().all() + assert (kx.toq(df, handle_nulls=True) + == kx.toq(kx.toq(df, handle_nulls=True).pd(), handle_nulls=True)).all().all() + if kx.config.pandas_2: + assert (kx.toq(df) == kx.toq(kx.toq(df).pd(as_arrow=True))).all().all() + assert (kx.toq(df, handle_nulls=True) + == kx.toq(kx.toq(df, handle_nulls=True).pd(as_arrow=True), + handle_nulls=True)).all().all() + + d = np.array(['2020-09-08T07:06:05.000004', '2020-09-08T07:06:05.000004'], + dtype='datetime64[us]') + dn = np.array(['', ''], dtype='datetime64[us]') + dnm = np.array(['', '2020-09-08T07:06:05.000004'], dtype='datetime64[us]') + df = pd.DataFrame(data={'d': d, 'dn': dn, 'dnm': dnm}) kd = kx.K(d) - assert isinstance(kd, kx.TimestampVector) + kd_hn = kx.K(d, handle_nulls=True) + kdn = kx.K(dn) + kdn_hn = kx.K(dn, handle_nulls=True) + assert all([isinstance(x, kx.TimestampVector) for x in [kd, kd_hn, kdn, kdn_hn]]) assert (kd.np() == d.astype(np.dtype('datetime64[ns]'))).all() + if kx.licensed: + assert (kx.toq(df) == kx.toq(kx.toq(df).pd())).all().all() + assert (kx.toq(df, handle_nulls=True) + == kx.toq(kx.toq(df, handle_nulls=True).pd(), handle_nulls=True)).all().all() + if kx.config.pandas_2: + assert (kx.toq(df) == kx.toq(kx.toq(df).pd(as_arrow=True))).all().all() + assert (kx.toq(df, handle_nulls=True) + == kx.toq(kx.toq(df, handle_nulls=True).pd(as_arrow=True), + handle_nulls=True)).all().all() + + d = np.array(['2020-09-08T07:06:05.000004', '2020-09-08T07:06:05.000004'], + dtype='datetime64[ms]') + dn = np.array(['', ''], dtype='datetime64[ms]') + dnm = np.array(['', '2020-09-08T07:06:05.000004'], dtype='datetime64[ms]') + df = pd.DataFrame(data={'d': d, 'dn': dn, 'dnm': dnm}) - d = np.array(['2020-09-08T07:06:05'], dtype='datetime64[s]') + kd = kx.K(d) + kd_hn = kx.K(d, handle_nulls=True) + kdn = kx.K(dn) + kdn_hn = kx.K(dn, handle_nulls=True) + assert all([isinstance(x, kx.TimestampVector) for x in [kd, kd_hn, kdn, kdn_hn]]) + assert (kd.np() == d.astype(np.dtype('datetime64[ns]'))).all() + if kx.licensed: + assert (kx.toq(df) == kx.toq(kx.toq(df).pd())).all().all() + assert (kx.toq(df, handle_nulls=True) + == kx.toq(kx.toq(df, handle_nulls=True).pd(), handle_nulls=True)).all().all() + if kx.config.pandas_2: + assert (kx.toq(df) == kx.toq(kx.toq(df).pd(as_arrow=True))).all().all() + assert (kx.toq(df, handle_nulls=True) + == kx.toq(kx.toq(df, handle_nulls=True).pd(as_arrow=True), + handle_nulls=True)).all().all() + + d = np.array(['2020-09-08T07:06:05.000004', '2020-09-08T07:06:05.000004'], + dtype='datetime64[s]') + dn = np.array(['', ''], dtype='datetime64[s]') + dnm = np.array(['', '2020-09-08T07:06:05.000004'], dtype='datetime64[s]') + df = pd.DataFrame(data={'d': d, 'dn': dn, 'dnm': dnm}) kd = kx.K(d) - assert isinstance(kd, kx.TimestampVector) + kd_hn = kx.K(d, handle_nulls=True) + kdn = kx.K(dn) + kdn_hn = kx.K(dn, handle_nulls=True) + assert all([isinstance(x, kx.TimestampVector) for x in [kd, kd_hn, kdn, kdn_hn]]) assert (kd.np() == d.astype(np.dtype('datetime64[ns]'))).all() + if kx.licensed: + assert (kx.toq(df) == kx.toq(kx.toq(df).pd())).all().all() + assert (kx.toq(df, handle_nulls=True) + == kx.toq(kx.toq(df, handle_nulls=True).pd(), handle_nulls=True)).all().all() + if kx.config.pandas_2: + assert (kx.toq(df) == kx.toq(kx.toq(df).pd(as_arrow=True))).all().all() + assert (kx.toq(df, handle_nulls=True) + == kx.toq(kx.toq(df, handle_nulls=True).pd(as_arrow=True), + handle_nulls=True)).all().all() @pytest.mark.unlicensed @@ -926,19 +996,6 @@ def test_from_pandas_dataframe_licensed(q, kx): assert time_tab.equals(kx.K(time_tab).pd()) -@pytest.mark.nep49 -def test_from_pandas_dataframe_licensed_warning(q, kx): - if pd.__version__.split('.')[0] == '2': - q('N:100') - gen_q_datatypes_table(q, 'dset_1D', int(q('N'))) - q('gen_names:{"dset_",/:x,/:string til count y}') - type_tab = q('flip (`$gen_names["tab";dset_1D])!N#\'dset_1D') - df = type_tab.pd() - del df.attrs['_PyKX_base_types'] - with pytest.warns(RuntimeWarning): - kx.K(df) - - @pytest.mark.unlicensed @pytest.mark.nep49 def test_from_complex_pandas_dataframe(kx, pd): diff --git a/tests/test_wrappers.py b/tests/test_wrappers.py index 0587c04..040209f 100644 --- a/tests/test_wrappers.py +++ b/tests/test_wrappers.py @@ -1525,7 +1525,6 @@ def test_py(self, q, kx): @pytest.mark.nep49 def test_np(self, q, kx): qv = q(self.v) - assert qv.np(raw=True).dtype == np.uintp assert qv.np().dtype == object assert qv.np()[1] == UUID(int=1) assert isinstance(qv.np()[-1], float) @@ -1565,7 +1564,6 @@ def test_contains(self, q): def test_empty_vector(self, q): assert q('0h$()').np().dtype == object - assert q('0h$()').np(raw=True).dtype == np.uint64 # NaN is tricky to compare, so we generate GUID vectors until we get one whose complex form has no @@ -2227,6 +2225,15 @@ def test_bool(self, q): with pytest.raises(TypeError): bool(q('0#', q(self.q_vec_str))) + def test_pd(self, q, kx): + assert all(q(self.q_vec_str).pd(raw=True).to_numpy() == [0, 1, 2, 0, 1, 2]) + assert all(q(self.q_vec_str).pd().to_numpy() == ['abc', 'xyz', 'hmm', 'abc', 'xyz', 'hmm']) + + if kx.config.pandas_2: + assert all(q(self.q_vec_str).pd(raw=True, as_arrow=True) == [0, 1, 2, 0, 1, 2]) + assert all( + q(self.q_vec_str).pd(as_arrow=True) == ['abc', 'xyz', 'hmm', 'abc', 'xyz', 'hmm']) + class Test_Anymap: def test_anymap(self, kx, q, tmp_path): @@ -2501,6 +2508,65 @@ def test_table_negative_indexing(self, q): with pytest.raises(IndexError): tab[-6] + def test_xbar(self, kx, q): + tab = q('([]10?100f;10?10f;10?1f)') + assert q('~', + tab.xbar({'x': 10}), + q('{[tab]update 10 xbar x from tab}', tab)) + assert q('~', + tab.xbar({'x': 10, 'x1': 2}), + q('{[tab]update 10 xbar x, 2 xbar x1 from tab}', tab)) + + with pytest.raises(kx.QError) as err: + tab.xbar({10: 10}) + assert 'Column(s) supplied' in str(err) + + @pytest.mark.skipif( + os.getenv('PYKX_THREADING') is not None, + reason='Not supported with PYKX_THREADING' + ) + def test_window_join(self, kx, q): + trades = kx.Table(data={ + 'sym': ['ibm', 'ibm', 'ibm'], + 'time': q('10:01:01 10:01:04 10:01:08'), + 'price': [100, 101, 105]}) + q['trades'] = trades + quotes = kx.Table(data={ + 'sym': 'ibm', + 'time': 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]}) + q['quotes'] = quotes + windows = q('{-2 1+\\:x}', trades['time']) + columns = ['sym', 'time'] + q['columns'] = columns + q['windows'] = windows + py_join = trades.window_join(quotes, + windows, + columns, + {'ask': [lambda x: max(x), 'ask'], + 'bid': [lambda x: min(x), 'bid']}) + q_join = trades.window_join(quotes, + windows, + columns, + {'ask': [kx.q('max'), 'ask'], + 'bid': [kx.q('min'), 'bid']}) + + only_q = kx.q('wj[windows; columns;trades;(quotes;(max;`ask);(min;`bid))]') + assert q('~', py_join, q_join) + assert q('~', py_join, only_q) + + py_multi_join = trades.window_join(quotes, + windows, + columns, + {'ask_min_bid': [lambda x, y: x - y, 'ask', 'bid']}) + + q_multi_join = trades.window_join(quotes, + windows, + columns, + {'ask_min_bid': [kx.q('{x - y}'), 'ask', 'bid']}) + assert q('~', py_multi_join, q_multi_join) + @pytest.mark.filterwarnings('ignore:Splayed tables are not yet implemented') class Test_SplayedTable: @@ -4101,19 +4167,6 @@ def test_repr_html(kx, q): @pytest.mark.unlicensed -@pytest.mark.xfail(reason="as_arrow functionality currently awaiting introduction", strict=False) -def test_pyarrow_pandas_ci_only(q): - if os.getenv('CI'): - with pytest.raises(NotImplementedError): - q('get`:a set (' - '(1 2;3 4);' - '`time`price`vol!(2022.03.29D16:45:14.880819;1.;100i);' - '([]a:1 2;b:("ab";"cd")))' - ).pd(as_arrow=True) - - -@pytest.mark.unlicensed -@pytest.mark.xfail(reason="as_arrow functionality currently awaiting introduction", strict=False) @pytest.mark.skipif(pd.__version__[0] == '1', reason="Only supported from Pandas 2.* onwards") def test_pyarrow_pandas_all_ipc(kx, q_port): with kx.QConnection(port=q_port) as q: @@ -4129,27 +4182,17 @@ def gen_q_datatypes_table(q, table_name: str, num_rows: int = 100) -> str: gen_q_datatypes_table(q, 'tab', 100) for vec in q('tab'): - assert 'pyarrow' in str(vec.pd(as_arrow=True)) + assert 'pyarrow' in vec.pd(as_arrow=True).dtype.__repr__() q('tab: flip (`a`b`c`d`e`f`g`h`i`j`k`l`m`n)!(tab)') cols = q('cols tab').py() dfa = q('tab').pd(as_arrow=True) for c in cols: - assert 'pyarrow' in str(dfa[c].dtype) + assert 'pyarrow' in dfa[c].dtype.__repr__() q('tab: (til 100)!(tab)') - with pytest.raises(NotImplementedError): - q('10?0Ng').pd(as_arrow=True) - - with pytest.raises(NotImplementedError): - q('0Nm').pd(as_arrow=True) - - with pytest.raises(NotImplementedError): - q('0Nu').pd(as_arrow=True) - @pytest.mark.unlicensed -@pytest.mark.xfail(reason="as_arrow functionality currently awaiting introduction", strict=False) @pytest.mark.skipif(pd.__version__[0] == '1', reason="Only supported from Pandas 2.* onwards") def test_pyarrow_pandas_all(q): def gen_q_datatypes_table(q, table_name: str, num_rows: int = 100) -> str: @@ -4164,30 +4207,96 @@ def gen_q_datatypes_table(q, table_name: str, num_rows: int = 100) -> str: gen_q_datatypes_table(q, 'tab', 100) for vec in q('tab'): - assert 'pyarrow' in str(vec.pd(as_arrow=True)) + assert 'pyarrow' in vec.pd(as_arrow=True).dtype.__repr__() q('tab: flip (`a`b`c`d`e`f`g`h`i`j`k`l`m`n)!(tab)') cols = q('cols tab').py() dfa = q('tab').pd(as_arrow=True) for c in cols: - assert 'pyarrow' in str(dfa[c].dtype) + assert 'pyarrow' in str(dfa[c].dtype.__repr__()) q('tab: (til 100)!(tab)') - with pytest.raises(NotImplementedError): - q('10?0Ng').pd(as_arrow=True) - with pytest.raises(NotImplementedError): - q('`u$v:6#u:`abc`xyz`hmm').pd(as_arrow=True) +@pytest.mark.skipif(pd.__version__[0] == '1', reason="Only supported from Pandas 2.* onwards") +def test_pyarrow_pandas_all_with_null_inf(kx): - with pytest.raises(NotImplementedError): - q('0Nm').pd(as_arrow=True) + def make_t(keycol=False): + t = kx.q('{d:"hijefpmdnuvt";flip (`$/:d)!(d$\\:1 0N),\'value each\'("-0W";"0W"),\\:/:d}', + None) + t = kx.q(''' + {update b:0101b,x:0x00112233,g:{0Ng,3?0Ng}[], + c:"0 24",s:`a``bb`cc,C:("aa";"";enlist "b";"cc") from x} + ''', t) + t = kx.q.xcol({'i': 'ii'}, t) - with pytest.raises(NotImplementedError): - q('0Nu').pd(as_arrow=True) + if keycol: + t = kx.q('{`keycol xkey update keycol:i from x}', t) + return t + + t=make_t() + + def test_pd(t, hn, r): + t_rt = kx.toq(t.pd(raw=r), handle_nulls=hn) + t_rt_as = kx.toq(t.pd(raw=r, as_arrow=True), handle_nulls=hn) + assert kx.q('~', t_rt, t_rt_as) + assert kx.q('~', t_rt.dtypes, t_rt_as.dtypes) + + # KXI-44586 g guids cannot convert + t=t.drop(columns=['g']) + t_rt_a = kx.toq([t[c].pd(raw=r) for c in t.columns.py()], handle_nulls=hn) + t_rt_as_a = kx.toq([t[c].pd(raw=r, as_arrow=True) for c in t.columns.py()], handle_nulls=hn) + + for x, y in zip(t_rt_a, t_rt_as_a): + assert kx.q('~', x, y) + assert type(x) == type(y) + + test_pd(t, hn=False, r=False) + test_pd(t, hn=True, r=False) + + # KXI-44569 C List return is junk + t=t.drop(columns=['C']) + + test_pd(t, hn=False, r=True) + test_pd(t, hn=True, r=True) + + t=make_t() + # Minute overflows Seconds when roundtripping + t=t.drop(columns=['u']) + + # Exclude nulls to test non masked array logic + test_pd(t.iloc[[0, 2, 3]], hn=False, r=False) + test_pd(t.iloc[[0, 2, 3]], hn=True, r=False) + + t=t.drop(columns=['C']) + + test_pd(t.iloc[[0, 2, 3]], hn=False, r=True) + test_pd(t.iloc[[0, 2, 3]], hn=True, r=True) + + t=make_t(keycol=True) + test_pd(t, hn=False, r=False) + test_pd(t, hn=True, r=False) + + # KXI-44569 C List return is junk + t=t.drop(columns=['C']) + + test_pd(t, hn=False, r=True) + test_pd(t, hn=True, r=True) + + t=make_t(keycol=True) + # Minute overflows Seconds when roundtripping + t=t.drop(columns=['u']) + + # Exclude nulls to test non masked array logic + test_pd(t.iloc[[0, 2, 3]], hn=False, r=False) + test_pd(t.iloc[[0, 2, 3]], hn=True, r=False) + + t=t.drop(columns=['C']) + + test_pd(t.iloc[[0, 2, 3]], hn=False, r=True) + test_pd(t.iloc[[0, 2, 3]], hn=True, r=True) @pytest.mark.embedded -@pytest.mark.xfail(reason="as_arrow functionality currently awaiting introduction", strict=False) @pytest.mark.skipif(pd.__version__[0] == '1', reason="Only supported from Pandas 2.* onwards") def test_pyarrow_pandas_table_roundtrip(kx): kx.q('gen_data:{@[;0;string]x#/:prd[x]?/:(`6;`6;0Ng),("bxhijefpdnuvt"$\\:0)}') @@ -4206,11 +4315,185 @@ def test_pyarrow_pandas_table_roundtrip(kx): assert (tab[x]._values == tab2[x]._values).all() -@pytest.mark.embedded -@pytest.mark.skipif(pd.__version__[0] == '1', reason="Only supported from Pandas 2.* onwards") -@pytest.mark.xfail(reason="as_arrow functionality currently awaiting introduction", strict=False) -def test_pyarrow_pandas_timedeltas(kx): - tds = kx.toq(kx.q(''' - ([] a:1D 1D01 1D01:02 1D01:01:01 1D01:01:01.001 1D01:01:01.001001 1D01:01:01.001001001) - ''').pd(as_arrow=True)['a']) - assert ([-17, -17, -17, -18, -19, -16, -16] == kx.q('{type each x}', tds)).all() +@pytest.mark.unlicensed +def test_all_timetypes(kx, q_port): + with kx.QConnection(port=q_port) as q: + # timestamp + td = q(''' + ([] a:2000.01.01D 2000.01.01D01 2000.01.01D01:02 2000.01.01D01:01:01 + 2000.01.01D01:01:01.001 2000.01.01D01:01:01.001001 + 2000.01.01D01:01:01.001001001) + ''') + if kx.config.pandas_2: + df = td.pd(as_arrow=True) + td_roundtrip = kx.toq(df) + assert 'timestamp[ns][pyarrow]' == str(df.dtypes['a']) + if kx.licensed: + assert str(td.dtypes['datatypes'][0]) == str(td_roundtrip.dtypes['datatypes'][0]) + assert all(td == td_roundtrip) + td_a_roundtrip = kx.toq(td['a'].pd(as_arrow=True)) + assert all(td['a'] == td_a_roundtrip) + df = td.pd() + assert 'datetime64[ns]' == str(df.dtypes['a']) + td_roundtrip = kx.toq(df) + if kx.licensed: + assert str(td.dtypes['datatypes'][0]) == str(td_roundtrip.dtypes['datatypes'][0]) + assert all(td == td_roundtrip) + td_a_roundtrip = kx.toq(td['a'].pd()) + assert all(td['a'] == td_a_roundtrip) + + # month + td = q('''([] a:2000.01 2000.12m)''') + if kx.config.pandas_2: + df = td.pd(as_arrow=True) + td_roundtrip = kx.toq(df) + assert 'timestamp[s][pyarrow]' == str(df.dtypes['a']) + if kx.licensed: + assert 'kx.TimestampAtom' == str(td_roundtrip.dtypes['datatypes'][0]) + assert all(td == td_roundtrip) + td_a_roundtrip = kx.toq(td['a'].pd(as_arrow=True)) + assert all(td['a'] == td_a_roundtrip) + df = td.pd() + if kx.config.pandas_2: + assert 'datetime64[s]' == str(df.dtypes['a']) + else: + assert 'datetime64[ns]' == str(df.dtypes['a']) + td_roundtrip = kx.toq(df) + if kx.licensed: + assert 'kx.TimestampAtom' == str(td_roundtrip.dtypes['datatypes'][0]) + assert all(td == td_roundtrip) + td_a_roundtrip = kx.toq(td['a'].pd()) + assert all(td['a'] == td_a_roundtrip) + + # date + td = q('([] a:2000.01.01 2000.01.02)') + if kx.config.pandas_2: + df = td.pd(as_arrow=True) + td_roundtrip = kx.toq(df) + assert 'timestamp[s][pyarrow]' == str(df.dtypes['a']) + if kx.licensed: + assert 'kx.TimestampAtom' == str(td_roundtrip.dtypes['datatypes'][0]) + assert all(td == td_roundtrip) + td_a_roundtrip = kx.toq(td['a'].pd(as_arrow=True)) + assert all(td['a'] == td_a_roundtrip) + df = td.pd() + if kx.config.pandas_2: + assert 'datetime64[s]' == str(df.dtypes['a']) + else: + assert 'datetime64[ns]' == str(df.dtypes['a']) + td_roundtrip = kx.toq(df) + if kx.licensed: + assert 'kx.TimestampAtom' == str(td_roundtrip.dtypes['datatypes'][0]) + assert all(td == td_roundtrip) + td_a_roundtrip = kx.toq(td['a'].pd()) + assert all(td['a'] == td_a_roundtrip) + + # timespan + td = q(''' + ([] a:1D 1D01 1D01:02 1D01:01:01 1D01:01:01.001 1D01:01:01.001001 + 1D01:01:01.001001001) + ''') + if kx.config.pandas_2: + df = td.pd(as_arrow=True) + td_roundtrip = kx.toq(df) + assert 'duration[ns][pyarrow]' == str(df.dtypes['a']) + if kx.licensed: + assert str(td.dtypes['datatypes'][0]) == str(td_roundtrip.dtypes['datatypes'][0]) + assert all(td == td_roundtrip) + td_a_roundtrip = kx.toq(td['a'].pd(as_arrow=True)) + assert all(td['a'] == td_a_roundtrip) + df = td.pd() + assert 'timedelta64[ns]' == str(df.dtypes['a']) + td_roundtrip = kx.toq(df) + if kx.licensed: + assert str(td.dtypes['datatypes'][0]) == str(td_roundtrip.dtypes['datatypes'][0]) + assert all(td == td_roundtrip) + td_a_roundtrip = kx.toq(td['a'].pd()) + assert all(td['a'] == td_a_roundtrip) + + # minute + td = q('([] a:00:00 00:01 00:10 01:00 24:00)') + if kx.config.pandas_2: + df = td.pd(as_arrow=True) + td_roundtrip = kx.toq(df) + assert 'duration[s][pyarrow]' == str(df.dtypes['a']) + if kx.licensed: + assert 'kx.SecondAtom' == str(td_roundtrip.dtypes['datatypes'][0]) + assert all(td == td_roundtrip) + td_a_roundtrip = kx.toq(td['a'].pd(as_arrow=True)) + assert all(td['a'] == td_a_roundtrip) + df = td.pd() + if kx.config.pandas_2: + assert 'timedelta64[s]' == str(df.dtypes['a']) + else: + assert 'timedelta64[ns]' == str(df.dtypes['a']) + td_roundtrip = kx.toq(df) + if kx.licensed: + if kx.config.pandas_2: + assert 'kx.SecondAtom' == str(td_roundtrip.dtypes['datatypes'][0]) + else: + assert 'kx.TimespanAtom' == str(td_roundtrip.dtypes['datatypes'][0]) + assert all(td == td_roundtrip) + td_a_roundtrip = kx.toq(td['a'].pd()) + assert all(td['a'] == td_a_roundtrip) + + # second + td = q('([] a:00:00:00 00:00:01 00:00:10 00:01:00 00:10:00 01:00:00 24:00:00)') + if kx.config.pandas_2: + df = td.pd(as_arrow=True) + td_roundtrip = kx.toq(df) + assert 'duration[s][pyarrow]' == str(df.dtypes['a']) + if kx.licensed: + assert str(td.dtypes['datatypes'][0]) == str(td_roundtrip.dtypes['datatypes'][0]) + assert all(td == td_roundtrip) + td_a_roundtrip = kx.toq(td['a'].pd(as_arrow=True)) + assert all(td['a'] == td_a_roundtrip) + df = td.pd() + if kx.config.pandas_2: + assert 'timedelta64[s]' == str(df.dtypes['a']) + else: + assert 'timedelta64[ns]' == str(df.dtypes['a']) + td_roundtrip = kx.toq(df) + if kx.licensed: + if kx.config.pandas_2: + assert str(td.dtypes['datatypes'][0]) == str(td_roundtrip.dtypes['datatypes'][0]) + else: + assert 'kx.TimespanAtom' == str(td_roundtrip.dtypes['datatypes'][0]) + assert all(td == td_roundtrip) + td_a_roundtrip = kx.toq(td['a'].pd()) + assert all(td['a'] == td_a_roundtrip) + + # time + td = q(''' + ([] a:00:00:00.000 00:00:00.001 00:00:01.000 00:00:10.000 + 00:01:00.000 00:10:00.000 01:00:00.000 24:00:00.000) + ''') + if kx.config.pandas_2: + df = td.pd(as_arrow=True) + td_roundtrip = kx.toq(df) + assert 'duration[ms][pyarrow]' == str(df.dtypes['a']) + if kx.licensed: + assert str(td.dtypes['datatypes'][0]) == str(td_roundtrip.dtypes['datatypes'][0]) + assert all(td == td_roundtrip) + td_a_roundtrip = kx.toq(td['a'].pd(as_arrow=True)) + assert all(td['a'] == td_a_roundtrip) + df = td.pd() + if kx.config.pandas_2: + assert 'timedelta64[ms]' == str(df.dtypes['a']) + else: + assert 'timedelta64[ns]' == str(df.dtypes['a']) + td_roundtrip = kx.toq(df) + if kx.licensed: + if kx.config.pandas_2: + assert str(td.dtypes['datatypes'][0]) == str(td_roundtrip.dtypes['datatypes'][0]) + else: + assert 'kx.TimespanAtom' == str(td_roundtrip.dtypes['datatypes'][0]) + assert all(td == td_roundtrip) + td_a_roundtrip = kx.toq(td['a'].pd()) + assert all(td['a'] == td_a_roundtrip) + + +@pytest.mark.unlicensed +def test_datetime64(kx): + df = pd.DataFrame(data={'a': np.array([9999, 1577899899], dtype='datetime64[s]')}) + all(df['a'] == kx.toq(df).pd()['a'])