wfdb-x 1.0.0__py3-none-any.whl

wfdb_x-1.0.0.dist-info/METADATA

@@ -0,0 +1,583 @@
+Metadata-Version: 2.4
+Name: wfdb-x
+Version: 1.0.0
+Summary: A faithful, lightweight Python implementation of the WFDB library and command-line tools (WFDB 10.7.0)
+Author-email: Reza Sameni <reza.sameni@gmail.com>
+Maintainer-email: Reza Sameni <reza.sameni@gmail.com>
+License-Expression: GPL-3.0-or-later
+Project-URL: Homepage, https://github.com/alphanumericslab/wfdb-x
+Project-URL: Source, https://github.com/alphanumericslab/wfdb-x
+Project-URL: Documentation, https://github.com/alphanumericslab/wfdb-x/tree/main/python#readme
+Project-URL: Issues, https://github.com/alphanumericslab/wfdb-x/issues
+Keywords: WFDB,PhysioNet,physiologic signals,ECG,biomedical signal processing
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Operating System :: OS Independent
+Classifier: Environment :: Console
+Classifier: Topic :: Scientific/Engineering :: Medical Science Apps.
+Classifier: Intended Audience :: Science/Research
+Classifier: Framework :: Jupyter
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.17
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: nbformat; extra == "test"
+Requires-Dist: nbclient; extra == "test"
+Requires-Dist: ipykernel; extra == "test"
+Provides-Extra: examples
+Requires-Dist: matplotlib; extra == "examples"
+Requires-Dist: jupyter; extra == "examples"
+Dynamic: license-file
+
+# WFDB-x for Python
+
+`wfdbx` reads and writes physiological signal records in the WFDB format used
+by [PhysioNet](https://physionet.org). It is a complete Python implementation
+of the WFDB Software Package 10.7.0: the library and all of its command-line
+tools. It reads and writes the same files as the original C library, and its
+tools print the same output.
+
+You can use it in three ways:
+
+* **High-level functions** that read and write whole records and annotation
+  files as NumPy arrays: `read_record`, `read_header`, `read_annotations`,
+  `write_record`, `write_annotations`, and `check_record`, which checks a
+  record.
+* **Command-line tools** such as `rdsamp`, `rdann` and `wrsamp`, run through
+  the `wfdbx` command.
+* **The WFDB library functions** under their C names (`isigopen`, `getvec`,
+  `getann`, ...), for programs written against the C library.
+
+The package is pure Python. It needs Python 3.9 or later and NumPy, and runs
+on Linux, macOS and Windows.
+
+WFDB-x is part of a project that provides the same package in seven languages
+with identical behavior; see the
+[project README](https://github.com/alphanumericslab/wfdb-x#readme).
+
+## Installation
+
+```sh
+pip install wfdb-x                # the package and the wfdbx command
+pip install "wfdb-x[examples]"    # also matplotlib and Jupyter, for the example notebooks
+```
+
+The package is imported as `wfdbx`. To install from a copy of the
+repository, run `pip install ./python`.
+
+## Quick start
+
+The package includes a sample record, `100s`: the first minute of record 100
+of the [MIT-BIH Arrhythmia Database](https://physionet.org/content/mitdb/),
+with two ECG signals at 360 Hz and its beat annotations.
+
+```python
+import wfdbx
+
+# Read the sample record from the package's data directory.
+wfdbx.wfdbx_set_input_dir(wfdbx.sample_data_dir())
+
+rec = wfdbx.read_record("100s", physical=True)   # signals in physical units
+print(rec.fs, rec.names, rec.signals.shape)       # 360.0 ['MLII', 'V5'] (21600, 2)
+
+hdr = wfdbx.read_header("100s")                    # the header only, no samples
+print(hdr.nsig, hdr.nsamples)                      # 2 21600
+
+ann = wfdbx.read_annotations("100s", "atr")        # beat annotations
+print(len(ann), ann.symbols[:3], ann.samples[:3])  # 75 ['+', 'N', 'N'] [ 18  77 370]
+
+# Write the first 10 seconds as a new record, "copy", in the current directory.
+x = wfdbx.read_record("100s", sampto="0:10")       # ADC units
+wfdbx.write_record("copy", x.signals, fs=x.fs, fmt=16, gains=x.gains,
+                   baselines=x.baselines, adcres=11, units="mV", names=x.names)
+```
+
+## Reading and writing records
+
+The examples in this section read the sample record `100s` (the first minute
+of record 100 of the MIT-BIH Arrhythmia Database, included with WFDB-x, in
+the directory `wfdbx.sample_data_dir()`), and write records of their own in
+the current directory.
+
+### Reading signals: `read_record`
+
+```python
+wfdbx.wfdbx_set_input_dir(wfdbx.sample_data_dir())   # the sample record 100s
+rec = wfdbx.read_record("100s", channels=["MLII"], sampfrom="0:10", sampto="0:20",
+                        physical=True)
+```
+
+| Argument | Meaning | Default |
+|---|---|---|
+| `record` | record name or path (see [Where files are read and written](#where-files-are-read-and-written)) | |
+| `channels` | signals to read, by number or name (as in `names`) | all signals |
+| `sampfrom`, `sampto` | first sample, and the sample after the last one: a sample number or a time string (see below) | the whole record |
+| `physical` | return physical units (float64) instead of ADC units (int32) | `False` |
+| `highres` | read a multi-frequency record at its highest sampling frequency | `False` |
+| `pad` | replace invalid samples by the previous valid one | `False` |
+| `checksum_warning` | warn when the data do not match the header's checksums | `True` |
+| `input_dir`, `network` | input directory and network access for this call only | the current settings |
+| `legacy` | behave as the original package (see [Legacy mode](#legacy-mode)) | `False` |
+
+Times can be sample numbers or WFDB time strings: `"0:10"` (10 seconds),
+`"1:02:03.5"`, `"s3600"` (sample 3600) or `"e"` (the end of the record).
+
+The result is a `Record`:
+
+| Field | Contents |
+|---|---|
+| `signals` | NumPy array, one row per sample and one column per signal: int32 ADC units, or float64 physical units with `physical=True` |
+| `fs` | sampling frequency in Hz (0 if the header gives none) |
+| `names`, `units`, `gains`, `baselines` | description (without white space at either end, which some headers add), physical units, gain (ADC units per physical unit; 0 means uncalibrated) and baseline of each signal |
+| `siginfo` | the full signal specifications (`Siginfo` objects) |
+| `sampfrom` | the number of the first sample returned |
+| `base_time` | start time and date as text, to the second, such as `"[14:00:03 21/06/2024]"` |
+| `base_time_ms` | start time in milliseconds after midnight, such as `50403500` for 14:00:03.500 |
+| `base_date` | start date as `(year, month, day)` |
+| `comments` | the info strings of the header |
+| `checksum_ok` | `False` if the data do not match the header's checksums |
+
+`base_time`, `base_time_ms` and `base_date` are `None` when the header does
+not give them. Invalid samples are `wfdbx.WFDB_INVALID_SAMPLE`, or NaN in
+physical units.
+
+### Reading a header: `read_header`
+
+`read_header(record)` reads the header of a record without opening its
+signal files. It returns a `Header` with these fields: `name`, `fs`,
+`counter_freq`, `base_counter`, `nsamples` (0 if the header does not give
+the length), `nsig`, `siginfo`, `base_time`, `base_time_ms`, `base_date` and
+`comments`. They have the same meaning as in `Record`.
+
+```python
+wfdbx.wfdbx_set_input_dir(wfdbx.sample_data_dir())   # the sample record 100s
+hdr = wfdbx.read_header("100s")
+for s in hdr.siginfo:
+    print(s.desc, s.fmt, s.gain, s.units)
+```
+
+### Reading annotations: `read_annotations`
+
+```python
+wfdbx.wfdbx_set_input_dir(wfdbx.sample_data_dir())   # the sample record 100s
+ann = wfdbx.read_annotations("100s", "atr", sampfrom="0:10", sampto="0:30")
+```
+
+`annotator` is the file suffix (`"atr"` reads `100s.atr`). The optional `fs`
+gives the sampling frequency when the record has no header, or its header
+gives none. The result is an `Annotations` object, in file order:
+
+| Field | Contents |
+|---|---|
+| `samples` | annotation times, in samples (int64) |
+| `codes`, `symbols` | annotation codes (`wfdbx.NORMAL`, `wfdbx.PVC`, ...) and their mnemonics (`"N"`, `"V"`, ...) |
+| `subtypes`, `chans`, `nums` | subtype, channel and annotator number of each annotation (int64) |
+| `aux` | auxiliary text of each annotation, or `None` |
+| `fs` | the frequency in which `samples` are counted (0 if unknown) |
+
+### Writing a record: `write_record`
+
+```python
+import numpy as np
+x = np.random.randn(3600, 2)                # random numbers, written as a record "rand"
+wfdbx.write_record("rand", x, fs=360, fmt=16, physical=True,
+                   gains=1000, adcres=16, units="mV", names=["A", "B"])
+```
+
+This writes the header `rand.hea` and the signal file `rand.dat`. You must
+give the sampling frequency, the gain and ADC resolution of each signal, and
+the units of each calibrated signal; there are no defaults. A gain of 0
+marks a signal as uncalibrated, which is only allowed for samples given in
+ADC units. Per-signal arguments take one value for all signals, or a list
+with one value per signal.
+
+| Argument | Meaning |
+|---|---|
+| `signals` | array with one row per sample and one column per signal; ADC units, or physical units with `physical=True` |
+| `fs` | sampling frequency in Hz |
+| `fmt` | storage format, such as 16, 212, 24 or 516 (FLAC); default 16 |
+| `gains`, `adcres`, `units` | gain, ADC resolution in bits, and physical units |
+| `baselines`, `adczeros`, `names` | optional signal specifications |
+| `base_time`, `comments` | start time (`"hh:mm:ss dd/mm/yyyy"`) and info strings |
+| `samps_per_frame` | samples per frame of each signal, for a multi-frequency record; `signals` then has one row per frame and `sum(samps_per_frame)` columns |
+| `dir` | directory in which to create the files |
+
+### Writing annotations: `write_annotations`
+
+This example writes the annotation file `rand.qrs` for the record `rand`
+written above:
+
+```python
+wfdbx.write_annotations("rand", "qrs", samples=[100, 460, 820], symbols=["N", "N", "V"])
+```
+
+Give the annotation types as `symbols` or as `codes`. `subtypes`, `chans`,
+`nums` and `aux` are optional. If the annotations are not in time order, the
+file is sorted when it is written. `sort=False` keeps the order you gave
+(without the library's advice to run `sortann`) and `sort=True` always
+sorts, for that call only. Without `sort`, the `WFDBANNSORT` environment
+variable decides (sorting is on unless it is `0`).
+
+### Errors and warnings
+
+* A record, header or annotation file that cannot be read or written raises
+  `IOError`. This includes a file that cannot be written completely, for
+  example on a full disk: "write error on record REC", "write error on
+  annotator ANN for record REC". (`wfdbx_write_errors()` counts such errors
+  for the C-style functions, which report them only with a message, as in
+  C.)
+* In `write_record`, `samps_per_frame` values that are not integers of at
+  least 1, and a number of columns of `signals` other than their sum, raise
+  `ValueError` before any file is created.
+* A signal file that is shorter than its header says raises `IOError`:
+  "can't read signal data of record REC (getvec status -3)".
+* An annotation file that ends before its end-of-file marker raises
+  `IOError`: "can't read annotation file ANN of record REC (getann status
+  -3)".
+* Invalid arguments, and a value the operation needs but the record does not
+  give, raise `ValueError`. For example, a time string such as `"0:10"`
+  needs the sampling frequency, and `physical=True` needs the gain of each
+  signal.
+* When the data do not match the checksums in the header, `read_record`
+  returns all the data and issues a `RuntimeWarning`: "checksum error in
+  record REC: the signal data do not match the checksums in its header".
+  `checksum_warning=False` turns the warning off; `rec.checksum_ok` is
+  `False` either way. Checksums are only checked when a read reaches the end
+  of the record.
+* A tool, or a program that uses the WFDB library functions, never writes a
+  signal file over one of the signal files it is reading. Opening such an
+  output fails with "output file NAME is also an input file". `write_record`
+  reads nothing, so it overwrites any existing files of the same name.
+
+The high-level functions call `wfdbquit()`, which closes anything opened
+with the WFDB library functions.
+
+### Checking a record: `check_record`
+
+```python
+wfdbx.wfdbx_set_input_dir(wfdbx.sample_data_dir())   # the sample record 100s
+report = wfdbx.check_record("100s", ["atr"])
+print(report)
+```
+
+`check_record(record, annotators)` checks the header of a record, its signal
+specifications, every sample of its signal files, and the annotation files
+you name. It reports each problem it finds. It never raises an exception for
+a problem in the record. It checks for problems similar to those found by
+Benjamin Moody's [wfdbcheck](https://github.com/bemoody/wfdbcheck).
+
+The result is a `CheckReport`. `report.ok` is `True` if there is no error.
+`report.issues` lists the problems. Each has a `severity`, a `code` (such as
+`"checksum"`), a `where` (`""` for the record, `"signal 1"`, `"segment s2"`,
+`"annotator atr"`) and a `message`.
+
+| Severity | Meaning |
+|---|---|
+| `error` | the record is damaged or does not follow the WFDB format: programs will read wrong data or fail |
+| `warning` | the record can be read, but something is missing or unusual, and may give wrong results |
+| `info` | a fact worth knowing, such as invalid (missing) samples |
+
+Printed, the report has one line per problem, or the line
+`no problems found`:
+
+```
+warning: signal 0: the units are not specified
+error: signal 1: the checksum does not match: the header gives 12, the samples sum to 13
+error: annotator atr: 3 annotations are out of order; the first is at sample 50, after sample 100
+```
+
+`report.lines()` returns these lines as a list. The lines are the same in
+the seven languages of WFDB-x. The checks run in normal mode, even if legacy mode is on, and the library
+prints no messages during the call.
+
+What is checked:
+
+* the header: that it can be read, the sampling frequency, the length, lines
+  of at most 255 characters, and the record name it gives;
+* each signal: description, gain, units, ADC resolution and range, storage
+  format, and signal file name;
+* the signal files: that they can be read, samples outside the ADC range,
+  invalid samples, checksums, and the length given in the header;
+* each segment of a multi-segment record, and its signals against the
+  record's;
+* the annotation files: that they can be read to the end, time order,
+  annotation codes, and annotations after the end of the record.
+
+The sample record `100s` gives two warnings: its header gives no units.
+
+## Where files are read and written
+
+WFDB-x reads and writes files exactly where you name them, and nowhere else:
+
+| The name is | It is read from | It is written to |
+|---|---|---|
+| a full path: `/data/mitdb/100`, `C:\data\100` | that path | that path |
+| a home path: `~/data/100` | your home directory | your home directory |
+| a URL: `https://.../100` | that URL, if network access is on | (URLs cannot be written) |
+| anything else: `100`, `mitdb/100`, `../data/100` | the **input directory** | the **output directory** |
+
+In this table, `/data/mitdb` stands for a local copy of the MIT-BIH
+Arrhythmia Database, and `100` for its record 100.
+
+The input and output directories are both the current directory unless you
+set them:
+
+| Setting | Function | Option of the high-level functions | Environment variable |
+|---|---|---|---|
+| input directory: a local directory, `~/...` or a URL | `wfdbx_set_input_dir(d)` | `input_dir=` | `WFDBX_INPUT_DIR` |
+| output directory | `wfdbx_set_output_dir(d)` | `dir=` | `WFDBX_OUTPUT_DIR` |
+| network access (off by default) | `wfdbx_set_network(1)` | `network=True` | `WFDBX_NETWORK=1` |
+
+A function call overrides the environment variable, and an option applies to
+that one call. `wfdbx_get_input_dir()`, `wfdbx_get_output_dir()` and
+`wfdbx_get_network()` return the current settings, and passing `None` to a
+`set` function restores the default.
+
+In this example, `/data/mitdb` stands for a local copy of the MIT-BIH
+Arrhythmia Database, which contains record 100:
+
+```python
+wfdbx.wfdbx_set_input_dir("/data/mitdb")
+rec = wfdbx.read_record("100")          # reads /data/mitdb/100.hea and 100.dat
+wfdbx.write_annotations("100", "qrs", samples=[100, 460], symbols=["N", "N"],
+                        dir="out")       # writes out/100.qrs
+```
+
+The signal files that a header names are read from the header's directory.
+
+### Record names
+
+A record name is made of letters, digits, `_`, `-` and `~`. `/` separates
+directories, and the names of directories may contain any characters, such
+as dots: `my.data/rec` is a valid record name, `rec.1` is not. A name whose
+last part contains a dot is the name of a file: `100s.hea` is read as the
+header of record `100s`, and `100s.edf` as an EDF file.
+
+Records can be written under any such name: `write_record("my.data/rec",
+...)` creates `my.data/rec.hea` and `my.data/rec.dat`. The header names the
+record and its signal file without the directory (`rec`, `rec.dat`), so the
+record can be read under any path that leads to it. Annotator names may
+contain letters, digits, `_`, `-` and `~`.
+
+### Reading from PhysioNet
+
+Set the input directory to the URL of the database and turn network access
+on. The URL of a database is `https://physionet.org/files/<database>/<version>/`.
+This example reads record 100 of the MIT-BIH Arrhythmia Database:
+
+```python
+rec = wfdbx.read_record("100", input_dir="https://physionet.org/files/mitdb/1.0.0/",
+                        network=True)
+```
+
+Remote files are read once and kept for the rest of the session. A download
+gives up when it cannot connect, or receives nothing, for 30 seconds.
+
+## Signal parameters
+
+WFDB-x never assumes a sampling frequency, gain, ADC resolution or units
+that a record does not give. Where one is needed, you must give it: in
+`write_record`, as the `fs` argument of `read_annotations`, or as an option
+of the tools (see below). A record whose header gives no frequency has
+`fs = 0`. See
+[DIVERGENCES.md](https://github.com/alphanumericslab/wfdb-x/blob/main/docs/DIVERGENCES.md)
+for the reasons.
+
+## Command-line tools
+
+Run a tool through the `wfdbx` command. These examples read the sample
+record, so they first set the input directory to the package's data
+directory:
+
+```sh
+export WFDBX_INPUT_DIR=$(python -c "import wfdbx; print(wfdbx.sample_data_dir())")
+wfdbx rdsamp -r 100s -t 10 -p      # print the first 10 seconds, in physical units
+wfdbx rdann -r 100s -a atr         # print the annotations
+wfdbx --list                       # list the tools
+```
+
+The tools have the options and output of the original WFDB tools, which are
+described in the *WFDB Applications Guide*
+([`third_party/wag.pdf`](https://github.com/alphanumericslab/wfdb-x/tree/main/third_party)):
+
+* signals: `rdsamp`, `wrsamp`, `wfdbdesc`, `sigamp`, `snip`, `xform`,
+  `sampfreq`, `signame`, `signum`, `wfdbcat`, `wfdbwhich`
+* times: `wfdbtime`, `time2sec`
+* annotations: `rdann`, `wrann`, `sortann`, `ann2rr`, `rr2ann`
+* converters: `edf2mit`, `mit2edf`, `rdedfann`, `wav2mit`, `mit2wav`,
+  `wfdb2mat`, `a2m`, `m2a`, `ad2m`, `md2a`, `ahaecg2mit`, `makeid`, `readid`,
+  `revise`, `parsescp`
+
+When an output file or the standard output cannot be written (a full disk,
+for example), a tool reports it and exits with status 1, as the standard
+Unix tools do (the original tools exited with status 0).
+
+The tools use the environment variables of the table above. To read record
+100 of the MIT-BIH Arrhythmia Database from PhysioNet:
+
+```sh
+export WFDBX_INPUT_DIR=https://physionet.org/files/mitdb/1.0.0/
+export WFDBX_NETWORK=1
+wfdbx rdsamp -r 100 -t 0:05
+```
+
+Tools that write signal parameters require them as options:
+
+| Tool | Required options |
+|---|---|
+| `wrsamp` (with `-o`) | `-F` frequency, `-G` gain, `-R` ADC resolution, and `-U` units for calibrated signals |
+| `wav2mit` | `-G` gain, and `-U` units unless the gain is 0 |
+| `ad2m`, `ahaecg2mit` | `-F`, `-G`, `-R`, and `-U` unless the gain is 0 |
+| `a2m`, `rdann`, `ann2rr`, `sortann`, `m2a` | `-F` frequency, when the record's header does not give one |
+
+For example, `wfdbx wrsamp -F 250 -G 200 -R 16 -U mV -i samples.txt -o rec`
+writes a record, `rec`, from the columns of numbers in the text file
+`samples.txt`.
+
+## The WFDB library functions
+
+Every function of the WFDB library is available under its C name, with the
+same arguments and return values, so programs and documentation written for
+the C library carry over directly. Where a C function fills an array, the
+Python function fills a list that you pass. This example reads the sample
+record `100s` (the first minute of record 100 of the MIT-BIH Arrhythmia
+Database, included with WFDB-x):
+
+```python
+import wfdbx as w
+
+w.wfdbx_set_input_dir(w.sample_data_dir())   # the directory of 100s
+
+si = []
+nsig = w.isigopen("100s", si, 2)     # open 2 signals; si receives their specifications
+v = [0] * nsig
+while w.getvec(v) > 0:               # v receives one sample per signal
+    ...
+
+a = w.Annotation()
+w.annopen("100s", [w.Anninfo("atr", w.WFDB_READ)])
+while w.getann(0, a) == 0:
+    print(a.time, w.annstr(a.anntyp), a.aux_string())
+w.wfdbquit()
+```
+
+Differences from C that come from the language:
+
+* Strings are `str`. Text and binary data are handled as ISO-8859-1, so every
+  byte sequence round-trips unchanged.
+* An annotation's `aux` is `None`, or `bytes` whose first byte is the length
+  of the text that follows, as in C. `Annotation.aux_string()` returns the
+  text.
+* `getframes(n)` reads up to `n` frames at once, as `n` calls of `getvec`
+  would, but decoding whole blocks of the signal files (also for
+  multi-frequency and multi-segment records). It returns a NumPy array
+  with one row per frame, and the `getvec` status of the first frame it
+  could not read. If it read all `n` frames, the status is the number of
+  signals.
+* `getseginfo()` returns a list of `Seginfo` objects.
+* Errors are reported by return values, as in C, not by exceptions.
+  `wfdberror()` returns the last message, and `wfdbquiet()` stops the
+  messages from being printed.
+* The library keeps the open record and annotators between calls, as in C.
+  `wfdbquit()` closes them; the directory and network settings are kept.
+
+The annotation codes (`NORMAL`, `PVC`, ...) and the functions of
+`<wfdb/ecgmap.h>` (`isqrs`, `map1`, `map2`, ...) are also provided. Use
+`help()` on any function for its documentation.
+
+## Legacy mode
+
+Legacy mode reproduces the original WFDB package exactly, including its
+assumed signal parameters and its search for files. Use it only to reproduce
+old results:
+
+* tools: `--legacy` as the first argument, as in `wfdbx rdsamp --legacy -r 100s`,
+  run in the directory of the sample record `100s` (`wfdbx.sample_data_dir()`).
+  Legacy mode finds files through the WFDB path, which begins with the
+  current directory, and does not use the input directory;
+* high-level functions: `legacy=True`;
+* the whole library: `wfdbx_set_legacy(1)`.
+
+[DIVERGENCES.md](https://github.com/alphanumericslab/wfdb-x/blob/main/docs/DIVERGENCES.md#legacy-mode)
+describes what changes in legacy mode.
+
+## Example notebooks
+
+The package includes seven Jupyter notebooks. Each runs without a network
+connection.
+
+| Notebook | Contents |
+|---|---|
+| `01_getting_started` | reading headers and signals; ADC and physical units |
+| `02_annotations_and_heart_rate` | reading annotations; RR intervals and heart rate |
+| `03_writing_records` | writing records and annotations |
+| `04_command_line_tools` | running the tools |
+| `05_c_library_api` | the WFDB library functions |
+| `06_physionet_records` | reading a record from PhysioNet |
+| `07_legacy_mode` | the original package's behavior, on request |
+
+Copy them to a directory and open them with Jupyter:
+
+```sh
+wfdbx --examples my-examples
+cd my-examples
+jupyter lab
+```
+
+## Notes
+
+* **FLAC.** Formats 508, 516 and 524 (FLAC-compressed signals) are read and
+  written without any external library. The C library reads files written
+  by WFDB-x with identical sample values, although the compressed bytes
+  differ from those of libFLAC.
+* **Speed.** Reading and writing whole records is vectorized with NumPy. On
+  a typical laptop, `read_record` reads 8 million samples in a few hundredths
+  of a second.
+
+## Testing
+
+From the root of the repository:
+
+```sh
+pip install -e "./python[test]"
+pytest python/tests
+```
+
+This runs the unit tests, the example notebooks and the cross-language
+conformance suite (about 1000 command-line cases, a few minutes). Set
+`WFDBX_CONFORMANCE=0` to skip the conformance suite, or, for example,
+`WFDBX_CONFORMANCE=rdsamp,rdann` to run the cases of some tools only. The
+conformance suite can also be run on its own, with more options (see
+[conformance.md](https://github.com/alphanumericslab/wfdb-x/blob/main/docs/conformance.md)):
+
+```sh
+python3 tests/conformance/harness.py check --impl python
+```
+
+The tests that write to `/dev/full` (write errors) are skipped where it does
+not exist, on macOS and Windows.
+
+## Authors and license
+
+The WFDB library and tools were written by George B. Moody, with revisions by
+Benjamin Moody and contributions from many others; `parsescp` was written by
+George B. Moody and Edna S. Moody. Each module names the authors of the C
+code it implements, and
+[AUTHORS.md](https://github.com/alphanumericslab/wfdb-x/blob/main/docs/AUTHORS.md)
+gives the details. The Python implementation was developed by Reza Sameni
+(2026), through AI-assisted development, cross-language
+verification and unit testing.
+
+WFDB-x is an independent reimplementation. Its Python code is a
+translation of the C code of the WFDB Software Package into Python,
+written for WFDB-x; it is not code by the original WFDB developers. It
+follows the original's logic and behavior, with the changes described
+in [DIVERGENCES.md](https://github.com/alphanumericslab/wfdb-x/blob/main/docs/DIVERGENCES.md).
+The authors of the original C code are credited in each file and in
+[AUTHORS.md](https://github.com/alphanumericslab/wfdb-x/blob/main/docs/AUTHORS.md).
+
+WFDB-x is distributed under the GNU General Public License, version 3 or
+(at your option) any later version. See
+[LICENSE](https://github.com/alphanumericslab/wfdb-x/blob/main/LICENSE).

wfdb_x-1.0.0.dist-info/RECORD

@@ -0,0 +1,65 @@
+wfdb_x-1.0.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+wfdbx/__init__.py,sha256=KoVRYNMkb2zGrSODAbodPPoPX7e683ofsDm9kVKhWZM,4673
+wfdbx/_annot.py,sha256=E8TYGtoHGohE67fZTUeObe35UP0VK3XDRLsYdxckWjU,61333
+wfdbx/_calib.py,sha256=lubvWuQL36J-00KEMT9JWiskx1qd29yCTLH6bATh3XI,7687
+wfdbx/_cstd.py,sha256=GtmLrHeVob5_chaDJ9eGPbM2I9iLb-PR_zhyBfbig74,13125
+wfdbx/_ecgcodes.py,sha256=A_cC4oAHu4L45A5MqlMKClM_oi186yzECasTViduqSg,9171
+wfdbx/_flac.py,sha256=1oG7tsG7dnhrrvIoHoBi19D2SNwApYfDhXSwNe2Q0QM,31241
+wfdbx/_signal.py,sha256=uGOxIQwBl7NW_1iuGhRm8Qv6rxpQ-OrorkH7Zo0-mE0,153042
+wfdbx/_wfdbinit.py,sha256=GkD7bEnPBCgISaxXw-5RFBNtxMIfK4fiQy9BK9Itdy8,2985
+wfdbx/_wfdbio.py,sha256=qYNvrfzu-8o0V7vtnnBTMS2W4sIZ6WZoIOmYurzW_NA,45511
+wfdbx/check.py,sha256=dUnTXYSK5b2aDDoBH_apY2zRRHLM2RYJ0PHCEHU9220,32895
+wfdbx/cli.py,sha256=hVLBvnYEiQQ00LuYIX6xThoqOesz_lmz6wkLbfKGlDo,2287
+wfdbx/highlevel.py,sha256=qSix62aUrAPvBk1RJrD3VWpMbmgTpwMcHG2dbxSM5y0,44385
+wfdbx/resources.py,sha256=b4Wu_p68yChF0UICPJG5wPaGQ5gBqKOn1Mezo_rqQ34,2227
+wfdbx/apps/__init__.py,sha256=jjCNDllQvxczsI1APtIrNmiKlIU4gms4_riHhIVOaSk,1176
+wfdbx/apps/_common.py,sha256=HBjTFhWXn9ltm34EKmaSX1GWi169RzhmT8trt3lCKN0,7588
+wfdbx/apps/a2m.py,sha256=rAyj_yvI-EaeUhKCVUnk5_do5MMzusFx-kCQaxE4gwI,9851
+wfdbx/apps/ad2m.py,sha256=YaBQ06cudGPqMMo7tuFz0_4Q0efCwGbJUA38LD8Gxrc,11704
+wfdbx/apps/ahaecg2mit.py,sha256=SCCdMlVE4_O3bjG9UWOVIq0LGKE-wXwgxSaT2T4cwTE,11296
+wfdbx/apps/ann2rr.py,sha256=JYjINPdvNACpog7xWIM_nFAOxLelZ2MCo7qXBL01YHg,12828
+wfdbx/apps/edf2mit.py,sha256=HwxslfeFaAIyQtPNe5Ma9e5TxwKK3dmiyP8_xP9A-UU,12838
+wfdbx/apps/m2a.py,sha256=dR3sH_1AqZ6nNg18NkJClko0NntQVJOBBm8ILzy0YjU,5205
+wfdbx/apps/makeid.py,sha256=xfH-vgP1Dt3FBCOwoKNRZ47bGMJ0bMehaUzEkMOoiJs,3911
+wfdbx/apps/md2a.py,sha256=ZaalL1kIvx2bpn8TytQc5INWssqZ1zelTjAqoe1DeEE,4152
+wfdbx/apps/mit2edf.py,sha256=TTQH_dhwyKDDOExD5drbIwwdcDWu4rSlLJ8ohGV3GIU,13916
+wfdbx/apps/mit2wav.py,sha256=8XciY_Pdn2jVuO_aubaW-cAsG9SOyugfIx_973ozexI,6360
+wfdbx/apps/parsescp.py,sha256=cLcGK0p9nKAcXtnm1QxC6Vt-gSQ7yVWsWo2YHu78GkY,77588
+wfdbx/apps/rdann.py,sha256=MJyI2A5RoIXX66s16q-lClDhty1tNCjzkOzHjHSnEno,11898
+wfdbx/apps/rdedfann.py,sha256=XbjvIQ3i_gejKuMkh8dWuLaJEVAxGe0u2h-wgnIzS8I,7297
+wfdbx/apps/rdsamp.py,sha256=bVWcJsqe3Rdymbr7nNEr9F3ZK7svnhuKZsvHIqdzkNY,17181
+wfdbx/apps/readid.py,sha256=2MLpgDgOtQHMDmZqpu84ToMf0I9DQfluFn9z1AX3WtI,2707
+wfdbx/apps/revise.py,sha256=h5daiv5y-mSZHNpac0UG0eePHfRGtzB1TFFpMiWN_bI,6706
+wfdbx/apps/rr2ann.py,sha256=6xLkqkBXt5rE56lgZWmgL43DsqikbFPigdcPaoENsVs,7317
+wfdbx/apps/sampfreq.py,sha256=dhhoBtTLNLjyoO6EmBIMLk1bfQ1BCb5r0B36SAuKqb8,2899
+wfdbx/apps/sigamp.py,sha256=pS-8N9A9KjZaoYbtIHvQw3zhQVu2s3i9wb3CmOFZ_j0,12528
+wfdbx/apps/signame.py,sha256=Tt0nUzK_eipKNdEfrCFY3_R8ZwiMA5MaX5IG1S7EaYU,4032
+wfdbx/apps/signum.py,sha256=Y61uOaFqnq9re-xQE-w1sJccEILCVBfcU2kMKIfSVC8,2309
+wfdbx/apps/snip.py,sha256=Ml3Ono-RlgycIzEWroIJyFo8RKg4HKZRrxhsAMFDMlw,13924
+wfdbx/apps/sortann.py,sha256=h3XF1yP_bAs2yLwXTLpRZFNWg5t0eKQp7aGvD9ekUf0,7085
+wfdbx/apps/time2sec.py,sha256=ok1t7fxvss8ZaPQYv5abB1JiD3I1fuofjPeHA4iKL_k,2678
+wfdbx/apps/wav2mit.py,sha256=PquER7pHJAH3dSQnyj58KTfB8rle34u8N7luGKeXghk,7994
+wfdbx/apps/wfdb2mat.py,sha256=T_are4xME8k9Kebc4VUVlg_ef8jsSyDoBZUd7lPR3q0,13362
+wfdbx/apps/wfdbcat.py,sha256=Boi6e1yzgarwVIdjgoohc1voLP8SrnJ5z3JCMGhhSsA,2357
+wfdbx/apps/wfdbdesc.py,sha256=jCOn1Zgm7ZXvKA7mP5RPBXOrUwDOTXuVywoCUNCnKsE,7783
+wfdbx/apps/wfdbtime.py,sha256=twtiJG-Se38IJBFLveiWixymyynSyL6jKBFebTJX9Mc,2930
+wfdbx/apps/wfdbwhich.py,sha256=9Os66RskKMBEwzLXEpRnSJ4Q64KCwO2DCiUxTn4nGT4,3105
+wfdbx/apps/wrann.py,sha256=NxRaaJnCnYKRoJlIJy1Dwfd0DbfhMga3K6iA2kt7ywQ,5167
+wfdbx/apps/wrsamp.py,sha256=t-XqQ9h08eTVI4RZTu1aaoXn_hAtixoV-OZ9Pdm7NjE,20895
+wfdbx/apps/xform.py,sha256=wyCZkpb0ZOO6QSmgzVL00hCX9ciFCgQeGl8JpaWQ-OE,30892
+wfdbx/examples/01_getting_started.ipynb,sha256=dCNseFwdqt6PEkY2FL4Ju5LcpmLNXPsQYnhZ2vKV5z8,6169
+wfdbx/examples/02_annotations_and_heart_rate.ipynb,sha256=KaYqPnc-_davtI8zXBP4WPFguk8VwQKaE3IqPL0utd4,4287
+wfdbx/examples/03_writing_records.ipynb,sha256=EOLes_22DwushFcz7O1jvmfCvjHiMrbIKvImcWGysRQ,4732
+wfdbx/examples/04_command_line_tools.ipynb,sha256=UxIkOYwd6f7oSzSkW8fymFoCBpfHnORp3Hzzeetld_E,4577
+wfdbx/examples/05_c_library_api.ipynb,sha256=p-7yjjf3lvo0OjS4ZKQNM589ZQsP7itNc52Q7tfwMw0,4006
+wfdbx/examples/06_physionet_records.ipynb,sha256=Uqff3cTiBoOj_GzV2JLrR5Tyf-f5CdlrNH_KumOZqk8,3973
+wfdbx/examples/07_legacy_mode.ipynb,sha256=_T9OcyfNLnq9pnvgqtepZWkZXTGsHUl4sDSOSkmjf6o,3757
+wfdbx/sample_data/100s.atr,sha256=I3KZxKJBVa2viNsbNw5BSBcPYzD6reSSLPocRgRODWc,158
+wfdbx/sample_data/100s.dat,sha256=lS_3fx-F8YUqRDVkHLDxC8GqjEhyJkL_s0MulYchHR8,64800
+wfdbx/sample_data/100s.hea,sha256=iLCesUXM-b3R6tBSV9MSIwqbejLyJOesa0O6IrxixcI,198
+wfdbx/sample_data/README.md,sha256=qQA0-FfjtDYRppjL8pq-fIgB9V4L55z_S7mNJc095A0,504
+wfdb_x-1.0.0.dist-info/METADATA,sha256=ZfqXdtwT-rrSUbjVUouzj3P0ge-8Vy3CmW_FoI6Fvt8,26213
+wfdb_x-1.0.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+wfdb_x-1.0.0.dist-info/entry_points.txt,sha256=sRvdoqU4uHKnRBunERCn3VEgP3ZOgRsQnFPe9JcoCcI,41
+wfdb_x-1.0.0.dist-info/top_level.txt,sha256=hAJl1HDAasm67h7BWMgwSviNO6wCnzTnJa7jE4m9qE0,6
+wfdb_x-1.0.0.dist-info/RECORD,,

wfdb_x-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

wfdb_x-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+wfdbx = wfdbx.cli:main