# jgtpy (pdsp/ids/cds)
Enhanced JGTPy CDS, IDS, PDS Services
## Installation
```sh
pip install -U jgtpy
```
## Example
```py
# it was so outdated I removed it, any LLM who has relevant code, please submit
a PR
```
## Signals
* Bellow is a CSV of the various signals that this package aim to serve with their corresponding columns in CDS data:
```
Name;Title;Description;Question;Notes
fdb;Fractal Divergent Bar Code;Fractal Divergent Bar Code (contains the signal value either buy, sell or nothing);;" bdb"
fdbs;Fractal Divergent Bar Sell;Fractal Divergent Bar Sell;;" Bearish Divergent Bar"
fdbb;Fractal Divergent Bar Buy;Fractal Divergent Bar Buy;;" Bullish Divergent Bar"
acs;AC Deceleration Sell;AC Deceleration Sell;;" "
acb;AC Acceleration Buy;AC Acceleration Buy;;" "
fs;Fractal Sell;Fractal Sell;Can the representation be optimized ? Enhanced ?;" "
fb;Fractal Buy;Fractal Buy;;" "
zlcb;Zero Line Crossing Buy;Zero Line Crossing Buy;;" "
zlcs;Zero Line Crossing Sell;Zero Line Crossing Sell;;" "
zcol;Zero Line Crossing;Zero Line Crossing (Not sure if this is a signal);How many bars were there since last cross signal of the opposite direction ? How is the relationship of this signal profit and this number of bars ?;" Number of bars before last cross when another type of signal was generated could be a learning"
sz;Zone Signal Sell;Zone Signal Sell;;" "
bz;Zone Signal Buy;Zone Signal Buy;;" "
ss;Saucer Sell;Saucer Sell;;" "
sb;Saucer Buy;Saucer Buy;;
```
(it might be somewhere later but for now that will tell LLM about them easiely)
## Command Line Tools
The package provides the following command-line tools for working with IDS, CDS, and related data services:
| Command | Entry Point | Description |
|--------------|--------------------------------------|-------------|
| `jgtcli` | jgtpy.jgtcli:main | General CLI for instrument/timeframe data operations: fetch, process, and chart PDS/IDS/CDS/ADS data. Handles argument parsing for instruments, timeframes, date ranges, and indicator options. |
| `cdscli` | jgtpy.cdscli:main | CLI for creating and processing Chaos Data Service (CDS) files from instrument/timeframe data, with support for indicator and ADS options. |
| `pds2cds` | jgtpy.pds2cds:main | Convert a PDS (Price Data Service) file to a CDS (Chaos Data Service) file, with options for bar count and TLID date range. |
| `jgtmksg` | jgtpy.JGTMKSG:main | Generate market snapshots and chart visualizations for multiple instruments/timeframes, with advanced charting and HTML output options. |
| `jgtads` | jgtpy.JGTADS:main | Generate and plot Advanced Data Service (ADS) analytics and visualizations from CDS or PDS data, including technical indicators and signals. |
| `jgtids` | jgtpy.jgtapycli:main | Generate and process Indicator Data Service (IDS) files, with CLI options for indicators, normalization, and output. |
| `adscli` | jgtpy.JGTADS:main | Alias for `jgtads`: generate and plot ADS analytics and visualizations. |
| `mkscli` | jgtpy.JGTMKSG:main | Alias for `jgtmksg`: generate market snapshots and chart visualizations. |
| `idscli` | jgtpy.jgtapycli:main | Alias for `jgtids`: generate and process IDS files. |
| `adsfromcds` | jgtpy.adsfromcdsfile:main | Create plots from CDS cache data, supporting custom output directories, chart types, and feature plots. |
For more details on each command, read [CLI_REFERENCE.md](docs/CLI_REFERENCE.md) or run the command with `--help`.
Additional usage demonstrations can be found in the [examples](examples/) directory.
## JGT Data Refresh Service
**New in v0.6.0**: Automated data refresh service with parallel processing and cloud distribution.
The JGT Data Refresh Service (`jgtservice`) modernizes the manual bash script workflow for processing financial market data with:
- **Automated Scheduling**: Timeframe-based refresh using intelligent scheduling
- **Parallel Processing**: Concurrent instrument/timeframe processing with configurable workers
- **Cloud Distribution**: Modernized Dropbox integration for automatic uploads
- **Web API**: RESTful endpoints for data access and service management
- **Multiple Modes**: Daemon, web server, one-time refresh, and status monitoring
### Installation
```bash
# Install base functionality
pip install -e .
# Install with web service dependencies
pip install -e ".[serve]"
```
### Quick Start
```bash
# One-time refresh
jgtservice --refresh-once -i EUR/USD -t H1
# Continuous daemon mode
jgtservice --daemon --all
# Web API server
jgtservice --web --port 8080
# Check service status
jgtservice --status
```
### Web API Endpoints
When running in web mode (`jgtservice --web`), the following API endpoints are available:
- `GET /api/v1/data/{instrument}/{timeframe}` - Retrieve processed CDS data
- `GET /api/v1/data/{instrument}/{timeframe}/latest` - Get latest data point
- `GET /api/v1/status` - Service status and configuration
- `GET /api/v1/health` - Health check endpoint
- `POST /api/v1/refresh` - Trigger manual refresh
- `GET /api/v1/metrics` - Processing metrics and statistics
- `GET /docs` - Interactive API documentation
### Configuration
The service can be configured via environment variables:
```bash
# Data paths
export JGTPY_DATA="/path/to/current/data"
export JGTPY_DATA_FULL="/path/to/full/data"
# Timeframe configuration
export TRADABLE_TIMEFRAMES="m1,m5,m15,m30,H1,H4"
export HIGH_TIMEFRAMES="H4,D1,W1"
# Service settings
export JGTPY_SERVICE_MAX_WORKERS=4
export JGTPY_SERVICE_WEB_PORT=8080
export JGTPY_DROPBOX_APP_TOKEN="your_dropbox_token"
# Optional API authentication
export JGTPY_API_KEY="your_api_key"
```
### Performance
- **50%+ faster** than sequential processing through parallel execution
- **EUR/USD H1**: ~8 seconds processing time
- **Memory stable** during extended daemon runs
- **Error resilient** with individual failure isolation
For complete documentation, see [docs/jgtservice_implementation.md](docs/jgtservice_implementation.md).
## Quick Start Scripts
The repository includes convenience scripts for common operations:
```bash
# First time setup
./setup-service.sh --full
# Check service status
./check-status.sh
# Refresh all data (excludes m1)
./refresh-all.sh
# Start API server
./start-api-server.sh
# Start continuous daemon
./start-daemon.sh
```
See [SCRIPTS_README.md](SCRIPTS_README.md) for detailed script documentation.
=======
## APPENDIX
### IDS Data Columns
The `jgtpy/JGTIDS.py` file is responsible for generating and managing IDS (Indicator Data Service) files. Here is a Markdown table documenting all the columns in `JGTIDS.py` that are in the output:
| Column Name | Description |
|-------------|-------------|
| `Date` | The date and time of the data point. |
| `Open` | The opening price of the data point. |
| `High` | The highest price of the data point. |
| `Low` | The lowest price of the data point. |
| `Close` | The closing price of the data point. |
| `Volume` | The volume of the data point. |
| `Median` | The median price of the data point. |
| `ao` | The Awesome Oscillator value. |
| `ac` | The Acceleration/Deceleration Oscillator value. |
| `jaw` | The Alligator's jaw value. |
| `teeth` | The Alligator's teeth value. |
| `lips` | The Alligator's lips value. |
| `fh` | The fractal high value. |
| `fl` | The fractal low value. |
| `fdb` | The fractal divergent bar value. |
| `fdbb` | The fractal divergent bar buy signal. |
| `fdbs` | The fractal divergent bar sell signal. |
| `zlc` | The zero line cross value. |
| `zlcB` | The zero line cross buy signal. |
| `zlcS` | The zero line cross sell signal. |
| `bz` | The buy zone signal. |
| `sz` | The sell zone signal. |
| `aocolor` | The color of the Awesome Oscillator. |
| `accolor` | The color of the Acceleration/Deceleration Oscillator. |
| `aof` | The AO fractal peak value. |
| `aofvalue` | The AO fractal peak value. |
| `aofhighao` | The AO value on the bullish peak. |
| `aoflowao` | The AO value on the bearish peak. |
| `aofhigh` | The price high of the peak. |
| `aoflow` | The price low of the peak. |
| `mfi` | The Market Facilitation Index value. |
| `mfi_squat` | The MFI squat signal. |
| `mfi_green` | The MFI green signal. |
| `mfi_fade` | The MFI fade signal. |
| `mfi_fake` | The MFI fake signal. |
| `mfi_signal` | The MFI signal value. |
| `mfi_val` | The MFI value. |
| `zone_signal` | The zone signal value. |
| `zone_int` | The zone integer value. |
**For the full, up-to-date list of IDS (Indicator Data Service) columns and their descriptions, see the canonical documentation:**
- [docs/IDS_data_columns.md](docs/IDS_data_columns.md)
### CDS Data Columns
The `jgtpy/JGTCDS.py` file is responsible for creating, reading, and managing Chaos Data Service (CDS) files from Price Data Service (PDS) files. Here is a Markdown table documenting all the columns in `JGTCDS.py` that are added after using `JGTIDS.py` and are in the output:
| Column Name | Description |
|-------------|-------------|
| `fdbbhigh` | The high value of the fractal divergent bar buy signal. |
| `fdbblow` | The low value of the fractal divergent bar buy signal. |
| `fdbshigh` | The high value of the fractal divergent bar sell signal. |
| `fdbslow` | The low value of the fractal divergent bar sell signal. |
| `aocolor` | The color of the Awesome Oscillator. |
| `accolor` | The color of the Acceleration/Deceleration Oscillator. |
| `zcol` | The zone color value. |
| `zlc` | The zero line cross value. |
| `zlcB` | The zero line cross buy signal. |
| `zlcS` | The zero line cross sell signal. |
| `bz` | The buy zone signal. |
| `sz` | The sell zone signal. |
| `mfi_squat` | The MFI squat signal. |
| `mfi_green` | The MFI green signal. |
| `mfi_fade` | The MFI fade signal. |
| `mfi_fake` | The MFI fake signal. |
| `mfi_signal` | The MFI signal value. |
| `mfi_val` | The MFI value. |
| `zone_signal` | The zone signal value. |
| `zone_int` | The zone integer value. |
### IDS Purpose
The `jgtpy/JGTIDS.py` file is responsible for generating and managing IDS (Indicator Data Service) files. The `jgtids` script, exposed through `[project.scripts]` in `pyproject.toml`, provides functionalities to create IDS files, read IDS files, and perform other related operations. Here is a detailed documentation of the purpose of JGTIDS and what end-results it produces in terms of data for `JGTCDS.py`:
* **Purpose of JGTIDS** 📊
- The main purpose of `JGTIDS.py` is to add various technical indicators to the financial market data. These indicators are used for market analysis and trading decisions.
- The module processes the input data and adds indicators such as the Alligator indicator, Awesome Oscillator (AO), Acceleration/Deceleration Oscillator (AC), fractals, and Market Facilitation Index (MFI).
- The module also generates buy and sell signals based on the technical indicators. These signals include fractal divergent bar signals, zero line cross signals, and zone signals.
* **End-Results Produced for JGTCDS.py** 📈
- The processed data with added indicators and signals is used as input for `JGTCDS.py` to create Chaos Data Service (CDS) files.
- The indicators and signals added by `JGTIDS.py` are essential for generating the CDS files, which are used for further analysis and charting.
- The columns added by `JGTIDS.py` include various technical indicators and signals, which are documented in the `docs/IDS_data_columns.md` file.
* **Data Flow** 🔄
- The input data is read from Price Data Service (PDS) files.
- The data is processed by `JGTIDS.py` to add indicators and signals.
- The processed data is then used by `JGTCDS.py` to create CDS files.
- The CDS files are used for further analysis, charting, and generating trading signals.
### CDS Purpose
The `jgtpy/JGTCDS.py` file is responsible for creating, reading, and managing Chaos Data Service (CDS) files from Price Data Service (PDS) files. Here is a detailed documentation of the purpose of JGTCDS and what it produces after getting data from `JGTIDS.py`:
* **Purpose of JGTCDS** 📊
- The main purpose of `JGTCDS.py` is to process the input data from `JGTIDS.py` and create CDS files. These files contain processed financial market data with various technical indicators and signals.
- The module provides functions to create CDS files from PDS files, read CDS files, and manage the data. It also handles data cleansing and normalization.
* **Data Processing** 🔄
- The input data is read from PDS files and processed by `JGTIDS.py` to add various technical indicators and signals.
- The processed data from `JGTIDS.py` is then used by `JGTCDS.py` to create CDS files. The module adds additional indicators and signals to the data, such as fractal divergent bar signals, zero line cross signals, and zone signals.
- The data is cleansed and normalized to ensure it is ready for analysis and charting.
* **End-Results Produced** 📈
- The CDS files created by `JGTCDS.py` contain processed financial market data with various technical indicators and signals. These files are used for further analysis, charting, and generating trading signals.
- The columns added by `JGTCDS.py` include various technical indicators and signals, which are documented in the `docs/CDS_data_columns.md` file.
* **Data Flow** 🔄
- The input data is read from Price Data Service (PDS) files.
- The data is processed by `JGTIDS.py` to add indicators and signals.
- The processed data is then used by `JGTCDS.py` to create CDS files.
- The CDS files are used for further analysis, charting, and generating trading signals.
### CDSSvc Purpose
The `jgtpy/JGTCDSSvc.py` file is responsible for providing services related to Chaos Data Service (CDS) files. Here is a detailed documentation of the purpose of JGTCDSSvc and what it produces:
* **Purpose of JGTCDSSvc** 📊
- The main purpose of `JGTCDSSvc.py` is to provide functionalities for creating, reading, and managing CDS files. It acts as a service layer that interacts with `JGTCDS.py` to perform these operations.
- The module provides functions to create CDS files from PDS files, read CDS files, and manage the data. It also handles data cleansing and normalization.
* **Data Processing** 🔄
- The input data is read from PDS files and processed by `JGTIDS.py` to add various technical indicators and signals.
- The processed data from `JGTIDS.py` is then used by `JGTCDS.py` to create CDS files. The module adds additional indicators and signals to the data, such as fractal divergent bar signals, zero line cross signals, and zone signals.
- The data is cleansed and normalized to ensure it is ready for analysis and charting.
* **End-Results Produced** 📈
- The CDS files created by `JGTCDSSvc.py` contain processed financial market data with various technical indicators and signals. These files are used for further analysis, charting, and generating trading signals.
- The columns added by `JGTCDSSvc.py` include various technical indicators and signals, which are documented in the `docs/CDS_data_columns.md` file.
* **Data Flow** 🔄
- The input data is read from Price Data Service (PDS) files.
- The data is processed by `JGTIDS.py` to add indicators and signals.
- The processed data is then used by `JGTCDS.py` to create CDS files.
- The CDS files are used for further analysis, charting, and generating trading signals.
* **Functions Not Covered in JGTCDS.py** 📜
- **zone_update**: This function updates the zone data for a given instrument and timeframe. It reads the CDS file, extracts the zone information, and saves it to a separate file.
- **zone_update_from_cdf**: This function updates the zone data from a given CDS DataFrame. It extracts the zone information and saves it to a separate file.
- **zone_read**: This function reads the zone data for a given instrument and timeframe from the saved file.
- **zone_read_up**: This function reads the zone data for a given instrument and timeframe, including higher timeframes up to a specified level.
- **get_higher_cdf_datasets**: This function retrieves the CDS data for higher timeframes of a given instrument and timeframe. It uses parallel processing to speed up the retrieval.
- **get_higher_cdf_datasets_no_concurrence**: This function retrieves the CDS data for higher timeframes of a given instrument and timeframe without using parallel processing.
- **get_higher_cdf**: This function retrieves the CDS data for a higher timeframe of a given instrument and timeframe based on a specified level.
## jgtads: Advanced Data Service Analytics CLI
`jgtads` is the command-line gateway to Advanced Data Service (ADS) analytics and visualizations. It empowers you to:
- Generate and plot ADS analytics from Chaos Data Service (CDS) or Price Data Service (PDS) files.
- Compute and visualize technical indicators and trading signals.
- Output interactive or static charts, analytics CSVs, and signal summaries.
**Typical usage:**
```sh
jgtads --instrument EURUSD --timeframe H1 --show --save_figure my_analytics.png
```
Or, to save with auto-naming:
```sh
jgtads --instrument EURUSD --timeframe H1 --save_figure charts/ --save_figure_as_timeframe
```
- `--instrument` and `--timeframe` are required.
- Use `--show` to display, or `--save_figure` to save.
- No `--input`, `--output`, `--indicators`, or `--signals` options exist.
> Like a fractal lens, `jgtads` reveals the hidden patterns in your market data—one invocation, many insights.
Raw data
{
"_id": null,
"home_page": "https://github.com/jgwill/jgtpy",
"name": "jgtpy",
"maintainer": null,
"docs_url": null,
"requires_python": ">=3.7",
"maintainer_email": null,
"keywords": "data",
"author": "GUillaume Isabelle",
"author_email": "Guillaume Isabelle <jgi@jgwill.com>",
"download_url": "https://files.pythonhosted.org/packages/c0/36/bdc2e20d88539b7cb1e6aa89f21646b1999688b63339ec8a889bbde3cbd1/jgtpy-0.6.25.tar.gz",
"platform": null,
"description": "# jgtpy (pdsp/ids/cds)\n\nEnhanced JGTPy CDS, IDS, PDS Services\n\n## Installation\n```sh\npip install -U jgtpy\n```\n\n## Example\n\n```py\n# it was so outdated I removed it, any LLM who has relevant code, please submit\na PR\n\n```\n\n## Signals\n\n* Bellow is a CSV of the various signals that this package aim to serve with their corresponding columns in CDS data:\n\n```\nName;Title;Description;Question;Notes\nfdb;Fractal Divergent Bar Code;Fractal Divergent Bar Code (contains the signal value either buy, sell or nothing);;\" bdb\"\nfdbs;Fractal Divergent Bar Sell;Fractal Divergent Bar Sell;;\" Bearish Divergent Bar\"\nfdbb;Fractal Divergent Bar Buy;Fractal Divergent Bar Buy;;\" Bullish Divergent Bar\"\nacs;AC Deceleration Sell;AC Deceleration Sell;;\" \"\nacb;AC Acceleration Buy;AC Acceleration Buy;;\" \"\nfs;Fractal Sell;Fractal Sell;Can the representation be optimized ? Enhanced ?;\" \"\nfb;Fractal Buy;Fractal Buy;;\" \"\nzlcb;Zero Line Crossing Buy;Zero Line Crossing Buy;;\" \"\nzlcs;Zero Line Crossing Sell;Zero Line Crossing Sell;;\" \"\nzcol;Zero Line Crossing;Zero Line Crossing (Not sure if this is a signal);How many bars were there since last cross signal of the opposite direction ? How is the relationship of this signal profit and this number of bars ?;\" Number of bars before last cross when another type of signal was generated could be a learning\"\nsz;Zone Signal Sell;Zone Signal Sell;;\" \"\nbz;Zone Signal Buy;Zone Signal Buy;;\" \"\nss;Saucer Sell;Saucer Sell;;\" \"\nsb;Saucer Buy;Saucer Buy;;\n```\n(it might be somewhere later but for now that will tell LLM about them easiely)\n\n## Command Line Tools\n\nThe package provides the following command-line tools for working with IDS, CDS, and related data services:\n\n| Command | Entry Point | Description |\n|--------------|--------------------------------------|-------------|\n| `jgtcli` | jgtpy.jgtcli:main | General CLI for instrument/timeframe data operations: fetch, process, and chart PDS/IDS/CDS/ADS data. Handles argument parsing for instruments, timeframes, date ranges, and indicator options. |\n| `cdscli` | jgtpy.cdscli:main | CLI for creating and processing Chaos Data Service (CDS) files from instrument/timeframe data, with support for indicator and ADS options. |\n| `pds2cds` | jgtpy.pds2cds:main | Convert a PDS (Price Data Service) file to a CDS (Chaos Data Service) file, with options for bar count and TLID date range. |\n| `jgtmksg` | jgtpy.JGTMKSG:main | Generate market snapshots and chart visualizations for multiple instruments/timeframes, with advanced charting and HTML output options. |\n| `jgtads` | jgtpy.JGTADS:main | Generate and plot Advanced Data Service (ADS) analytics and visualizations from CDS or PDS data, including technical indicators and signals. |\n| `jgtids` | jgtpy.jgtapycli:main | Generate and process Indicator Data Service (IDS) files, with CLI options for indicators, normalization, and output. |\n| `adscli` | jgtpy.JGTADS:main | Alias for `jgtads`: generate and plot ADS analytics and visualizations. |\n| `mkscli` | jgtpy.JGTMKSG:main | Alias for `jgtmksg`: generate market snapshots and chart visualizations. |\n| `idscli` | jgtpy.jgtapycli:main | Alias for `jgtids`: generate and process IDS files. |\n| `adsfromcds` | jgtpy.adsfromcdsfile:main | Create plots from CDS cache data, supporting custom output directories, chart types, and feature plots. |\n\nFor more details on each command, read [CLI_REFERENCE.md](docs/CLI_REFERENCE.md) or run the command with `--help`.\n\nAdditional usage demonstrations can be found in the [examples](examples/) directory.\n\n## JGT Data Refresh Service\n\n**New in v0.6.0**: Automated data refresh service with parallel processing and cloud distribution.\n\nThe JGT Data Refresh Service (`jgtservice`) modernizes the manual bash script workflow for processing financial market data with:\n\n- **Automated Scheduling**: Timeframe-based refresh using intelligent scheduling\n- **Parallel Processing**: Concurrent instrument/timeframe processing with configurable workers \n- **Cloud Distribution**: Modernized Dropbox integration for automatic uploads\n- **Web API**: RESTful endpoints for data access and service management\n- **Multiple Modes**: Daemon, web server, one-time refresh, and status monitoring\n\n### Installation\n\n```bash\n# Install base functionality\npip install -e .\n\n# Install with web service dependencies\npip install -e \".[serve]\"\n```\n\n### Quick Start\n\n```bash\n# One-time refresh\njgtservice --refresh-once -i EUR/USD -t H1\n\n# Continuous daemon mode \njgtservice --daemon --all\n\n# Web API server\njgtservice --web --port 8080\n\n# Check service status\njgtservice --status\n```\n\n### Web API Endpoints\n\nWhen running in web mode (`jgtservice --web`), the following API endpoints are available:\n\n- `GET /api/v1/data/{instrument}/{timeframe}` - Retrieve processed CDS data\n- `GET /api/v1/data/{instrument}/{timeframe}/latest` - Get latest data point\n- `GET /api/v1/status` - Service status and configuration\n- `GET /api/v1/health` - Health check endpoint\n- `POST /api/v1/refresh` - Trigger manual refresh\n- `GET /api/v1/metrics` - Processing metrics and statistics\n- `GET /docs` - Interactive API documentation\n\n### Configuration\n\nThe service can be configured via environment variables:\n\n```bash\n# Data paths\nexport JGTPY_DATA=\"/path/to/current/data\" \nexport JGTPY_DATA_FULL=\"/path/to/full/data\"\n\n# Timeframe configuration\nexport TRADABLE_TIMEFRAMES=\"m1,m5,m15,m30,H1,H4\"\nexport HIGH_TIMEFRAMES=\"H4,D1,W1\"\n\n# Service settings\nexport JGTPY_SERVICE_MAX_WORKERS=4\nexport JGTPY_SERVICE_WEB_PORT=8080\nexport JGTPY_DROPBOX_APP_TOKEN=\"your_dropbox_token\"\n\n# Optional API authentication\nexport JGTPY_API_KEY=\"your_api_key\"\n```\n\n### Performance\n\n- **50%+ faster** than sequential processing through parallel execution\n- **EUR/USD H1**: ~8 seconds processing time\n- **Memory stable** during extended daemon runs\n- **Error resilient** with individual failure isolation\n\nFor complete documentation, see [docs/jgtservice_implementation.md](docs/jgtservice_implementation.md).\n\n## Quick Start Scripts\n\nThe repository includes convenience scripts for common operations:\n\n```bash\n# First time setup\n./setup-service.sh --full\n\n# Check service status\n./check-status.sh\n\n# Refresh all data (excludes m1)\n./refresh-all.sh\n\n# Start API server\n./start-api-server.sh\n\n# Start continuous daemon\n./start-daemon.sh\n```\n\nSee [SCRIPTS_README.md](SCRIPTS_README.md) for detailed script documentation.\n\n=======\n\n\n\n## APPENDIX\n\n### IDS Data Columns\n\nThe `jgtpy/JGTIDS.py` file is responsible for generating and managing IDS (Indicator Data Service) files. Here is a Markdown table documenting all the columns in `JGTIDS.py` that are in the output:\n\n| Column Name | Description |\n|-------------|-------------|\n| `Date` | The date and time of the data point. |\n| `Open` | The opening price of the data point. |\n| `High` | The highest price of the data point. |\n| `Low` | The lowest price of the data point. |\n| `Close` | The closing price of the data point. |\n| `Volume` | The volume of the data point. |\n| `Median` | The median price of the data point. |\n| `ao` | The Awesome Oscillator value. |\n| `ac` | The Acceleration/Deceleration Oscillator value. |\n| `jaw` | The Alligator's jaw value. |\n| `teeth` | The Alligator's teeth value. |\n| `lips` | The Alligator's lips value. |\n| `fh` | The fractal high value. |\n| `fl` | The fractal low value. |\n| `fdb` | The fractal divergent bar value. |\n| `fdbb` | The fractal divergent bar buy signal. |\n| `fdbs` | The fractal divergent bar sell signal. |\n| `zlc` | The zero line cross value. |\n| `zlcB` | The zero line cross buy signal. |\n| `zlcS` | The zero line cross sell signal. |\n| `bz` | The buy zone signal. |\n| `sz` | The sell zone signal. |\n| `aocolor` | The color of the Awesome Oscillator. |\n| `accolor` | The color of the Acceleration/Deceleration Oscillator. |\n| `aof` | The AO fractal peak value. |\n| `aofvalue` | The AO fractal peak value. |\n| `aofhighao` | The AO value on the bullish peak. |\n| `aoflowao` | The AO value on the bearish peak. |\n| `aofhigh` | The price high of the peak. |\n| `aoflow` | The price low of the peak. |\n| `mfi` | The Market Facilitation Index value. |\n| `mfi_squat` | The MFI squat signal. |\n| `mfi_green` | The MFI green signal. |\n| `mfi_fade` | The MFI fade signal. |\n| `mfi_fake` | The MFI fake signal. |\n| `mfi_signal` | The MFI signal value. |\n| `mfi_val` | The MFI value. |\n| `zone_signal` | The zone signal value. |\n| `zone_int` | The zone integer value. |\n\n**For the full, up-to-date list of IDS (Indicator Data Service) columns and their descriptions, see the canonical documentation:**\n\n- [docs/IDS_data_columns.md](docs/IDS_data_columns.md)\n\n### CDS Data Columns\n\nThe `jgtpy/JGTCDS.py` file is responsible for creating, reading, and managing Chaos Data Service (CDS) files from Price Data Service (PDS) files. Here is a Markdown table documenting all the columns in `JGTCDS.py` that are added after using `JGTIDS.py` and are in the output:\n\n| Column Name | Description |\n|-------------|-------------|\n| `fdbbhigh` | The high value of the fractal divergent bar buy signal. |\n| `fdbblow` | The low value of the fractal divergent bar buy signal. |\n| `fdbshigh` | The high value of the fractal divergent bar sell signal. |\n| `fdbslow` | The low value of the fractal divergent bar sell signal. |\n| `aocolor` | The color of the Awesome Oscillator. |\n| `accolor` | The color of the Acceleration/Deceleration Oscillator. |\n| `zcol` | The zone color value. |\n| `zlc` | The zero line cross value. |\n| `zlcB` | The zero line cross buy signal. |\n| `zlcS` | The zero line cross sell signal. |\n| `bz` | The buy zone signal. |\n| `sz` | The sell zone signal. |\n| `mfi_squat` | The MFI squat signal. |\n| `mfi_green` | The MFI green signal. |\n| `mfi_fade` | The MFI fade signal. |\n| `mfi_fake` | The MFI fake signal. |\n| `mfi_signal` | The MFI signal value. |\n| `mfi_val` | The MFI value. |\n| `zone_signal` | The zone signal value. |\n| `zone_int` | The zone integer value. |\n\n### IDS Purpose\n\nThe `jgtpy/JGTIDS.py` file is responsible for generating and managing IDS (Indicator Data Service) files. The `jgtids` script, exposed through `[project.scripts]` in `pyproject.toml`, provides functionalities to create IDS files, read IDS files, and perform other related operations. Here is a detailed documentation of the purpose of JGTIDS and what end-results it produces in terms of data for `JGTCDS.py`:\n\n* **Purpose of JGTIDS** \ud83d\udcca\n - The main purpose of `JGTIDS.py` is to add various technical indicators to the financial market data. These indicators are used for market analysis and trading decisions.\n - The module processes the input data and adds indicators such as the Alligator indicator, Awesome Oscillator (AO), Acceleration/Deceleration Oscillator (AC), fractals, and Market Facilitation Index (MFI).\n - The module also generates buy and sell signals based on the technical indicators. These signals include fractal divergent bar signals, zero line cross signals, and zone signals.\n\n* **End-Results Produced for JGTCDS.py** \ud83d\udcc8\n - The processed data with added indicators and signals is used as input for `JGTCDS.py` to create Chaos Data Service (CDS) files.\n - The indicators and signals added by `JGTIDS.py` are essential for generating the CDS files, which are used for further analysis and charting.\n - The columns added by `JGTIDS.py` include various technical indicators and signals, which are documented in the `docs/IDS_data_columns.md` file.\n\n* **Data Flow** \ud83d\udd04\n - The input data is read from Price Data Service (PDS) files.\n - The data is processed by `JGTIDS.py` to add indicators and signals.\n - The processed data is then used by `JGTCDS.py` to create CDS files.\n - The CDS files are used for further analysis, charting, and generating trading signals.\n\n### CDS Purpose\n\nThe `jgtpy/JGTCDS.py` file is responsible for creating, reading, and managing Chaos Data Service (CDS) files from Price Data Service (PDS) files. Here is a detailed documentation of the purpose of JGTCDS and what it produces after getting data from `JGTIDS.py`:\n\n* **Purpose of JGTCDS** \ud83d\udcca\n - The main purpose of `JGTCDS.py` is to process the input data from `JGTIDS.py` and create CDS files. These files contain processed financial market data with various technical indicators and signals.\n - The module provides functions to create CDS files from PDS files, read CDS files, and manage the data. It also handles data cleansing and normalization.\n\n* **Data Processing** \ud83d\udd04\n - The input data is read from PDS files and processed by `JGTIDS.py` to add various technical indicators and signals.\n - The processed data from `JGTIDS.py` is then used by `JGTCDS.py` to create CDS files. The module adds additional indicators and signals to the data, such as fractal divergent bar signals, zero line cross signals, and zone signals.\n - The data is cleansed and normalized to ensure it is ready for analysis and charting.\n\n* **End-Results Produced** \ud83d\udcc8\n - The CDS files created by `JGTCDS.py` contain processed financial market data with various technical indicators and signals. These files are used for further analysis, charting, and generating trading signals.\n - The columns added by `JGTCDS.py` include various technical indicators and signals, which are documented in the `docs/CDS_data_columns.md` file.\n\n* **Data Flow** \ud83d\udd04\n - The input data is read from Price Data Service (PDS) files.\n - The data is processed by `JGTIDS.py` to add indicators and signals.\n - The processed data is then used by `JGTCDS.py` to create CDS files.\n - The CDS files are used for further analysis, charting, and generating trading signals.\n\n### CDSSvc Purpose\n\nThe `jgtpy/JGTCDSSvc.py` file is responsible for providing services related to Chaos Data Service (CDS) files. Here is a detailed documentation of the purpose of JGTCDSSvc and what it produces:\n\n* **Purpose of JGTCDSSvc** \ud83d\udcca\n - The main purpose of `JGTCDSSvc.py` is to provide functionalities for creating, reading, and managing CDS files. It acts as a service layer that interacts with `JGTCDS.py` to perform these operations.\n - The module provides functions to create CDS files from PDS files, read CDS files, and manage the data. It also handles data cleansing and normalization.\n\n* **Data Processing** \ud83d\udd04\n - The input data is read from PDS files and processed by `JGTIDS.py` to add various technical indicators and signals.\n - The processed data from `JGTIDS.py` is then used by `JGTCDS.py` to create CDS files. The module adds additional indicators and signals to the data, such as fractal divergent bar signals, zero line cross signals, and zone signals.\n - The data is cleansed and normalized to ensure it is ready for analysis and charting.\n\n* **End-Results Produced** \ud83d\udcc8\n - The CDS files created by `JGTCDSSvc.py` contain processed financial market data with various technical indicators and signals. These files are used for further analysis, charting, and generating trading signals.\n - The columns added by `JGTCDSSvc.py` include various technical indicators and signals, which are documented in the `docs/CDS_data_columns.md` file.\n\n* **Data Flow** \ud83d\udd04\n - The input data is read from Price Data Service (PDS) files.\n - The data is processed by `JGTIDS.py` to add indicators and signals.\n - The processed data is then used by `JGTCDS.py` to create CDS files.\n - The CDS files are used for further analysis, charting, and generating trading signals.\n\n* **Functions Not Covered in JGTCDS.py** \ud83d\udcdc\n - **zone_update**: This function updates the zone data for a given instrument and timeframe. It reads the CDS file, extracts the zone information, and saves it to a separate file.\n - **zone_update_from_cdf**: This function updates the zone data from a given CDS DataFrame. It extracts the zone information and saves it to a separate file.\n - **zone_read**: This function reads the zone data for a given instrument and timeframe from the saved file.\n - **zone_read_up**: This function reads the zone data for a given instrument and timeframe, including higher timeframes up to a specified level.\n - **get_higher_cdf_datasets**: This function retrieves the CDS data for higher timeframes of a given instrument and timeframe. It uses parallel processing to speed up the retrieval.\n - **get_higher_cdf_datasets_no_concurrence**: This function retrieves the CDS data for higher timeframes of a given instrument and timeframe without using parallel processing.\n - **get_higher_cdf**: This function retrieves the CDS data for a higher timeframe of a given instrument and timeframe based on a specified level.\n\n\n## jgtads: Advanced Data Service Analytics CLI\n\n`jgtads` is the command-line gateway to Advanced Data Service (ADS) analytics and visualizations. It empowers you to:\n\n- Generate and plot ADS analytics from Chaos Data Service (CDS) or Price Data Service (PDS) files.\n- Compute and visualize technical indicators and trading signals.\n- Output interactive or static charts, analytics CSVs, and signal summaries.\n\n**Typical usage:**\n\n```sh\njgtads --instrument EURUSD --timeframe H1 --show --save_figure my_analytics.png\n```\n\nOr, to save with auto-naming:\n\n```sh\njgtads --instrument EURUSD --timeframe H1 --save_figure charts/ --save_figure_as_timeframe\n```\n\n- `--instrument` and `--timeframe` are required.\n- Use `--show` to display, or `--save_figure` to save.\n- No `--input`, `--output`, `--indicators`, or `--signals` options exist.\n\n> Like a fractal lens, `jgtads` reveals the hidden patterns in your market data\u2014one invocation, many insights.\n",
"bugtrack_url": null,
"license": null,
"summary": "Enhanced JGTPy CDS, IDS, PDSP Services",
"version": "0.6.25",
"project_urls": {
"Bug Tracker": "https://github.com/jgwill/jgtpy/issues",
"Homepage": "https://github.com/jgwill/jgtpy"
},
"split_keywords": [
"data"
],
"urls": [
{
"comment_text": null,
"digests": {
"blake2b_256": "e9f2a1af23317dfe67c514f3483aeca619d489581c9896ef1f9b94c6a47b1e95",
"md5": "b777d1870fe524d10d457010124ab257",
"sha256": "73abed9e88bc807a93d9865590f54e4666d017d09979badc042dc8f2da7fb190"
},
"downloads": -1,
"filename": "jgtpy-0.6.25-py3-none-any.whl",
"has_sig": false,
"md5_digest": "b777d1870fe524d10d457010124ab257",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.7",
"size": 225400,
"upload_time": "2025-07-11T20:43:39",
"upload_time_iso_8601": "2025-07-11T20:43:39.043833Z",
"url": "https://files.pythonhosted.org/packages/e9/f2/a1af23317dfe67c514f3483aeca619d489581c9896ef1f9b94c6a47b1e95/jgtpy-0.6.25-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "c036bdc2e20d88539b7cb1e6aa89f21646b1999688b63339ec8a889bbde3cbd1",
"md5": "8f7fb56e97babbe281e61a3130b0a66c",
"sha256": "295033069e366e2a79333c1456589798cb70aecb3c13b70ced47f3699faeb67f"
},
"downloads": -1,
"filename": "jgtpy-0.6.25.tar.gz",
"has_sig": false,
"md5_digest": "8f7fb56e97babbe281e61a3130b0a66c",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.7",
"size": 213168,
"upload_time": "2025-07-11T20:43:40",
"upload_time_iso_8601": "2025-07-11T20:43:40.878768Z",
"url": "https://files.pythonhosted.org/packages/c0/36/bdc2e20d88539b7cb1e6aa89f21646b1999688b63339ec8a889bbde3cbd1/jgtpy-0.6.25.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2025-07-11 20:43:40",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "jgwill",
"github_project": "jgtpy",
"travis_ci": false,
"coveralls": true,
"github_actions": true,
"requirements": [
{
"name": "matplotlib",
"specs": []
},
{
"name": "numpy",
"specs": []
},
{
"name": "packaging",
"specs": []
},
{
"name": "pandas",
"specs": []
},
{
"name": "Pillow",
"specs": []
},
{
"name": "plotly",
"specs": []
},
{
"name": "ply",
"specs": []
},
{
"name": "pyparsing",
"specs": []
},
{
"name": "python-dateutil",
"specs": []
},
{
"name": "python-dotenv",
"specs": []
},
{
"name": "pytz",
"specs": []
},
{
"name": "requests",
"specs": []
},
{
"name": "six",
"specs": []
},
{
"name": "stone",
"specs": []
},
{
"name": "tenacity",
"specs": []
},
{
"name": "typing_extensions",
"specs": []
},
{
"name": "urllib3",
"specs": []
},
{
"name": "mplfinance",
"specs": []
},
{
"name": "tlid",
"specs": []
},
{
"name": "jgtapy",
"specs": []
},
{
"name": "jgtutils",
"specs": []
},
{
"name": "scipy",
"specs": []
},
{
"name": "tomli",
"specs": []
},
{
"name": "markdown-it-py",
"specs": []
},
{
"name": "panel",
"specs": []
},
{
"name": "flask",
"specs": []
},
{
"name": "scipy",
"specs": []
},
{
"name": "jinja2",
"specs": []
},
{
"name": "dash",
"specs": []
},
{
"name": "panel",
"specs": []
},
{
"name": "tdqm",
"specs": []
},
{
"name": "jgtfxcon",
"specs": []
}
],
"tox": true,
"lcname": "jgtpy"
}
JSON
