new version vbt

init fixes2 (#209 )
fix module inits (#208 )
2024-06-20 22:13:43 +02:00 · 2024-06-13 11:52:14 +02:00 · 2024-06-13 11:47:05 +02:00 · 2024-06-13 11:02:41 +02:00 · 2024-06-04 14:07:44 +02:00 · 2024-06-04 12:49:32 +02:00
1187 changed files with 104523 additions and 4867 deletions
--- a/README.md
+++ b/README.md
@@ -1,9 +1,9 @@
-# V2TRADING - Advanced Algorithmic Trading Platform
+**README - V2TRADING - Advanced Algorithmic Trading Platform**

-## Overview
-Custom-built algorithmic trading platform for research, backtesting and live trading. Trading engine capable of processing tick data, providing custom aggregation, managing trades, and supporting backtesting in a highly accurate and efficient manner.
+**Overview**
+Custom-built algorithmic trading platform for research, backtesting and automated trading. Trading engine capable of processing tick data, managing trades, and supporting backtesting in a highly accurate and efficient manner.

-## Key Features
+**Key Features**
 - **Trading Engine**: At the core of the platform is a trading engine that processes tick data in real time. This engine is responsible for aggregating data and managing the execution of trades, ensuring precision and speed in trade placement and execution.

 - **High-Fidelity Backtesting Environment**: ability to backtest strategies with 1:1 precision - meaning a tick-by-tick backtesting. This level of precision in backtesting, down to millisecond accuracy, mirrors live trading environments and is vital for developing and testing high-frequency trading strategies.
@@ -51,78 +51,3 @@ This repository represents a sophisticated and evolving tool for algorithmic tra
 </p>


-# Installation Instructions
-This document outlines the steps for installing and setting up the necessary environment for the application. These instructions are applicable for both Windows and Linux operating systems. Please follow the steps carefully to ensure a smooth setup.
-
-## Prerequisites
-Before beginning the installation process, ensure the following prerequisites are met:
-
- TA-Lib Library:
-  - Windows: Download and build the TA-Lib library. Install Visual Studio Community with the Visual C++ feature. Navigate to `C:\ta-lib\c\make\cdr\win32\msvc` in the command prompt and build the library using the available makefile.
-  - Linux: Install TA-Lib using your distribution's package manager or compile from source following the instructions available on the TA-Lib GitHub repository.
- 
- Alpaca Paper Trading Account: Create an account at [Alpaca Markets](https://alpaca.markets/) and generate `API_KEY` and `SECRET_KEY` for your paper trading account.
-
-## Installation Steps
-**Clone the Repository:** Clone the remote repository to your local machine.
-   `git clone git@github.com:drew2323/v2trading.git <name_of_local_folder>`
-   
-**Install Python:** Ensure Python 3.10.11 is installed on your system.
-
-**Create a Virtual Environment:** Set up a Python virtual environment.
-   `python -m venv <path_to_venv_folder>`
-   
-**Activate Virtual Environment:**
-   - Windows: `source ./<venv_folder>/Scripts/activate`
-   - Linux: `source ./<venv_folder>/bin/activate`
-
-**Install Dependencies:** Install the program requirements.
-   pip install -r requirements.txt
-   Note: It's permissible to comment out references to `keras` and `tensorflow` modules, as well as the `ml-room` repository in `requirements.txt`.
-
-**Environment Variables:** In `run.sh`, modify the `VIRTUAL_ENV_DIR` and `PYTHON_TO_USE` variables as necessary.
-
-**Data Directory:** Navigate to `DATA_DIR` and create folders: `aggcache`, `tradecache`, and `models`.
-
-**Media and Static Folders:** Create `media` and `static` folders one level above the repository directory. Also create `.env` file there.
-
-**Database Setup:** Create the `v2trading.db` file using SQL commands from `v2trading_create_db.sql`.
-```
-    import sqlite3
-    with open("v2trading_create_db.sql", "r") as f:
-        sql_statements = f.read()
-    conn = sqlite3.connect('v2trading.db')
-    cursor = conn.cursor()
-    cursor.executescript(sql_statements)
-    conn.commit()
-    conn.close()
-```
-Ensure the `config_table` is not empty by making an initial entry.
-
-**Start the Application:** Run `main.py` in VSCode to start the application.
-
-**Accessing the Application:** If the uvicorn server runs successfully at `http://0.0.0.0:8000`, access the application at `http://localhost:8000/static/`.
-
-**Database Configuration:** Add dynamic button and JS configurations to the `config_table` in `v2trading.db` via the "Config" section on the main page.
-Please replace placeholders (e.g., `<name_of_local_folder>`, `<path_to_venv_folder>`) with your actual paths and details. Follow these instructions to ensure the application is set up correctly and ready for use.
-
-## Environmental variables
-Trading platform can support N different accounts. Their API keys are stored as environmental variables in .env file located in the root directory.
-Account for trading api is selected when each strategy is run. However for realtime websocket data), always ACCOUNT1 is used for all strategies. The data point selection (iex vs sip) is set by LIVE_DATA_FEED environment variable.  
-
-.env file should contain:
-
-```
-ACCOUNT1_LIVE_API_KEY=<ACCOUNT1_LIVE_API_KEY>
-ACCOUNT1_LIVE_SECRET_KEY=<ACCOUNT1_LIVE_SECRET_KEY>
-ACCOUNT1_LIVE_FEED=sip
-ACCOUNT1_PAPER_API_KEY=<ACCOUNT1_PAPER_API_KEY>
-ACCOUNT1_PAPER_SECRET_KEY=<ACCOUNT1_PAPER_SECRET_KEY>
-ACCOUNT1_PAPER_FEED=sip
-ACCOUNT2_PAPER_API_KEY=<ACCOUNT2_PAPER_API_KEY>
-ACCOUNT2_PAPER_SECRET_KEY=ACCOUNT2_PAPER_SECRET_KEY<>
-ACCOUNT2_PAPER_FEED=iex
-WEB_API_KEY=<pass-for-webapi>
-```
-
-
--- a/requirements_newest.txt
+++ b/requirements_newest.txt
@@ -1,243 +0,0 @@
-absl-py
-alpaca
-alpaca-py
-altair
-annotated-types
-anyio
-appdirs
-appnope
-APScheduler
-argon2-cffi
-argon2-cffi-bindings
-arrow
-asttokens
-astunparse
-async-lru
-attrs
-Babel
-beautifulsoup4
-better-exceptions
-bleach
-blinker
-bottle
-cachetools
-CD
-certifi
-cffi
-chardet
-charset-normalizer
-click
-colorama
-comm
-contourpy
-cycler
-dash
-dash-bootstrap-components
-dash-core-components
-dash-html-components
-dash-table
-dateparser
-debugpy
-decorator
-defusedxml
-dill
-dm-tree
-entrypoints
-exceptiongroup
-executing
-fastapi
-fastjsonschema
-filelock
-Flask
-flatbuffers
-fonttools
-fpdf2
-fqdn
-gast
-gitdb
-GitPython
-google-auth
-google-auth-oauthlib
-google-pasta
-greenlet
-grpcio
-h11
-h5py
-html2text
-httpcore
-httpx
-humanize
-icecream
-idna
-imageio
-importlib-metadata
-ipykernel
-ipython
-ipywidgets
-isoduration
-itables
-itsdangerous
-jax
-jaxlib
-jedi
-Jinja2
-joblib
-json5
-jsonpointer
-jsonschema
-jsonschema-specifications
-jupyter-events
-jupyter-lsp
-jupyter_client
-jupyter_core
-jupyter_server
-jupyter_server_terminals
-jupyterlab
-jupyterlab-widgets
-jupyterlab_pygments
-jupyterlab_server
-kaleido
-keras
-keras-core
-keras-nightly
-keras-nlp-nightly
-keras-tcn @ git+https://github.com/drew2323/keras-tcn.git
-kiwisolver
-libclang
-lightweight-charts @ git+https://github.com/drew2323/lightweight-charts-python.git
-llvmlite
-Markdown
-markdown-it-py
-MarkupSafe
-matplotlib
-matplotlib-inline
-mdurl
-mistune
-ml-dtypes
-mlroom @ git+https://github.com/drew2323/mlroom.git
-mplfinance
-msgpack
-mypy-extensions
-namex
-nbclient
-nbconvert
-nbformat
-nest-asyncio
-newtulipy
-notebook_shim
-numba
-numpy
-oauthlib
-opt-einsum
-orjson
-overrides
-packaging
-pandas
-pandocfilters
-param
-parso
-patsy
-pexpect
-Pillow
-platformdirs
-plotly
-prometheus_client
-prompt-toolkit
-proto-plus
-protobuf
-proxy-tools
-psutil
-ptyprocess
-pure-eval
-pyarrow
-pyasn1
-pyasn1-modules
-pycparser
-pyct
-pydantic
-pydantic_core
-pydeck
-Pygments
-pyinstrument
-pyparsing
-pyrsistent
-pysos
-python-dateutil
-python-dotenv
-python-json-logger
-python-multipart
-pytz
-pytz-deprecation-shim
-pyviz-comms
-PyWavelets
-pywebview
-PyYAML
-pyzmq
-referencing
-regex
-requests
-requests-oauthlib
-rfc3339-validator
-rfc3986-validator
-rich
-rpds-py
-rsa
-schedule
-scikit-learn
-scipy
-seaborn
-semver
-Send2Trash
-six
-smmap
-sniffio
-soupsieve
-SQLAlchemy
-sseclient-py
-stack-data
-starlette
-statsmodels
-streamlit
-structlog
-TA-Lib
-tb-nightly
-tenacity
-tensorboard
-tensorboard-data-server
-tensorflow-addons
-tensorflow-estimator
-tensorflow-io-gcs-filesystem
-termcolor
-terminado
-tf-estimator-nightly
-tf-nightly
-tf_keras-nightly
-threadpoolctl
-tinycss2
-tinydb
-tinydb-serialization
-tinyflux
-toml
-tomli
-toolz
-tornado
-tqdm
-traitlets
-typeguard
-types-python-dateutil
-typing_extensions
-tzdata
-tzlocal
-uri-template
-urllib3
-uvicorn
-validators
-wcwidth
-webcolors
-webencodings
-websocket-client
-websockets
-Werkzeug
-widgetsnbextension
-wrapt
-zipp
--- a/research/strat_LINREG_MULTI/v1_SINGLE.ipynb
+++ b/research/strat_LINREG_MULTI/v1_SINGLE.ipynb
--- a/research/strat_ORDER_IMBALANCE/v2_SINGLE.ipynb
+++ b/research/strat_ORDER_IMBALANCE/v2_SINGLE.ipynb
@@ -1691,7 +1691,7 @@
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
-   "version": "3.10.11"
+   "version": "3.10.10"
  }
 },
 "nbformat": 4,
--- a/research/strat_SUPERTREND/.ipynb_checkpoints/v2_SINGLE-checkpoint.ipynb
+++ b/research/strat_SUPERTREND/.ipynb_checkpoints/v2_SINGLE-checkpoint.ipynb
--- a/research/strat_SUPERTREND/SUPERTREND_v1_MULTI.ipynb
+++ b/research/strat_SUPERTREND/SUPERTREND_v1_MULTI.ipynb
@@ -1,932 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from v2realbot.tools.loadbatch import load_batch\n",
-    "from v2realbot.utils.utils import zoneNY\n",
-    "import pandas as pd\n",
-    "import numpy as np\n",
-    "import vectorbtpro as vbt\n",
-    "from itables import init_notebook_mode, show\n",
-    "import datetime\n",
-    "from itertools import product\n",
-    "from v2realbot.config import ACCOUNT1_PAPER_API_KEY, ACCOUNT1_PAPER_SECRET_KEY, DATA_DIR\n",
-    "\n",
-    "init_notebook_mode(all_interactive=True)\n",
-    "\n",
-    "vbt.settings.set_theme(\"dark\")\n",
-    "vbt.settings['plotting']['layout']['width'] = 1280\n",
-    "vbt.settings.plotting.auto_rangebreaks = True\n",
-    "# Set the option to display with pagination\n",
-    "pd.set_option('display.notebook_repr_html', True)\n",
-    "pd.set_option('display.max_rows', 10)  # Number of rows per page\n",
-    "\n",
-    "# Define the market open and close times\n",
-    "market_open = datetime.time(9, 30)\n",
-    "market_close = datetime.time(16, 0)\n",
-    "entry_window_opens = 1\n",
-    "entry_window_closes = 370\n",
-    "\n",
-    "forced_exit_start = 380\n",
-    "forced_exit_end = 390\n",
-    "\n",
-    "#LOAD FROM PARQUET\n",
-    "#list all files is dir directory with parquet extension\n",
-    "dir = DATA_DIR + \"/notebooks/\"\n",
-    "import os\n",
-    "files = [f for f in os.listdir(dir) if f.endswith(\".parquet\")]\n",
-    "#print('\\n'.join(map(str, files)))\n",
-    "file_name = \"ohlcv_df-SPY-2024-01-01T09:30:00-2024-05-14T16:00:00.parquet\"\n",
-    "ohlcv_df = pd.read_parquet(dir+file_name,engine='pyarrow')\n",
-    "basic_data = vbt.Data.from_data(vbt.symbol_dict({\"SPY\": ohlcv_df}), tz_convert=zoneNY)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#parameters (primary y line, secondary y line, close)\n",
-    "def plot_2y_close(priminds, secinds, close):\n",
-    "    fig = vbt.make_subplots(rows=1, cols=1, shared_xaxes=True, specs=[[{\"secondary_y\": True}]], vertical_spacing=0.02, subplot_titles=(\"MOM\", \"Price\" ))\n",
-    "    close.vbt.plot(fig=fig, add_trace_kwargs=dict(secondary_y=False), trace_kwargs=dict(line=dict(color=\"blue\")))\n",
-    "    for ind in priminds:\n",
-    "        ind.plot(fig=fig, add_trace_kwargs=dict(secondary_y=False))\n",
-    "    for ind in secinds:\n",
-    "        ind.plot(fig=fig, add_trace_kwargs=dict(secondary_y=True))\n",
-    "    return fig\n",
-    "\n",
-    "# close = basic_data.xloc[\"09:30\":\"10:00\"].close"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#PIPELINE - FOR - LOOP\n",
-    "\n",
-    "#indicator parameters\n",
-    "mom_timeperiod = list(range(2, 12))\n",
-    "\n",
-    "#uzavreni okna od 1 do 200\n",
-    "#entry_window_closes = list(range(2, 50, 3))\n",
-    "entry_window_closes = [5, 10, 30, 45]\n",
-    "#entry_window_closes = 30\n",
-    "#threshold  entries parameters\n",
-    "#long\n",
-    "mom_th = np.round(np.arange(0.01, 0.5 + 0.02, 0.02),4).tolist()#-0.02\n",
-    "# short\n",
-    "#mom_th = np.round(np.arange(-0.01, -0.3 - 0.02, -0.02),4).tolist()#-0.02\n",
-    "roc_th = np.round(np.arange(-0.2, -0.8 - 0.05, -0.05),4).tolist()#-0.2\n",
-    "#print(mom_th, roc_th)\n",
-    "\n",
-    "#portfolio simulation parameters\n",
-    "sl_stop =np.round(np.arange(0.02/100, 0.7/100, 0.05/100),4).tolist()\n",
-    "tp_stop = np.round(np.arange(0.02/100, 0.7/100, 0.05/100),4).tolist()\n",
-    "\n",
-    "combs = list(product(mom_timeperiod, mom_th, roc_th, sl_stop, tp_stop))\n",
-    "\n",
-    "@vbt.parameterized(merge_func = \"concat\", random_subset = 2000, show_progress=True)  \n",
-    "def test_strat(entry_window_closes=60,\n",
-    "               mom_timeperiod=2,\n",
-    "               mom_th=-0.04,\n",
-    "               #roc_th=-0.2,\n",
-    "               sl_stop=0.19/100,\n",
-    "               tp_stop=0.19/100):\n",
-    "    # mom_timeperiod=2\n",
-    "    # mom_th=-0.06\n",
-    "    # roc_th=-0.2\n",
-    "    # sl_stop=0.04/100\n",
-    "    # tp_stop=0.04/100\n",
-    "\n",
-    "    momshort = vbt.indicator(\"talib:MOM\").run(basic_data.close, timeperiod=mom_timeperiod, short_name = \"slope_short\")\n",
-    "    rocp = vbt.indicator(\"talib:ROC\").run(basic_data.close, short_name = \"rocp\")\n",
-    "    #rate of change + momentum\n",
-    "\n",
-    "    #momshort.plot rocp.real_crossed_below(roc_th) & \n",
-    "    #short_signal = momshort.real_crossed_below(mom_th)\n",
-    "    long_signal = momshort.real_crossed_above(mom_th)\n",
-    "    # print(\"short signal\")\n",
-    "    # print(short_signal.value_counts())\n",
-    "\n",
-    "    #forced_exit = pd.Series(False, index=close.index)\n",
-    "    forced_exit = basic_data.symbol_wrapper.fill(False)\n",
-    "    #entry_window_open = pd.Series(False, index=close.index)\n",
-    "    entry_window_open=  basic_data.symbol_wrapper.fill(False)\n",
-    "\n",
-    "    #print(entry_window_closes, \"entry window closes\")\n",
-    "    # Calculate the time difference in minutes from market open for each timestamp\n",
-    "    elapsed_min_from_open = (forced_exit.index.hour - market_open.hour) * 60 + (forced_exit.index.minute - market_open.minute)\n",
-    "\n",
-    "    entry_window_open[(elapsed_min_from_open >= entry_window_opens) & (elapsed_min_from_open < entry_window_closes)] = True\n",
-    "\n",
-    "    #print(entry_window_open.value_counts())\n",
-    "\n",
-    "    forced_exit[(elapsed_min_from_open >= forced_exit_start) & (elapsed_min_from_open < forced_exit_end)] = True\n",
-    "    #short_entries = (short_signal & entry_window_open)\n",
-    "    #short_exits = forced_exit\n",
-    "    entries = (long_signal & entry_window_open)\n",
-    "    exits = forced_exit\n",
-    "    #long_entries.info()\n",
-    "    #number of trues and falses in long_entries\n",
-    "    #print(short_exits.value_counts())\n",
-    "    #print(short_entries.value_counts())\n",
-    "\n",
-    "    #fig = plot_2y_close([],[momshort, rocp], close)\n",
-    "    #short_signal.vbt.signals.plot_as_entries(close, fig=fig, add_trace_kwargs=dict(secondary_y=False))\n",
-    "    #print(sl_stop)\n",
-    "    #tsl_th=sl_stop, \n",
-    "    #short_entries=short_entries, short_exits=short_exits,\n",
-    "    pf = vbt.Portfolio.from_signals(close=basic_data.close, entries=entries, exits=exits, tsl_stop=sl_stop, tp_stop = tp_stop, fees=0.0167/100, freq=\"1s\", price=\"close\") #sl_stop=sl_stop, tp_stop = sl_stop,\n",
-    "    \n",
-    "    return pf.stats([\n",
-    "        'total_return',\n",
-    "        'max_dd', \n",
-    "        'total_trades', \n",
-    "        'win_rate', \n",
-    "        'expectancy'\n",
-    "    ])\n",
-    "\n",
-    "pf_results = test_strat(vbt.Param(entry_window_closes),\n",
-    "                        vbt.Param(mom_timeperiod),\n",
-    "                        vbt.Param(mom_th),\n",
-    "                        #vbt.Param(roc_th)\n",
-    "                        vbt.Param(sl_stop),\n",
-    "                        vbt.Param(tp_stop, condition=\"tp_stop > sl_stop\"))\n",
-    "pf_results = pf_results.unstack(level=-1)\n",
-    "pf_results.sort_values(by=[\"Total Return [%]\", \"Max Drawdown [%]\"], ascending=[False, True])\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#pf_results.load(\"10tiscomb.pickle\")\n",
-    "#pf_results.info()\n",
-    "\n",
-    "vbt.save(pf_results, \"8tiscomb_tsl.pickle\")\n",
-    "\n",
-    "# pf_results = vbt.load(\"8tiscomb_tsl.pickle\")\n",
-    "# pf_results\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# parallel_coordinates method¶\n",
-    "\n",
-    "# attach_px_methods.<locals>.plot_func(\n",
-    "#     *args,\n",
-    "#     layout=None,\n",
-    "#     **kwargs\n",
-    "# )\n",
-    "\n",
-    "# pf_results.vbt.px.parallel_coordinates() #ocdf\n",
-    "\n",
-    "res = pf_results.reset_index()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "pf_results"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import pandas as pd\n",
-    "from sklearn.decomposition import PCA\n",
-    "from sklearn.preprocessing import StandardScaler\n",
-    "import matplotlib.pyplot as plt\n",
-    "\n",
-    "# Assuming pf_results is your DataFrame\n",
-    "# Convert columns to numeric, assuming NaNs where conversion fails\n",
-    "metrics = ['Total Return [%]', 'Max Drawdown [%]', 'Total Trades']\n",
-    "for metric in metrics:\n",
-    "    pf_results[metric] = pd.to_numeric(pf_results[metric], errors='coerce')\n",
-    "\n",
-    "# Handle missing values, for example filling with the median\n",
-    "pf_results['Max Drawdown [%]'].fillna(pf_results['Max Drawdown [%]'].median(), inplace=True)\n",
-    "\n",
-    "# Extract the metrics into a new DataFrame\n",
-    "data_for_pca = pf_results[metrics]\n",
-    "\n",
-    "# Standardize the data before applying PCA\n",
-    "scaler = StandardScaler()\n",
-    "data_scaled = scaler.fit_transform(data_for_pca)\n",
-    "\n",
-    "# Apply PCA\n",
-    "pca = PCA(n_components=2)  # Adjust components as needed\n",
-    "principal_components = pca.fit_transform(data_scaled)\n",
-    "\n",
-    "# Create a DataFrame with the principal components\n",
-    "pca_results = pd.DataFrame(data=principal_components, columns=['PC1', 'PC2'])\n",
-    "\n",
-    "# Visualize the results\n",
-    "plt.figure(figsize=(8,6))\n",
-    "plt.scatter(pca_results['PC1'], pca_results['PC2'], alpha=0.5)\n",
-    "plt.xlabel('Principal Component 1')\n",
-    "plt.ylabel('Principal Component 2')\n",
-    "plt.title('PCA of Strategy Optimization Results')\n",
-    "plt.grid(True)\n",
-    "plt.savefig(\"ddd.png\")\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Check if there is any unnamed level and rename it\n",
-    "if None in df.index.names:\n",
-    "    # Generate new names list replacing None with 'stat'\n",
-    "    new_names = ['stat' if name is None else name for name in df.index.names]\n",
-    "    df.index.set_names(new_names, inplace=True)\n",
-    "\n",
-    "rs= df\n",
-    "\n",
-    "rs.info()\n",
-    "\n",
-    "\n",
-    "# # Now, 'stat' is the name of the previously unnamed level\n",
-    "\n",
-    "# # Filter for 'Total Return' assuming it is a correct identifier in the 'stat' level\n",
-    "# total_return_series = df.xs('Total Return [%]', level='stat')\n",
-    "\n",
-    "# # Sort the Series to get the largest 'Total Return' values\n",
-    "# sorted_series = total_return_series.sort_values(ascending=False)\n",
-    "\n",
-    "# # Print the sorted filtered data\n",
-    "# sorted_series.head(20)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "sorted_series.vbt.save()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#df.info()\n",
-    "total_return_series = df.xs('Total Return [%]')\n",
-    "sorted_series = total_return_series.sort_values(ascending=False)\n",
-    "\n",
-    "# Display the top N entries, e.g., top 5\n",
-    "sorted_series.head(5)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "df"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "comb_stats_df.nlargest(10, 'Total Return [%]')\n",
-    "#stats_df.info()\n",
-    "\n",
-    "\n",
-    "8\t-0.06\t-0.2\t0.0028\t0.0048\t4.156254\n",
-    "4               -0.02   -0.25   0.0028   0.0048      0.84433\n",
-    "3   -0.02   -0.25   0.0033   0.0023   Total Return [%]     0.846753\n",
-    "#2\t-0.04\t-0.2\t0.0019\t0.0019\n",
-    "# 2\t-0.04\t-0.2\t0.0019\t0.0019\t0.556919\t91\t60.43956\t0.00612\n",
-    "# 2\t-0.04\t-0.25\t0.0019\t0.0019\t0.556919\t91\t60.43956\t0.00612\n",
-    "# 2\t-0.04\t-0.3\t0.0019\t0.0019\t0.556919\t91\t60.43956\t0.00612\n",
-    "# 2\t-0.04\t-0.35\t0.0019\t0.0019\t0.556919\t91\t60.43956\t0.00612\n",
-    "# 2\t-0.04\t-0.4\t0.0019\t0.0019\t0.556919\t91\t60.43956\t0.00612\n",
-    "# 2\t-0.04\t-0.2\t0.0019\t0.0017\t0.451338\t93\t63.44086\t0.004853\n",
-    "# 2\t-0.04\t-0.25\t0.0019\t0.0017\t0.451338\t93\t63.44086\t0.004853\n",
-    "# 2\t-0.04\t-0.3\t0.0019\t0.0017\t0.451338\t93\t63.44086\t0.004853\n",
-    "# 2\t-0.04\t-0.35\t0.0019\t0.0017\t0.451338\t93\t63.44086\t0.004853\n",
-    "# 2\t-0.04\t-0.4\t0.0019\t0.0017\t0.451338\t93\t63.44086\t0.004853"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "pf.plot()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "basic_data.symbols"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    ">>> def apply_func(ts, entries, exits, fastw, sloww, minp=None):\n",
-    "...     fast_ma = vbt.nb.rolling_mean_nb(ts, fastw, minp=minp)\n",
-    "...     slow_ma = vbt.nb.rolling_mean_nb(ts, sloww, minp=minp)\n",
-    "...     entries[:] = vbt.nb.crossed_above_nb(fast_ma, slow_ma)  \n",
-    "...     exits[:] = vbt.nb.crossed_above_nb(slow_ma, fast_ma)\n",
-    "...     return (fast_ma, slow_ma)  \n",
-    "\n",
-    ">>> CrossSig = vbt.IF(\n",
-    "...     class_name=\"CrossSig\",\n",
-    "...     input_names=['ts'],\n",
-    "...     in_output_names=['entries', 'exits'],\n",
-    "...     param_names=['fastw', 'sloww'],\n",
-    "...     output_names=['fast_ma', 'slow_ma']\n",
-    "... ).with_apply_func(\n",
-    "...     apply_func,\n",
-    "...     in_output_settings=dict(\n",
-    "...         entries=dict(dtype=np.bool_),  #initialize output with bool\n",
-    "...         exits=dict(dtype=np.bool_)\n",
-    "...     )\n",
-    "... )\n",
-    ">>> cross_sig = CrossSig.run(ts2, 2, 4)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#PIPELINE - parameters in one go\n",
-    "\n",
-    "\n",
-    "#TOTO prepsat do FOR-LOOPu\n",
-    "\n",
-    "\n",
-    "#indicator parameters\n",
-    "mom_timeperiod = list(range(2, 6))\n",
-    "\n",
-    "#threshold  entries parameters\n",
-    "mom_th = np.round(np.arange(-0.02, -0.1 - 0.02, -0.02),4).tolist()#-0.02\n",
-    "roc_th = np.round(np.arange(-0.2, -0.4 - 0.05, -0.05),4).tolist()#-0.2\n",
-    "#print(mom_th, roc_th)\n",
-    "#jejich product\n",
-    "# mom_th_prod, roc_th_prod = zip(*product(mom_th, roc_th))\n",
-    "\n",
-    "# #convert threshold to vbt param\n",
-    "# mom_th_index = vbt.Param(mom_th_prod, name='mom_th_th') \n",
-    "# roc_th_index = vbt.Param(roc_th_prod, name='roc_th_th')\n",
-    "\n",
-    "mom_th = vbt.Param(mom_th, name='mom_th')\n",
-    "roc_th = vbt.Param(roc_th, name='roc_th')\n",
-    "\n",
-    "#portfolio simulation parameters\n",
-    "sl_stop = np.arange(0.03/100, 0.2/100, 0.02/100).tolist()\n",
-    "# Using the round function\n",
-    "sl_stop = [round(val, 4) for val in sl_stop]\n",
-    "tp_stop = np.arange(0.03/100, 0.2/100, 0.02/100).tolist()\n",
-    "# Using the round function\n",
-    "tp_stop = [round(val, 4) for val in tp_stop]\n",
-    "sl_stop = vbt.Param(sl_stop) #np.nan mean s no stoploss\n",
-    "tp_stop = vbt.Param(tp_stop) #np.nan mean s no stoploss\n",
-    "\n",
-    "\n",
-    "#def test_mom(window=14, mom_th=0.2, roc_th=0.2, sl_stop=0.03/100, tp_stop=0.03/100):\n",
-    "#close = basic_data.xloc[\"09:30\":\"10:00\"].close\n",
-    "momshort = vbt.indicator(\"talib:MOM\").run(basic_data.get(\"Close\"), timeperiod=mom_timeperiod, short_name = \"slope_short\")\n",
-    "\n",
-    "#ht_trendline = vbt.indicator(\"talib:HT_TRENDLINE\").run(close, short_name = \"httrendline\")\n",
-    "rocp = vbt.indicator(\"talib:ROC\").run(basic_data.get(\"Close\"), short_name = \"rocp\")\n",
-    "#rate of change + momentum\n",
-    "\n",
-    "rocp_signal = rocp.real_crossed_below(mom_th)\n",
-    "mom_signal = momshort.real_crossed_below(roc_th)\n",
-    "\n",
-    "#mom_signal\n",
-    "print(rocp_signal.info())\n",
-    "print(mom_signal.info())\n",
-    "#print(rocp.real)\n",
-    "\n",
-    "\n",
-    "short_signal = (mom_signal.vbt & rocp_signal)\n",
-    "\n",
-    "# #short_signal = (rocp.real_crossed_below(roc_th_index) & momshort.real_crossed_below(mom_th_index))\n",
-    "# forced_exit = m1_data.symbol_wrapper.fill(False)\n",
-    "# entry_window_open=  m1_data.symbol_wrapper.fill(False)\n",
-    "\n",
-    "\n",
-    "# # Calculate the time difference in minutes from market open for each timestamp\n",
-    "# elapsed_min_from_open = (forced_exit.index.hour - market_open.hour) * 60 + (forced_exit.index.minute - market_open.minute)\n",
-    "\n",
-    "# entry_window_open[(elapsed_min_from_open >= entry_window_opens) & (elapsed_min_from_open < entry_window_closes)] = True\n",
-    "# forced_exit[(elapsed_min_from_open >= forced_exit_start) & (elapsed_min_from_open < forced_exit_end)] = True\n",
-    "# short_entries = (short_signal & entry_window_open)\n",
-    "# short_exits = forced_exit\n",
-    "# #long_entries.info()\n",
-    "# #number of trues and falses in long_entries\n",
-    "# #short_exits.value_counts()\n",
-    "# #short_entries.value_counts()\n",
-    "\n",
-    "\n",
-    "# pf = vbt.Portfolio.from_signals(close=close, short_entries=short_entries, short_exits=short_exits, sl_stop=sl_stop, tp_stop = tp_stop, fees=0.0167/100, freq=\"1s\") #sl_stop=sl_stop, tp_stop = sl_stop,\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# filter dates"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#filter na dny\n",
-    "dates_of_interest = pd.to_datetime(['2024-04-22']).tz_localize('US/Eastern')\n",
-    "filtered_df = df.loc[df.index.normalize().isin(dates_of_interest)]\n",
-    "\n",
-    "df = filtered_df\n",
-    "df.info()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# import plotly.io as pio\n",
-    "# pio.renderers.default = 'notebook'\n",
-    "\n",
-    "#naloadujeme do vbt symbol as column\n",
-    "basic_data = vbt.Data.from_data({\"BAC\": df}, tz_convert=zoneNY)\n",
-    "\n",
-    "vbt.settings.plotting.auto_rangebreaks = True\n",
-    "#basic_data.data[\"BAC\"].vbt.ohlcv.plot()\n",
-    "\n",
-    "#basic_data.data[\"BAC\"]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "m1_data = basic_data[['Open', 'High', 'Low', 'Close', 'Volume']]\n",
-    "\n",
-    "m1_data.data[\"BAC\"]\n",
-    "#m5_data = m1_data.resample(\"5T\")\n",
-    "\n",
-    "#m5_data.data[\"BAC\"].head(10)\n",
-    "\n",
-    "# m15_data = m1_data.resample(\"15T\")\n",
-    "\n",
-    "# m15 = m15_data.data[\"BAC\"]\n",
-    "\n",
-    "# m15.vbt.ohlcv.plot()\n",
-    "\n",
-    "# m1_data.wrapper.index\n",
-    "\n",
-    "# m1_resampler = m1_data.wrapper.get_resampler(\"1T\")\n",
-    "# m1_resampler.index_difference(reverse=True)\n",
-    "\n",
-    "\n",
-    "# m5_resampler.prettify()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# MOM indicator"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "vbt.phelp(vbt.indicator(\"talib:ROCP\").run)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "vyuzití rychleho klesani na sekundove urovni behem open rush\n",
-    "- MOM + ROC during open rush\n",
-    "- short signal\n",
-    "- pipeline kombinace thresholdu pro vstup mom_th, roc_th + hodnota sl_stop a tp_stop (pripadne trailing) - nalezeni optimalni kombinace atributu"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# fig = plot_2y_close([ht_trendline],[momshort, rocp], close)\n",
-    "# short_signal.vbt.signals.plot_as_entries(close, fig=fig, add_trace_kwargs=dict(secondary_y=False))   \n",
-    "\n",
-    "#parameters (primary y line, secondary y line, close)\n",
-    "def plot_2y_close(priminds, secinds, close):\n",
-    "    fig = vbt.make_subplots(rows=1, cols=1, shared_xaxes=True, specs=[[{\"secondary_y\": True}]], vertical_spacing=0.02, subplot_titles=(\"MOM\", \"Price\" ))\n",
-    "    close.vbt.plot(fig=fig, add_trace_kwargs=dict(secondary_y=False), trace_kwargs=dict(line=dict(color=\"blue\")))\n",
-    "    for ind in priminds:\n",
-    "        ind.plot(fig=fig, add_trace_kwargs=dict(secondary_y=False))\n",
-    "    for ind in secinds:\n",
-    "        ind.plot(fig=fig, add_trace_kwargs=dict(secondary_y=True))\n",
-    "    return fig\n",
-    "\n",
-    "close = m1_data.xloc[\"09:30\":\"10:00\"].close\n",
-    "momshort = vbt.indicator(\"talib:MOM\").run(close, timeperiod=3, short_name = \"slope_short\")\n",
-    "ht_trendline = vbt.indicator(\"talib:HT_TRENDLINE\").run(close, short_name = \"httrendline\")\n",
-    "rocp = vbt.indicator(\"talib:ROC\").run(close, short_name = \"rocp\")\n",
-    "#rate of change + momentum\n",
-    "short_signal = (rocp.real_crossed_below(-0.2) & momshort.real_crossed_below(-0.02))\n",
-    "#indlong = vbt.indicator(\"talib:MOM\").run(close, timeperiod=10, short_name = \"slope_long\")\n",
-    "fig = plot_2y_close([ht_trendline],[momshort, rocp], close)\n",
-    "short_signal.vbt.signals.plot_as_entries(close, fig=fig, add_trace_kwargs=dict(secondary_y=False))   "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "close = m1_data.close\n",
-    "#vbt.phelp(vbt.OLS.run)\n",
-    "\n",
-    "#oer steepmnes of regression line\n",
-    "#talib.LINEARREG_SLOPE(close, timeperiod=timeperiod)\n",
-    "#a také ON BALANCE VOLUME - http://5.161.179.223:8000/static/js/vbt/api/indicators/custom/obv/index.html\n",
-    "\n",
-    "\n",
-    "\n",
-    "mom_ind = vbt.indicator(\"talib:MOM\") \n",
-    "#vbt.phelp(mom_ind.run)\n",
-    "\n",
-    "mom = mom_ind.run(close, timeperiod=10)\n",
-    "\n",
-    "plot_2y_close(mom, close)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# defining ENTRY WINDOW and forced EXIT window"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#m1_data.data[\"BAC\"].info()\n",
-    "import datetime\n",
-    "# Define the market open and close times\n",
-    "market_open = datetime.time(9, 30)\n",
-    "market_close = datetime.time(16, 0)\n",
-    "entry_window_opens = 2\n",
-    "entry_window_closes = 30\n",
-    "\n",
-    "forced_exit_start = 380\n",
-    "forced_exit_end = 390\n",
-    "\n",
-    "forced_exit = m1_data.symbol_wrapper.fill(False)\n",
-    "entry_window_open=  m1_data.symbol_wrapper.fill(False)\n",
-    "\n",
-    "# Calculate the time difference in minutes from market open for each timestamp\n",
-    "elapsed_min_from_open = (forced_exit.index.hour - market_open.hour) * 60 + (forced_exit.index.minute - market_open.minute)\n",
-    "\n",
-    "entry_window_open[(elapsed_min_from_open >= entry_window_opens) & (elapsed_min_from_open < entry_window_closes)] = True\n",
-    "forced_exit[(elapsed_min_from_open >= forced_exit_start) & (elapsed_min_from_open < forced_exit_end)] = True\n",
-    "\n",
-    "#entry_window_open.info()\n",
-    "# forced_exit.tail(100)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "close = m1_data.close\n",
-    "\n",
-    "#rsi = vbt.RSI.run(close, window=14)\n",
-    "\n",
-    "short_entries = (short_signal & entry_window_open)\n",
-    "short_exits = forced_exit\n",
-    "#long_entries.info()\n",
-    "#number of trues and falses in long_entries\n",
-    "#short_exits.value_counts()\n",
-    "short_entries.value_counts()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def plot_rsi(close, entries, exits):\n",
-    "    fig = vbt.make_subplots(rows=1, cols=1, shared_xaxes=True, specs=[[{\"secondary_y\": True}]], vertical_spacing=0.02, subplot_titles=(\"RSI\", \"Price\" ))\n",
-    "    close.vbt.plot(fig=fig, add_trace_kwargs=dict(secondary_y=True))\n",
-    "    #rsi.plot(fig=fig, add_trace_kwargs=dict(secondary_y=False))\n",
-    "    entries.vbt.signals.plot_as_entries(close, fig=fig, add_trace_kwargs=dict(secondary_y=False))  \n",
-    "    exits.vbt.signals.plot_as_exits(close, fig=fig, add_trace_kwargs=dict(secondary_y=False))  \n",
-    "    return fig\n",
-    "\n",
-    "plot_rsi(close, short_entries, short_exits)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "vbt.phelp(vbt.Portfolio.from_signals)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "sl_stop = np.arange(0.03/100, 0.2/100, 0.02/100).tolist()\n",
-    "# Using the round function\n",
-    "sl_stop = [round(val, 4) for val in sl_stop]\n",
-    "print(sl_stop)\n",
-    "sl_stop = vbt.Param(sl_stop) #np.nan mean s no stoploss\n",
-    "\n",
-    "pf = vbt.Portfolio.from_signals(close=close, short_entries=short_entries, short_exits=short_exits, sl_stop=0.03/100, tp_stop = 0.03/100, fees=0.0167/100, freq=\"1s\") #sl_stop=sl_stop, tp_stop = sl_stop,\n",
-    "\n",
-    "#pf.stats()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#list of orders\n",
-    "#pf.orders.records_readable\n",
-    "#pf.orders.plots()\n",
-    "#pf.stats()\n",
-    "pf.stats()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "pf.plot()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "pf[(0.0015,0.0013)].plot()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "pf[0.03].plot_trade_signals()\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# pristup k pf jako multi index"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#pf[0.03].plot()\n",
-    "#pf.order_records\n",
-    "pf[(0.03)].stats()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#zgrupovane statistiky\n",
-    "stats_df = pf.stats([\n",
-    "    'total_return',\n",
-    "    'total_trades',\n",
-    "    'win_rate',\n",
-    "    'expectancy'\n",
-    "], agg_func=None)\n",
-    "stats_df\n",
-    "\n",
-    "\n",
-    "stats_df.nlargest(10, 'Total Return [%]')\n",
-    "#stats_df.info()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "pf[(0.0011,0.0013000000000000002)].plot()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from pandas.tseries.offsets import DateOffset\n",
-    "\n",
-    "temp_data = basic_data['2024-4-22']\n",
-    "temp_data\n",
-    "res1m = temp_data[[\"Open\", \"High\", \"Low\", \"Close\", \"Volume\"]]\n",
-    "\n",
-    "# Define a custom date offset that starts at 9:30 AM and spans 4 hours\n",
-    "custom_offset = DateOffset(hours=4, minutes=30)\n",
-    "\n",
-    "# res1m = res1m.get().resample(\"4H\").agg({  \n",
-    "#     \"Open\": \"first\",\n",
-    "#     \"High\": \"max\",\n",
-    "#     \"Low\": \"min\",\n",
-    "#     \"Close\": \"last\",\n",
-    "#     \"Volume\": \"sum\"\n",
-    "# })\n",
-    "\n",
-    "res4h = res1m.resample(\"1h\", resample_kwargs=dict(origin=\"start\"))\n",
-    "\n",
-    "res4h.data\n",
-    "\n",
-    "res15m = res1m.resample(\"15T\", resample_kwargs=dict(origin=\"start\"))\n",
-    "\n",
-    "res15m.data[\"BAC\"]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "@vbt.njit\n",
-    "def long_entry_place_func_nb(c, low, close, time_in_ns, rsi14, window_open, window_close):\n",
-    "    market_open_minutes = 570  # 9 hours * 60 minutes + 30 minutes\n",
-    "\n",
-    "    for out_i in range(len(c.out)):\n",
-    "        i = c.from_i + out_i\n",
-    "\n",
-    "        current_minutes = vbt.dt_nb.hour_nb(time_in_ns[i]) * 60 + vbt.dt_nb.minute_nb(time_in_ns[i])\n",
-    "        #print(\"current_minutes\", current_minutes)\n",
-    "        # Calculate elapsed minutes since market open at 9:30 AM\n",
-    "        elapsed_from_open = current_minutes - market_open_minutes\n",
-    "        elapsed_from_open = elapsed_from_open if elapsed_from_open >= 0 else 0\n",
-    "        #print( \"elapsed_from_open\", elapsed_from_open)\n",
-    "\n",
-    "        #elapsed_from_open = elapsed_minutes_from_open_nb(time_in_ns) \n",
-    "        in_window = elapsed_from_open > window_open and elapsed_from_open < window_close\n",
-    "        #print(\"in_window\", in_window)\n",
-    "        # if in_window:\n",
-    "        #     print(\"in window\")\n",
-    "\n",
-    "        if in_window and rsi14[i] > 60: # and low[i, c.col] <= hit_price: # and hour == 9:  # (4)!\n",
-    "            return out_i\n",
-    "    return -1\n",
-    "\n",
-    "@vbt.njit\n",
-    "def long_exit_place_func_nb(c, high, close, time_index, tp, sl):  # (5)!\n",
-    "    entry_i = c.from_i - c.wait\n",
-    "    entry_price = close[entry_i, c.col]\n",
-    "    hit_price = entry_price * (1 + tp)\n",
-    "    stop_price = entry_price * (1 - sl)\n",
-    "    for out_i in range(len(c.out)):\n",
-    "        i = c.from_i + out_i\n",
-    "        last_bar_of_day = vbt.dt_nb.day_changed_nb(time_index[i], time_index[i + 1])\n",
-    "\n",
-    "        #print(next_day)\n",
-    "        if last_bar_of_day: #pokud je dalsi next day, tak zavirame posledni\n",
-    "            print(\"ted\",out_i)\n",
-    "            return out_i\n",
-    "        if close[i, c.col] >= hit_price or close[i, c.col] <= stop_price :\n",
-    "            return out_i\n",
-    "    return -1\n",
-    "\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "df = pd.DataFrame(np.random.random(size=(5, 10)), columns=list('abcdefghij'))\n",
-    "\n",
-    "df"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "df.sum()"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".venv",
-   "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.11"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
--- a/research/strat_SUPERTREND/SUPERTREND_v1_SINGLE.ipynb
+++ b/research/strat_SUPERTREND/SUPERTREND_v1_SINGLE.ipynb
@@ -1,782 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# SUPERTREND\n",
-    "\n",
-    "* kombinace supertrendu na vice urovnich"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from dotenv import load_dotenv\n",
-    "\n",
-    "#as V2realbot is client , load env variables here\n",
-    "env_file = \"/Users/davidbrazda/Documents/Development/python/.env\"\n",
-    "# Load the .env file\n",
-    "load_dotenv(env_file)\n",
-    "\n",
-    "from v2realbot.utils.utils import zoneNY\n",
-    "import pandas as pd\n",
-    "import numpy as np\n",
-    "import vectorbtpro as vbt\n",
-    "# from itables import init_notebook_mode, show\n",
-    "import datetime\n",
-    "from itertools import product\n",
-    "from v2realbot.config import DATA_DIR\n",
-    "from lightweight_charts import JupyterChart, chart, Panel, PlotAccessor\n",
-    "from IPython.display import display\n",
-    "\n",
-    "# init_notebook_mode(all_interactive=True)\n",
-    "\n",
-    "vbt.settings.set_theme(\"dark\")\n",
-    "vbt.settings['plotting']['layout']['width'] = 1280\n",
-    "vbt.settings.plotting.auto_rangebreaks = True\n",
-    "# Set the option to display with pagination\n",
-    "pd.set_option('display.notebook_repr_html', True)\n",
-    "pd.set_option('display.max_rows', 10)  # Number of rows per page"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "trades_df-BAC-2024-01-01T09_30_00-2024-05-14T16_00_00-CO4B7VPWUZF-100.parquet\n",
-      "trades_df-BAC-2024-01-11T09:30:00-2024-01-12T16:00:00.parquet\n",
-      "trades_df-SPY-2024-01-01T09:30:00-2024-05-14T16:00:00.parquet\n",
-      "trades_df-BAC-2023-01-01T09_30_00-2024-05-25T16_00_00-47BCFOPUVWZ-100.parquet\n",
-      "ohlcv_df-BAC-2024-01-11T09:30:00-2024-01-12T16:00:00.parquet\n",
-      "trades_df-BAC-2024-05-15T09_30_00-2024-05-25T16_00_00-47BCFOPUVWZ-100.parquet\n",
-      "ohlcv_df-BAC-2024-01-01T09_30_00-2024-05-25T16_00_00-47BCFOPUVWZ-100.parquet\n",
-      "ohlcv_df-SPY-2024-01-01T09:30:00-2024-05-14T16:00:00.parquet\n",
-      "ohlcv_df-BAC-2024-01-01T09_30_00-2024-05-14T16_00_00-CO4B7VPWUZF-100.parquet\n",
-      "ohlcv_df-BAC-2023-01-01T09_30_00-2024-05-25T16_00_00-47BCFOPUVWZ-100.parquet\n",
-      "ohlcv_df-BAC-2023-01-01T09_30_00-2024-05-25T15_30_00-47BCFOPUVWZ-100.parquet\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "351"
-      ]
-     },
-     "execution_count": 2,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# Define the market open and close times\n",
-    "market_open = datetime.time(9, 30)\n",
-    "market_close = datetime.time(16, 0)\n",
-    "entry_window_opens = 1\n",
-    "entry_window_closes = 370\n",
-    "forced_exit_start = 380\n",
-    "forced_exit_end = 390\n",
-    "\n",
-    "#LOAD FROM PARQUET\n",
-    "#list all files is dir directory with parquet extension\n",
-    "dir = DATA_DIR + \"/notebooks/\"\n",
-    "import os\n",
-    "files = [f for f in os.listdir(dir) if f.endswith(\".parquet\")]\n",
-    "print('\\n'.join(map(str, files)))\n",
-    "file_name = \"ohlcv_df-BAC-2023-01-01T09_30_00-2024-05-25T15_30_00-47BCFOPUVWZ-100.parquet\"\n",
-    "ohlcv_df = pd.read_parquet(dir+file_name,engine='pyarrow')\n",
-    "#filter ohlcv_df to certain date range (assuming datetime index)\n",
-    "#ohlcv_df = ohlcv_df.loc[\"2024-02-12 9:30\":\"2024-02-14 16:00\"]\n",
-    "\n",
-    "#add vwap column to ohlcv_df\n",
-    "#ohlcv_df[\"hlcc4\"] = (ohlcv_df[\"close\"] + ohlcv_df[\"high\"] + ohlcv_df[\"low\"] + ohlcv_df[\"close\"]) / 4\n",
-    "\n",
-    "basic_data = vbt.Data.from_data(vbt.symbol_dict({\"BAC\": ohlcv_df}), tz_convert=zoneNY)\n",
-    "ohlcv_df= None\n",
-    "basic_data.wrapper.index.normalize().nunique()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "<class 'pandas.core.frame.DataFrame'>\n",
-      "DatetimeIndex: 4549772 entries, 2023-01-03 09:30:01-05:00 to 2024-05-24 15:59:59-04:00\n",
-      "Data columns (total 10 columns):\n",
-      " #   Column      Dtype                     \n",
-      "---  ------      -----                     \n",
-      " 0   open        float64                   \n",
-      " 1   high        float64                   \n",
-      " 2   low         float64                   \n",
-      " 3   close       float64                   \n",
-      " 4   volume      float64                   \n",
-      " 5   trades      float64                   \n",
-      " 6   updated     datetime64[ns, US/Eastern]\n",
-      " 7   vwap        float64                   \n",
-      " 8   buyvolume   float64                   \n",
-      " 9   sellvolume  float64                   \n",
-      "dtypes: datetime64[ns, US/Eastern](1), float64(9)\n",
-      "memory usage: 381.8 MB\n"
-     ]
-    }
-   ],
-   "source": [
-    "basic_data.data[\"BAC\"].info()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Add resample function to custom columns"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from vectorbtpro.utils.config import merge_dicts, Config, HybridConfig\n",
-    "from vectorbtpro import _typing as tp\n",
-    "from vectorbtpro.generic import nb as generic_nb\n",
-    "\n",
-    "_feature_config: tp.ClassVar[Config] = HybridConfig(\n",
-    "    {\n",
-    "        \"buyvolume\": dict(\n",
-    "            resample_func=lambda self, obj, resampler: obj.vbt.resample_apply(\n",
-    "                resampler,\n",
-    "                generic_nb.sum_reduce_nb,\n",
-    "            )\n",
-    "        ),\n",
-    "        \"sellvolume\": dict(\n",
-    "            resample_func=lambda self, obj, resampler: obj.vbt.resample_apply(\n",
-    "                resampler,\n",
-    "                generic_nb.sum_reduce_nb,\n",
-    "            )\n",
-    "        ),\n",
-    "        \"trades\": dict(\n",
-    "            resample_func=lambda self, obj, resampler: obj.vbt.resample_apply(\n",
-    "                resampler,\n",
-    "                generic_nb.sum_reduce_nb,\n",
-    "            )\n",
-    "        )\n",
-    "    }\n",
-    ")\n",
-    "\n",
-    "basic_data._feature_config = _feature_config"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "s1data = basic_data[['open', 'high', 'low', 'close', 'volume','vwap','buyvolume','trades','sellvolume']]\n",
-    "\n",
-    "s5data = s1data.resample(\"5s\")\n",
-    "s5data = s5data.transform(lambda df: df.between_time('09:30', '16:00').dropna())\n",
-    "\n",
-    "t1data = basic_data[['open', 'high', 'low', 'close', 'volume','vwap','buyvolume','trades','sellvolume']].resample(\"1T\")\n",
-    "t1data = t1data.transform(lambda df: df.between_time('09:30', '16:00').dropna())\n",
-    "# t1data.data[\"BAC\"].info()\n",
-    "\n",
-    "t30data  = basic_data[['open', 'high', 'low', 'close', 'volume','vwap','buyvolume','trades','sellvolume']].resample(\"30T\")\n",
-    "t30data = t30data.transform(lambda df: df.between_time('09:30', '16:00').dropna())\n",
-    "# t30data.data[\"BAC\"].info()\n",
-    "\n",
-    "s1close = s1data.close\n",
-    "t1close = t1data.close\n",
-    "t30close = t30data.close\n",
-    "t30volume = t30data.volume\n",
-    "\n",
-    "#resample on specific index \n",
-    "resampler = vbt.Resampler(t30data.index, s1data.index, source_freq=\"30T\", target_freq=\"1s\")\n",
-    "t30close_realigned = t30close.vbt.realign_closing(resampler)\n",
-    "\n",
-    "#resample 1min to s\n",
-    "resampler_s = vbt.Resampler(t1data.index, s1data.index, source_freq=\"1T\", target_freq=\"1s\")\n",
-    "t1close_realigned = t1close.vbt.realign_closing(resampler_s)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "datetime64[ns, US/Eastern]\n",
-      "datetime64[ns, US/Eastern]\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(t30data.index.dtype)\n",
-    "print(s1data.index.dtype)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "<class 'pandas.core.frame.DataFrame'>\n",
-      "DatetimeIndex: 4551 entries, 2023-01-03 09:30:00-05:00 to 2024-05-24 15:30:00-04:00\n",
-      "Data columns (total 9 columns):\n",
-      " #   Column      Non-Null Count  Dtype  \n",
-      "---  ------      --------------  -----  \n",
-      " 0   open        4551 non-null   float64\n",
-      " 1   high        4551 non-null   float64\n",
-      " 2   low         4551 non-null   float64\n",
-      " 3   close       4551 non-null   float64\n",
-      " 4   volume      4551 non-null   float64\n",
-      " 5   vwap        4551 non-null   float64\n",
-      " 6   buyvolume   4551 non-null   float64\n",
-      " 7   trades      4551 non-null   float64\n",
-      " 8   sellvolume  4551 non-null   float64\n",
-      "dtypes: float64(9)\n",
-      "memory usage: 355.5 KB\n"
-     ]
-    }
-   ],
-   "source": [
-    "t30data.data[\"BAC\"].info()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "vbt.IF.list_indicators(\"*vwap\")\n",
-    "vbt.phelp(vbt.VWAP.run)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# VWAP"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "\n",
-    "t1vwap_h = vbt.VWAP.run(t1data.high, t1data.low, t1data.close, t1data.volume, anchor=\"H\")\n",
-    "t1vwap_d = vbt.VWAP.run(t1data.high, t1data.low, t1data.close, t1data.volume, anchor=\"D\")\n",
-    "t1vwap_t = vbt.VWAP.run(t1data.high, t1data.low, t1data.close, t1data.volume, anchor=\"T\")\n",
-    "\n",
-    "t1vwap_h_real = t1vwap_h.vwap.vbt.realign_closing(resampler_s)\n",
-    "t1vwap_d_real = t1vwap_d.vwap.vbt.realign_closing(resampler_s)\n",
-    "t1vwap_t_real = t1vwap_t.vwap.vbt.realign_closing(resampler_s)\n",
-    "\n",
-    "#t1vwap_5t.xloc[\"2024-01-3 09:30:00\":\"2024-01-03 16:00:00\"].plot()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#m30data.close.lw.plot()\n",
-    "#quick few liner\n",
-    "pane1 = Panel(\n",
-    "    histogram=[\n",
-    "               #(s1data.volume, \"volume\",None, 0.8),\n",
-    "               #(m30volume, \"m30volume\",None, 1)\n",
-    "               ], # [(series, name, \"rgba(53, 94, 59, 0.6)\", opacity)]\n",
-    "    right=[\n",
-    "          (s1data.close, \"1s close\"),\n",
-    "            (t1data.close, \"1min close\"),\n",
-    "            (t1vwap_t, \"1mvwap_t\"),\n",
-    "            (t1vwap_h, \"1mvwap_h\"),\n",
-    "            (t1vwap_d, \"1mvwap_d\"),\n",
-    "            (t1vwap_t_real, \"1mvwap_t_real\"),\n",
-    "            (t1vwap_h_real, \"1mvwap_h_real\"),\n",
-    "            (t1vwap_d_real, \"1mvwap_d_real\")\n",
-    "        #    (t1close_realigned, \"1min close realigned\"),\n",
-    "        #    (m30data.close, \"30min-close\"),\n",
-    "        #    (m30close_realigned, \"30min close realigned\"),\n",
-    "           ],\n",
-    ")\n",
-    "ch = chart([pane1], size=\"s\", xloc=slice(\"2024-05-1 09:30:00\",\"2024-05-25 16:00:00\"))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# SUPERTREND"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "supertrend_s1 = vbt.SUPERTREND.run(s1data.high, s1data.low, s1data.close, period=5, multiplier=3)\n",
-    "direction_series_s1 = supertrend_s1.direction\n",
-    "supertrend_t1 = vbt.SUPERTREND.run(t1data.high, t1data.low, t1data.close, period=14, multiplier=3)\n",
-    "direction_series_t1 = supertrend_t1.direction\n",
-    "supertrend_t30 = vbt.SUPERTREND.run(t30data.high, t30data.low, t30data.close, period=14, multiplier=3)\n",
-    "direction_series_t30 = supertrend_t30.direction\n",
-    "\n",
-    "resampler_1t_sec = vbt.Resampler(direction_series_t1.index, direction_series_s1.index, source_freq=\"1T\", target_freq=\"1s\")\n",
-    "resampler_30t_sec = vbt.Resampler(direction_series_t30.index, direction_series_s1.index, source_freq=\"30T\", target_freq=\"1s\")\n",
-    "direction_series_t1_realigned = direction_series_t1.vbt.realign_closing(resampler_1t_sec)\n",
-    "direction_series_t30_realigned = direction_series_t30.vbt.realign_closing(resampler_30t_sec)\n",
-    "\n",
-    "#supertrend_s1.xloc[\"2024-01-3 09:30:00\":\"2024-01-03 16:00:00\"].plot()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# aligned_ups= pd.Series(False, index=direction_real.index)\n",
-    "# aligned_downs= pd.Series(False, index=direction_real.index)\n",
-    "\n",
-    "# aligned_ups = direction_real == 1 & supertrend.direction == 1\n",
-    "# aligned_ups"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "s5close = s5data.data[\"BAC\"].close\n",
-    "s5open = s5data.data[\"BAC\"].open\n",
-    "s5high = s5data.data[\"BAC\"].high\n",
-    "s5close_prev = s5close.shift(1)\n",
-    "s5open_prev = s5open.shift(1)\n",
-    "s5high_prev = s5high.shift(1)\n",
-    "#gap nahoru od byci svicky a nevraci se zpet na jeji uroven\n",
-    "entry_ups = (s5close_prev > s5open_prev) & (s5open > s5high_prev + 0.010) & (s5close > s5close_prev)\n",
-    "\n",
-    "entry_ups.value_counts()\n",
-    "\n",
-    "#entry_ups.info()\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Entry window"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "market_open = datetime.time(9, 30)\n",
-    "market_close = datetime.time(16, 0)\n",
-    "entry_window_opens = 10\n",
-    "entry_window_closes = 370"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "entry_window_open= pd.Series(False, index=entry_ups.index)\n",
-    "# Calculate the time difference in minutes from market open for each timestamp\n",
-    "elapsed_min_from_open = (entry_ups.index.hour - market_open.hour) * 60 + (entry_ups.index.minute - market_open.minute)\n",
-    "entry_window_open[(elapsed_min_from_open >= entry_window_opens) & (elapsed_min_from_open < entry_window_closes)] = True\n",
-    "#entry_window_open\n",
-    "\n",
-    "entry_ups = entry_ups & entry_window_open\n",
-    "# entry_ups\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "s5vwap_h = vbt.VWAP.run(s5data.high, s5data.low, s5data.close, s5data.volume, anchor=\"H\")\n",
-    "s5vwap_d = vbt.VWAP.run(s5data.high, s5data.low, s5data.close, s5data.volume, anchor=\"D\")\n",
-    "\n",
-    "# s5vwap_h_real = s5vwap_h.vwap.vbt.realign_closing(resampler_s)\n",
-    "# s5vwap_d_real = s5vwap_d.vwap.vbt.realign_closing(resampler_s)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "pane1 = Panel(\n",
-    "    ohlcv=(s5data.data[\"BAC\"],), #(series, entries, exits, other_markers)\n",
-    "    histogram=[], # [(series, name, \"rgba(53, 94, 59, 0.6), opacity\")]\n",
-    "    right=[#(bbands,), #[(series, name, entries, exits, other_markers)]\n",
-    "        (s5data.data[\"BAC\"].close, \"close\", entry_ups),\n",
-    "        (s5data.data[\"BAC\"].open, \"open\"),\n",
-    "        (s5vwap_h, \"vwap5s_H\",),\n",
-    "        (s5vwap_d, \"vwap5s_D\",)\n",
-    "        #    (t1data.data[\"BAC\"].vwap, \"vwap\"),\n",
-    "        #   (t1data.close, \"1min close\"),\n",
-    "        #    (supertrend_s1.trend,\"STtrend\"),\n",
-    "        #    (supertrend_s1.long,\"STlong\"),\n",
-    "        #    (supertrend_s1.short,\"STshort\")\n",
-    "           ],\n",
-    "    left = [\n",
-    "        #(direction_series_s1,\"direction_s1\"),\n",
-    "        #    (direction_series_t1,\"direction_t1\"),\n",
-    "        #    (direction_series_t30,\"direction_t30\")\n",
-    "            \n",
-    "            ],\n",
-    "    # right=[(bbands.upperband, \"upperband\",),\n",
-    "    #       (bbands.lowerband, \"lowerband\",),\n",
-    "    #       (bbands.middleband, \"middleband\",)\n",
-    "    #       ], #[(series, name, entries, exits, other_markers)]\n",
-    "    middle1=[],\n",
-    "    middle2=[],\n",
-    ")\n",
-    "\n",
-    "# pane2 = Panel(\n",
-    "#     ohlcv=(t1data.data[\"BAC\"],uptrend_m30, downtrend_m30), #(series, entries, exits, other_markers)\n",
-    "#     histogram=[], # [(series, name, \"rgba(53, 94, 59, 0.6), opacity\")]\n",
-    "#     left=[#(bbands,), #[(series, name, entries, exits, other_markers)]\n",
-    "#            (direction_real,\"direction30min_real\"),\n",
-    "#            ],\n",
-    "#     # left = [(supertrendm30.direction,\"STdirection30\")],\n",
-    "#     # # right=[(bbands.upperband, \"upperband\",),\n",
-    "#     # #       (bbands.lowerband, \"lowerband\",),\n",
-    "#     # #       (bbands.middleband, \"middleband\",)\n",
-    "#     # #       ], #[(series, name, entries, exits, other_markers)]\n",
-    "#     middle1=[],\n",
-    "#     middle2=[],\n",
-    "#     title = \"1m\")\n",
-    "\n",
-    "ch = chart([pane1], sync=True, size=\"s\", xloc=slice(\"2024-02-20 09:30:00\",\"2024-02-22 16:00:00\"), precision=6)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# data = s5data.xloc[\"2024-01-03 09:30:00\":\"2024-03-10 16:00:00\"]\n",
-    "# entry = entry_ups.vbt.xloc[\"2024-01-03 09:30:00\":\"2024-03-10 16:00:00\"].obj\n",
-    "\n",
-    "pf = vbt.Portfolio.from_signals(close=s5data, entries=entry_ups, direction=\"longonly\", sl_stop=0.05/100, tp_stop = 0.05/100, fees=0.0167/100, freq=\"5s\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "pf.xloc[\"2024-01-26 09:30:00\":\"2024-02-28 16:00:00\"].positions.plot()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "pf.xloc[\"2024-01-26 09:30:00\":\"2024-01-28 16:00:00\"].plot()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "pd.set_option('display.max_rows', None)\n",
-    "pf.stats()\n",
-    "# pf.xloc[\"monday\"].stats()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "buyvolume = t1data.data[\"BAC\"].buyvolume\n",
-    "sellvolume = t1data.data[\"BAC\"].sellvolume\n",
-    "totalvolume = buyvolume + sellvolume\n",
-    "\n",
-    "#adjust to minimal value to avoid division by zero\n",
-    "sellvolume_adjusted = sellvolume.replace(0, 1e-10)\n",
-    "oibratio = buyvolume / sellvolume\n",
-    "\n",
-    "#cumulative order flow (net difference)\n",
-    "cof = buyvolume - sellvolume\n",
-    "\n",
-    "# Calculate the order imbalance (net differene) normalize the order imbalance by calculating the difference between buy and sell volumes and then scaling it by the total volume.\n",
-    "order_imbalance = cof / totalvolume\n",
-    "order_imbalance = order_imbalance.fillna(0) #nan nahradime 0\n",
-    "\n",
-    "order_imbalance_allvolume = cof / t1data.data[\"BAC\"].volume\n",
-    "\n",
-    "order_imbalance_sma = vbt.indicator(\"talib:EMA\").run(order_imbalance, timeperiod=5)\n",
-    "short_signals = order_imbalance.vbt < -0.5\n",
-    "#short_entries = oibratio.vbt < 0.01\n",
-    "short_signals.value_counts()\n",
-    "short_signals.name = \"short_entries\"\n",
-    "#.fillna(False)\n",
-    "short_exits = short_signals.shift(-2).fillna(False).astype(bool)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "pane1 = Panel(\n",
-    "    ohlcv=(t1data.data[\"BAC\"],), #(series, entries, exits, other_markers)\n",
-    "    histogram=[(order_imbalance_allvolume, \"oib_allvolume\", \"rgba(53, 94, 59, 0.6)\",0.5),\n",
-    "               (t1data.data[\"BAC\"].trades, \"trades\",None,0.4),\n",
-    "               ], # [(series, name, \"rgba(53, 94, 59, 0.6)\", opacity)]\n",
-    "    # right=[\n",
-    "    #        (supertrend.trend,\"STtrend\"),\n",
-    "    #        (supertrend.long,\"STlong\"),\n",
-    "    #        (supertrend.short,\"STshort\")\n",
-    "    #        ],\n",
-    "    # left = [(supertrend.direction,\"STdirection\")],\n",
-    "    # right=[(bbands.upperband, \"upperband\",),\n",
-    "    #       (bbands.lowerband, \"lowerband\",),\n",
-    "    #       (bbands.middleband, \"middleband\",)\n",
-    "    #       ], #[(series, name, entries, exits, other_markers)]\n",
-    "    middle1=[],\n",
-    "    middle2=[],\n",
-    ")\n",
-    "\n",
-    "pane2 = Panel(\n",
-    "    ohlcv=(basic_data.data[\"BAC\"],), #(series, entries, exits, other_markers)\n",
-    "    left=[(basic_data.data[\"BAC\"].trades, \"trades\")],\n",
-    "    histogram=[(basic_data.data[\"BAC\"].trades, \"trades_hist\", \"white\", 0.5)], #\"rgba(53, 94, 59, 0.6)\"\n",
-    "    #           ], # [(series, name, \"rgba(53, 94, 59, 0.6)\")]\n",
-    "    # right=[\n",
-    "    #        (supertrend.trend,\"STtrend\"),\n",
-    "    #        (supertrend.long,\"STlong\"),\n",
-    "    #        (supertrend.short,\"STshort\")\n",
-    "    #        ],\n",
-    "    # left = [(supertrend.direction,\"STdirection\")],\n",
-    "    # right=[(bbands.upperband, \"upperband\",),\n",
-    "    #       (bbands.lowerband, \"lowerband\",),\n",
-    "    #       (bbands.middleband, \"middleband\",)\n",
-    "    #       ], #[(series, name, entries, exits, other_markers)]\n",
-    "    middle1=[],\n",
-    "    middle2=[],\n",
-    ")\n",
-    "\n",
-    "\n",
-    "ch = chart([pane1, pane2], size=\"m\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#short_signal = t1slope.real_below(t1_th) & t2slope.real_below(t2_th) & t3slope.real_below(t3_th) & t4slope.real_below(t4_th)\n",
-    "#long_signal = t1slope.real_above(t1_th) & t2slope.real_above(t2_th) & t3slope.real_above(t3_th) & t4slope.real_above(t4_th)\n",
-    "\n",
-    "#test na daily s reversem  crossed 0\n",
-    "short_signal = t2slope.vbt < -0.01 & t3slope.vbt < -0.01  #min value of threshold\n",
-    "long_signal = t2slope.vbt > 0.01 & t3slope.vbt > 0.01  #min\n",
-    "\n",
-    "# thirty_up_signal = t3slope.vbt.crossed_above(0.01)\n",
-    "# thirty_down_signal = t3slope.vbt.crossed_below(-0.01)\n",
-    "\n",
-    "fig = plot_2y_close(priminds=[], secinds=[t3slope], close=t1data.close)\n",
-    "#short_signal.vbt.signals.plot_as_entries(basic_data.close, fig=fig)\n",
-    "\n",
-    "short_signal.vbt.signals.plot_as_entries(t1data.close, fig=fig, trace_kwargs=dict(name=\"SHORTS\",\n",
-    "                                                                                    line=dict(color=\"#ffe476\"),\n",
-    "                                                                                    marker=dict(color=\"red\", symbol=\"triangle-down\"),\n",
-    "                                                                                    fill=None,\n",
-    "                                                                                    connectgaps=True,\n",
-    "                                                                                    ))\n",
-    "long_signal.vbt.signals.plot_as_entries(t1data.close, fig=fig, trace_kwargs=dict(name=\"LONGS\",\n",
-    "                                                                                    line=dict(color=\"#ffe476\"),\n",
-    "                                                                                    marker=dict(color=\"limegreen\"),\n",
-    "                                                                                    fill=None,\n",
-    "                                                                                    connectgaps=True,\n",
-    "                                                                                    ))\n",
-    "\n",
-    "# thirty_down_signal.vbt.signals.plot_as_entries(t1data.close, fig=fig, trace_kwargs=dict(name=\"DOWN30\",\n",
-    "#                                                                                     line=dict(color=\"#ffe476\"),\n",
-    "#                                                                                     marker=dict(color=\"yellow\", symbol=\"triangle-down\"),\n",
-    "#                                                                                     fill=None,\n",
-    "#                                                                                     connectgaps=True,\n",
-    "#                                                                                     ))\n",
-    "# thirty_up_signal.vbt.signals.plot_as_entries(t1data.close, fig=fig, trace_kwargs=dict(name=\"UP30\",\n",
-    "#                                                                                     line=dict(color=\"#ffe476\"),\n",
-    "#                                                                                     marker=dict(color=\"grey\"),\n",
-    "#                                                                                     fill=None,\n",
-    "#                                                                                     connectgaps=True,\n",
-    "#                                                                                     ))\n",
-    "\n",
-    "# thirtymin_slope_to_compare.vbt.plot(fig=fig, add_trace_kwargs=dict(secondary_y=True), trace_kwargs=dict(name=\"30min slope\",\n",
-    "#                                                                                         line=dict(color=\"yellow\"),                                                                                     \n",
-    "#                                                                                         fill=None,\n",
-    "#                                                                                         connectgaps=True,\n",
-    "#                                                                                         ))\n",
-    "\n",
-    "fig.show()\n",
-    "# print(\"short signal\")\n",
-    "# print(short_signal.value_counts())\n",
-    "\n",
-    "#forced_exit = pd.Series(False, index=close.index)\n",
-    "forced_exit = basic_data.symbol_wrapper.fill(False)\n",
-    "#entry_window_open = pd.Series(False, index=close.index)\n",
-    "entry_window_open=  basic_data.symbol_wrapper.fill(False)\n",
-    "\n",
-    "# Calculate the time difference in minutes from market open for each timestamp\n",
-    "elapsed_min_from_open = (forced_exit.index.hour - market_open.hour) * 60 + (forced_exit.index.minute - market_open.minute)\n",
-    "\n",
-    "entry_window_open[(elapsed_min_from_open >= entry_window_opens) & (elapsed_min_from_open < entry_window_closes)] = True\n",
-    "\n",
-    "#print(entry_window_open.value_counts())\n",
-    "\n",
-    "forced_exit[(elapsed_min_from_open >= forced_exit_start) & (elapsed_min_from_open < forced_exit_end)] = True\n",
-    "short_entries = (short_signal & entry_window_open)\n",
-    "short_exits = forced_exit\n",
-    "\n",
-    "entries = (long_signal & entry_window_open)\n",
-    "exits = forced_exit\n",
-    "#long_entries.info()\n",
-    "#number of trues and falses in long_entries\n",
-    "# print(short_exits.value_counts())\n",
-    "# print(short_entries.value_counts())\n",
-    "\n",
-    "#fig = plot_2y_close([],[momshort, rocp], close)\n",
-    "#short_signal.vbt.signals.plot_as_entries(close, fig=fig, add_trace_kwargs=dict(secondary_y=False))\n",
-    "#print(sl_stop)\n",
-    "#short_entries=short_entries, short_exits=short_exits,\n",
-    "# pf = vbt.Portfolio.from_signals(close=basic_data, entries=short_entries, exits=exits, tsl_stop=0.005, tp_stop = 0.05, fees=0.0167/100, freq=\"1s\") #sl_stop=sl_stop, tp_stop = sl_stop,\n",
-    "\n",
-    "# pf.stats()\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "forced_exit = t1data.symbol_wrapper.fill(False)\n",
-    "#entry_window_open = pd.Series(False, index=close.index)\n",
-    "entry_window_open=  t1data.symbol_wrapper.fill(False)\n",
-    "\n",
-    "# Calculate the time difference in minutes from market open for each timestamp\n",
-    "elapsed_min_from_open = (forced_exit.index.hour - market_open.hour) * 60 + (forced_exit.index.minute - market_open.minute)\n",
-    "\n",
-    "entry_window_open[(elapsed_min_from_open >= entry_window_opens) & (elapsed_min_from_open < entry_window_closes)] = True\n",
-    "\n",
-    "#print(entry_window_open.value_counts())\n",
-    "\n",
-    "forced_exit[(elapsed_min_from_open >= forced_exit_start) & (elapsed_min_from_open < forced_exit_end)] = True\n",
-    "short_entries = (short_signals & entry_window_open)\n",
-    "short_exits = forced_exit\n",
-    "\n",
-    "entries = (long_signals & entry_window_open)\n",
-    "exits = forced_exit\n",
-    "\n",
-    "pf = vbt.Portfolio.from_signals(close=t1data, entries=entries, exits=exits, short_entries=short_entries, short_exits=exits,\n",
-    "td_stop=2, time_delta_format=\"rows\",\n",
-    "tsl_stop=0.005, tp_stop = 0.005, fees=0.0167/100)#, freq=\"1s\") #sl_stop=sl_stop, tp_stop = sl_stop,\n",
-    "\n",
-    "pf.stats()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "pf.plot()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "pf.get_drawdowns().records_readable"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "pf.orders.records_readable"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".venv",
-   "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.11"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
--- a/testy/archive/config.py
+++ b/testy/archive/config.py
@@ -1,3 +1,3 @@
-API_KEY = ''
-SECRET_KEY = ''
+API_KEY = 'PKGGEWIEYZOVQFDRY70L'
+SECRET_KEY = 'O5Kt8X4RLceIOvM98i5LdbalItsX7hVZlbPYHy8Y'
 MAX_BATCH_SIZE = 1
--- a/testy/fibonaccistoploss.py
+++ b/testy/fibonaccistoploss.py
@@ -1,9 +1,9 @@
 import numpy as np
-from v2realbot.common.model import Trade, TradeDirection, TradeStatus
+from v2realbot.common.PrescribedTradeModel import Trade, TradeDirection, TradeStatus
 from typing import Tuple
 from copy import deepcopy
 from v2realbot.strategy.base import StrategyState
-from v2realbot.strategyblocks.activetrade.helpers import get_max_profit_price, get_profit_target_price, get_signal_section_directive, keyword_conditions_met
+from v2realbot.strategyblocks.activetrade.helpers import get_max_profit_price, get_profit_target_price, get_override_for_active_trade, keyword_conditions_met
 from v2realbot.utils.utils import safe_get
 # FIBONACCI PRO PROFIT A SL

@@ -63,10 +63,10 @@ class SLOptimizer:

    def initialize_levels(self, state):
        directive_name = 'SL_opt_exit_levels_'+str(self.direction)
-        SL_opt_exit_levels = get_signal_section_directive(state=state, directive_name=directive_name, default_value=safe_get(state.vars, directive_name, None))
+        SL_opt_exit_levels = get_override_for_active_trade(state=state, directive_name=directive_name, default_value=safe_get(state.vars, directive_name, None))

        directive_name = 'SL_opt_exit_sizes_'+str(self.direction)
-        SL_opt_exit_sizes = get_signal_section_directive(state=state, directive_name=directive_name, default_value=safe_get(state.vars, directive_name, None))
+        SL_opt_exit_sizes = get_override_for_active_trade(state=state, directive_name=directive_name, default_value=safe_get(state.vars, directive_name, None))

        if SL_opt_exit_levels is None or SL_opt_exit_sizes is not None:
            print("no directives found: SL_opt_exit_levels/SL_opt_exit_sizes")
--- a/testy/testtt.py
+++ b/testy/testtt.py
@@ -1,2 +0,0 @@
-import locale
-print(locale.getdefaultlocale())
--- a/v2realbot/ENTRY_ClassicSL_v01.py
+++ b/v2realbot/ENTRY_ClassicSL_v01.py
@@ -59,12 +59,25 @@ Hlavní loop:

 """
 def next(data, state: StrategyState):
-    print(10*"*", state.account_variables)
+    ##print(10*"*","NEXT START",10*"*")
+    # important vars state.avgp, state.positions, state.vars, data
+    
+    #indicators moved to call_next in upper class

-    execute_prescribed_trades(state, data)
-    signal_search(state, data)
-    execute_prescribed_trades(state, data) #pro jistotu ihned zpracujeme
-    manage_active_trade(state, data)
+    #pokud mame prazdne pozice a neceka se na nic
+    if state.positions == 0 and state.vars.pending is None:
+        #vykoname trady ve fronte
+        execute_prescribed_trades(state, data)
+        #pokud se neaktivoval nejaky trade, poustime signal search - ale jen jednou za bar?
+        #if conf_bar == 1:
+        if state.vars.pending is None:
+            signal_search(state, data)
+            #pro jistotu ihned zpracujeme
+            execute_prescribed_trades(state, data)
+
+    #mame aktivni trade a neceka se n anic
+    elif state.vars.activeTrade and state.vars.pending is None:
+            manage_active_trade(state, data)

 def init(state: StrategyState):
    #place to declare new vars
@@ -75,13 +88,13 @@ def init(state: StrategyState):

    #nove atributy na rizeni tradu
    #identifikuje provedenou změnu na Tradu (neděláme změny dokud nepřijde potvrzeni z notifikace)
-    #state.vars.pending = None #nahrazeno pebnding pod accountem state.account_variables[account.name].pending
+    state.vars.pending = None
    #obsahuje aktivni Trade a jeho nastaveni
-    #state.vars.activeTrade = None #pending/Trade moved to account_variables
+    state.vars.activeTrade = None #pending/Trade
    #obsahuje pripravene Trady ve frontě
    state.vars.prescribedTrades = []
    #flag pro reversal
-    #state.vars.requested_followup = None #nahrazeno pod accountem
+    state.vars.requested_followup = None

    #TODO presunout inicializaci work_dict u podminek - sice hodnoty nepujdou zmenit, ale zlepsi se performance
    #pripadne udelat refresh kazdych x-iterací
@@ -89,8 +102,9 @@ def init(state: StrategyState):
    state.vars.mode = None
    state.vars.last_50_deltas = []
    state.vars.next_new = 0
-    state.vars.last_entry_index = None #mponechano obecne pro vsechny accounty
-    state.vars.last_exit_index = None #obecna varianta ponechana
+    state.vars.last_buy_index = None
+    state.vars.last_exit_index = None
+    state.vars.last_in_index = None
    state.vars.last_update_time = 0
    state.vars.reverse_position_waiting_amount = 0
    #INIT promenne, ktere byly zbytecne ve stratvars
--- a/v2realbot/backtesting/backtester.py
+++ b/v2realbot/backtesting/backtester.py
@@ -39,7 +39,7 @@
 """
 from uuid import UUID, uuid4
 from alpaca.trading.enums import OrderSide, OrderStatus, TradeEvent, OrderType
-from v2realbot.common.model import TradeUpdate, Order, Account
+from v2realbot.common.model import TradeUpdate, Order
 from rich import print as printanyway
 import threading
 import asyncio
@@ -61,7 +61,6 @@ import dash_bootstrap_components as dbc
 from dash.dependencies import Input, Output
 from dash import dcc, html, dash_table, Dash
 import v2realbot.utils.config_handler as cfh
-from typing import Set
 """"
 LATENCY DELAYS
 .000 trigger - last_trade_time (.4246266)
@@ -75,20 +74,7 @@ lock = threading.Lock
 #todo nejspis dat do classes, aby se mohlo backtestovat paralelne
 #ted je globalni promena last_time_now a self.account a cash
 class Backtester:
-    """
-    Initializes a new instance of the Backtester class.
-    Args:
-        symbol (str): The symbol of the security being backtested.
-        accounts (set): A set of accounts to use for backtesting.
-        order_fill_callback (callable): A callback function to handle order fills.
-        btdata (list): A list of backtesting data.
-        bp_from (datetime): The start date of the backtesting period.
-        bp_to (datetime): The end date of the backtesting period.
-        cash (float, optional): The initial cash balance. Defaults to 100000.
-    Returns:
-        None
-    """
-    def __init__(self, symbol: str, accounts: Set, order_fill_callback: callable, btdata: list, bp_from: datetime, bp_to: datetime, cash: float = 100000):
+    def __init__(self, symbol: str, order_fill_callback: callable, btdata: list, bp_from: datetime, bp_to: datetime, cash: float = 100000):
        #this TIME value determines true time for submit, replace, cancel order should happen (allowing past)
        #it is set by every iteration of BT or before fill callback - allowing past events to happen
        self.time = None
@@ -97,7 +83,6 @@ class Backtester:
        self.btdata = btdata
        self.backtest_start = None
        self.backtest_end = None
-        self.accounts = accounts
        self.cash_init = cash
        #backtesting period
        self.bp_from = bp_from
@@ -105,10 +90,9 @@ class Backtester:
        self.cash = cash
        self.cash_reserved_for_shorting = 0
        self.trades = []
-        self.internal_account = { account.name:{self.symbol: [0, 0]} for account in accounts }
-        # { "ACCOUNT1": {}"BAC": [avgp, size]}, .... }
-        self.open_orders =[] #open orders shared for all accounts, account being an attribute
-
+        self.account = { "BAC": [0, 0] }
+        # { "BAC": [avgp, size] }
+        self.open_orders =[]
        # self.open_orders = [Order(id=uuid4(),
        #                         submitted_at = datetime(2023, 3, 17, 9, 30, 0, 0, tzinfo=zoneNY),
        #                         symbol = "BAC",
@@ -126,8 +110,6 @@ class Backtester:
        #                         side = OrderSide.BUY)]
    
    #
-  
-
    def execute_orders_and_callbacks(self, intime: float):
        """""
        Voláno ze strategie před každou iterací s časem T.
@@ -184,7 +166,7 @@ class Backtester:

        for order in self.open_orders:
            #pokud je vyplneny symbol, tak jedeme jen tyto, jinak vsechny
-            print(order.account.name, order.id, datetime.timestamp(order.submitted_at), order.symbol, order.side, order.order_type, order.qty, order.limit_price, order.submitted_at)
+            print(order.id, datetime.timestamp(order.submitted_at), order.symbol, order.side, order.order_type, order.qty, order.limit_price, order.submitted_at)
            if order.canceled_at:
                #ic("deleting canceled order",order.id)
                todel.append(order)
@@ -366,22 +348,21 @@ class Backtester:

            #ic(o.filled_at, o.filled_avg_price)

-            a = self.update_internal_account(o = o)
+            a = self.update_account(o = o)
            if a < 0:
                tlog("update_account ERROR")
                return -1

-            trade = TradeUpdate(account=o.account,
-                                order = o,
+            trade = TradeUpdate(order = o,
                                event = TradeEvent.FILL,
                                execution_id = str(uuid4()),
                                timestamp = datetime.fromtimestamp(fill_time),
-                                position_qty= self.internal_account[o.account.name][o.symbol][0],
+                                position_qty= self.account[o.symbol][0],
                                price=float(fill_price),
                                qty = o.qty,
                                value = float(o.qty*fill_price),
                                cash = self.cash,
-                                pos_avg_price = self.internal_account[o.account.name][o.symbol][1])
+                                pos_avg_price = self.account[o.symbol][1])
            
            self.trades.append(trade)

@@ -398,49 +379,49 @@ class Backtester:
        self.time = time + float(cfh.config_handler.get_val('BT_DELAYS','fill_to_not'))
        print("current bt.time",self.time)
        #print("FILL NOTIFICATION: ", tradeupdate)
-        res = asyncio.run(self.order_fill_callback(tradeupdate, tradeupdate.account))
+        res = asyncio.run(self.order_fill_callback(tradeupdate))
        return 0

-    def update_internal_account(self, o: Order):
+    def update_account(self, o: Order):
        #updatujeme self.account
        #pokud neexistuje klic v accountu vytvorime si ho
-        if o.symbol not in self.internal_account[o.account.name]:
+        if o.symbol not in self.account:
            # { "BAC": [size, avgp] }
-            self.internal_account[o.account.name][o.symbol] = [0,0]
+            self.account[o.symbol] = [0,0]

        if o.side == OrderSide.BUY:
            #[size, avgp]
-            newsize = (self.internal_account[o.account.name][o.symbol][0] + o.qty)
+            newsize = (self.account[o.symbol][0] + o.qty)
            #JPLNE UZAVRENI SHORT  (avgp 0)
            if newsize == 0: newavgp = 0
            #CASTECNE UZAVRENI SHORT (avgp puvodni)
-            elif newsize < 0: newavgp = self.internal_account[o.account.name][o.symbol][1]
+            elif newsize < 0: newavgp = self.account[o.symbol][1]
            #JDE O LONG (avgp nove)
            else:
-                newavgp = ((self.internal_account[o.account.name][o.symbol][0] * self.internal_account[o.account.name][o.symbol][1]) + (o.qty * o.filled_avg_price)) / (self.internal_account[o.account.name][o.symbol][0] + o.qty)
+                newavgp = ((self.account[o.symbol][0] * self.account[o.symbol][1]) + (o.qty * o.filled_avg_price)) / (self.account[o.symbol][0] + o.qty)
            
-            self.internal_account[o.account.name][o.symbol] = [newsize, newavgp]
+            self.account[o.symbol] = [newsize, newavgp]
            self.cash = self.cash - (o.qty * o.filled_avg_price)
            return 1
        #sell
        elif o.side == OrderSide.SELL:
-            newsize = self.internal_account[o.account.name][o.symbol][0]-o.qty
+            newsize = self.account[o.symbol][0]-o.qty
            #UPLNE UZAVRENI LONGU (avgp 0)
            if newsize == 0: newavgp = 0
            #CASTECNE UZAVRENI LONGU (avgp puvodni)
-            elif newsize > 0: newavgp = self.internal_account[o.account.name][o.symbol][1]
+            elif newsize > 0: newavgp = self.account[o.symbol][1]
            #jde o SHORT (avgp nove)
            else:
                #pokud je predchozi 0 - tzn. jde o prvni short
-                if self.internal_account[o.account.name][o.symbol][1] == 0:
+                if self.account[o.symbol][1] == 0:
                    newavgp = o.filled_avg_price
                else:
-                    newavgp = ((abs(self.internal_account[o.account.name][o.symbol][0]) * self.internal_account[o.account.name][o.symbol][1]) + (o.qty * o.filled_avg_price)) / (abs(self.internal_account[o.account.name][o.symbol][0]) + o.qty)
+                    newavgp = ((abs(self.account[o.symbol][0]) * self.account[o.symbol][1]) + (o.qty * o.filled_avg_price)) / (abs(self.account[o.symbol][0]) + o.qty)

-            self.internal_account[o.account.name][o.symbol] = [newsize, newavgp]
+            self.account[o.symbol] = [newsize, newavgp]

            #pokud jde o prodej longu(nova pozice je>=0) upravujeme cash
-            if self.internal_account[o.account.name][o.symbol][0] >= 0:
+            if self.account[o.symbol][0] >= 0:
                self.cash = float(self.cash + (o.qty * o.filled_avg_price))
                print("uprava cashe, jde o prodej longu")
            else:
@@ -485,7 +466,7 @@ class Backtester:
        # #ic("get last price")
        # return self.btdata[i-1][1]

-    def submit_order(self, time: float, symbol: str, side: OrderSide, size: int, order_type: OrderType, account: Account, price: float = None):
+    def submit_order(self, time: float, symbol: str, side: OrderSide, size: int, order_type: OrderType, price: float = None):
        """submit order
        - zakladni validace
        - vloží do self.open_orders s daným časem
@@ -518,9 +499,9 @@ class Backtester:
            return -1
    
        #pokud neexistuje klic v accountu vytvorime si ho
-        if symbol not in self.internal_account[account.name]:
+        if symbol not in self.account:
            # { "BAC": [size, avgp] }
-            self.internal_account[account.name][symbol] = [0,0]
+            self.account[symbol] = [0,0]

        #check for available quantity
        if side == OrderSide.SELL:
@@ -528,15 +509,15 @@ class Backtester:
            reserved_price = 0
            #with lock:
            for o in self.open_orders:
-                if o.side == OrderSide.SELL and o.symbol == symbol and o.canceled_at is None and o.account==account:
+                if o.side == OrderSide.SELL and o.symbol == symbol and o.canceled_at is None:
                    reserved += o.qty
                    cena = o.limit_price if o.limit_price else self.get_last_price(time, o.symbol)
                    reserved_price += o.qty * cena
                print("blokovano v open orders pro sell qty: ", reserved, "celkem:", reserved_price)
            
-            actual_minus_reserved = int(self.internal_account[account.name][symbol][0]) - reserved 
+            actual_minus_reserved = int(self.account[symbol][0]) - reserved 
            if actual_minus_reserved > 0 and actual_minus_reserved - int(size) < 0:
-                printanyway("not enough shares available to sell or shorting while long position",self.internal_account[account.name][symbol][0],"reserved",reserved,"available",int(self.internal_account[account.name][symbol][0]) - reserved,"selling",size)
+                printanyway("not enough shares available to sell or shorting while long position",self.account[symbol][0],"reserved",reserved,"available",int(self.account[symbol][0]) - reserved,"selling",size)
                return -1
            
            #if is shorting - check available cash to short
@@ -552,13 +533,13 @@ class Backtester:
            reserved_price = 0
            #with lock:
            for o in self.open_orders:
-                if o.side == OrderSide.BUY and o.canceled_at is None and o.account==account:
+                if o.side == OrderSide.BUY and o.canceled_at is None:
                    cena = o.limit_price if o.limit_price else self.get_last_price(time, o.symbol)
                    reserved_price += o.qty * cena
                    reserved_qty += o.qty
                    print("blokovano v open orders for buy: qty, price", reserved_qty, reserved_price)

-            actual_plus_reserved_qty = int(self.internal_account[account.name][symbol][0]) + reserved_qty
+            actual_plus_reserved_qty = int(self.account[symbol][0]) + reserved_qty
            
            #jde o uzavreni shortu
            if actual_plus_reserved_qty < 0 and (actual_plus_reserved_qty + int(size)) > 0:
@@ -574,7 +555,6 @@ class Backtester:

        id = str(uuid4())
        order = Order(id=id,
-                    account=account,
                    submitted_at = datetime.fromtimestamp(float(time)),
                    symbol=symbol,
                    order_type = order_type,
@@ -589,7 +569,7 @@ class Backtester:
        return id


-    def replace_order(self, id: str, time: float, account: Account, size: int = None, price: float = None):
+    def replace_order(self, id: str, time: float, size: int = None, price: float = None):
        """replace order
        - zakladni validace vrací synchronně
        - vrací číslo nové objednávky
@@ -606,7 +586,7 @@ class Backtester:
        #with lock:
        for o in self.open_orders:
            print(o.id)
-            if str(o.id) == str(id) and o.account == account:
+            if str(o.id) == str(id):
                newid = str(uuid4())
                o.id = newid
                o.submitted_at = datetime.fromtimestamp(time)
@@ -617,7 +597,7 @@ class Backtester:
        print("BT: replacement order doesnt exist")
        return 0
    
-    def cancel_order(self, time: float, id: str, account: Account):
+    def cancel_order(self, time: float, id: str):
        """cancel order
        - základní validace vrací synchronně
        - vymaže objednávku z open orders
@@ -633,22 +613,22 @@ class Backtester:
            return 0
        #with lock:
        for o in self.open_orders:
-            if str(o.id) == id and o.account == account:
+            if str(o.id) == id:
                o.canceled_at = time
                print("set as canceled in self.open_orders")
                return 1
        print("BTC: cantchange. open order doesnt exist")
        return 0
    
-    def get_open_position(self, symbol: str, account: Account):
+    def get_open_position(self, symbol: str):
        """get positions ->(avg,size)"""
        #print("BT:get open positions entry")
        try:
-            return self.internal_account[account.name][symbol][1], self.internal_account[account.name][symbol][0]
+            return self.account[symbol][1], self.account[symbol][0]
        except:
            return (0,0)

-    def get_open_orders(self, side: OrderSide, symbol: str, account: Account):
+    def get_open_orders(self, side: OrderSide, symbol: str):
        """get open orders ->list(OrderNotification)""" 
        print("BT:get open orders entry")
        if len(self.open_orders) == 0:
@@ -658,7 +638,7 @@ class Backtester:
        #with lock:
        for o in self.open_orders:
            #print(o)
-            if o.symbol == symbol and o.canceled_at is None and o.account == account:
+            if o.symbol == symbol and o.canceled_at is None:
                if side is None or o.side == side:
                    res.append(o)
        return res
--- a/v2realbot/common/PrescribedTradeModel.py
+++ b/v2realbot/common/PrescribedTradeModel.py
@@ -0,0 +1,41 @@
+from enum import Enum
+from datetime import datetime
+from pydantic import BaseModel
+from typing import Any, Optional, List, Union
+from uuid import UUID
+class TradeStatus(str, Enum):
+    READY = "ready"
+    ACTIVATED = "activated"
+    CLOSED = "closed"
+    #FINISHED = "finished"
+
+class TradeDirection(str, Enum):
+    LONG = "long"
+    SHORT = "short"
+
+class TradeStoplossType(str, Enum):
+    FIXED = "fixed"
+    TRAILING = "trailing"
+
+#Predpis obchodu vygenerovany signalem, je to zastresujici jednotka
+#ke kteremu jsou pak navazany jednotlivy FILLy (reprezentovany model.TradeUpdate) - napr. castecne exity atp.
+class Trade(BaseModel):
+    id: UUID
+    last_update: datetime
+    entry_time: Optional[datetime] = None
+    exit_time: Optional[datetime] = None
+    status: TradeStatus
+    generated_by: Optional[str] = None
+    direction: TradeDirection
+    entry_price: Optional[float] = None
+    goal_price: Optional[float] = None
+    size: Optional[int] = None
+    # size_multiplier je pomocna promenna pro pocitani relativniho denniho profit
+    size_multiplier: Optional[float] = None    
+    # stoploss_type: TradeStoplossType
+    stoploss_value: Optional[float] = None
+    profit: Optional[float] = 0
+    profit_sum: Optional[float] = 0
+    rel_profit: Optional[float] = 0
+    rel_profit_cum: Optional[float] = 0
+    
--- a/v2realbot/common/model.py
+++ b/v2realbot/common/model.py
@@ -5,75 +5,10 @@ from rich import print
 from typing import Any, Optional, List, Union
 from datetime import datetime, date
 from pydantic import BaseModel, Field
-from v2realbot.enums.enums import Mode, Account, SchedulerStatus, Moddus, Market, Followup
+from v2realbot.enums.enums import Mode, Account, SchedulerStatus, Moddus, Market
 from alpaca.data.enums import Exchange
-from enum import Enum
-from datetime import datetime
-from pydantic import BaseModel
-from typing import Any, Optional, List, Union
-from uuid import UUID


-#prescribed model
-#from prescribed model
-class InstantIndicator(BaseModel):
-    name: str
-    toml: str
-
-
-class TradeStatus(str, Enum):
-    READY = "ready"
-    ACTIVATED = "activated"
-    CLOSED = "closed"
-    #FINISHED = "finished"
-
-class TradeDirection(str, Enum):
-    LONG = "long"
-    SHORT = "short"
-
-class TradeStoplossType(str, Enum):
-    FIXED = "fixed"
-    TRAILING = "trailing"
-
-#Predpis obchodu vygenerovany signalem, je to zastresujici jednotka
-#ke kteremu jsou pak navazany jednotlivy FILLy (reprezentovany model.TradeUpdate) - napr. castecne exity atp.
-class Trade(BaseModel):
-    account: Account
-    id: UUID
-    last_update: datetime
-    entry_time: Optional[datetime] = None
-    exit_time: Optional[datetime] = None
-    status: TradeStatus
-    generated_by: Optional[str] = None
-    direction: TradeDirection
-    entry_price: Optional[float] = None
-    goal_price: Optional[float] = None
-    size: Optional[int] = None
-    # size_multiplier je pomocna promenna pro pocitani relativniho denniho profit
-    size_multiplier: Optional[float] = None    
-    # stoploss_type: TradeStoplossType
-    stoploss_value: Optional[float] = None
-    profit: Optional[float] = 0
-    profit_sum: Optional[float] = 0
-    rel_profit: Optional[float] = 0
-    rel_profit_cum: Optional[float] = 0
-
-#account variables that can be accessed by ACCOUNT key dictionary
-class AccountVariables(BaseModel):
-    positions: float = 0
-    avgp: float = 0
-    pending: str = None
-    blockbuy: int = 0
-    wait_for_fill: float = None
-    profit: float = 0
-    docasny_rel_profit: list = []
-    rel_profit_cum: list = []
-    last_entry_index: int = None #acc varianta, mame taky obnecnou state.vars.last_entry_index
-    requested_followup: Followup = None
-    activeTrade: Trade = None
-    dont_exit_already_activated: bool = False
-    #activeTrade, prescribedTrades
-    #tbd transferables?


 #models for server side datatables
@@ -156,7 +91,7 @@ class TestList(BaseModel):
    dates: List[Intervals]

 #for GUI to fetch historical trades on given symbol
-class TradeView(BaseModel):
+class Trade(BaseModel):
    symbol: str
    timestamp: datetime
    exchange: Optional[Union[Exchange, str]] = None
@@ -254,8 +189,8 @@ class RunnerView(BaseModel):
    run_symbol: Optional[str] = None
    run_trade_count: Optional[int] = 0
    run_profit: Optional[float] = 0
-    run_positions: Optional[dict] = 0
-    run_avgp: Optional[dict] = 0
+    run_positions: Optional[int] = 0
+    run_avgp: Optional[float] = 0
    run_stopped: Optional[datetime] = None
    run_paused: Optional[datetime] = None    
 
@@ -273,8 +208,8 @@ class Runner(BaseModel):
    run_ilog_save: Optional[bool] = False
    run_trade_count: Optional[int] = None
    run_profit: Optional[float] = None
-    run_positions: Optional[dict] = None
-    run_avgp: Optional[dict] = None
+    run_positions: Optional[int] = None
+    run_avgp: Optional[float] = None
    run_strat_json: Optional[str] = None
    run_stopped: Optional[datetime] = None
    run_paused: Optional[datetime] = None   
@@ -312,7 +247,6 @@ class Bar(BaseModel):
    vwap: Optional[float] = 0

 class Order(BaseModel):
-    account: Account
    id: UUID
    submitted_at: datetime
    filled_at: Optional[datetime] = None
@@ -328,7 +262,6 @@ class Order(BaseModel):

 #entita pro kazdy kompletni FILL, je navazana na prescribed_trade 
 class TradeUpdate(BaseModel):
-    account: Account
    event: Union[TradeEvent, str]
    execution_id: Optional[UUID] = None
    order: Order
@@ -374,8 +307,8 @@ class RunArchive(BaseModel):
    ilog_save: Optional[bool] = False
    profit: float = 0
    trade_count: int = 0
-    end_positions: Union[dict,str] = None
-    end_positions_avgp: Union[dict,str] = None
+    end_positions: int = 0
+    end_positions_avgp: float = 0
    metrics: Union[dict, str] = None
    stratvars_toml: Optional[str] = None

@@ -396,8 +329,8 @@ class RunArchiveView(BaseModel):
    ilog_save: Optional[bool] = False
    profit: float = 0
    trade_count: int = 0
-    end_positions: Union[dict,int] = None
-    end_positions_avgp: Union[dict,float] = None
+    end_positions: int = 0
+    end_positions_avgp: float = 0
    metrics: Union[dict, str] = None
    batch_profit: float = 0  # Total profit for the batch - now calculated during query
    batch_count: int = 0  # Count of runs in the batch - now calculated during query
@@ -414,8 +347,6 @@ class SLHistory(BaseModel):
    id: Optional[UUID] = None
    time: datetime
    sl_val: float
-    direction: TradeDirection
-    account: Account

 #Contains archive of running strategies (runner) - detail data
 class RunArchiveDetail(BaseModel):
@@ -428,3 +359,9 @@ class RunArchiveDetail(BaseModel):
    trades: List[TradeUpdate]
    ext_data: Optional[dict] = None
    
+
+class InstantIndicator(BaseModel):
+    name: str
+    toml: str
+
+
--- a/v2realbot/common/transform.py
+++ b/v2realbot/common/transform.py
@@ -51,8 +51,8 @@ def row_to_runarchiveview(row: dict) -> RunArchiveView:
        ilog_save=bool(row['ilog_save']),
        profit=float(row['profit']),
        trade_count=int(row['trade_count']),
-        end_positions=orjson.loads(row['end_positions']),
-        end_positions_avgp=orjson.loads(row['end_positions_avgp']),
+        end_positions=int(row['end_positions']),
+        end_positions_avgp=float(row['end_positions_avgp']),
        metrics=orjson.loads(row['metrics']) if row['metrics'] else None,
        batch_profit=int(row['batch_profit']) if row['batch_profit'] and row['batch_id'] else 0,
        batch_count=int(row['batch_count']) if row['batch_count'] and row['batch_id'] else 0,
@@ -79,8 +79,8 @@ def row_to_runarchive(row: dict) -> RunArchive:
        ilog_save=bool(row['ilog_save']),
        profit=float(row['profit']),
        trade_count=int(row['trade_count']),
-        end_positions=str(row['end_positions']),
-        end_positions_avgp=str(row['end_positions_avgp']),
+        end_positions=int(row['end_positions']),
+        end_positions_avgp=float(row['end_positions_avgp']),
        metrics=orjson.loads(row['metrics']),
        stratvars_toml=row['stratvars_toml'],
        transferables=orjson.loads(row['transferables']) if row['transferables'] else None
--- a/v2realbot/config.py
+++ b/v2realbot/config.py
@@ -17,6 +17,9 @@ RUNNER_DETAIL_DIRECTORY = Path(__file__).parent.parent.parent / "runner_detail"
 LOG_PATH = Path(__file__).parent.parent
 LOG_FILE = Path(__file__).parent.parent / "strat.log"
 JOB_LOG_FILE = Path(__file__).parent.parent / "job.log"
+DOTENV_DIRECTORY = Path(__file__).parent.parent.parent
+ENV_FILE = DOTENV_DIRECTORY / '.env'
+

 #stratvars that cannot be changed in gui
 STRATVARS_UNCHANGEABLES = ['pendingbuys', 'blockbuy', 'jevylozeno', 'limitka']
@@ -27,26 +30,6 @@ MODEL_DIR = Path(DATA_DIR)/"models"
 PROFILING_NEXT_ENABLED = False
 PROFILING_OUTPUT_DIR = DATA_DIR

-def find_dotenv(start_path):
-    """
-    Searches for a .env file in the given directory or its parents and returns the path.
-
-    Args:
-        start_path: The directory to start searching from.
-
-    Returns:
-        Path to the .env file if found, otherwise None.
-    """
-    current_path = Path(start_path)
-    for _ in range(6):  # Limit search depth to 5 levels
-        dotenv_path = current_path / '.env'
-        if dotenv_path.exists():
-            return dotenv_path
-        current_path = current_path.parent
-    return None
-
-ENV_FILE = find_dotenv(__file__)
-
 #NALOADUJEME DOTENV ENV VARIABLES
 if load_dotenv(ENV_FILE, verbose=True) is False:
    print(f"Error loading.env file {ENV_FILE}. Now depending on ENV VARIABLES set externally.")
@@ -83,10 +66,10 @@ def get_key(mode: Mode, account: Account):
        return None
    dict = globals()
    try:
-        API_KEY = dict[str.upper(str(account.name)) + "_" + str.upper(str(mode.name)) + "_API_KEY" ]
-        SECRET_KEY = dict[str.upper(str(account.name)) + "_" + str.upper(str(mode.name)) + "_SECRET_KEY" ]
-        PAPER = dict[str.upper(str(account.name)) + "_" + str.upper(str(mode.name)) + "_PAPER" ]
-        FEED = dict[str.upper(str(account.name)) + "_" + str.upper(str(mode.name)) + "_FEED" ]
+        API_KEY = dict[str.upper(str(account.value)) + "_" + str.upper(str(mode.value)) + "_API_KEY" ]
+        SECRET_KEY = dict[str.upper(str(account.value)) + "_" + str.upper(str(mode.value)) + "_SECRET_KEY" ]
+        PAPER = dict[str.upper(str(account.value)) + "_" + str.upper(str(mode.value)) + "_PAPER" ]
+        FEED = dict[str.upper(str(account.value)) + "_" + str.upper(str(mode.value)) + "_FEED" ]
        return Keys(API_KEY, SECRET_KEY, PAPER, FEED)
    except KeyError:
        print("Not valid combination to get keys for", mode, account)
@@ -110,7 +93,7 @@ data_feed_type_str = os.environ.get('ACCOUNT1_PAPER_FEED', 'iex')  # Default to
 # Convert the string to DataFeed enum
 try:
    ACCOUNT1_PAPER_FEED = DataFeed(data_feed_type_str)
-except nameError:
+except ValueError:
    # Handle the case where the environment variable does not match any enum member
    print(f"Invalid data feed type: {data_feed_type_str} in ACCOUNT1_PAPER_FEED defaulting to 'iex'")
    ACCOUNT1_PAPER_FEED = DataFeed.SIP
@@ -128,7 +111,7 @@ data_feed_type_str = os.environ.get('ACCOUNT1_LIVE_FEED', 'iex')  # Default to '
 # Convert the string to DataFeed enum
 try:
    ACCOUNT1_LIVE_FEED = DataFeed(data_feed_type_str)
-except nameError:
+except ValueError:
    # Handle the case where the environment variable does not match any enum member
    print(f"Invalid data feed type: {data_feed_type_str} in ACCOUNT1_LIVE_FEED defaulting to 'iex'")
    ACCOUNT1_LIVE_FEED = DataFeed.IEX
@@ -146,7 +129,7 @@ data_feed_type_str = os.environ.get('ACCOUNT2_PAPER_FEED', 'iex')  # Default to
 # Convert the string to DataFeed enum
 try:
    ACCOUNT2_PAPER_FEED = DataFeed(data_feed_type_str)
-except nameError:
+except ValueError:
    # Handle the case where the environment variable does not match any enum member
    print(f"Invalid data feed type: {data_feed_type_str} in ACCOUNT2_PAPER_FEED defaulting to 'iex'")
    ACCOUNT2_PAPER_FEED = DataFeed.IEX
@@ -165,7 +148,7 @@ except nameError:
 # # Convert the string to DataFeed enum
 # try:
 #     ACCOUNT2_LIVE_FEED = DataFeed(data_feed_type_str)
-# except nameError:
+# except ValueError:
 #     # Handle the case where the environment variable does not match any enum member
 #     print(f"Invalid data feed type: {data_feed_type_str} in ACCOUNT2_LIVE_FEED defaulting to 'iex'")
 #     ACCOUNT2_LIVE_FEED = DataFeed.IEX
--- a/v2realbot/controller/run_manager.py
+++ b/v2realbot/controller/run_manager.py
@@ -3,7 +3,7 @@ from uuid import UUID, uuid4
 from v2realbot.common.model import RunManagerRecord, StrategyInstance, RunDay, StrategyInstance, Runner, RunRequest, RunArchive, RunArchiveView, RunArchiveViewPagination, RunArchiveDetail, RunArchiveChange, Bar, TradeEvent, TestList, Intervals, ConfigItem, InstantIndicator, DataTablesRequest
 from v2realbot.utils.utils import validate_and_format_time, AttributeDict, zoneNY, zonePRG, safe_get, dict_replace_value, Store, parse_toml_string, json_serial, is_open_hours, send_to_telegram, concatenate_weekdays, transform_data
 from v2realbot.utils.ilog import delete_logs
-from v2realbot.common.model import Trade, TradeDirection, TradeStatus, TradeStoplossType
+from v2realbot.common.PrescribedTradeModel import Trade, TradeDirection, TradeStatus, TradeStoplossType
 from datetime import datetime
 from v2realbot.loader.trade_offline_streamer import Trade_Offline_Streamer
 from threading import Thread, current_thread, Event, enumerate
--- a/v2realbot/controller/services.py
+++ b/v2realbot/controller/services.py
@@ -8,9 +8,9 @@ from alpaca.data.timeframe import TimeFrame
 from v2realbot.strategy.base import StrategyState
 from v2realbot.enums.enums import RecordType, StartBarAlign, Mode, Account, OrderSide
 from v2realbot.common.model import RunDay, StrategyInstance, Runner, RunRequest, RunArchive, RunArchiveView, RunArchiveViewPagination, RunArchiveDetail, RunArchiveChange, Bar, TradeEvent, TestList, Intervals, ConfigItem, InstantIndicator, DataTablesRequest
-from v2realbot.utils.utils import AttributeDict, zoneNY, zonePRG, safe_get, dict_replace_value, Store, parse_toml_string, json_serial, is_open_hours, send_to_telegram, concatenate_weekdays, transform_data, gaka
+from v2realbot.utils.utils import AttributeDict, zoneNY, zonePRG, safe_get, dict_replace_value, Store, parse_toml_string, json_serial, is_open_hours, send_to_telegram, concatenate_weekdays, transform_data
 from v2realbot.utils.ilog import delete_logs
-from v2realbot.common.model import Trade, TradeDirection, TradeStatus, TradeStoplossType
+from v2realbot.common.PrescribedTradeModel import Trade, TradeDirection, TradeStatus, TradeStoplossType
 from datetime import datetime
 from v2realbot.loader.trade_offline_streamer import Trade_Offline_Streamer
 from threading import Thread, current_thread, Event, enumerate
@@ -71,8 +71,8 @@ def get_all_runners():
            if i.run_instance:
                i.run_profit = round(float(i.run_instance.state.profit),2)
                i.run_trade_count = len(i.run_instance.state.tradeList)
-                i.run_positions = gaka(i.run_instance.state.account_variables, "positions")
-                i.run_avgp = gaka(i.run_instance.state.account_variables, "avgp", lambda x: round(float(x),3))
+                i.run_positions = i.run_instance.state.positions
+                i.run_avgp = round(float(i.run_instance.state.avgp),3)
        return (0, db.runners)
    else:
        return (0, [])
@@ -94,8 +94,8 @@ def get_runner(id: UUID):
        if str(i.id) == str(id):
            i.run_profit = round(float(i.run_instance.state.profit),2)
            i.run_trade_count = len(i.run_instance.state.tradeList)
-            i.run_positions =gaka(i.run_instance.state.account_variables, "positions")
-            i.run_avgp = gaka(i.run_instance.state.account_variables, "avgp", lambda x: round(float(x),3))
+            i.run_positions = i.run_instance.state.positions
+            i.run_avgp = round(float(i.run_instance.state.avgp),3)
            return (0, i)
    return (-2, "not found")

@@ -738,14 +738,13 @@ def populate_metrics_output_directory(strat: StrategyInstance, inter_batch_param

    tradeList = strat.state.tradeList

-    trade_dict = AttributeDict(account=[],orderid=[],timestamp=[],symbol=[],side=[],order_type=[],qty=[],price=[],position_qty=[])
+    trade_dict = AttributeDict(orderid=[],timestamp=[],symbol=[],side=[],order_type=[],qty=[],price=[],position_qty=[])
    if strat.mode == Mode.BT:
        trade_dict["value"] = []
        trade_dict["cash"] = []
        trade_dict["pos_avg_price"] = []
    for t in tradeList:
        if t.event == TradeEvent.FILL:
-            trade_dict.account.append(t.account)
            trade_dict.orderid.append(str(t.order.id))
            trade_dict.timestamp.append(t.timestamp)
            trade_dict.symbol.append(t.order.symbol)
@@ -769,12 +768,10 @@ def populate_metrics_output_directory(strat: StrategyInstance, inter_batch_param
    max_positions = max_positions[max_positions['side'] == OrderSide.SELL]
    max_positions = max_positions.drop(columns=['side'], axis=1)

-    res = dict(account_variables={}, profit={})
+    res = dict(profit={})
    #filt = max_positions['side'] == 'OrderSide.BUY'
-
-    res["account_variables"] = transform_data(strat.state.account_variables, json_serial)
-
    res["pos_cnt"] = dict(zip(str(max_positions['qty']), max_positions['count']))
+
    #naplneni batch sum profitu
    if inter_batch_params is not None:
        res["profit"]["batch_sum_profit"] = int(inter_batch_params["batch_profit"])
@@ -926,8 +923,8 @@ def archive_runner(runner: Runner, strat: StrategyInstance, inter_batch_params:
                                            settings = settings,
                                            profit=round(float(strat.state.profit),2),
                                            trade_count=len(strat.state.tradeList),
-                                            end_positions=gaka(strat.state.account_variables, "positions"),
-                                            end_positions_avgp=gaka(strat.state.account_variables, "avgp", lambda x: round(float(x),3)),
+                                            end_positions=strat.state.positions,
+                                            end_positions_avgp=round(float(strat.state.avgp),3),
                                            metrics=results_metrics,
                                            stratvars_toml=runner.run_stratvars_toml,
                                            transferables=strat.state.vars["transferables"]
@@ -1267,7 +1264,6 @@ def insert_archive_header(archeader: RunArchive):
    try:
        c = conn.cursor()
        #json_string = orjson.dumps(archeader, default=json_serial, option=orjson.OPT_PASSTHROUGH_DATETIME)
-        #print(archeader)

        res = c.execute("""
            INSERT INTO runner_header 
@@ -1275,7 +1271,7 @@ def insert_archive_header(archeader: RunArchive):
            VALUES
            (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
            """,
-            (str(archeader.id), str(archeader.strat_id), archeader.batch_id, archeader.symbol, archeader.name, archeader.note, archeader.started, archeader.stopped, archeader.mode, archeader.account, archeader.bt_from, archeader.bt_to, orjson.dumps(archeader.strat_json).decode('utf-8'), orjson.dumps(archeader.settings).decode('utf-8'), archeader.ilog_save, archeader.profit, archeader.trade_count, orjson.dumps(archeader.end_positions).decode('utf-8'), orjson.dumps(archeader.end_positions_avgp).decode('utf-8'), orjson.dumps(archeader.metrics, default=json_serial, option=orjson.OPT_PASSTHROUGH_DATETIME).decode('utf-8'), archeader.stratvars_toml, orjson.dumps(archeader.transferables).decode('utf-8')))
+            (str(archeader.id), str(archeader.strat_id), archeader.batch_id, archeader.symbol, archeader.name, archeader.note, archeader.started, archeader.stopped, archeader.mode, archeader.account, archeader.bt_from, archeader.bt_to, orjson.dumps(archeader.strat_json).decode('utf-8'), orjson.dumps(archeader.settings).decode('utf-8'), archeader.ilog_save, archeader.profit, archeader.trade_count, archeader.end_positions, archeader.end_positions_avgp, orjson.dumps(archeader.metrics, default=json_serial, option=orjson.OPT_PASSTHROUGH_DATETIME).decode('utf-8'), archeader.stratvars_toml, orjson.dumps(archeader.transferables).decode('utf-8')))

        #retry not yet supported for statement format above
        #res = execute_with_retry(c,statement)
@@ -1650,14 +1646,13 @@ def preview_indicator_byTOML(id: UUID, indicator: InstantIndicator, save: bool =
        new_inds = AttributeDict(**new_inds)
        new_tick_inds = {key: [] for key in detail.indicators[1].keys()}
        new_tick_inds = AttributeDict(**new_tick_inds)
-        def_account = Account("ACCOUNT1")
-        interface = BacktestInterface(symbol="X", bt=None, account=def_account)
+        interface = BacktestInterface(symbol="X", bt=None)

        ##dame nastaveni indikatoru do tvaru, ktery stratvars ocekava (pro dynmaicke inicializace)
        stratvars = AttributeDict(indicators=AttributeDict(**{jmeno:toml_parsed}))
        #print("stratvars", stratvars)

-        state = StrategyState(name="XX", symbol = "X", stratvars = AttributeDict(**stratvars), interface=interface, accounts=[def_account], account=def_account)
+        state = StrategyState(name="XX", symbol = "X", stratvars = AttributeDict(**stratvars), interface=interface)

        #inicializujeme stavove promenne a novy indikator v cilovem dict
        if output == "bar":
--- a/v2realbot/interfaces/backtest_interface.py
+++ b/v2realbot/interfaces/backtest_interface.py
@@ -5,7 +5,6 @@ from v2realbot.backtesting.backtester import Backtester
 from datetime import datetime
 from v2realbot.utils.utils import zoneNY
 import v2realbot.utils.config_handler as cfh
-from v2realbot.common.model import Account

 """"
 backtester methods can be called
@@ -17,9 +16,8 @@ both should be backtestable
 if method are called for the past self.time must be set accordingly
 """
 class BacktestInterface(GeneralInterface):
-    def __init__(self, symbol, bt: Backtester, account: Account) -> None:
+    def __init__(self, symbol, bt: Backtester) -> None:
        self.symbol = symbol
-        self.account = account
        self.bt = bt
        self.count_api_requests = cfh.config_handler.get_val('COUNT_API_REQUESTS')
        self.mincnt = list([dict(minute=0,count=0)])
@@ -45,48 +43,48 @@ class BacktestInterface(GeneralInterface):
    def buy(self, size = 1, repeat: bool = False):
        self.count()
        #add REST API latency
-        return self.bt.submit_order(time=self.bt.time + cfh.config_handler.get_val('BT_DELAYS','strat_to_sub'),symbol=self.symbol,side=OrderSide.BUY,size=size,order_type = OrderType.MARKET, account=self.account) 
+        return self.bt.submit_order(time=self.bt.time + cfh.config_handler.get_val('BT_DELAYS','strat_to_sub'),symbol=self.symbol,side=OrderSide.BUY,size=size,order_type = OrderType.MARKET) 
    
    """buy limit"""
    def buy_l(self, price: float, size: int = 1, repeat: bool = False, force: int = 0):
        self.count()
-        return self.bt.submit_order(time=self.bt.time + cfh.config_handler.get_val('BT_DELAYS','strat_to_sub'),symbol=self.symbol,side=OrderSide.BUY,size=size,price=price,order_type = OrderType.LIMIT, account=self.account) 
+        return self.bt.submit_order(time=self.bt.time + cfh.config_handler.get_val('BT_DELAYS','strat_to_sub'),symbol=self.symbol,side=OrderSide.BUY,size=size,price=price,order_type = OrderType.LIMIT) 
    
    """sell market"""
    def sell(self, size = 1, repeat: bool = False):
        self.count()
-        return self.bt.submit_order(time=self.bt.time + cfh.config_handler.get_val('BT_DELAYS','strat_to_sub'),symbol=self.symbol,side=OrderSide.SELL,size=size,order_type = OrderType.MARKET, account=self.account) 
+        return self.bt.submit_order(time=self.bt.time + cfh.config_handler.get_val('BT_DELAYS','strat_to_sub'),symbol=self.symbol,side=OrderSide.SELL,size=size,order_type = OrderType.MARKET) 

    """sell limit"""
    async def sell_l(self, price: float, size = 1, repeat: bool = False):
        self.count()
-        return self.bt.submit_order(time=self.bt.time + cfh.config_handler.get_val('BT_DELAYS','strat_to_sub'),symbol=self.symbol,side=OrderSide.SELL,size=size,price=price,order_type = OrderType.LIMIT, account=self.account)        
+        return self.bt.submit_order(time=self.bt.time + cfh.config_handler.get_val('BT_DELAYS','strat_to_sub'),symbol=self.symbol,side=OrderSide.SELL,size=size,price=price,order_type = OrderType.LIMIT)        

    """replace order"""
    async def repl(self, orderid: str, price: float = None, size: int = None, repeat: bool = False):
        self.count()
-        return self.bt.replace_order(time=self.bt.time + cfh.config_handler.get_val('BT_DELAYS','strat_to_sub'),id=orderid,size=size,price=price, account=self.account)
+        return self.bt.replace_order(time=self.bt.time + cfh.config_handler.get_val('BT_DELAYS','strat_to_sub'),id=orderid,size=size,price=price)
    
    """cancel order"""
    #TBD exec predtim?
    def cancel(self, orderid: str):
        self.count()
-        return self.bt.cancel_order(time=self.bt.time + cfh.config_handler.get_val('BT_DELAYS','strat_to_sub'), id=orderid, account=self.account)
+        return self.bt.cancel_order(time=self.bt.time + cfh.config_handler.get_val('BT_DELAYS','strat_to_sub'), id=orderid)

    """get positions ->(size,avgp)"""
    #TBD exec predtim?
    def pos(self):
        self.count()
-        return self.bt.get_open_position(symbol=self.symbol, account=self.account)
+        return self.bt.get_open_position(symbol=self.symbol)

    """get open orders ->list(Order)"""      
    def get_open_orders(self, side: OrderSide, symbol: str):
        self.count()
-        return self.bt.get_open_orders(side=side, symbol=symbol, account=self.account)
+        return self.bt.get_open_orders(side=side, symbol=symbol)
    
    def get_last_price(self, symbol: str):
        self.count()
-        return self.bt.get_last_price(time=self.bt.time, account=self.account)
+        return self.bt.get_last_price(time=self.bt.time)


    
--- a/v2realbot/interfaces/live_interface.py
+++ b/v2realbot/interfaces/live_interface.py
@@ -97,7 +97,7 @@ class LiveInterface(GeneralInterface):
            return -1

    """sell limit"""
-    def sell_l(self, price: float, size = 1, repeat: bool = False):
+    async def sell_l(self, price: float, size = 1, repeat: bool = False):
        self.size = size
        self.repeat = repeat

@@ -124,7 +124,7 @@ class LiveInterface(GeneralInterface):
            return -1
        
    """order replace"""
-    def repl(self, orderid: str, price: float = None, size: int = None, repeatl: bool = False):
+    async def repl(self, orderid: str, price: float = None, size: int = None, repeatl: bool = False):
        
        if not price and not size:
            print("price or size has to be filled")
--- a/v2realbot/loader/order_updates_streamer.py
+++ b/v2realbot/loader/order_updates_streamer.py
@@ -1,7 +1,6 @@
-from threading import Thread, current_thread
+from threading import Thread
 from alpaca.trading.stream import TradingStream
 from v2realbot.config import Keys
-from v2realbot.common.model import Account

 #jelikoz Alpaca podporuje pripojeni libovolneho poctu websocket instanci na order updates
 #vytvorime pro kazdou bezici instanci vlastni webservisu (jinak bychom museli delat instanci pro kombinaci ACCOUNT1 - LIVE, ACCOUNT1 - PAPER, ACCOUNT2 - PAPER ..)
@@ -15,16 +14,15 @@ As Alpaca supports connecting of any number of trade updates clients
 new instance of this websocket thread is created for each strategy instance.
 """""
 class LiveOrderUpdatesStreamer(Thread):
-    def __init__(self, key: Keys, name: str, account: Account) -> None:
+    def __init__(self, key: Keys, name: str) -> None:
        self.key = key
-        self.account = account
        self.strategy = None
        self.client = TradingStream(api_key=key.API_KEY, secret_key=key.SECRET_KEY, paper=key.PAPER)
        Thread.__init__(self, name=name)
    
    #notif dispatcher - pouze 1 strategie
    async def distributor(self,data):     
-        if self.strategy.symbol == data.order.symbol: await self.strategy.order_updates(data, self.account)
+        if self.strategy.symbol == data.order.symbol: await self.strategy.order_updates(data)

   # connects callback to interface object - responses for given symbol are routed to interface callback
    def connect_callback(self, st):
@@ -41,6 +39,6 @@ class LiveOrderUpdatesStreamer(Thread):
            print("connect strategy first")
            return
        self.client.subscribe_trade_updates(self.distributor)
-        print("*"*10, "WS Order Update Streamer started for", current_thread().name,"*"*10)
+        print("*"*10, "WS Order Update Streamer started for", self.strategy.name, "*"*10)
        self.client.run()
        
--- a/v2realbot/main.py
+++ b/v2realbot/main.py
@@ -10,7 +10,7 @@ from fastapi.security import APIKeyHeader
 import uvicorn
 from uuid import UUID
 from v2realbot.utils.ilog import get_log_window
-from v2realbot.common.model import RunManagerRecord, StrategyInstance, RunnerView, RunRequest, TradeView, RunArchive, RunArchiveView, RunArchiveViewPagination, RunArchiveDetail, Bar, RunArchiveChange, TestList, ConfigItem, InstantIndicator, DataTablesRequest, AnalyzerInputs
+from v2realbot.common.model import RunManagerRecord, StrategyInstance, RunnerView, RunRequest, Trade, RunArchive, RunArchiveView, RunArchiveViewPagination, RunArchiveDetail, Bar, RunArchiveChange, TestList, ConfigItem, InstantIndicator, DataTablesRequest, AnalyzerInputs
 from fastapi import FastAPI, WebSocket, WebSocketDisconnect, Depends, HTTPException, status, WebSocketException, Cookie, Query, Request
 from fastapi.responses import FileResponse, StreamingResponse, JSONResponse
 from fastapi.staticfiles import StaticFiles
@@ -18,7 +18,6 @@ from fastapi.security import HTTPBasic, HTTPBasicCredentials
 from v2realbot.enums.enums import Env, Mode
 from typing import Annotated
 import os
-import psutil
 import uvicorn
 import orjson
 from queue import Queue, Empty
@@ -334,7 +333,7 @@ def stop_all_runners():
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Error: {res}:{id}")

@app.get("/tradehistory/{symbol}", dependencies=[Depends(api_key_auth)])
-def get_trade_history(symbol: str, timestamp_from: float, timestamp_to:float) -> list[TradeView]:
+def get_trade_history(symbol: str, timestamp_from: float, timestamp_to:float) -> list[Trade]:
    res, set = cs.get_trade_history(symbol, timestamp_from, timestamp_to)
    if res == 0:
        return set
@@ -1026,25 +1025,7 @@ def get_metadata(model_name: str):
    #         "last_modified": os.path.getmtime(model_path),
    #         # ... other metadata fields ...
    #     }
-@app.get("/system-info")
-def get_system_info():
-    """Get system info, e.g. disk free space, used percentage ... """
-    disk_total = round(psutil.disk_usage('/').total / 1024**3, 1)
-    disk_used = round(psutil.disk_usage('/').used / 1024**3, 1)
-    disk_free = round(psutil.disk_usage('/').free / 1024**3, 1)
-    disk_used_percentage = round(psutil.disk_usage('/').percent, 1)
-    # memory_total = round(psutil.virtual_memory().total / 1024**3, 1)
-    # memory_perc = round(psutil.virtual_memory().percent, 1)
-    # cpu_time_user = round(psutil.cpu_times().user,1)
-    # cpu_time_system = round(psutil.cpu_times().system,1)
-    # cpu_time_idle = round(psutil.cpu_times().idle,1)
-    # network_sent = round(psutil.net_io_counters().bytes_sent / 1024**3, 6)
-    # network_recv = round(psutil.net_io_counters().bytes_recv / 1024**3, 6)
-    return {"disk_space": {"total": disk_total, "used": disk_used, "free" : disk_free, "used_percentage" : disk_used_percentage},
-            # "memory": {"total": memory_total, "used_percentage": memory_perc},
-            # "cpu_time" : {"user": cpu_time_user, "system": cpu_time_system, "idle": cpu_time_idle},
-            # "network": {"sent": network_sent, "received": network_recv}
-            }
+

 # Thread function to insert data from the queue into the database
 def insert_queue2db():
--- a/v2realbot/reporting/analyzer/WIP_daily_profit_distribution.py
+++ b/v2realbot/reporting/analyzer/WIP_daily_profit_distribution.py
@@ -12,7 +12,7 @@ import numpy as np
 import v2realbot.controller.services as cs
 from rich import print
 from v2realbot.common.model import AnalyzerInputs
-from v2realbot.common.model import TradeDirection, TradeStatus, Trade, TradeStoplossType
+from v2realbot.common.PrescribedTradeModel import TradeDirection, TradeStatus, Trade, TradeStoplossType
 from v2realbot.utils.utils import isrising, isfalling,zoneNY, price2dec, safe_get#, print
 from pathlib import Path
 from v2realbot.config import WEB_API_KEY, DATA_DIR, MEDIA_DIRECTORY
--- a/v2realbot/reporting/analyzer/daily_profit_distribution.py
+++ b/v2realbot/reporting/analyzer/daily_profit_distribution.py
@@ -12,7 +12,7 @@ import numpy as np
 import v2realbot.controller.services as cs
 from rich import print
 from v2realbot.common.model import AnalyzerInputs
-from v2realbot.common.model import TradeDirection, TradeStatus, Trade, TradeStoplossType
+from v2realbot.common.PrescribedTradeModel import TradeDirection, TradeStatus, Trade, TradeStoplossType
 from v2realbot.utils.utils import isrising, isfalling,zoneNY, price2dec, safe_get#, print
 from pathlib import Path
 from v2realbot.config import WEB_API_KEY, DATA_DIR, MEDIA_DIRECTORY
--- a/v2realbot/reporting/analyzer/example_plugin.py
+++ b/v2realbot/reporting/analyzer/example_plugin.py
@@ -11,7 +11,7 @@ import numpy as np
 import v2realbot.controller.services as cs
 from rich import print
 from v2realbot.common.model import AnalyzerInputs
-from v2realbot.common.model import TradeDirection, TradeStatus, Trade, TradeStoplossType
+from v2realbot.common.PrescribedTradeModel import TradeDirection, TradeStatus, Trade, TradeStoplossType
 from v2realbot.utils.utils import isrising, isfalling,zoneNY, price2dec, safe_get#, print
 from pathlib import Path
 from v2realbot.config import WEB_API_KEY, DATA_DIR, MEDIA_DIRECTORY
--- a/v2realbot/reporting/analyzer/find_optimal_cutoff.py
+++ b/v2realbot/reporting/analyzer/find_optimal_cutoff.py
@@ -11,7 +11,7 @@ import numpy as np
 import v2realbot.controller.services as cs
 from rich import print
 from v2realbot.common.model import AnalyzerInputs
-from v2realbot.common.model import TradeDirection, TradeStatus, Trade, TradeStoplossType
+from v2realbot.common.PrescribedTradeModel import TradeDirection, TradeStatus, Trade, TradeStoplossType
 from v2realbot.utils.utils import isrising, isfalling,zoneNY, price2dec, safe_get#, print
 from pathlib import Path
 from v2realbot.config import WEB_API_KEY, DATA_DIR, MEDIA_DIRECTORY
--- a/v2realbot/reporting/analyzer/find_optimal_cutoff_REL.py
+++ b/v2realbot/reporting/analyzer/find_optimal_cutoff_REL.py
@@ -11,7 +11,7 @@ import numpy as np
 import v2realbot.controller.services as cs
 from rich import print
 from v2realbot.common.model import AnalyzerInputs
-from v2realbot.common.model import TradeDirection, TradeStatus, Trade, TradeStoplossType
+from v2realbot.common.PrescribedTradeModel import TradeDirection, TradeStatus, Trade, TradeStoplossType
 from v2realbot.utils.utils import isrising, isfalling,zoneNY, price2dec, safe_get#, print
 from pathlib import Path
 from v2realbot.config import WEB_API_KEY, DATA_DIR, MEDIA_DIRECTORY
--- a/v2realbot/reporting/analyzer/ls_profit_distribution.py
+++ b/v2realbot/reporting/analyzer/ls_profit_distribution.py
@@ -11,7 +11,7 @@ import numpy as np
 import v2realbot.controller.services as cs
 from rich import print
 from v2realbot.common.model import AnalyzerInputs
-from v2realbot.common.model import TradeDirection, TradeStatus, Trade, TradeStoplossType
+from v2realbot.common.PrescribedTradeModel import TradeDirection, TradeStatus, Trade, TradeStoplossType
 from v2realbot.utils.utils import isrising, isfalling,zoneNY, price2dec, safe_get#, print
 from pathlib import Path
 from v2realbot.config import WEB_API_KEY, DATA_DIR, MEDIA_DIRECTORY
--- a/v2realbot/reporting/analyzer/profit_distribution_by_month.py
+++ b/v2realbot/reporting/analyzer/profit_distribution_by_month.py
@@ -11,7 +11,7 @@ import numpy as np
 import v2realbot.controller.services as cs
 from rich import print
 from v2realbot.common.model import AnalyzerInputs
-from v2realbot.common.model import TradeDirection, TradeStatus, Trade, TradeStoplossType
+from v2realbot.common.PrescribedTradeModel import TradeDirection, TradeStatus, Trade, TradeStoplossType
 from v2realbot.utils.utils import isrising, isfalling,zoneNY, price2dec, safe_get#, print
 from pathlib import Path
 from v2realbot.config import WEB_API_KEY, DATA_DIR, MEDIA_DIRECTORY
--- a/v2realbot/reporting/analyzer/profit_sum_by_hour.py
+++ b/v2realbot/reporting/analyzer/profit_sum_by_hour.py
@@ -11,7 +11,7 @@ import numpy as np
 import v2realbot.controller.services as cs
 from rich import print
 from v2realbot.common.model import AnalyzerInputs
-from v2realbot.common.model import TradeDirection, TradeStatus, Trade, TradeStoplossType
+from v2realbot.common.PrescribedTradeModel import TradeDirection, TradeStatus, Trade, TradeStoplossType
 from v2realbot.utils.utils import isrising, isfalling,zoneNY, price2dec, safe_get#, print
 from pathlib import Path
 from v2realbot.config import WEB_API_KEY, DATA_DIR, MEDIA_DIRECTORY
--- a/v2realbot/reporting/analyzer/summarize_trade_metrics.py
+++ b/v2realbot/reporting/analyzer/summarize_trade_metrics.py
@@ -12,7 +12,7 @@ import numpy as np
 import v2realbot.controller.services as cs
 from rich import print
 from v2realbot.common.model import AnalyzerInputs
-from v2realbot.common.model import TradeDirection, TradeStatus, Trade, TradeStoplossType
+from v2realbot.common.PrescribedTradeModel import TradeDirection, TradeStatus, Trade, TradeStoplossType
 from v2realbot.utils.utils import isrising, isfalling,zoneNY, price2dec, safe_get#, print
 from pathlib import Path
 from v2realbot.config import WEB_API_KEY, DATA_DIR, MEDIA_DIRECTORY
--- a/v2realbot/reporting/archive/optimizecutoff.py
+++ b/v2realbot/reporting/archive/optimizecutoff.py
@@ -10,7 +10,7 @@ from enum import Enum
 import numpy as np
 import v2realbot.controller.services as cs
 from rich import print
-from v2realbot.common.model import TradeDirection, TradeStatus, Trade, TradeStoplossType
+from v2realbot.common.PrescribedTradeModel import TradeDirection, TradeStatus, Trade, TradeStoplossType
 from v2realbot.utils.utils import isrising, isfalling,zoneNY, price2dec, safe_get#, print
 from pathlib import Path
 from v2realbot.config import WEB_API_KEY, DATA_DIR, MEDIA_DIRECTORY
--- a/v2realbot/reporting/archive/optimizecutoffprofloss.py
+++ b/v2realbot/reporting/archive/optimizecutoffprofloss.py
@@ -10,7 +10,7 @@ from enum import Enum
 import numpy as np
 import v2realbot.controller.services as cs
 from rich import print
-from v2realbot.common.model import TradeDirection, TradeStatus, Trade, TradeStoplossType
+from v2realbot.common.PrescribedTradeModel import TradeDirection, TradeStatus, Trade, TradeStoplossType
 from v2realbot.utils.utils import isrising, isfalling,zoneNY, price2dec, safe_get#, print
 from pathlib import Path
 from v2realbot.config import WEB_API_KEY, DATA_DIR, MEDIA_DIRECTORY
--- a/v2realbot/reporting/archive/optimizecutoffv2.py
+++ b/v2realbot/reporting/archive/optimizecutoffv2.py
@@ -10,7 +10,7 @@ from enum import Enum
 import numpy as np
 import v2realbot.controller.services as cs
 from rich import print
-from v2realbot.common.model import TradeDirection, TradeStatus, Trade, TradeStoplossType
+from v2realbot.common.PrescribedTradeModel import TradeDirection, TradeStatus, Trade, TradeStoplossType
 from v2realbot.utils.utils import isrising, isfalling,zoneNY, price2dec, safe_get#, print
 from pathlib import Path
 from v2realbot.config import WEB_API_KEY, DATA_DIR, MEDIA_DIRECTORY
--- a/v2realbot/reporting/load_trades.py
+++ b/v2realbot/reporting/load_trades.py
@@ -11,7 +11,7 @@ import numpy as np
 import v2realbot.controller.services as cs
 from rich import print
 from v2realbot.common.model import AnalyzerInputs
-from v2realbot.common.model import TradeDirection, TradeStatus, Trade, TradeStoplossType
+from v2realbot.common.PrescribedTradeModel import TradeDirection, TradeStatus, Trade, TradeStoplossType
 from v2realbot.utils.utils import isrising, isfalling,zoneNY, price2dec, safe_get#, print
 from pathlib import Path
 from v2realbot.config import WEB_API_KEY, DATA_DIR, MEDIA_DIRECTORY
@@ -23,7 +23,7 @@ from collections import defaultdict
 from scipy.stats import zscore
 from io import BytesIO
 from typing import Tuple, Optional, List
-from v2realbot.common.model import TradeDirection, TradeStatus, Trade, TradeStoplossType
+from v2realbot.common.PrescribedTradeModel import TradeDirection, TradeStatus, Trade, TradeStoplossType

 def load_trades(runner_ids: List = None, batch_id: str = None) -> Tuple[int, List[Trade], int]:
    if runner_ids is None and batch_id is None:
--- a/v2realbot/reporting/metricstoolsimage.py
+++ b/v2realbot/reporting/metricstoolsimage.py
@@ -10,7 +10,7 @@ from enum import Enum
 import numpy as np
 import v2realbot.controller.services as cs
 from rich import print
-from v2realbot.common.model import TradeDirection, TradeStatus, Trade, TradeStoplossType
+from v2realbot.common.PrescribedTradeModel import TradeDirection, TradeStatus, Trade, TradeStoplossType
 from v2realbot.utils.utils import isrising, isfalling,zoneNY, price2dec, safe_get, print
 from pathlib import Path
 from v2realbot.config import WEB_API_KEY, DATA_DIR, MEDIA_DIRECTORY
--- a/v2realbot/scheduler/ap_scheduler.py
+++ b/v2realbot/scheduler/ap_scheduler.py
@@ -4,7 +4,7 @@ from uuid import UUID, uuid4
 from v2realbot.enums.enums import Moddus, SchedulerStatus, RecordType, StartBarAlign, Mode, Account, OrderSide
 from v2realbot.common.model import RunManagerRecord, StrategyInstance, RunDay, StrategyInstance, Runner, RunRequest, RunArchive, RunArchiveView, RunArchiveViewPagination, RunArchiveDetail, RunArchiveChange, Bar, TradeEvent, TestList, Intervals, ConfigItem, InstantIndicator, DataTablesRequest, Market
 from v2realbot.utils.utils import validate_and_format_time, AttributeDict, zoneNY, zonePRG, safe_get, dict_replace_value, Store, parse_toml_string, json_serial, is_open_hours, send_to_telegram, concatenate_weekdays, transform_data
-from v2realbot.common.model import Trade, TradeDirection, TradeStatus, TradeStoplossType
+from v2realbot.common.PrescribedTradeModel import Trade, TradeDirection, TradeStatus, TradeStoplossType
 from datetime import datetime
 from v2realbot.config import JOB_LOG_FILE, STRATVARS_UNCHANGEABLES, ACCOUNT1_PAPER_API_KEY, ACCOUNT1_PAPER_SECRET_KEY, ACCOUNT1_LIVE_API_KEY, ACCOUNT1_LIVE_SECRET_KEY, DATA_DIR, MEDIA_DIRECTORY, RUNNER_DETAIL_DIRECTORY
 import numpy as np
--- a/v2realbot/static/index.html
+++ b/v2realbot/static/index.html
@@ -131,29 +131,9 @@

        <!-- <script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/monaco-editor/0.41.0/min/vs/editor/editor.main.js"></script>  -->
        <!-- <script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/monaco-editor/0.41.0/min/vs/loader.min.js"></script>   -->
-        <script src="/static/js/systeminfo.js"> </script>
    </head>
    <body>
        <div id="main" class="mainConteiner flex-container content">
-            <div id="system-info" class="flex-items"> 
-                <label data-bs-toggle="collapse" data-bs-target="#system-info-inner" aria-expanded="true">
-                    <h4>System Info </h4>
-                </label>
-                <div id="system-info-inner" class="collapse">
-                    <div id="system-info-output"></div>
-                    <div id="graphical-output"> 
-                        <div id="disk-gauge-container">
-                            <span id="title"> Disk Space: </span>
-                            <span id="free-space">Free: -- GB</span> | 
-                            <span id="total-space">Total: -- GB</span> | 
-                            <span id="used-percent">Used: -- %</span>
-                            <div id="disk-gauge">
-                            <div id="disk-gauge-bar"></div>
-                            </div>
-                        </div>
-                    </div>
-                </div>
-            </div>
            <div id="chartContainer" class="flex-items">
                <label data-bs-toggle="collapse" data-bs-target="#chartContainerInner" aria-expanded="true">
                    <h4>Chart</h4>
@@ -235,7 +215,7 @@
                </div>
            </div>
            <div id="hist-trades" class="flex-items">
-                <div id="form-trades">               
+                <div id="form-trades">
                    <label data-bs-toggle="collapse" data-bs-target="#trades-data">
                        <h4>Trade History</h4>
                    </label>
@@ -250,7 +230,6 @@
                        <!-- <table id="trades-data-table" class="dataTable no-footer" style="width: 300px;display: contents;"></table> -->
                </div>
            </div>
-
            <div id="runner-table" class="flex-items">
                <label data-bs-toggle="collapse" data-bs-target="#runner-table-inner">
                    <h4>Running Strategies</h4>
--- a/v2realbot/static/js/archivechart.js
+++ b/v2realbot/static/js/archivechart.js
@@ -11,44 +11,6 @@ var markersLine = null
 var avgBuyLine = null
 var profitLine = null
 var slLine = []
-
-//create function which for each ACCOUNT1, ACCOUNT2 or ACCOUNT3 returns color for buy and color for sell - which can be strings representing color
-//HELPERS FUNCTION - will go to utils
-/**
- * Returns an object containing the colors for buy and sell for the specified account.
- *
- * Parameters:
- *     account (string): The account for which to retrieve the colors (ACCOUNT1, ACCOUNT2, or ACCOUNT3).
- *
- * Returns:
- *     object: An object with 'buy' and 'sell' properties containing the corresponding color strings.
- * 
- * Account 1:
-#FF6B6B, #FF9999
-Account 2:
-#4ECDC4, #83E8E1
-Account 3:
-#FFD93D, #FFE787
-Account 4:
-#6C5CE7, #A29BFE
-Another option for colors:
-
-#1F77B4 (Entry) and #AEC7E8 (Exit)
-#FF7F0E (Entry) and #FFBB78 (Exit)
-#2CA02C (Entry) and #98DF8A (Exit)
-#D62728 (Entry) and #FF9896 (Exit)
-    */
-function getAccountColors(account) {
-    const accountColors = {
-        ACCOUNT1: { accid: 'A1', buy: '#FF7F0E', sell: '#FFBB78' },
-        ACCOUNT2: { accid: 'A2',buy: '#1F77B4', sell: '#AEC7E8' },
-        ACCOUNT3: { accid: 'A3',buy: '#2CA02C', sell: '#98DF8A' },
-        ACCOUNT4: { accid: 'A4',buy: '#D62728', sell: '#FF9896' },
-        ACCOUNT5: { accid: 'A5',buy: 'purple', sell: 'orange' }
-    };
-    return accountColors[account] || { buy: '#37cade', sell: 'red' };
-}  
-
 //TRANSFORM object returned from REST API get_arch_run_detail
 //to series and markers required by lightweigth chart
 //input array object bars = { high: [1,2,3], time: [1,2,3], close: [2,2,2]...}
@@ -72,11 +34,6 @@ function transform_data(data) {
    //cas of first record, nekdy jsou stejny - musim pridat setinku
    prev_cas = 0
    if ((data.ext_data !== null) && (data.ext_data.sl_history)) {
-        ///sort sl_history according to order id string - i need all same order id together
-        data.ext_data.sl_history.sort(function (a, b) {
-            return a.id.localeCompare(b.id);
-          });
-
        data.ext_data.sl_history.forEach((histRecord, index, array) => {
            
            //console.log("plnime")
@@ -91,7 +48,6 @@ function transform_data(data) {
                //init nova sada
                sl_line_sada = []
                sl_line_markers_sada = []
-                sline_color = "#f5aa42"
            }

            prev_id = histRecord.id
@@ -109,21 +65,12 @@ function transform_data(data) {
            sline = {}
            sline["time"] = cas
            sline["value"] = histRecord.sl_val
-            if (histRecord.account) {
-                const accColors = getAccountColors(histRecord.account)
-                sline_color = histRecord.direction == "long" ? accColors.buy : accColors.sell //idealne
-                sline["color"] = sline_color
-            }
-
            sl_line_sada.push(sline)

-            //ZDE JSEM SKONCIL
-            //COLOR SE NASTAVUJE V SERIES OPTIONS POZDEJI - nejak vymyslet
-
            sline_markers = {}
            sline_markers["time"] = cas
            sline_markers["position"] = "inBar" 
-            sline_markers["color"] = sline_color
+            sline_markers["color"] = "#f5aa42"
            //sline_markers["shape"] = "circle"
            //console.log("SHOW_SL_DIGITS",SHOW_SL_DIGITS)
            sline_markers["text"] = SHOW_SL_DIGITS ? histRecord.sl_val.toFixed(3) : ""
@@ -292,33 +239,31 @@ function transform_data(data) {
                // //a_markers["text"] = CHART_SHOW_TEXT ? trade.position_qty + "/" + parseFloat(trade.pos_avg_price).toFixed(3) :trade.position_qty
                // avgp_markers.push(a_markers)
            }
-        }      
-
-        const { accid: accountId,buy: buyColor, sell: sellColor } = getAccountColors(trade.account);
+        }
+        

        //buy sell markery
        marker = {}
        marker["time"] = timestamp;
        // marker["position"] = (trade.order.side == "buy") ? "belowBar" : "aboveBar" 
        marker["position"] = (trade.order.side == "buy") ? "aboveBar" : "aboveBar" 
-        marker["color"] = (trade.order.side == "buy") ? buyColor : sellColor
+        marker["color"] = (trade.order.side == "buy") ? "#37cade" : "red"
        //marker["shape"] = (trade.order.side == "buy") ? "arrowUp" : "arrowDown"
        marker["shape"] = (trade.order.side == "buy") ? "arrowUp" : "arrowDown"
        //marker["text"] =  trade.qty + "/" + trade.price
        qt_optimized = (trade.order.qty % 1000 === 0) ? (trade.order.qty / 1000).toFixed(1) + 'K' : trade.order.qty
  
-        marker["text"] = accountId + " " //account shortcut
        if (CHART_SHOW_TEXT) {
            //včetně qty
            //marker["text"] =  qt_optimized + "@" + trade.price
                
            //bez qty
-            marker["text"] +=  trade.price
+            marker["text"] =  trade.price
            closed_trade_marker_and_profit = (trade.profit) ? "c" + trade.profit.toFixed(1) + "/" + trade.profit_sum.toFixed(1) : "c"
            marker["text"] += (trade.position_qty == 0) ? closed_trade_marker_and_profit : ""
        } else {
            closed_trade_marker_and_profit = (trade.profit) ? "c" + trade.profit.toFixed(1) + "/" + trade.profit_sum.toFixed(1) : "c"
-            marker["text"] += (trade.position_qty == 0) ? closed_trade_marker_and_profit : trade.price.toFixed(3)
+            marker["text"] = (trade.position_qty == 0) ? closed_trade_marker_and_profit : trade.price.toFixed(3)
        }

        markers.push(marker)
@@ -899,7 +844,7 @@ function display_buy_markers(data) {
        //console.log("uvnitr")
        slLine_temp = chart.addLineSeries({
            //    title: "avgpbuyline",
-                color: slRecord[0]["color"] ? slRecord[0]["color"] : '#e4c76d',
+                color: '#e4c76d',
            //    color: 'transparent',
                lineWidth: 1,
                lastValueVisible: false
--- a/v2realbot/static/js/systeminfo.js
+++ b/v2realbot/static/js/systeminfo.js
@@ -1,31 +0,0 @@
-    function get_system_info() {
-        console.log('Button get system status clicked')
-        $.ajax({
-            url: '/system-info',
-            type: 'GET',
-            beforeSend: function (xhr) {
-                xhr.setRequestHeader('X-API-Key',
-                API_KEY); },
-            success: function(response) {
-                $.each(response, function(index, item) {
-                    if (index=="disk_space") {
-                        $('#disk-gauge-bar').css('width', response.disk_space.used_percentage + '%');
-                        $('#free-space').text('Free: ' + response.disk_space.free + ' GB');
-                        $('#total-space').text('Total: ' + response.disk_space.total + ' GB');
-                        $('#used-percent').text('Used: ' + response.disk_space.used_percentage + '%');
-                    } else {
-                        var formatted_item = JSON.stringify(item, null, 4)
-                        $('#system-info-output').append('<p>' + index + ': ' + formatted_item + '</p>');
-                    }
-                });            
-            },
-            error: function(xhr, status, error) {
-                $('#disk-gauge-bar').html('An error occurred: ' + error + xhr.responseText + status);
-            }
-        });
-    }
-
-
-$(document).ready(function(){
-  get_system_info()
-});
--- a/v2realbot/static/js/tables/archivetable/init.js
+++ b/v2realbot/static/js/tables/archivetable/init.js
@@ -172,7 +172,7 @@ function initialize_archiveRecords() {
                    {
                        targets: [13,14,15],
                        render: function ( data, type, row ) {
-                            return '<div class="tdsmall">'+JSON.stringify(data, null, 2)+'</div>'
+                            return '<div class="tdsmall">'+data+'</div>'
                        },
                    },
                    {
--- a/v2realbot/static/js/vbt/.html
+++ b/v2realbot/static/js/vbt/.html
--- a/v2realbot/static/js/vbt/api/_opt_deps/index.html
+++ b/v2realbot/static/js/vbt/api/_opt_deps/index.html
--- a/v2realbot/static/js/vbt/api/_settings/index.html
+++ b/v2realbot/static/js/vbt/api/_settings/index.html
--- a/v2realbot/static/js/vbt/api/accessors/index.html
+++ b/v2realbot/static/js/vbt/api/accessors/index.html
--- a/v2realbot/static/js/vbt/api/base/accessors/index.html
+++ b/v2realbot/static/js/vbt/api/base/accessors/index.html
--- a/v2realbot/static/js/vbt/api/base/chunking/index.html
+++ b/v2realbot/static/js/vbt/api/base/chunking/index.html
--- a/v2realbot/static/js/vbt/api/base/combining/index.html
+++ b/v2realbot/static/js/vbt/api/base/combining/index.html
--- a/v2realbot/static/js/vbt/api/base/decorators/index.html
+++ b/v2realbot/static/js/vbt/api/base/decorators/index.html
--- a/v2realbot/static/js/vbt/api/base/flex_indexing/index.html
+++ b/v2realbot/static/js/vbt/api/base/flex_indexing/index.html
--- a/v2realbot/static/js/vbt/api/base/grouping/base/index.html
+++ b/v2realbot/static/js/vbt/api/base/grouping/base/index.html
--- a/v2realbot/static/js/vbt/api/base/grouping/index.html
+++ b/v2realbot/static/js/vbt/api/base/grouping/index.html
--- a/v2realbot/static/js/vbt/api/base/grouping/nb/index.html
+++ b/v2realbot/static/js/vbt/api/base/grouping/nb/index.html
--- a/v2realbot/static/js/vbt/api/base/index.html
+++ b/v2realbot/static/js/vbt/api/base/index.html
--- a/v2realbot/static/js/vbt/api/base/indexes/index.html
+++ b/v2realbot/static/js/vbt/api/base/indexes/index.html
--- a/v2realbot/static/js/vbt/api/base/indexing/index.html
+++ b/v2realbot/static/js/vbt/api/base/indexing/index.html
--- a/v2realbot/static/js/vbt/api/base/merging/index.html
+++ b/v2realbot/static/js/vbt/api/base/merging/index.html
--- a/v2realbot/static/js/vbt/api/base/preparing/index.html
+++ b/v2realbot/static/js/vbt/api/base/preparing/index.html
--- a/v2realbot/static/js/vbt/api/base/resampling/base/index.html
+++ b/v2realbot/static/js/vbt/api/base/resampling/base/index.html
--- a/v2realbot/static/js/vbt/api/base/resampling/index.html
+++ b/v2realbot/static/js/vbt/api/base/resampling/index.html
--- a/v2realbot/static/js/vbt/api/base/resampling/nb/index.html
+++ b/v2realbot/static/js/vbt/api/base/resampling/nb/index.html
--- a/v2realbot/static/js/vbt/api/base/reshaping/index.html
+++ b/v2realbot/static/js/vbt/api/base/reshaping/index.html
--- a/v2realbot/static/js/vbt/api/base/wrapping/index.html
+++ b/v2realbot/static/js/vbt/api/base/wrapping/index.html
--- a/v2realbot/static/js/vbt/api/data/base/index.html
+++ b/v2realbot/static/js/vbt/api/data/base/index.html
--- a/v2realbot/static/js/vbt/api/data/custom/alpaca/index.html
+++ b/v2realbot/static/js/vbt/api/data/custom/alpaca/index.html
--- a/v2realbot/static/js/vbt/api/data/custom/av/index.html
+++ b/v2realbot/static/js/vbt/api/data/custom/av/index.html
--- a/v2realbot/static/js/vbt/api/data/custom/bento/index.html
+++ b/v2realbot/static/js/vbt/api/data/custom/bento/index.html
--- a/v2realbot/static/js/vbt/api/data/custom/binance/index.html
+++ b/v2realbot/static/js/vbt/api/data/custom/binance/index.html
--- a/v2realbot/static/js/vbt/api/data/custom/ccxt/index.html
+++ b/v2realbot/static/js/vbt/api/data/custom/ccxt/index.html
--- a/v2realbot/static/js/vbt/api/data/custom/csv/index.html
+++ b/v2realbot/static/js/vbt/api/data/custom/csv/index.html
--- a/v2realbot/static/js/vbt/api/data/custom/custom/index.html
+++ b/v2realbot/static/js/vbt/api/data/custom/custom/index.html
--- a/v2realbot/static/js/vbt/api/data/custom/db/index.html
+++ b/v2realbot/static/js/vbt/api/data/custom/db/index.html
--- a/v2realbot/static/js/vbt/api/data/custom/duckdb/index.html
+++ b/v2realbot/static/js/vbt/api/data/custom/duckdb/index.html
--- a/v2realbot/static/js/vbt/api/data/custom/feather/index.html
+++ b/v2realbot/static/js/vbt/api/data/custom/feather/index.html
--- a/v2realbot/static/js/vbt/api/data/custom/file/index.html
+++ b/v2realbot/static/js/vbt/api/data/custom/file/index.html
--- a/v2realbot/static/js/vbt/api/data/custom/gbm/index.html
+++ b/v2realbot/static/js/vbt/api/data/custom/gbm/index.html
--- a/v2realbot/static/js/vbt/api/data/custom/gbm_ohlc/index.html
+++ b/v2realbot/static/js/vbt/api/data/custom/gbm_ohlc/index.html
--- a/v2realbot/static/js/vbt/api/data/custom/hdf/index.html
+++ b/v2realbot/static/js/vbt/api/data/custom/hdf/index.html
--- a/v2realbot/static/js/vbt/api/data/custom/index.html
+++ b/v2realbot/static/js/vbt/api/data/custom/index.html
--- a/v2realbot/static/js/vbt/api/data/custom/local/index.html
+++ b/v2realbot/static/js/vbt/api/data/custom/local/index.html
--- a/v2realbot/static/js/vbt/api/data/custom/ndl/index.html
+++ b/v2realbot/static/js/vbt/api/data/custom/ndl/index.html
--- a/v2realbot/static/js/vbt/api/data/custom/parquet/index.html
+++ b/v2realbot/static/js/vbt/api/data/custom/parquet/index.html
--- a/v2realbot/static/js/vbt/api/data/custom/polygon/index.html
+++ b/v2realbot/static/js/vbt/api/data/custom/polygon/index.html
--- a/v2realbot/static/js/vbt/api/data/custom/random/index.html
+++ b/v2realbot/static/js/vbt/api/data/custom/random/index.html
--- a/v2realbot/static/js/vbt/api/data/custom/random_ohlc/index.html
+++ b/v2realbot/static/js/vbt/api/data/custom/random_ohlc/index.html
--- a/v2realbot/static/js/vbt/api/data/custom/remote/index.html
+++ b/v2realbot/static/js/vbt/api/data/custom/remote/index.html
--- a/v2realbot/static/js/vbt/api/data/custom/sql/index.html
+++ b/v2realbot/static/js/vbt/api/data/custom/sql/index.html
--- a/v2realbot/static/js/vbt/api/data/custom/synthetic/index.html
+++ b/v2realbot/static/js/vbt/api/data/custom/synthetic/index.html
--- a/v2realbot/static/js/vbt/api/data/custom/tv/index.html
+++ b/v2realbot/static/js/vbt/api/data/custom/tv/index.html
--- a/v2realbot/static/js/vbt/api/data/custom/yf/index.html
+++ b/v2realbot/static/js/vbt/api/data/custom/yf/index.html
--- a/v2realbot/static/js/vbt/api/data/decorators/index.html
+++ b/v2realbot/static/js/vbt/api/data/decorators/index.html
--- a/v2realbot/static/js/vbt/api/data/index.html
+++ b/v2realbot/static/js/vbt/api/data/index.html
--- a/v2realbot/static/js/vbt/api/data/nb/index.html
+++ b/v2realbot/static/js/vbt/api/data/nb/index.html
--- a/v2realbot/static/js/vbt/api/data/saver/index.html
+++ b/v2realbot/static/js/vbt/api/data/saver/index.html
--- a/v2realbot/static/js/vbt/api/data/updater/index.html
+++ b/v2realbot/static/js/vbt/api/data/updater/index.html
--- a/v2realbot/static/js/vbt/api/generic/accessors/index.html
+++ b/v2realbot/static/js/vbt/api/generic/accessors/index.html
--- a/v2realbot/static/js/vbt/api/generic/analyzable/index.html
+++ b/v2realbot/static/js/vbt/api/generic/analyzable/index.html
--- a/v2realbot/static/js/vbt/api/generic/decorators/index.html
+++ b/v2realbot/static/js/vbt/api/generic/decorators/index.html
--- a/v2realbot/static/js/vbt/api/generic/drawdowns/index.html
+++ b/v2realbot/static/js/vbt/api/generic/drawdowns/index.html
--- a/v2realbot/static/js/vbt/api/generic/enums/index.html
+++ b/v2realbot/static/js/vbt/api/generic/enums/index.html
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
David Brazda	671bc20586	new version vbt	2024-06-20 22:13:43 +02:00
David Brazda	1f85b271db	init fixes2 (#209 )	2024-06-13 11:52:14 +02:00
David Brazda	cc27d6f69f	fix module inits (#208 ) * research added * fix module inits	2024-06-13 11:47:05 +02:00
David Brazda	78f2162d59	research added (#207 )	2024-06-13 11:02:41 +02:00
David Brazda	7ec1f9c8b9	Create testdoc.md (#204 )	2024-06-04 14:07:44 +02:00
David Brazda	1659cc7a6e	static site pwd protected, load dotenv moved to config, aggregator vecotrized chng (#203 )	2024-06-04 12:49:32 +02:00
David Brazda	05b7725a25	vectorized aggregator, minor changes (#198 )	2024-05-17 14:09:42 +02:00
pvlasak	3de7d23009	Feature/dotenv (#195 ) * load_dotenv from python-dotenv library imported * WEB_API_KEY is read as virtual environment variable specified in .env file * env file referenced by variable imported from config.py * env file directory and env file variables defined * bash script to create env file * Delete env_migration.sh --------- Co-authored-by: David Brazda <davidbrazda61@gmail.com>	2024-05-09 12:47:32 +02:00
David Brazda	9e7d974ebd	sitemap added (#194 )	2024-04-28 18:56:36 +02:00
David Brazda	66a4cb5d7c	update of vbt doc	2024-04-25 06:24:51 +02:00
David Brazda	0bf9aadb0c	fix	2024-04-17 13:04:57 +02:00
pvlasak	81ca678f55	Feature/market attribute (#185 ) * RunManagerRecord class has a new attribute market. Market enum is imported. * row_to_runmanager function considers market column * add_run_manager_record and update_run_manager_record functions are changed. fetch_all_markets_in_run_manager is new. * new Market enumeration class is defined * market_value used for job scheduling. start and stop functions have modifications of market parameter input * new is_market_day function + modifications of get_todays_market_times function * market attribute set default to US * row_to_runmanager function has no string formatter for market attribute * add_run_manager_record function adn update_run_manager_record function update the DB column market based on record.market data * start_runman_record and stop_runman_record have got no market parameter * get_todays_market_times function is changed * default value for market atribute is Market.US * update_run_manager_record function has no if condition for market key * market_value deleted, used enumaration value Market.US instead of string US * get_todays_market_times has a new if condition for Market.CRYPTO * update includes market column in the run_manager table * market attribute in Run Manager record has value given by enumeration as Market.US * documentation of changes made in the branch * remove README_feature_market.md * back to original state * Delete README_feature_market.md * _start_runman_record has an additional else condition * is_market_day renamed to is_US_market_day * transferables column added into runner_header table	2024-04-17 12:14:01 +02:00
David Brazda	96c7f7207f	vectorbtdoc	2024-04-16 15:53:51 +02:00
David Brazda	26b72763da	bugfix (#181 )	2024-03-18 18:42:09 +01:00
David Brazda	adc7c3c1b6	hard stop / soft stop for cutoff (#177 ) martingale base (#178 )	2024-03-15 13:36:28 +01:00
David Brazda	a6343abe88	highlight logs on gui (#176 )	2024-03-15 11:06:18 +01:00
David Brazda	075984fcff	archrunner db query searches for symbol, name (#175 )	2024-03-15 10:04:46 +01:00
David Brazda	5fce627fe3	toml validation to frontend (#174 )	2024-03-14 17:39:52 +01:00
David Brazda	8de1356aa8	#163 transferables (#172 )	2024-03-14 14:16:01 +01:00
David Brazda	7f47890cad	#168 #166 and additional fixes (#169 )	2024-03-13 12:31:06 +01:00
David Brazda	8cf1aea2a8	run updte	2024-03-07 14:07:46 +01:00
David Brazda	9231c1d273	bugfix - kontrolu na maxloss provadime az u eventy FILL, kdy je znama celkova castka	2024-03-06 15:50:16 +01:00
David Brazda	9391d89aab	#148 #158 config refactoring to support profiles/reloading (#165 )	2024-03-06 14:30:24 +01:00
David Brazda	9cff5fe6a1	#155 + presun row_to from db.py to transform.py	2024-03-06 13:31:09 +01:00
David Brazda	0e5cf5f3e0	Merge pull request #161 from drew2323/local Minor changes for installation on windows	2024-03-04 17:03:50 +01:00
David Brazda	90c33c0528	Delete run.sh	2024-03-04 17:01:47 +01:00
Petr Vlasak	e9e6534d2b	primary live account api and secret changed	2024-03-04 16:57:10 +01:00
Petr Vlasak	5874528d23	line 29 has deleted integrity and crossorigin value	2024-02-28 08:08:21 +01:00
Petr Vlasak	985445d814	user_data_dir function has a second parameter author, ACCOUNT1_LIVE has still PAPER_API_KEY and SECRET_KEY	2024-02-28 08:04:02 +01:00
Petr Vlasak	6c1f7f0e2e	changed VIRTUAL_ENV_DIR and PYTHON_TO_USE	2024-02-27 18:15:35 +01:00
David Brazda	20aaa2ac23	#135 -> BT same period button	2024-02-27 12:03:57 +07:00
David Brazda	691514b102	all dates in gui are in market time zone (even start/stop)	2024-02-27 10:53:30 +07:00
David Brazda	84903aff77	batchprofit/batchcount columns hidden from archiverunners gui	2024-02-27 08:15:07 +07:00
David Brazda	4887e32665	#149	2024-02-26 22:42:03 +07:00
David Brazda	ce99448a48	moved config related services into separated package	2024-02-26 19:35:19 +07:00
David Brazda	887ea0ef00	#147	2024-02-26 11:30:13 +07:00
David Brazda	af7b678699	zpet debug podminka	2024-02-24 21:23:17 +07:00
David Brazda	04c63df045	docasny disable pro testing	2024-02-24 21:17:10 +07:00
David Brazda	ebac207489	#143	2024-02-24 20:32:01 +07:00
David Brazda	9f99ddc86a	live_data_feed stored in runner_archive	2024-02-23 21:20:07 +07:00
David Brazda	e75fbc7194	bugfix	2024-02-23 21:04:23 +07:00
David Brazda	c4d05f47ff	#139 konfigurace LIVE_DATA_FEED	2024-02-23 12:35:02 +07:00
David Brazda	f6e31f45f9	#136 bugfix properly closing ws	2024-02-23 10:30:12 +07:00
David Brazda	c42b1c4e1e	fix	2024-02-22 23:23:20 +07:00
David Brazda	1bf11d0dc4	fix	2024-02-22 23:20:54 +07:00
David Brazda	1abbb07390	Scheduler support #24sched	2024-02-22 23:05:49 +07:00
David Brazda	b58639454b	unknown symbol msg	2024-02-12 10:45:23 +07:00
David Brazda	a7e83fe051	bugfix create batch image (check for None from Alpaca)	2024-02-11 15:26:15 +07:00
David Brazda	6795338eba	createbatch image tool + send to telefram enrichment	2024-02-11 12:37:19 +07:00
David Brazda	9aa8b58877	updatnute requirements.txt	2024-02-10 21:35:53 +07:00
David Brazda	eff78e8157	keys to env variables, optimalizations	2024-02-10 21:02:00 +07:00
David Brazda	d8bcc4bb8f	Merge branch 'master' of https://github.com/drew2323/v2trading	2024-02-06 11:16:58 +07:00
David Brazda	7abdf47545	ok	2024-02-06 11:16:09 +07:00
David Brazda	1f8afef042	calendar wrapper with retry, histo bars with retry	2024-02-06 11:14:38 +07:00
David Brazda	df60d16eb4	Update README.md	2024-02-06 09:52:53 +07:00
David Brazda	535c2824b0	Update README.md	2024-02-06 09:34:33 +07:00
David Brazda	9cf936672d	Update README.md	2024-02-06 09:30:56 +07:00
David Brazda	c1ad713a12	bugfix None in trade response	2024-02-05 10:22:20 +07:00
David Brazda	e9bb8b84ec	fixes	2024-02-04 17:55:43 +07:00
David Brazda	603736d441	Merge branch 'master' of https://github.com/drew2323/v2trading	2024-02-04 17:54:09 +07:00
David Brazda	2c968691d1	Update README.md	2024-01-31 13:39:33 +07:00
David Brazda	435b4d899a	Create README.md	2024-01-31 13:37:45 +07:00