instruction stringlengths 0 1k | input stringlengths 1 1k | output stringlengths 10 6.51k |
|---|---|---|
import reflex as rx
from stock_market_dashboard.components.line_chart import trading_line_chart
from stock_market_dashboard.components.main_header import main_header
from stock_market_dashboard.components.options_table import options_table
|
from stock_market_dashboard.components.positions_table import positions_table
from stock_market_dashboard.states.trading_state import TradingState
def index() -> rx.Component:
"""The main page component for the trading dashboard."""
return rx.el.div(
main_header(),
rx.el.main(
trading_line_chart(),
options_table(),
orders_table(),
positions_table(),
class_name="grid grid-cols-1 lg:grid-cols-3 gap-4 p-4",
),
class_name="min-h-screen bg-gray-900 text-gray-300 font-sans",
on_mount=TradingState.start_simulation,
)
app = rx.App(
theme=rx.theme(appearance="light"),
stylesheets=["/styles.css"],
)
app.add_page(index, route="/")
| from stock_market_dashboard.components.orders_table import orders_table |
import reflex as rx
from stock_market_dashboard.components.line_chart import trading_line_chart
from stock_market_dashboard.components.main_header import main_header
from stock_market_dashboard.components.options_table import options_table
from stock_market_dashboard.components.orders_table import orders_table
|
from stock_market_dashboard.states.trading_state import TradingState
def index() -> rx.Component:
"""The main page component for the trading dashboard."""
return rx.el.div(
main_header(),
rx.el.main(
trading_line_chart(),
options_table(),
orders_table(),
positions_table(),
class_name="grid grid-cols-1 lg:grid-cols-3 gap-4 p-4",
),
class_name="min-h-screen bg-gray-900 text-gray-300 font-sans",
on_mount=TradingState.start_simulation,
)
app = rx.App(
theme=rx.theme(appearance="light"),
stylesheets=["/styles.css"],
)
app.add_page(index, route="/")
| from stock_market_dashboard.components.positions_table import positions_table |
import reflex as rx
from stock_market_dashboard.components.line_chart import trading_line_chart
from stock_market_dashboard.components.main_header import main_header
from stock_market_dashboard.components.options_table import options_table
from stock_market_dashboard.components.orders_table import orders_table
from stock_market_dashboard.components.positions_table import positions_table
|
def index() -> rx.Component:
"""The main page component for the trading dashboard."""
return rx.el.div(
main_header(),
rx.el.main(
trading_line_chart(),
options_table(),
orders_table(),
positions_table(),
class_name="grid grid-cols-1 lg:grid-cols-3 gap-4 p-4",
),
class_name="min-h-screen bg-gray-900 text-gray-300 font-sans",
on_mount=TradingState.start_simulation,
)
app = rx.App(
theme=rx.theme(appearance="light"),
stylesheets=["/styles.css"],
)
app.add_page(index, route="/")
| from stock_market_dashboard.states.trading_state import TradingState |
import reflex as rx
from stock_market_dashboard.components.line_chart import trading_line_chart
from stock_market_dashboard.components.main_header import main_header
from stock_market_dashboard.components.options_table import options_table
from stock_market_dashboard.components.orders_table import orders_table
from stock_market_dashboard.components.positions_table import positions_table
from stock_market_dashboard.states.trading_state import TradingState
def index() -> rx.Component:
"""The main page component for the trading dashboard."""
return rx.el.div(
main_header(),
rx.el.main(
trading_line_chart(),
options_table(),
orders_table(),
positions_table(),
class_name="grid grid-cols-1 lg:grid-cols-3 gap-4 p-4",
),
class_name="min-h-screen bg-gray-900 text-gray-300 font-sans",
on_mount=TradingState.start_simulation,
)
|
app.add_page(index, route="/")
| app = rx.App(
theme=rx.theme(appearance="light"),
stylesheets=["/styles.css"],
) |
from stock_market_dashboard.components.tooltip_props import TOOLTIP_PROPS
from stock_market_dashboard.states.trading_state import StockInfo, TradingState
def stock_info_header(stock: StockInfo) -> rx.Component:
return rx.el.div(
rx.el.div(
rx.el.h2(
stock["symbol"],
class_name="text-xl font-bold text-white",
),
rx.el.span(
stock["price"].to_string(),
class_name="text-xl font-semibold text-white mr-2",
),
rx.el.span(
stock["change"].to_string(),
class_name=rx.cond(
stock["change"] >= 0,
"text-green-400",
"text-red-400",
),
),
rx.el.span(
stock["change_percent"].to_string(),
class_name=rx.cond(
stock["change"] >= 0,
"text-green-400 text-sm ml-1",
| import reflex as rx | |
import reflex as rx
|
from stock_market_dashboard.states.trading_state import StockInfo, TradingState
def stock_info_header(stock: StockInfo) -> rx.Component:
return rx.el.div(
rx.el.div(
rx.el.h2(
stock["symbol"],
class_name="text-xl font-bold text-white",
),
rx.el.span(
stock["price"].to_string(),
class_name="text-xl font-semibold text-white mr-2",
),
rx.el.span(
stock["change"].to_string(),
class_name=rx.cond(
stock["change"] >= 0,
"text-green-400",
"text-red-400",
),
),
rx.el.span(
stock["change_percent"].to_string(),
class_name=rx.cond(
stock["change"] >= 0,
"text-green-400 text-sm ml-1",
"text-red-400 text-sm ml-1",
),
| from stock_market_dashboard.components.tooltip_props import TOOLTIP_PROPS |
import reflex as rx
from stock_market_dashboard.components.tooltip_props import TOOLTIP_PROPS
|
def stock_info_header(stock: StockInfo) -> rx.Component:
return rx.el.div(
rx.el.div(
rx.el.h2(
stock["symbol"],
class_name="text-xl font-bold text-white",
),
rx.el.span(
stock["price"].to_string(),
class_name="text-xl font-semibold text-white mr-2",
),
rx.el.span(
stock["change"].to_string(),
class_name=rx.cond(
stock["change"] >= 0,
"text-green-400",
"text-red-400",
),
),
rx.el.span(
stock["change_percent"].to_string(),
class_name=rx.cond(
stock["change"] >= 0,
"text-green-400 text-sm ml-1",
"text-red-400 text-sm ml-1",
),
),
class_name="flex items-baseline gap-2",
),
rx.e | from stock_market_dashboard.states.trading_state import StockInfo, TradingState |
center mt-1",
),
class_name="mb-3",
)
def chart_controls() -> rx.Component:
return rx.el.div(
rx.el.div(
rx.foreach(
["1D", "1W", "1M", "3M", "1Y", "5Y", "All"],
lambda item: rx.el.button(
item,
class_name="text-xs text-gray-400 hover:text-white px-2 py-1 rounded hover:bg-gray-700",
),
),
class_name="flex space-x-1",
),
rx.el.div(
rx.el.span(
"Interval: 1h",
class_name="text-xs text-gray-400 mr-3",
),
rx.el.button(
"Auto-scale",
class_name="text-xs text-gray-400 hover:text-white px-2 py-1 rounded hover:bg-gray-700",
),
class_name="flex items-center",
),
class_name="flex justify-between items-center mt-2 px-2 max-md:hidden",
)
def trading_line_chart() -> rx.Component:
|
max_price = rx.Var.create(
f"Math.max(...{TradingState.chart_data.to_string()}.map(p => p.price))"
).to(int)
padding = (max_price - min_price) * 0.1
y_domain = rx.Var.create(f"[{min_price} - {padding}, {max_price} + {padding}]")
return rx.el.div(
stock_info_header(TradingState.stock_info),
rx.recharts.line_chart(
rx.recharts.cartesian_grid(
stroke_dasharray="3 3",
stroke="#4b5563",
horizontal=True,
vertical=False,
),
rx.recharts.graphing_tooltip(**TOOLTIP_PROPS),
rx.recharts.line(
data_key="price",
stroke="#22c55e",
dot=False,
type_="monotone",
stroke_width=2,
is_animation_active=False,
),
rx.recharts.x_axis(
data_key="time",
axis_line=False,
tick_line=False,
| min_price = rx.Var.create(
f"Math.min(...{TradingState.chart_data.to_string()}.map(p => p.price))"
).to(int) |
rx.el.div(
rx.foreach(
["1D", "1W", "1M", "3M", "1Y", "5Y", "All"],
lambda item: rx.el.button(
item,
class_name="text-xs text-gray-400 hover:text-white px-2 py-1 rounded hover:bg-gray-700",
),
),
class_name="flex space-x-1",
),
rx.el.div(
rx.el.span(
"Interval: 1h",
class_name="text-xs text-gray-400 mr-3",
),
rx.el.button(
"Auto-scale",
class_name="text-xs text-gray-400 hover:text-white px-2 py-1 rounded hover:bg-gray-700",
),
class_name="flex items-center",
),
class_name="flex justify-between items-center mt-2 px-2 max-md:hidden",
)
def trading_line_chart() -> rx.Component:
min_price = rx.Var.create(
f"Math.min(...{TradingState.chart_data.to_string()}.map(p => p.price))"
).to(int)
|
padding = (max_price - min_price) * 0.1
y_domain = rx.Var.create(f"[{min_price} - {padding}, {max_price} + {padding}]")
return rx.el.div(
stock_info_header(TradingState.stock_info),
rx.recharts.line_chart(
rx.recharts.cartesian_grid(
stroke_dasharray="3 3",
stroke="#4b5563",
horizontal=True,
vertical=False,
),
rx.recharts.graphing_tooltip(**TOOLTIP_PROPS),
rx.recharts.line(
data_key="price",
stroke="#22c55e",
dot=False,
type_="monotone",
stroke_width=2,
is_animation_active=False,
),
rx.recharts.x_axis(
data_key="time",
axis_line=False,
tick_line=False,
stroke="#9ca3af",
tick_size=10,
tick_count=6,
interval="preserveStar | max_price = rx.Var.create(
f"Math.max(...{TradingState.chart_data.to_string()}.map(p => p.price))"
).to(int) |
m: rx.el.button(
item,
class_name="text-xs text-gray-400 hover:text-white px-2 py-1 rounded hover:bg-gray-700",
),
),
class_name="flex space-x-1",
),
rx.el.div(
rx.el.span(
"Interval: 1h",
class_name="text-xs text-gray-400 mr-3",
),
rx.el.button(
"Auto-scale",
class_name="text-xs text-gray-400 hover:text-white px-2 py-1 rounded hover:bg-gray-700",
),
class_name="flex items-center",
),
class_name="flex justify-between items-center mt-2 px-2 max-md:hidden",
)
def trading_line_chart() -> rx.Component:
min_price = rx.Var.create(
f"Math.min(...{TradingState.chart_data.to_string()}.map(p => p.price))"
).to(int)
max_price = rx.Var.create(
f"Math.max(...{TradingState.chart_data.to_string()}.map(p => p.price))"
).to(int)
|
y_domain = rx.Var.create(f"[{min_price} - {padding}, {max_price} + {padding}]")
return rx.el.div(
stock_info_header(TradingState.stock_info),
rx.recharts.line_chart(
rx.recharts.cartesian_grid(
stroke_dasharray="3 3",
stroke="#4b5563",
horizontal=True,
vertical=False,
),
rx.recharts.graphing_tooltip(**TOOLTIP_PROPS),
rx.recharts.line(
data_key="price",
stroke="#22c55e",
dot=False,
type_="monotone",
stroke_width=2,
is_animation_active=False,
),
rx.recharts.x_axis(
data_key="time",
axis_line=False,
tick_line=False,
stroke="#9ca3af",
tick_size=10,
tick_count=6,
interval="preserveStartEnd",
padding={"left": 10, | padding = (max_price - min_price) * 0.1 |
class_name="text-xs text-gray-400 hover:text-white px-2 py-1 rounded hover:bg-gray-700",
),
),
class_name="flex space-x-1",
),
rx.el.div(
rx.el.span(
"Interval: 1h",
class_name="text-xs text-gray-400 mr-3",
),
rx.el.button(
"Auto-scale",
class_name="text-xs text-gray-400 hover:text-white px-2 py-1 rounded hover:bg-gray-700",
),
class_name="flex items-center",
),
class_name="flex justify-between items-center mt-2 px-2 max-md:hidden",
)
def trading_line_chart() -> rx.Component:
min_price = rx.Var.create(
f"Math.min(...{TradingState.chart_data.to_string()}.map(p => p.price))"
).to(int)
max_price = rx.Var.create(
f"Math.max(...{TradingState.chart_data.to_string()}.map(p => p.price))"
).to(int)
padding = (max_price - min_price) * 0.1
|
return rx.el.div(
stock_info_header(TradingState.stock_info),
rx.recharts.line_chart(
rx.recharts.cartesian_grid(
stroke_dasharray="3 3",
stroke="#4b5563",
horizontal=True,
vertical=False,
),
rx.recharts.graphing_tooltip(**TOOLTIP_PROPS),
rx.recharts.line(
data_key="price",
stroke="#22c55e",
dot=False,
type_="monotone",
stroke_width=2,
is_animation_active=False,
),
rx.recharts.x_axis(
data_key="time",
axis_line=False,
tick_line=False,
stroke="#9ca3af",
tick_size=10,
tick_count=6,
interval="preserveStartEnd",
padding={"left": 10, "right": 10},
custom_attrs={"fontSize": "10px"},
),
| y_domain = rx.Var.create(f"[{min_price} - {padding}, {max_price} + {padding}]") |
from stock_market_dashboard.states.trading_state import TradingState
def main_header() -> rx.Component:
tabs = [
"Options trading",
"Market tracker",
"Positions analysis",
]
return rx.el.header(
rx.el.div(
# Tab group (wraps + scrolls on small screens)
rx.el.div(
rx.el.img(
src="/favicon.ico",
class_name="h-6 w-6 mr-4 flex-shrink-0 max-md:hidden",
),
rx.foreach(
tabs,
lambda tab: rx.el.button(
tab,
on_click=TradingState.set_active_main_tab(tab),
class_name=rx.cond(
TradingState.active_main_tab == tab,
"px-1 py-2 text-sm font-medium text-white border-b-2 border-green-500",
"px-1 py-2 text-sm font-medium text-gray-400 hover:text-white hov | import reflex as rx | |
import reflex as rx
|
def main_header() -> rx.Component:
tabs = [
"Options trading",
"Market tracker",
"Positions analysis",
]
return rx.el.header(
rx.el.div(
# Tab group (wraps + scrolls on small screens)
rx.el.div(
rx.el.img(
src="/favicon.ico",
class_name="h-6 w-6 mr-4 flex-shrink-0 max-md:hidden",
),
rx.foreach(
tabs,
lambda tab: rx.el.button(
tab,
on_click=TradingState.set_active_main_tab(tab),
class_name=rx.cond(
TradingState.active_main_tab == tab,
"px-1 py-2 text-sm font-medium text-white border-b-2 border-green-500",
"px-1 py-2 text-sm font-medium text-gray-400 hover:text-white hover:border-b-2 hover:border-gray-500",
),
| from stock_market_dashboard.states.trading_state import TradingState |
import reflex as rx
from stock_market_dashboard.states.trading_state import TradingState
def main_header() -> rx.Component:
|
return rx.el.header(
rx.el.div(
# Tab group (wraps + scrolls on small screens)
rx.el.div(
rx.el.img(
src="/favicon.ico",
class_name="h-6 w-6 mr-4 flex-shrink-0 max-md:hidden",
),
rx.foreach(
tabs,
lambda tab: rx.el.button(
tab,
on_click=TradingState.set_active_main_tab(tab),
class_name=rx.cond(
TradingState.active_main_tab == tab,
"px-1 py-2 text-sm font-medium text-white border-b-2 border-green-500",
"px-1 py-2 text-sm font-medium text-gray-400 hover:text-white hover:border-b-2 hover:border-gray-500",
),
),
),
class_name="flex flex-wrap items-center space-x-1 overflow-x-auto whitespace-nowrap py | tabs = [
"Options trading",
"Market tracker",
"Positions analysis",
] |
from stock_market_dashboard.states.trading_state import TradingState
def options_header(
stock_symbol: str,
price: rx.Var[float],
change: rx.Var[float],
change_percent: rx.Var[float],
) -> rx.Component:
return rx.el.div(
rx.el.span(
f"{stock_symbol}",
class_name="text-sm font-bold text-white mr-2",
),
rx.el.span(
price.to_string(),
class_name="text-sm font-semibold text-white mr-1",
),
rx.el.span(
change.to_string(),
class_name=rx.cond(
change >= 0,
"text-green-400 text-xs",
"text-red-400 text-xs",
),
),
rx.el.span(
change_percent.to_string(),
class_name=rx.cond(
change >= 0,
"text-green-400 text-xs ml-1",
"text-red-400 text-xs ml-1",
),
),
class_name="mb-2 px-2",
)
def opt | import reflex as rx | |
import reflex as rx
|
def options_header(
stock_symbol: str,
price: rx.Var[float],
change: rx.Var[float],
change_percent: rx.Var[float],
) -> rx.Component:
return rx.el.div(
rx.el.span(
f"{stock_symbol}",
class_name="text-sm font-bold text-white mr-2",
),
rx.el.span(
price.to_string(),
class_name="text-sm font-semibold text-white mr-1",
),
rx.el.span(
change.to_string(),
class_name=rx.cond(
change >= 0,
"text-green-400 text-xs",
"text-red-400 text-xs",
),
),
rx.el.span(
change_percent.to_string(),
class_name=rx.cond(
change >= 0,
"text-green-400 text-xs ml-1",
"text-red-400 text-xs ml-1",
),
),
class_name="mb-2 px-2",
)
def options_sub_tabs() -> rx.Component:
tabs = [
"4D Fri Oct 18", | from stock_market_dashboard.states.trading_state import TradingState |
import reflex as rx
from stock_market_dashboard.states.trading_state import TradingState
|
def options_sub_tabs() -> rx.Component:
tabs = [
"4D Fri Oct 18",
"11D Fri Oct 25",
"18D Fri Nov 1",
"25D Fri Nov 8",
"32D Fri Nov 15",
]
return rx.el.div(
rx.foreach(
tabs,
lambda tab: rx.el.button(
tab,
on_click=TradingState.set_active_sub_tab(tab),
class_name=rx.cond(
TradingState.active_sub_tab == tab,
"text-xs text-white bg-gray-700 px-3 py-1 rounded",
"text-xs text-gray-400 hover:text-white px-3 py-1",
),
),
),
class_name="flex space-x-2 border-b border-gray-700 mb-2 pb-1 px-2 overflow-x-auto",
)
def render_option_cell(
value: rx.Var,
class_name: str,
is_numeric: bool = True,
format_spec: str = ".2f",
prefix: str = "",
suffix: str = "",
) -> rx.Component:
formatted_value = rx.cond(value, value.to_string(), "-")
| def options_header(
stock_symbol: str,
price: rx.Var[float],
change: rx.Var[float],
change_percent: rx.Var[float],
) -> rx.Component:
return rx.el.div(
rx.el.span(
f"{stock_symbol}",
class_name="text-sm font-bold text-white mr-2",
),
rx.el.span(
price.to_string(),
class_name="text-sm font-semibold text-white mr-1",
),
rx.el.span(
change.to_string(),
class_name=rx.cond(
change >= 0,
"text-green-400 text-xs",
"text-red-400 text-xs",
),
),
rx.el.span(
change_percent.to_string(),
class_name=rx.cond(
change >= 0,
"text-green-400 text-xs ml-1",
"text-red-400 text-xs ml-1",
),
),
class_name="mb-2 px-2",
) |
x as rx
from stock_market_dashboard.states.trading_state import TradingState
def options_header(
stock_symbol: str,
price: rx.Var[float],
change: rx.Var[float],
change_percent: rx.Var[float],
) -> rx.Component:
return rx.el.div(
rx.el.span(
f"{stock_symbol}",
class_name="text-sm font-bold text-white mr-2",
),
rx.el.span(
price.to_string(),
class_name="text-sm font-semibold text-white mr-1",
),
rx.el.span(
change.to_string(),
class_name=rx.cond(
change >= 0,
"text-green-400 text-xs",
"text-red-400 text-xs",
),
),
rx.el.span(
change_percent.to_string(),
class_name=rx.cond(
change >= 0,
"text-green-400 text-xs ml-1",
"text-red-400 text-xs ml-1",
),
),
class_name="mb-2 px-2",
)
|
def render_option_cell(
value: rx.Var,
class_name: str,
is_numeric: bool = True,
format_spec: str = ".2f",
prefix: str = "",
suffix: str = "",
) -> rx.Component:
formatted_value = rx.cond(value, value.to_string(), "-")
return rx.el.td(formatted_value, class_name=class_name)
def render_combined_option_row(
item: rx.Var[dict[str, dict[str, int]]],
) -> rx.Component:
call_option = item["call"]
put_option = item["put"]
strike = item["strike"]
call_headers_config = [
("mark", "px-2 py-1 text-xs text-right"),
(
"percent_change_to",
"px-2 py-1 text-xs text-right",
True,
".2f",
"",
"%",
),
(
"delta",
"px-2 py-1 text-xs text-right",
True,
".4f",
),
(
"oi",
"px-2 py-1 text-xs text-right text-gray-400",
False,
),
(
| def options_sub_tabs() -> rx.Component:
tabs = [
"4D Fri Oct 18",
"11D Fri Oct 25",
"18D Fri Nov 1",
"25D Fri Nov 8",
"32D Fri Nov 15",
]
return rx.el.div(
rx.foreach(
tabs,
lambda tab: rx.el.button(
tab,
on_click=TradingState.set_active_sub_tab(tab),
class_name=rx.cond(
TradingState.active_sub_tab == tab,
"text-xs text-white bg-gray-700 px-3 py-1 rounded",
"text-xs text-gray-400 hover:text-white px-3 py-1",
),
),
),
class_name="flex space-x-2 border-b border-gray-700 mb-2 pb-1 px-2 overflow-x-auto",
) |
change_percent.to_string(),
class_name=rx.cond(
change >= 0,
"text-green-400 text-xs ml-1",
"text-red-400 text-xs ml-1",
),
),
class_name="mb-2 px-2",
)
def options_sub_tabs() -> rx.Component:
tabs = [
"4D Fri Oct 18",
"11D Fri Oct 25",
"18D Fri Nov 1",
"25D Fri Nov 8",
"32D Fri Nov 15",
]
return rx.el.div(
rx.foreach(
tabs,
lambda tab: rx.el.button(
tab,
on_click=TradingState.set_active_sub_tab(tab),
class_name=rx.cond(
TradingState.active_sub_tab == tab,
"text-xs text-white bg-gray-700 px-3 py-1 rounded",
"text-xs text-gray-400 hover:text-white px-3 py-1",
),
),
),
class_name="flex space-x-2 border-b border-gray-700 mb-2 pb-1 px-2 overflow-x-auto",
)
|
def render_combined_option_row(
item: rx.Var[dict[str, dict[str, int]]],
) -> rx.Component:
call_option = item["call"]
put_option = item["put"]
strike = item["strike"]
call_headers_config = [
("mark", "px-2 py-1 text-xs text-right"),
(
"percent_change_to",
"px-2 py-1 text-xs text-right",
True,
".2f",
"",
"%",
),
(
"delta",
"px-2 py-1 text-xs text-right",
True,
".4f",
),
(
"oi",
"px-2 py-1 text-xs text-right text-gray-400",
False,
),
(
"volume",
"px-2 py-1 text-xs text-right text-gray-400",
False,
),
(
"iv",
"px-2 py-1 text-xs text-right",
True,
".2f",
"",
"%",
),
(
"low",
"px-2 py-1 tex | def render_option_cell(
value: rx.Var,
class_name: str,
is_numeric: bool = True,
format_spec: str = ".2f",
prefix: str = "",
suffix: str = "",
) -> rx.Component:
formatted_value = rx.cond(value, value.to_string(), "-")
return rx.el.td(formatted_value, class_name=class_name) |
),
),
class_name="mb-2 px-2",
)
def options_sub_tabs() -> rx.Component:
tabs = [
"4D Fri Oct 18",
"11D Fri Oct 25",
"18D Fri Nov 1",
"25D Fri Nov 8",
"32D Fri Nov 15",
]
return rx.el.div(
rx.foreach(
tabs,
lambda tab: rx.el.button(
tab,
on_click=TradingState.set_active_sub_tab(tab),
class_name=rx.cond(
TradingState.active_sub_tab == tab,
"text-xs text-white bg-gray-700 px-3 py-1 rounded",
"text-xs text-gray-400 hover:text-white px-3 py-1",
),
),
),
class_name="flex space-x-2 border-b border-gray-700 mb-2 pb-1 px-2 overflow-x-auto",
)
def render_option_cell(
value: rx.Var,
class_name: str,
is_numeric: bool = True,
format_spec: str = ".2f",
prefix: str = "",
suffix: str = "",
) -> rx.Component:
|
return rx.el.td(formatted_value, class_name=class_name)
def render_combined_option_row(
item: rx.Var[dict[str, dict[str, int]]],
) -> rx.Component:
call_option = item["call"]
put_option = item["put"]
strike = item["strike"]
call_headers_config = [
("mark", "px-2 py-1 text-xs text-right"),
(
"percent_change_to",
"px-2 py-1 text-xs text-right",
True,
".2f",
"",
"%",
),
(
"delta",
"px-2 py-1 text-xs text-right",
True,
".4f",
),
(
"oi",
"px-2 py-1 text-xs text-right text-gray-400",
False,
),
(
"volume",
"px-2 py-1 text-xs text-right text-gray-400",
False,
),
(
"iv",
"px-2 py-1 text-xs text-right",
True,
".2f",
"",
"%",
| formatted_value = rx.cond(value, value.to_string(), "-") |
"32D Fri Nov 15",
]
return rx.el.div(
rx.foreach(
tabs,
lambda tab: rx.el.button(
tab,
on_click=TradingState.set_active_sub_tab(tab),
class_name=rx.cond(
TradingState.active_sub_tab == tab,
"text-xs text-white bg-gray-700 px-3 py-1 rounded",
"text-xs text-gray-400 hover:text-white px-3 py-1",
),
),
),
class_name="flex space-x-2 border-b border-gray-700 mb-2 pb-1 px-2 overflow-x-auto",
)
def render_option_cell(
value: rx.Var,
class_name: str,
is_numeric: bool = True,
format_spec: str = ".2f",
prefix: str = "",
suffix: str = "",
) -> rx.Component:
formatted_value = rx.cond(value, value.to_string(), "-")
return rx.el.td(formatted_value, class_name=class_name)
def render_combined_option_row(
item: rx.Var[dict[str, dict[str, int]]],
) -> rx.Component:
|
put_option = item["put"]
strike = item["strike"]
call_headers_config = [
("mark", "px-2 py-1 text-xs text-right"),
(
"percent_change_to",
"px-2 py-1 text-xs text-right",
True,
".2f",
"",
"%",
),
(
"delta",
"px-2 py-1 text-xs text-right",
True,
".4f",
),
(
"oi",
"px-2 py-1 text-xs text-right text-gray-400",
False,
),
(
"volume",
"px-2 py-1 text-xs text-right text-gray-400",
False,
),
(
"iv",
"px-2 py-1 text-xs text-right",
True,
".2f",
"",
"%",
),
(
"low",
"px-2 py-1 text-xs text-right text-gray-400",
),
(
"high",
"px-2 py-1 text-xs text-right text-gray-400" | call_option = item["call"] |
return rx.el.div(
rx.foreach(
tabs,
lambda tab: rx.el.button(
tab,
on_click=TradingState.set_active_sub_tab(tab),
class_name=rx.cond(
TradingState.active_sub_tab == tab,
"text-xs text-white bg-gray-700 px-3 py-1 rounded",
"text-xs text-gray-400 hover:text-white px-3 py-1",
),
),
),
class_name="flex space-x-2 border-b border-gray-700 mb-2 pb-1 px-2 overflow-x-auto",
)
def render_option_cell(
value: rx.Var,
class_name: str,
is_numeric: bool = True,
format_spec: str = ".2f",
prefix: str = "",
suffix: str = "",
) -> rx.Component:
formatted_value = rx.cond(value, value.to_string(), "-")
return rx.el.td(formatted_value, class_name=class_name)
def render_combined_option_row(
item: rx.Var[dict[str, dict[str, int]]],
) -> rx.Component:
call_option = item["call"]
|
strike = item["strike"]
call_headers_config = [
("mark", "px-2 py-1 text-xs text-right"),
(
"percent_change_to",
"px-2 py-1 text-xs text-right",
True,
".2f",
"",
"%",
),
(
"delta",
"px-2 py-1 text-xs text-right",
True,
".4f",
),
(
"oi",
"px-2 py-1 text-xs text-right text-gray-400",
False,
),
(
"volume",
"px-2 py-1 text-xs text-right text-gray-400",
False,
),
(
"iv",
"px-2 py-1 text-xs text-right",
True,
".2f",
"",
"%",
),
(
"low",
"px-2 py-1 text-xs text-right text-gray-400",
),
(
"high",
"px-2 py-1 text-xs text-right text-gray-400",
),
(
| put_option = item["put"] |
foreach(
tabs,
lambda tab: rx.el.button(
tab,
on_click=TradingState.set_active_sub_tab(tab),
class_name=rx.cond(
TradingState.active_sub_tab == tab,
"text-xs text-white bg-gray-700 px-3 py-1 rounded",
"text-xs text-gray-400 hover:text-white px-3 py-1",
),
),
),
class_name="flex space-x-2 border-b border-gray-700 mb-2 pb-1 px-2 overflow-x-auto",
)
def render_option_cell(
value: rx.Var,
class_name: str,
is_numeric: bool = True,
format_spec: str = ".2f",
prefix: str = "",
suffix: str = "",
) -> rx.Component:
formatted_value = rx.cond(value, value.to_string(), "-")
return rx.el.td(formatted_value, class_name=class_name)
def render_combined_option_row(
item: rx.Var[dict[str, dict[str, int]]],
) -> rx.Component:
call_option = item["call"]
put_option = item["put"]
|
call_headers_config = [
("mark", "px-2 py-1 text-xs text-right"),
(
"percent_change_to",
"px-2 py-1 text-xs text-right",
True,
".2f",
"",
"%",
),
(
"delta",
"px-2 py-1 text-xs text-right",
True,
".4f",
),
(
"oi",
"px-2 py-1 text-xs text-right text-gray-400",
False,
),
(
"volume",
"px-2 py-1 text-xs text-right text-gray-400",
False,
),
(
"iv",
"px-2 py-1 text-xs text-right",
True,
".2f",
"",
"%",
),
(
"low",
"px-2 py-1 text-xs text-right text-gray-400",
),
(
"high",
"px-2 py-1 text-xs text-right text-gray-400",
),
(
"bid",
rx. | strike = item["strike"] |
-1 text-xs text-left font-semibold text-red-400",
),
True,
".2f",
"$",
),
(
"delta",
"px-2 py-1 text-xs text-left",
True,
".4f",
),
(
"oi",
"px-2 py-1 text-xs text-left text-gray-400",
False,
),
(
"volume",
"px-2 py-1 text-xs text-left text-gray-400",
False,
),
(
"iv",
"px-2 py-1 text-xs text-left",
True,
".2f",
"",
"%",
),
(
"percent_change_to",
"px-2 py-1 text-xs text-left",
True,
".2f",
"",
"%",
),
("mark", "px-2 py-1 text-xs text-left"),
(
"gamma",
"px-2 py-1 text-xs text-left text-gray-400",
True,
".2f",
),
]
|
return rx.el.tr(
rx.cond(
call_option,
rx.fragment(
*[
render_option_cell(call_option[key], cn, *fmt)
for key, cn, *fmt in call_headers_config
]
),
rx.fragment(
*[
rx.el.td(
"-",
class_name="px-2 py-1 text-xs text-gray-500 text-right",
)
for _ in call_headers_config
]
),
),
rx.el.td(
strike.to_string(),
class_name=rx.cond(
is_near_the_money,
"px-3 py-1 text-xs text-center font-bold text-white bg-yellow-700",
"px-3 py-1 text-xs text-center font-bold text-white bg-gray-600",
),
),
rx.cond(
put_option,
rx.fragment(
*[
render_option_cell | is_near_the_money = rx.Var.create(
f"Math.abs({strike} - {TradingState.stock_info['price']}) < 5"
) |
t-xs text-center font-bold text-white bg-yellow-700",
"px-3 py-1 text-xs text-center font-bold text-white bg-gray-600",
),
),
rx.cond(
put_option,
rx.fragment(
*[
render_option_cell(put_option[key], cn, *fmt)
for key, cn, *fmt in put_headers_config
]
),
rx.fragment(
*[
rx.el.td(
"-",
class_name="px-2 py-1 text-xs text-gray-500 text-left",
)
for _ in put_headers_config
]
),
),
class_name="border-b border-gray-700 hover:bg-gray-700",
)
def options_table() -> rx.Component:
call_headers = [
"Mark",
"% to",
"Delta",
"OI",
"Volume",
"IV",
"Low",
"High",
"Bid",
"Ask",
]
|
return rx.el.div(
options_header(
TradingState.stock_info["symbol"],
TradingState.stock_info["price"],
TradingState.stock_info["change"],
TradingState.stock_info["change_percent"],
),
options_sub_tabs(),
rx.el.div(
rx.el.table(
rx.el.thead(
rx.el.tr(
rx.el.th(
"Calls",
col_span=len(call_headers),
class_name="text-sm font-semibold text-white pb-2 text-center border-b-2 border-green-500 sticky top-0 bg-gray-800 z-20",
),
rx.el.th(
"Strike",
class_name="text-sm font-semibold text-white pb-2 text-center border-b-2 border-gray-500 sticky top-0 bg-gray-800 z-20",
),
rx.el.th(
"P | put_headers = [
"Bid",
"Ask",
"Delta",
"OI",
"Volume",
"IV",
"Change % to",
"Mark",
"Gamma",
] |
from stock_market_dashboard.states.trading_state import Order, TradingState
def get_status_color(status: rx.Var[str]) -> rx.Var[str]:
return rx.match(
status,
("Filled", "text-green-400"),
("Canceled", "text-red-400"),
("Working", "text-yellow-400"),
("Sending", "text-blue-400"),
"text-gray-400",
)
def get_side_color(side: rx.Var[str]) -> rx.Var[str]:
return rx.cond(side == "Buy", "text-green-400", "text-red-400")
def render_order_row(order: Order) -> rx.Component:
return rx.el.tr(
rx.el.td(
order["symbol"],
class_name="px-3 py-2 whitespace-nowrap text-sm font-medium text-white",
),
rx.el.td(
order["status"],
class_name=rx.cond(
order["status"] == "Filled",
"px-3 py-2 whitespace-nowrap text-sm text-green-400",
rx.cond(
order["status"] == "Canceled",
"px-3 py | import reflex as rx | |
import reflex as rx
|
def get_status_color(status: rx.Var[str]) -> rx.Var[str]:
return rx.match(
status,
("Filled", "text-green-400"),
("Canceled", "text-red-400"),
("Working", "text-yellow-400"),
("Sending", "text-blue-400"),
"text-gray-400",
)
def get_side_color(side: rx.Var[str]) -> rx.Var[str]:
return rx.cond(side == "Buy", "text-green-400", "text-red-400")
def render_order_row(order: Order) -> rx.Component:
return rx.el.tr(
rx.el.td(
order["symbol"],
class_name="px-3 py-2 whitespace-nowrap text-sm font-medium text-white",
),
rx.el.td(
order["status"],
class_name=rx.cond(
order["status"] == "Filled",
"px-3 py-2 whitespace-nowrap text-sm text-green-400",
rx.cond(
order["status"] == "Canceled",
"px-3 py-2 whitespace-nowrap text-sm text-red-400",
rx.cond(
| from stock_market_dashboard.states.trading_state import Order, TradingState |
import reflex as rx
from stock_market_dashboard.states.trading_state import Order, TradingState
|
def get_side_color(side: rx.Var[str]) -> rx.Var[str]:
return rx.cond(side == "Buy", "text-green-400", "text-red-400")
def render_order_row(order: Order) -> rx.Component:
return rx.el.tr(
rx.el.td(
order["symbol"],
class_name="px-3 py-2 whitespace-nowrap text-sm font-medium text-white",
),
rx.el.td(
order["status"],
class_name=rx.cond(
order["status"] == "Filled",
"px-3 py-2 whitespace-nowrap text-sm text-green-400",
rx.cond(
order["status"] == "Canceled",
"px-3 py-2 whitespace-nowrap text-sm text-red-400",
rx.cond(
order["status"] == "Working",
"px-3 py-2 whitespace-nowrap text-sm text-yellow-400",
rx.cond(
order["status"] == "Sending",
"px-3 py-2 whitespace-nowrap text- | def get_status_color(status: rx.Var[str]) -> rx.Var[str]:
return rx.match(
status,
("Filled", "text-green-400"),
("Canceled", "text-red-400"),
("Working", "text-yellow-400"),
("Sending", "text-blue-400"),
"text-gray-400",
) |
import reflex as rx
from stock_market_dashboard.states.trading_state import Order, TradingState
def get_status_color(status: rx.Var[str]) -> rx.Var[str]:
return rx.match(
status,
("Filled", "text-green-400"),
("Canceled", "text-red-400"),
("Working", "text-yellow-400"),
("Sending", "text-blue-400"),
"text-gray-400",
)
|
def render_order_row(order: Order) -> rx.Component:
return rx.el.tr(
rx.el.td(
order["symbol"],
class_name="px-3 py-2 whitespace-nowrap text-sm font-medium text-white",
),
rx.el.td(
order["status"],
class_name=rx.cond(
order["status"] == "Filled",
"px-3 py-2 whitespace-nowrap text-sm text-green-400",
rx.cond(
order["status"] == "Canceled",
"px-3 py-2 whitespace-nowrap text-sm text-red-400",
rx.cond(
order["status"] == "Working",
"px-3 py-2 whitespace-nowrap text-sm text-yellow-400",
rx.cond(
order["status"] == "Sending",
"px-3 py-2 whitespace-nowrap text-sm text-blue-400",
"px-3 py-2 whitespace-nowrap text-sm text-gray-400",
| def get_side_color(side: rx.Var[str]) -> rx.Var[str]:
return rx.cond(side == "Buy", "text-green-400", "text-red-400") |
"px-3 py-2 whitespace-nowrap text-sm text-gray-400",
),
),
),
),
),
rx.el.td(
order["side"],
class_name=rx.cond(
order["side"] == "Buy",
"px-3 py-2 whitespace-nowrap text-sm text-green-400",
"px-3 py-2 whitespace-nowrap text-sm text-red-400",
),
),
rx.el.td(
order["type"],
class_name="px-3 py-2 whitespace-nowrap text-sm text-gray-300",
),
rx.el.td(
order["qty"].to_string(),
class_name="px-3 py-2 whitespace-nowrap text-sm text-gray-300 text-right",
),
rx.el.td(
order["total_cost"].to_string(),
class_name="px-3 py-2 whitespace-nowrap text-sm text-gray-300 text-right",
),
class_name="border-b border-gray-700 hover:bg-gray-700",
)
def orders_table() -> rx.Component:
|
header_classes = [
"px-3 py-2 text-left text-xs font-medium text-gray-400 uppercase tracking-wider border-b border-gray-700",
"px-3 py-2 text-left text-xs font-medium text-gray-400 uppercase tracking-wider border-b border-gray-700",
"px-3 py-2 text-left text-xs font-medium text-gray-400 uppercase tracking-wider border-b border-gray-700",
"px-3 py-2 text-left text-xs font-medium text-gray-400 uppercase tracking-wider border-b border-gray-700",
"px-3 py-2 text-right text-xs font-medium text-gray-400 uppercase tracking-wider border-b border-gray-700",
"px-3 py-2 text-right text-xs font-medium text-gray-400 uppercase tracking-wider border-b border-gray-700",
]
return rx.el.div(
rx.el.h3(
"Recent orders",
class_name="text-lg font-semibold text-white mb-3 px-3",
),
rx.el.div(
rx.el.table(
rx.el.thead(
rx.el.tr(
rx | headers = [
"Symbol",
"Status",
"Side",
"Type",
"Qty",
"Total cost",
] |
import reflex as rx
from stock_market_dashboard.states.trading_state import Position, TradingState
def format_currency(
value: rx.Var[Union[float, None]],
) -> rx.Var[str]:
return rx.cond(value is not None, value.to_string(), "-")
def format_signed_currency(
value: rx.Var[Union[float, None]],
) -> rx.Var[str]:
return rx.cond(value is not None, value.to_string(), "-")
def format_float(
value: rx.Var[Union[float, None]],
format_spec: str = ".2f",
) -> rx.Var[str]:
return rx.cond(value is not None, value.to_string(), "-")
def format_signed_percent(
value: rx.Var[Union[float, None]],
) -> rx.Var[str]:
return rx.cond(value is not None, value.to_string(), "-")
def get_return_color(
value: rx.Var[Union[float, None]],
) -> rx.Var[str]:
return rx.cond(
value is not None,
rx.cond(value >= 0, "text-green-400", "text-red-400"),
"text-gray-300",
)
def render_position_row(pos: Position) -> rx.Component:
return | from typing import Union | |
from typing import Union
|
from stock_market_dashboard.states.trading_state import Position, TradingState
def format_currency(
value: rx.Var[Union[float, None]],
) -> rx.Var[str]:
return rx.cond(value is not None, value.to_string(), "-")
def format_signed_currency(
value: rx.Var[Union[float, None]],
) -> rx.Var[str]:
return rx.cond(value is not None, value.to_string(), "-")
def format_float(
value: rx.Var[Union[float, None]],
format_spec: str = ".2f",
) -> rx.Var[str]:
return rx.cond(value is not None, value.to_string(), "-")
def format_signed_percent(
value: rx.Var[Union[float, None]],
) -> rx.Var[str]:
return rx.cond(value is not None, value.to_string(), "-")
def get_return_color(
value: rx.Var[Union[float, None]],
) -> rx.Var[str]:
return rx.cond(
value is not None,
rx.cond(value >= 0, "text-green-400", "text-red-400"),
"text-gray-300",
)
def render_position_row(pos: Position) -> rx.Component:
return rx.el.tr(
rx | import reflex as rx |
from typing import Union
import reflex as rx
|
def format_currency(
value: rx.Var[Union[float, None]],
) -> rx.Var[str]:
return rx.cond(value is not None, value.to_string(), "-")
def format_signed_currency(
value: rx.Var[Union[float, None]],
) -> rx.Var[str]:
return rx.cond(value is not None, value.to_string(), "-")
def format_float(
value: rx.Var[Union[float, None]],
format_spec: str = ".2f",
) -> rx.Var[str]:
return rx.cond(value is not None, value.to_string(), "-")
def format_signed_percent(
value: rx.Var[Union[float, None]],
) -> rx.Var[str]:
return rx.cond(value is not None, value.to_string(), "-")
def get_return_color(
value: rx.Var[Union[float, None]],
) -> rx.Var[str]:
return rx.cond(
value is not None,
rx.cond(value >= 0, "text-green-400", "text-red-400"),
"text-gray-300",
)
def render_position_row(pos: Position) -> rx.Component:
return rx.el.tr(
rx.el.td(
pos["symbol"],
class_name="px-3 py-2 whitespace- | from stock_market_dashboard.states.trading_state import Position, TradingState |
from typing import Union
import reflex as rx
from stock_market_dashboard.states.trading_state import Position, TradingState
|
def format_signed_currency(
value: rx.Var[Union[float, None]],
) -> rx.Var[str]:
return rx.cond(value is not None, value.to_string(), "-")
def format_float(
value: rx.Var[Union[float, None]],
format_spec: str = ".2f",
) -> rx.Var[str]:
return rx.cond(value is not None, value.to_string(), "-")
def format_signed_percent(
value: rx.Var[Union[float, None]],
) -> rx.Var[str]:
return rx.cond(value is not None, value.to_string(), "-")
def get_return_color(
value: rx.Var[Union[float, None]],
) -> rx.Var[str]:
return rx.cond(
value is not None,
rx.cond(value >= 0, "text-green-400", "text-red-400"),
"text-gray-300",
)
def render_position_row(pos: Position) -> rx.Component:
return rx.el.tr(
rx.el.td(
pos["symbol"],
class_name="px-3 py-2 whitespace-nowrap text-sm font-medium text-white",
),
rx.el.td(
format_float(pos["qty"], ".3f"),
class_name="px-3 | def format_currency(
value: rx.Var[Union[float, None]],
) -> rx.Var[str]:
return rx.cond(value is not None, value.to_string(), "-") |
from typing import Union
import reflex as rx
from stock_market_dashboard.states.trading_state import Position, TradingState
def format_currency(
value: rx.Var[Union[float, None]],
) -> rx.Var[str]:
return rx.cond(value is not None, value.to_string(), "-")
|
def format_float(
value: rx.Var[Union[float, None]],
format_spec: str = ".2f",
) -> rx.Var[str]:
return rx.cond(value is not None, value.to_string(), "-")
def format_signed_percent(
value: rx.Var[Union[float, None]],
) -> rx.Var[str]:
return rx.cond(value is not None, value.to_string(), "-")
def get_return_color(
value: rx.Var[Union[float, None]],
) -> rx.Var[str]:
return rx.cond(
value is not None,
rx.cond(value >= 0, "text-green-400", "text-red-400"),
"text-gray-300",
)
def render_position_row(pos: Position) -> rx.Component:
return rx.el.tr(
rx.el.td(
pos["symbol"],
class_name="px-3 py-2 whitespace-nowrap text-sm font-medium text-white",
),
rx.el.td(
format_float(pos["qty"], ".3f"),
class_name="px-3 py-2 whitespace-nowrap text-sm text-gray-300 text-right",
),
rx.el.td(
format_currency(pos["mkt_val"]),
clas | def format_signed_currency(
value: rx.Var[Union[float, None]],
) -> rx.Var[str]:
return rx.cond(value is not None, value.to_string(), "-") |
from typing import Union
import reflex as rx
from stock_market_dashboard.states.trading_state import Position, TradingState
def format_currency(
value: rx.Var[Union[float, None]],
) -> rx.Var[str]:
return rx.cond(value is not None, value.to_string(), "-")
def format_signed_currency(
value: rx.Var[Union[float, None]],
) -> rx.Var[str]:
return rx.cond(value is not None, value.to_string(), "-")
|
def format_signed_percent(
value: rx.Var[Union[float, None]],
) -> rx.Var[str]:
return rx.cond(value is not None, value.to_string(), "-")
def get_return_color(
value: rx.Var[Union[float, None]],
) -> rx.Var[str]:
return rx.cond(
value is not None,
rx.cond(value >= 0, "text-green-400", "text-red-400"),
"text-gray-300",
)
def render_position_row(pos: Position) -> rx.Component:
return rx.el.tr(
rx.el.td(
pos["symbol"],
class_name="px-3 py-2 whitespace-nowrap text-sm font-medium text-white",
),
rx.el.td(
format_float(pos["qty"], ".3f"),
class_name="px-3 py-2 whitespace-nowrap text-sm text-gray-300 text-right",
),
rx.el.td(
format_currency(pos["mkt_val"]),
class_name="px-3 py-2 whitespace-nowrap text-sm text-gray-300 text-right",
),
rx.el.td(
format_signed_currency(pos["day_return"]),
cl | def format_float(
value: rx.Var[Union[float, None]],
format_spec: str = ".2f",
) -> rx.Var[str]:
return rx.cond(value is not None, value.to_string(), "-") |
from typing import Union
import reflex as rx
from stock_market_dashboard.states.trading_state import Position, TradingState
def format_currency(
value: rx.Var[Union[float, None]],
) -> rx.Var[str]:
return rx.cond(value is not None, value.to_string(), "-")
def format_signed_currency(
value: rx.Var[Union[float, None]],
) -> rx.Var[str]:
return rx.cond(value is not None, value.to_string(), "-")
def format_float(
value: rx.Var[Union[float, None]],
format_spec: str = ".2f",
) -> rx.Var[str]:
return rx.cond(value is not None, value.to_string(), "-")
|
def get_return_color(
value: rx.Var[Union[float, None]],
) -> rx.Var[str]:
return rx.cond(
value is not None,
rx.cond(value >= 0, "text-green-400", "text-red-400"),
"text-gray-300",
)
def render_position_row(pos: Position) -> rx.Component:
return rx.el.tr(
rx.el.td(
pos["symbol"],
class_name="px-3 py-2 whitespace-nowrap text-sm font-medium text-white",
),
rx.el.td(
format_float(pos["qty"], ".3f"),
class_name="px-3 py-2 whitespace-nowrap text-sm text-gray-300 text-right",
),
rx.el.td(
format_currency(pos["mkt_val"]),
class_name="px-3 py-2 whitespace-nowrap text-sm text-gray-300 text-right",
),
rx.el.td(
format_signed_currency(pos["day_return"]),
class_name=rx.cond(
pos["day_return"] is not None,
rx.cond(
pos["day_return"] >= 0,
| def format_signed_percent(
value: rx.Var[Union[float, None]],
) -> rx.Var[str]:
return rx.cond(value is not None, value.to_string(), "-") |
from typing import Union
import reflex as rx
from stock_market_dashboard.states.trading_state import Position, TradingState
def format_currency(
value: rx.Var[Union[float, None]],
) -> rx.Var[str]:
return rx.cond(value is not None, value.to_string(), "-")
def format_signed_currency(
value: rx.Var[Union[float, None]],
) -> rx.Var[str]:
return rx.cond(value is not None, value.to_string(), "-")
def format_float(
value: rx.Var[Union[float, None]],
format_spec: str = ".2f",
) -> rx.Var[str]:
return rx.cond(value is not None, value.to_string(), "-")
def format_signed_percent(
value: rx.Var[Union[float, None]],
) -> rx.Var[str]:
return rx.cond(value is not None, value.to_string(), "-")
|
def render_position_row(pos: Position) -> rx.Component:
return rx.el.tr(
rx.el.td(
pos["symbol"],
class_name="px-3 py-2 whitespace-nowrap text-sm font-medium text-white",
),
rx.el.td(
format_float(pos["qty"], ".3f"),
class_name="px-3 py-2 whitespace-nowrap text-sm text-gray-300 text-right",
),
rx.el.td(
format_currency(pos["mkt_val"]),
class_name="px-3 py-2 whitespace-nowrap text-sm text-gray-300 text-right",
),
rx.el.td(
format_signed_currency(pos["day_return"]),
class_name=rx.cond(
pos["day_return"] is not None,
rx.cond(
pos["day_return"] >= 0,
"px-3 py-2 whitespace-nowrap text-sm text-right text-green-400",
"px-3 py-2 whitespace-nowrap text-sm text-right text-red-400",
),
"px-3 py-2 whitespace-nowrap text | def get_return_color(
value: rx.Var[Union[float, None]],
) -> rx.Var[str]:
return rx.cond(
value is not None,
rx.cond(value >= 0, "text-green-400", "text-red-400"),
"text-gray-300",
) |
rx.el.td(
format_float(pos["gamma"], ".4f"),
class_name="px-3 py-2 whitespace-nowrap text-sm text-gray-300 text-right",
),
rx.el.td(
format_float(pos["theta"], ".4f"),
class_name="px-3 py-2 whitespace-nowrap text-sm text-gray-300 text-right",
),
rx.el.td(
rx.cond(
pos["iv"] is not None,
format_float(pos["iv"].to(float), ".2f") + "%",
"-",
),
class_name="px-3 py-2 whitespace-nowrap text-sm text-gray-300 text-right",
),
rx.el.td(
pos["type"],
class_name="px-3 py-2 whitespace-nowrap text-sm text-gray-300",
),
rx.el.td(
pos["dte"].to_string(),
class_name="px-3 py-2 whitespace-nowrap text-sm text-gray-300 text-center",
),
class_name="border-b border-gray-700 hover:bg-gray-700",
)
def positions_table() -> rx.Component:
|
header_alignments = [
"left",
"right",
"right",
"right",
"right",
"right",
"right",
"right",
"right",
"right",
"right",
"right",
"right",
"right",
"left",
"center",
]
header_classes = [
f"px-3 py-2 text-{align} text-xs font-medium text-gray-400 uppercase tracking-wider border-b border-gray-700 whitespace-nowrap"
for align in header_alignments
]
return rx.el.div(
rx.el.h3(
"Positions",
class_name="text-lg font-semibold text-white mb-3 px-3",
),
rx.el.div(
rx.el.table(
rx.el.thead(
rx.el.tr(
rx.foreach(
list(zip(headers, header_classes)),
lambda item: rx.el.th(item[0], class_name=item[1]),
),
class_name="s | headers = [
"Symbol",
"Qty",
"Mkt val",
"Day return",
"Day %",
"Total ret",
"Mark",
"Avg cost",
"Bid",
"Ask",
"Delta",
"Gamma",
"Theta",
"IV",
"Type",
"DTE",
] |
-300 text-right",
),
rx.el.td(
rx.cond(
pos["iv"] is not None,
format_float(pos["iv"].to(float), ".2f") + "%",
"-",
),
class_name="px-3 py-2 whitespace-nowrap text-sm text-gray-300 text-right",
),
rx.el.td(
pos["type"],
class_name="px-3 py-2 whitespace-nowrap text-sm text-gray-300",
),
rx.el.td(
pos["dte"].to_string(),
class_name="px-3 py-2 whitespace-nowrap text-sm text-gray-300 text-center",
),
class_name="border-b border-gray-700 hover:bg-gray-700",
)
def positions_table() -> rx.Component:
headers = [
"Symbol",
"Qty",
"Mkt val",
"Day return",
"Day %",
"Total ret",
"Mark",
"Avg cost",
"Bid",
"Ask",
"Delta",
"Gamma",
"Theta",
"IV",
"Type",
"DTE",
]
|
header_classes = [
f"px-3 py-2 text-{align} text-xs font-medium text-gray-400 uppercase tracking-wider border-b border-gray-700 whitespace-nowrap"
for align in header_alignments
]
return rx.el.div(
rx.el.h3(
"Positions",
class_name="text-lg font-semibold text-white mb-3 px-3",
),
rx.el.div(
rx.el.table(
rx.el.thead(
rx.el.tr(
rx.foreach(
list(zip(headers, header_classes)),
lambda item: rx.el.th(item[0], class_name=item[1]),
),
class_name="sticky top-0 bg-gray-800 z-10",
)
),
rx.el.tbody(
rx.foreach(
TradingState.positions,
render_position_row,
)
),
class_name="min-w-fu | header_alignments = [
"left",
"right",
"right",
"right",
"right",
"right",
"right",
"right",
"right",
"right",
"right",
"right",
"right",
"right",
"left",
"center",
] |
,
rx.el.td(
pos["type"],
class_name="px-3 py-2 whitespace-nowrap text-sm text-gray-300",
),
rx.el.td(
pos["dte"].to_string(),
class_name="px-3 py-2 whitespace-nowrap text-sm text-gray-300 text-center",
),
class_name="border-b border-gray-700 hover:bg-gray-700",
)
def positions_table() -> rx.Component:
headers = [
"Symbol",
"Qty",
"Mkt val",
"Day return",
"Day %",
"Total ret",
"Mark",
"Avg cost",
"Bid",
"Ask",
"Delta",
"Gamma",
"Theta",
"IV",
"Type",
"DTE",
]
header_alignments = [
"left",
"right",
"right",
"right",
"right",
"right",
"right",
"right",
"right",
"right",
"right",
"right",
"right",
"right",
"left",
"center",
]
|
return rx.el.div(
rx.el.h3(
"Positions",
class_name="text-lg font-semibold text-white mb-3 px-3",
),
rx.el.div(
rx.el.table(
rx.el.thead(
rx.el.tr(
rx.foreach(
list(zip(headers, header_classes)),
lambda item: rx.el.th(item[0], class_name=item[1]),
),
class_name="sticky top-0 bg-gray-800 z-10",
)
),
rx.el.tbody(
rx.foreach(
TradingState.positions,
render_position_row,
)
),
class_name="min-w-full divide-y divide-gray-700",
),
class_name="overflow-x-auto overflow-y-auto max-h-[200px]",
),
class_name="bg-gray-800 p-3 rounded-lg border border-gray-700",
| header_classes = [
f"px-3 py-2 text-{align} text-xs font-medium text-gray-400 uppercase tracking-wider border-b border-gray-700 whitespace-nowrap"
for align in header_alignments
] |
class ChartDataPoint(TypedDict):
time: str
price: float
class Option(TypedDict):
type: Literal["Call", "Put"]
mark: float
percent_change_to: float
delta: float
oi: int
volume: int
iv: float
low: float
high: float
bid: float
ask: float
strike: float
gamma: float
class Order(TypedDict):
symbol: str
status: Literal["Sending", "Working", "Filled", "Canceled"]
side: Literal["Buy", "Sell"]
type: Literal["Market", "Limit", "Stop market"]
qty: int
total_cost: float
class Position(TypedDict):
symbol: str
qty: float
mkt_val: float
day_return: float
day_percent: float
total_ret: float
mark: float
avg_cost: float
bid: float
ask: float
delta: float
gamma: float
theta: float
iv: Union[float, None]
type: Literal["Equities", "Options"]
dte: Union[int, str]
class StockInfo(TypedDict):
symbol: str
price: float
change: float
change_ | from typing import Literal, TypedDict, Union | |
from typing import Literal, TypedDict, Union
|
class Option(TypedDict):
type: Literal["Call", "Put"]
mark: float
percent_change_to: float
delta: float
oi: int
volume: int
iv: float
low: float
high: float
bid: float
ask: float
strike: float
gamma: float
class Order(TypedDict):
symbol: str
status: Literal["Sending", "Working", "Filled", "Canceled"]
side: Literal["Buy", "Sell"]
type: Literal["Market", "Limit", "Stop market"]
qty: int
total_cost: float
class Position(TypedDict):
symbol: str
qty: float
mkt_val: float
day_return: float
day_percent: float
total_ret: float
mark: float
avg_cost: float
bid: float
ask: float
delta: float
gamma: float
theta: float
iv: Union[float, None]
type: Literal["Equities", "Options"]
dte: Union[int, str]
class StockInfo(TypedDict):
symbol: str
price: float
change: float
change_percent: float
volume: str
open: float
high: float
| class ChartDataPoint(TypedDict):
time: str
price: float |
options_calls_data = [
{
"type": "Call",
"mark": 185.63,
"percent_change_to": 8.73,
"delta": 0.6837,
"oi": 375,
"volume": 1814,
"iv": 8.73,
"low": 174.32,
"high": 185.43,
"bid": 2.12,
"ask": 2.59,
"strike": 170.0,
"gamma": 0.0,
},
{
"type": "Call",
"mark": 185.43,
"percent_change_to": 2.35,
"delta": 0.4321,
"oi": 170,
"volume": 412,
"iv": 4.31,
"low": 174.52,
"high": 185.43,
"bid": 1.02,
"ask": 1.31,
"strike": 175.0,
"gamma": 0.0,
},
{
"type": "Call",
"mark": 185.43,
"percent_change_to": 10.36,
"delta": 0.4531,
"oi": 321,
"volume": 2310,
"iv": 6.06,
"low": 174.51,
"high": 184.51,
"bid": 0.78,
"ask": 0.84,
"strike": 180.0,
"gamma": 0.0,
},
{
" | stock_info_data = {
"symbol": "HMNI",
"price": 182.92,
"change": 3.65,
"change_percent": 0.19,
"volume": "268.38K",
"open": 181.21,
"high": 184.03,
"low": 180.05,
"close": 182.34,
} | |
import datetime
import random
from typing import List, Literal
import reflex as rx
from stock_market_dashboard.models.models import (
ChartDataPoint,
Option,
Order,
Position,
StockInfo,
)
from stock_market_dashboard.states.data import (
options_calls_data,
options_puts_data,
positions_data,
recent_orders_data,
stock_info_data,
)
class TradingState(rx.State):
stock_info: StockInfo = stock_info_data
chart_data: list[ChartDataPoint] = []
options_calls: list[Option] = options_calls_data
options_puts: list[Option] = options_puts_data
recent_orders: list[Order] = recent_orders_data
positions: list[Position] = positions_data
active_main_tab: str = "Options trading"
active_sub_tab: str = "4D Fri Oct 18"
running_simulation: bool = False
@rx.var
def combined_options(
self,
) -> List[dict[str, dict[str, int]]]:
"""Combine call and put options based on strike price."""
calls_by_str | import asyncio | |
import asyncio
|
import random
from typing import List, Literal
import reflex as rx
from stock_market_dashboard.models.models import (
ChartDataPoint,
Option,
Order,
Position,
StockInfo,
)
from stock_market_dashboard.states.data import (
options_calls_data,
options_puts_data,
positions_data,
recent_orders_data,
stock_info_data,
)
class TradingState(rx.State):
stock_info: StockInfo = stock_info_data
chart_data: list[ChartDataPoint] = []
options_calls: list[Option] = options_calls_data
options_puts: list[Option] = options_puts_data
recent_orders: list[Order] = recent_orders_data
positions: list[Position] = positions_data
active_main_tab: str = "Options trading"
active_sub_tab: str = "4D Fri Oct 18"
running_simulation: bool = False
@rx.var
def combined_options(
self,
) -> List[dict[str, dict[str, int]]]:
"""Combine call and put options based on strike price."""
calls_by_strike = {opt["stri | import datetime |
import asyncio
import datetime
|
from typing import List, Literal
import reflex as rx
from stock_market_dashboard.models.models import (
ChartDataPoint,
Option,
Order,
Position,
StockInfo,
)
from stock_market_dashboard.states.data import (
options_calls_data,
options_puts_data,
positions_data,
recent_orders_data,
stock_info_data,
)
class TradingState(rx.State):
stock_info: StockInfo = stock_info_data
chart_data: list[ChartDataPoint] = []
options_calls: list[Option] = options_calls_data
options_puts: list[Option] = options_puts_data
recent_orders: list[Order] = recent_orders_data
positions: list[Position] = positions_data
active_main_tab: str = "Options trading"
active_sub_tab: str = "4D Fri Oct 18"
running_simulation: bool = False
@rx.var
def combined_options(
self,
) -> List[dict[str, dict[str, int]]]:
"""Combine call and put options based on strike price."""
calls_by_strike = {opt["strike"]: opt for | import random |
import asyncio
import datetime
import random
|
import reflex as rx
from stock_market_dashboard.models.models import (
ChartDataPoint,
Option,
Order,
Position,
StockInfo,
)
from stock_market_dashboard.states.data import (
options_calls_data,
options_puts_data,
positions_data,
recent_orders_data,
stock_info_data,
)
class TradingState(rx.State):
stock_info: StockInfo = stock_info_data
chart_data: list[ChartDataPoint] = []
options_calls: list[Option] = options_calls_data
options_puts: list[Option] = options_puts_data
recent_orders: list[Order] = recent_orders_data
positions: list[Position] = positions_data
active_main_tab: str = "Options trading"
active_sub_tab: str = "4D Fri Oct 18"
running_simulation: bool = False
@rx.var
def combined_options(
self,
) -> List[dict[str, dict[str, int]]]:
"""Combine call and put options based on strike price."""
calls_by_strike = {opt["strike"]: opt for opt in self.options_calls}
| from typing import List, Literal |
import asyncio
import datetime
import random
from typing import List, Literal
|
from stock_market_dashboard.models.models import (
ChartDataPoint,
Option,
Order,
Position,
StockInfo,
)
from stock_market_dashboard.states.data import (
options_calls_data,
options_puts_data,
positions_data,
recent_orders_data,
stock_info_data,
)
class TradingState(rx.State):
stock_info: StockInfo = stock_info_data
chart_data: list[ChartDataPoint] = []
options_calls: list[Option] = options_calls_data
options_puts: list[Option] = options_puts_data
recent_orders: list[Order] = recent_orders_data
positions: list[Position] = positions_data
active_main_tab: str = "Options trading"
active_sub_tab: str = "4D Fri Oct 18"
running_simulation: bool = False
@rx.var
def combined_options(
self,
) -> List[dict[str, dict[str, int]]]:
"""Combine call and put options based on strike price."""
calls_by_strike = {opt["strike"]: opt for opt in self.options_calls}
puts_by_strike = {o | import reflex as rx |
import asyncio
import datetime
import random
from typing import List, Literal
import reflex as rx
|
from stock_market_dashboard.states.data import (
options_calls_data,
options_puts_data,
positions_data,
recent_orders_data,
stock_info_data,
)
class TradingState(rx.State):
stock_info: StockInfo = stock_info_data
chart_data: list[ChartDataPoint] = []
options_calls: list[Option] = options_calls_data
options_puts: list[Option] = options_puts_data
recent_orders: list[Order] = recent_orders_data
positions: list[Position] = positions_data
active_main_tab: str = "Options trading"
active_sub_tab: str = "4D Fri Oct 18"
running_simulation: bool = False
@rx.var
def combined_options(
self,
) -> List[dict[str, dict[str, int]]]:
"""Combine call and put options based on strike price."""
calls_by_strike = {opt["strike"]: opt for opt in self.options_calls}
puts_by_strike = {opt["strike"]: opt for opt in self.options_puts}
all_strikes = sorted(set(calls_by_strike.keys()) | set(puts_by_strike. | from stock_market_dashboard.models.models import (
ChartDataPoint,
Option,
Order,
Position,
StockInfo,
) |
import asyncio
import datetime
import random
from typing import List, Literal
import reflex as rx
from stock_market_dashboard.models.models import (
ChartDataPoint,
Option,
Order,
Position,
StockInfo,
)
|
class TradingState(rx.State):
stock_info: StockInfo = stock_info_data
chart_data: list[ChartDataPoint] = []
options_calls: list[Option] = options_calls_data
options_puts: list[Option] = options_puts_data
recent_orders: list[Order] = recent_orders_data
positions: list[Position] = positions_data
active_main_tab: str = "Options trading"
active_sub_tab: str = "4D Fri Oct 18"
running_simulation: bool = False
@rx.var
def combined_options(
self,
) -> List[dict[str, dict[str, int]]]:
"""Combine call and put options based on strike price."""
calls_by_strike = {opt["strike"]: opt for opt in self.options_calls}
puts_by_strike = {opt["strike"]: opt for opt in self.options_puts}
all_strikes = sorted(set(calls_by_strike.keys()) | set(puts_by_strike.keys()))
combined = [
{
"call": calls_by_strike.get(strike),
"put": puts_by_strike.get(strike),
| from stock_market_dashboard.states.data import (
options_calls_data,
options_puts_data,
positions_data,
recent_orders_data,
stock_info_data,
) |
port asyncio
import datetime
import random
from typing import List, Literal
import reflex as rx
from stock_market_dashboard.models.models import (
ChartDataPoint,
Option,
Order,
Position,
StockInfo,
)
from stock_market_dashboard.states.data import (
options_calls_data,
options_puts_data,
positions_data,
recent_orders_data,
stock_info_data,
)
class TradingState(rx.State):
stock_info: StockInfo = stock_info_data
chart_data: list[ChartDataPoint] = []
options_calls: list[Option] = options_calls_data
options_puts: list[Option] = options_puts_data
recent_orders: list[Order] = recent_orders_data
positions: list[Position] = positions_data
active_main_tab: str = "Options trading"
active_sub_tab: str = "4D Fri Oct 18"
running_simulation: bool = False
@rx.var
def combined_options(
self,
) -> List[dict[str, dict[str, int]]]:
"""Combine call and put options based on strike price."""
|
puts_by_strike = {opt["strike"]: opt for opt in self.options_puts}
all_strikes = sorted(set(calls_by_strike.keys()) | set(puts_by_strike.keys()))
combined = [
{
"call": calls_by_strike.get(strike),
"put": puts_by_strike.get(strike),
"strike": strike,
}
for strike in all_strikes
]
return combined
def _generate_initial_chart_data(self):
"""Generates some initial random chart data."""
if not self.chart_data:
now = datetime.datetime.now(datetime.timezone.utc)
start_price = self.stock_info["price"]
data = []
for i in range(60):
time = now - datetime.timedelta(minutes=59 - i)
price_change = random.uniform(-0.5, 0.5)
new_price = max(0.1, start_price + price_change)
data.append(
{
"time": time.st | calls_by_strike = {opt["strike"]: opt for opt in self.options_calls} |
import reflex as rx
from stock_market_dashboard.models.models import (
ChartDataPoint,
Option,
Order,
Position,
StockInfo,
)
from stock_market_dashboard.states.data import (
options_calls_data,
options_puts_data,
positions_data,
recent_orders_data,
stock_info_data,
)
class TradingState(rx.State):
stock_info: StockInfo = stock_info_data
chart_data: list[ChartDataPoint] = []
options_calls: list[Option] = options_calls_data
options_puts: list[Option] = options_puts_data
recent_orders: list[Order] = recent_orders_data
positions: list[Position] = positions_data
active_main_tab: str = "Options trading"
active_sub_tab: str = "4D Fri Oct 18"
running_simulation: bool = False
@rx.var
def combined_options(
self,
) -> List[dict[str, dict[str, int]]]:
"""Combine call and put options based on strike price."""
calls_by_strike = {opt["strike"]: opt for opt in self.options_calls}
|
all_strikes = sorted(set(calls_by_strike.keys()) | set(puts_by_strike.keys()))
combined = [
{
"call": calls_by_strike.get(strike),
"put": puts_by_strike.get(strike),
"strike": strike,
}
for strike in all_strikes
]
return combined
def _generate_initial_chart_data(self):
"""Generates some initial random chart data."""
if not self.chart_data:
now = datetime.datetime.now(datetime.timezone.utc)
start_price = self.stock_info["price"]
data = []
for i in range(60):
time = now - datetime.timedelta(minutes=59 - i)
price_change = random.uniform(-0.5, 0.5)
new_price = max(0.1, start_price + price_change)
data.append(
{
"time": time.strftime("%H:%M"),
"price": round(new_price, 2),
| puts_by_strike = {opt["strike"]: opt for opt in self.options_puts} |
ChartDataPoint,
Option,
Order,
Position,
StockInfo,
)
from stock_market_dashboard.states.data import (
options_calls_data,
options_puts_data,
positions_data,
recent_orders_data,
stock_info_data,
)
class TradingState(rx.State):
stock_info: StockInfo = stock_info_data
chart_data: list[ChartDataPoint] = []
options_calls: list[Option] = options_calls_data
options_puts: list[Option] = options_puts_data
recent_orders: list[Order] = recent_orders_data
positions: list[Position] = positions_data
active_main_tab: str = "Options trading"
active_sub_tab: str = "4D Fri Oct 18"
running_simulation: bool = False
@rx.var
def combined_options(
self,
) -> List[dict[str, dict[str, int]]]:
"""Combine call and put options based on strike price."""
calls_by_strike = {opt["strike"]: opt for opt in self.options_calls}
puts_by_strike = {opt["strike"]: opt for opt in self.options_puts}
|
combined = [
{
"call": calls_by_strike.get(strike),
"put": puts_by_strike.get(strike),
"strike": strike,
}
for strike in all_strikes
]
return combined
def _generate_initial_chart_data(self):
"""Generates some initial random chart data."""
if not self.chart_data:
now = datetime.datetime.now(datetime.timezone.utc)
start_price = self.stock_info["price"]
data = []
for i in range(60):
time = now - datetime.timedelta(minutes=59 - i)
price_change = random.uniform(-0.5, 0.5)
new_price = max(0.1, start_price + price_change)
data.append(
{
"time": time.strftime("%H:%M"),
"price": round(new_price, 2),
}
)
start_price = new_price
| all_strikes = sorted(set(calls_by_strike.keys()) | set(puts_by_strike.keys())) |
t_dashboard.states.data import (
options_calls_data,
options_puts_data,
positions_data,
recent_orders_data,
stock_info_data,
)
class TradingState(rx.State):
stock_info: StockInfo = stock_info_data
chart_data: list[ChartDataPoint] = []
options_calls: list[Option] = options_calls_data
options_puts: list[Option] = options_puts_data
recent_orders: list[Order] = recent_orders_data
positions: list[Position] = positions_data
active_main_tab: str = "Options trading"
active_sub_tab: str = "4D Fri Oct 18"
running_simulation: bool = False
@rx.var
def combined_options(
self,
) -> List[dict[str, dict[str, int]]]:
"""Combine call and put options based on strike price."""
calls_by_strike = {opt["strike"]: opt for opt in self.options_calls}
puts_by_strike = {opt["strike"]: opt for opt in self.options_puts}
all_strikes = sorted(set(calls_by_strike.keys()) | set(puts_by_strike.keys()))
|
return combined
def _generate_initial_chart_data(self):
"""Generates some initial random chart data."""
if not self.chart_data:
now = datetime.datetime.now(datetime.timezone.utc)
start_price = self.stock_info["price"]
data = []
for i in range(60):
time = now - datetime.timedelta(minutes=59 - i)
price_change = random.uniform(-0.5, 0.5)
new_price = max(0.1, start_price + price_change)
data.append(
{
"time": time.strftime("%H:%M"),
"price": round(new_price, 2),
}
)
start_price = new_price
self.chart_data = data
def _update_data_simulation(self):
"""Simulates live data updates."""
price_change = random.uniform(-0.2, 0.2)
old_price = self.stock_info["price"]
new_price = round(max(0.1, | combined = [
{
"call": calls_by_strike.get(strike),
"put": puts_by_strike.get(strike),
"strike": strike,
}
for strike in all_strikes
] |
r] = recent_orders_data
positions: list[Position] = positions_data
active_main_tab: str = "Options trading"
active_sub_tab: str = "4D Fri Oct 18"
running_simulation: bool = False
@rx.var
def combined_options(
self,
) -> List[dict[str, dict[str, int]]]:
"""Combine call and put options based on strike price."""
calls_by_strike = {opt["strike"]: opt for opt in self.options_calls}
puts_by_strike = {opt["strike"]: opt for opt in self.options_puts}
all_strikes = sorted(set(calls_by_strike.keys()) | set(puts_by_strike.keys()))
combined = [
{
"call": calls_by_strike.get(strike),
"put": puts_by_strike.get(strike),
"strike": strike,
}
for strike in all_strikes
]
return combined
def _generate_initial_chart_data(self):
"""Generates some initial random chart data."""
if not self.chart_data:
|
start_price = self.stock_info["price"]
data = []
for i in range(60):
time = now - datetime.timedelta(minutes=59 - i)
price_change = random.uniform(-0.5, 0.5)
new_price = max(0.1, start_price + price_change)
data.append(
{
"time": time.strftime("%H:%M"),
"price": round(new_price, 2),
}
)
start_price = new_price
self.chart_data = data
def _update_data_simulation(self):
"""Simulates live data updates."""
price_change = random.uniform(-0.2, 0.2)
old_price = self.stock_info["price"]
new_price = round(max(0.1, old_price + price_change), 2)
self.stock_info["price"] = new_price
self.stock_info["change"] = round(new_price - self.stock_info["close"], 2)
self.stock_info["change_percent"] = (
roun | now = datetime.datetime.now(datetime.timezone.utc) |
ns_data
active_main_tab: str = "Options trading"
active_sub_tab: str = "4D Fri Oct 18"
running_simulation: bool = False
@rx.var
def combined_options(
self,
) -> List[dict[str, dict[str, int]]]:
"""Combine call and put options based on strike price."""
calls_by_strike = {opt["strike"]: opt for opt in self.options_calls}
puts_by_strike = {opt["strike"]: opt for opt in self.options_puts}
all_strikes = sorted(set(calls_by_strike.keys()) | set(puts_by_strike.keys()))
combined = [
{
"call": calls_by_strike.get(strike),
"put": puts_by_strike.get(strike),
"strike": strike,
}
for strike in all_strikes
]
return combined
def _generate_initial_chart_data(self):
"""Generates some initial random chart data."""
if not self.chart_data:
now = datetime.datetime.now(datetime.timezone.utc)
|
data = []
for i in range(60):
time = now - datetime.timedelta(minutes=59 - i)
price_change = random.uniform(-0.5, 0.5)
new_price = max(0.1, start_price + price_change)
data.append(
{
"time": time.strftime("%H:%M"),
"price": round(new_price, 2),
}
)
start_price = new_price
self.chart_data = data
def _update_data_simulation(self):
"""Simulates live data updates."""
price_change = random.uniform(-0.2, 0.2)
old_price = self.stock_info["price"]
new_price = round(max(0.1, old_price + price_change), 2)
self.stock_info["price"] = new_price
self.stock_info["change"] = round(new_price - self.stock_info["close"], 2)
self.stock_info["change_percent"] = (
round(
self.stock_info["change"] / self | start_price = self.stock_info["price"] |
str = "4D Fri Oct 18"
running_simulation: bool = False
@rx.var
def combined_options(
self,
) -> List[dict[str, dict[str, int]]]:
"""Combine call and put options based on strike price."""
calls_by_strike = {opt["strike"]: opt for opt in self.options_calls}
puts_by_strike = {opt["strike"]: opt for opt in self.options_puts}
all_strikes = sorted(set(calls_by_strike.keys()) | set(puts_by_strike.keys()))
combined = [
{
"call": calls_by_strike.get(strike),
"put": puts_by_strike.get(strike),
"strike": strike,
}
for strike in all_strikes
]
return combined
def _generate_initial_chart_data(self):
"""Generates some initial random chart data."""
if not self.chart_data:
now = datetime.datetime.now(datetime.timezone.utc)
start_price = self.stock_info["price"]
data = []
|
self.chart_data = data
def _update_data_simulation(self):
"""Simulates live data updates."""
price_change = random.uniform(-0.2, 0.2)
old_price = self.stock_info["price"]
new_price = round(max(0.1, old_price + price_change), 2)
self.stock_info["price"] = new_price
self.stock_info["change"] = round(new_price - self.stock_info["close"], 2)
self.stock_info["change_percent"] = (
round(
self.stock_info["change"] / self.stock_info["close"] * 100,
2,
)
if self.stock_info["close"]
else 0
)
now = datetime.datetime.now(datetime.timezone.utc)
self.chart_data.append(
{
"time": now.strftime("%H:%M"),
"price": new_price,
}
)
if len(self.chart_data) > 60:
self.chart_data.pop(0)
if self.recent_orders:
order_index = random.ra | for i in range(60):
time = now - datetime.timedelta(minutes=59 - i)
price_change = random.uniform(-0.5, 0.5)
new_price = max(0.1, start_price + price_change)
data.append(
{
"time": time.strftime("%H:%M"),
"price": round(new_price, 2),
}
)
start_price = new_price |
mulation: bool = False
@rx.var
def combined_options(
self,
) -> List[dict[str, dict[str, int]]]:
"""Combine call and put options based on strike price."""
calls_by_strike = {opt["strike"]: opt for opt in self.options_calls}
puts_by_strike = {opt["strike"]: opt for opt in self.options_puts}
all_strikes = sorted(set(calls_by_strike.keys()) | set(puts_by_strike.keys()))
combined = [
{
"call": calls_by_strike.get(strike),
"put": puts_by_strike.get(strike),
"strike": strike,
}
for strike in all_strikes
]
return combined
def _generate_initial_chart_data(self):
"""Generates some initial random chart data."""
if not self.chart_data:
now = datetime.datetime.now(datetime.timezone.utc)
start_price = self.stock_info["price"]
data = []
for i in range(60):
|
price_change = random.uniform(-0.5, 0.5)
new_price = max(0.1, start_price + price_change)
data.append(
{
"time": time.strftime("%H:%M"),
"price": round(new_price, 2),
}
)
start_price = new_price
self.chart_data = data
def _update_data_simulation(self):
"""Simulates live data updates."""
price_change = random.uniform(-0.2, 0.2)
old_price = self.stock_info["price"]
new_price = round(max(0.1, old_price + price_change), 2)
self.stock_info["price"] = new_price
self.stock_info["change"] = round(new_price - self.stock_info["close"], 2)
self.stock_info["change_percent"] = (
round(
self.stock_info["change"] / self.stock_info["close"] * 100,
2,
)
if self.stock_info["close"]
else | time = now - datetime.timedelta(minutes=59 - i) |
self,
) -> List[dict[str, dict[str, int]]]:
"""Combine call and put options based on strike price."""
calls_by_strike = {opt["strike"]: opt for opt in self.options_calls}
puts_by_strike = {opt["strike"]: opt for opt in self.options_puts}
all_strikes = sorted(set(calls_by_strike.keys()) | set(puts_by_strike.keys()))
combined = [
{
"call": calls_by_strike.get(strike),
"put": puts_by_strike.get(strike),
"strike": strike,
}
for strike in all_strikes
]
return combined
def _generate_initial_chart_data(self):
"""Generates some initial random chart data."""
if not self.chart_data:
now = datetime.datetime.now(datetime.timezone.utc)
start_price = self.stock_info["price"]
data = []
for i in range(60):
time = now - datetime.timedelta(minutes=59 - i)
|
new_price = max(0.1, start_price + price_change)
data.append(
{
"time": time.strftime("%H:%M"),
"price": round(new_price, 2),
}
)
start_price = new_price
self.chart_data = data
def _update_data_simulation(self):
"""Simulates live data updates."""
price_change = random.uniform(-0.2, 0.2)
old_price = self.stock_info["price"]
new_price = round(max(0.1, old_price + price_change), 2)
self.stock_info["price"] = new_price
self.stock_info["change"] = round(new_price - self.stock_info["close"], 2)
self.stock_info["change_percent"] = (
round(
self.stock_info["change"] / self.stock_info["close"] * 100,
2,
)
if self.stock_info["close"]
else 0
)
now = datetime.datetime.now(datetime. | price_change = random.uniform(-0.5, 0.5) |
"""Combine call and put options based on strike price."""
calls_by_strike = {opt["strike"]: opt for opt in self.options_calls}
puts_by_strike = {opt["strike"]: opt for opt in self.options_puts}
all_strikes = sorted(set(calls_by_strike.keys()) | set(puts_by_strike.keys()))
combined = [
{
"call": calls_by_strike.get(strike),
"put": puts_by_strike.get(strike),
"strike": strike,
}
for strike in all_strikes
]
return combined
def _generate_initial_chart_data(self):
"""Generates some initial random chart data."""
if not self.chart_data:
now = datetime.datetime.now(datetime.timezone.utc)
start_price = self.stock_info["price"]
data = []
for i in range(60):
time = now - datetime.timedelta(minutes=59 - i)
price_change = random.uniform(-0.5, 0.5)
|
data.append(
{
"time": time.strftime("%H:%M"),
"price": round(new_price, 2),
}
)
start_price = new_price
self.chart_data = data
def _update_data_simulation(self):
"""Simulates live data updates."""
price_change = random.uniform(-0.2, 0.2)
old_price = self.stock_info["price"]
new_price = round(max(0.1, old_price + price_change), 2)
self.stock_info["price"] = new_price
self.stock_info["change"] = round(new_price - self.stock_info["close"], 2)
self.stock_info["change_percent"] = (
round(
self.stock_info["change"] / self.stock_info["close"] * 100,
2,
)
if self.stock_info["close"]
else 0
)
now = datetime.datetime.now(datetime.timezone.utc)
self.chart_data.append(
{
| new_price = max(0.1, start_price + price_change) |
ys()) | set(puts_by_strike.keys()))
combined = [
{
"call": calls_by_strike.get(strike),
"put": puts_by_strike.get(strike),
"strike": strike,
}
for strike in all_strikes
]
return combined
def _generate_initial_chart_data(self):
"""Generates some initial random chart data."""
if not self.chart_data:
now = datetime.datetime.now(datetime.timezone.utc)
start_price = self.stock_info["price"]
data = []
for i in range(60):
time = now - datetime.timedelta(minutes=59 - i)
price_change = random.uniform(-0.5, 0.5)
new_price = max(0.1, start_price + price_change)
data.append(
{
"time": time.strftime("%H:%M"),
"price": round(new_price, 2),
}
)
|
self.chart_data = data
def _update_data_simulation(self):
"""Simulates live data updates."""
price_change = random.uniform(-0.2, 0.2)
old_price = self.stock_info["price"]
new_price = round(max(0.1, old_price + price_change), 2)
self.stock_info["price"] = new_price
self.stock_info["change"] = round(new_price - self.stock_info["close"], 2)
self.stock_info["change_percent"] = (
round(
self.stock_info["change"] / self.stock_info["close"] * 100,
2,
)
if self.stock_info["close"]
else 0
)
now = datetime.datetime.now(datetime.timezone.utc)
self.chart_data.append(
{
"time": now.strftime("%H:%M"),
"price": new_price,
}
)
if len(self.chart_data) > 60:
self.chart_data.pop(0)
if self.recent_orders:
order_index = random.ra | start_price = new_price |
combined = [
{
"call": calls_by_strike.get(strike),
"put": puts_by_strike.get(strike),
"strike": strike,
}
for strike in all_strikes
]
return combined
def _generate_initial_chart_data(self):
"""Generates some initial random chart data."""
if not self.chart_data:
now = datetime.datetime.now(datetime.timezone.utc)
start_price = self.stock_info["price"]
data = []
for i in range(60):
time = now - datetime.timedelta(minutes=59 - i)
price_change = random.uniform(-0.5, 0.5)
new_price = max(0.1, start_price + price_change)
data.append(
{
"time": time.strftime("%H:%M"),
"price": round(new_price, 2),
}
)
start_price = new_price
|
def _update_data_simulation(self):
"""Simulates live data updates."""
price_change = random.uniform(-0.2, 0.2)
old_price = self.stock_info["price"]
new_price = round(max(0.1, old_price + price_change), 2)
self.stock_info["price"] = new_price
self.stock_info["change"] = round(new_price - self.stock_info["close"], 2)
self.stock_info["change_percent"] = (
round(
self.stock_info["change"] / self.stock_info["close"] * 100,
2,
)
if self.stock_info["close"]
else 0
)
now = datetime.datetime.now(datetime.timezone.utc)
self.chart_data.append(
{
"time": now.strftime("%H:%M"),
"price": new_price,
}
)
if len(self.chart_data) > 60:
self.chart_data.pop(0)
if self.recent_orders:
order_index = random.randint(0, len(self.recent_orders) - | self.chart_data = data |
s_by_strike.get(strike),
"strike": strike,
}
for strike in all_strikes
]
return combined
def _generate_initial_chart_data(self):
"""Generates some initial random chart data."""
if not self.chart_data:
now = datetime.datetime.now(datetime.timezone.utc)
start_price = self.stock_info["price"]
data = []
for i in range(60):
time = now - datetime.timedelta(minutes=59 - i)
price_change = random.uniform(-0.5, 0.5)
new_price = max(0.1, start_price + price_change)
data.append(
{
"time": time.strftime("%H:%M"),
"price": round(new_price, 2),
}
)
start_price = new_price
self.chart_data = data
def _update_data_simulation(self):
"""Simulates live data updates."""
|
old_price = self.stock_info["price"]
new_price = round(max(0.1, old_price + price_change), 2)
self.stock_info["price"] = new_price
self.stock_info["change"] = round(new_price - self.stock_info["close"], 2)
self.stock_info["change_percent"] = (
round(
self.stock_info["change"] / self.stock_info["close"] * 100,
2,
)
if self.stock_info["close"]
else 0
)
now = datetime.datetime.now(datetime.timezone.utc)
self.chart_data.append(
{
"time": now.strftime("%H:%M"),
"price": new_price,
}
)
if len(self.chart_data) > 60:
self.chart_data.pop(0)
if self.recent_orders:
order_index = random.randint(0, len(self.recent_orders) - 1)
statuses: List[
Literal[
"Sending",
"Working",
| price_change = random.uniform(-0.2, 0.2) |
: strike,
}
for strike in all_strikes
]
return combined
def _generate_initial_chart_data(self):
"""Generates some initial random chart data."""
if not self.chart_data:
now = datetime.datetime.now(datetime.timezone.utc)
start_price = self.stock_info["price"]
data = []
for i in range(60):
time = now - datetime.timedelta(minutes=59 - i)
price_change = random.uniform(-0.5, 0.5)
new_price = max(0.1, start_price + price_change)
data.append(
{
"time": time.strftime("%H:%M"),
"price": round(new_price, 2),
}
)
start_price = new_price
self.chart_data = data
def _update_data_simulation(self):
"""Simulates live data updates."""
price_change = random.uniform(-0.2, 0.2)
|
new_price = round(max(0.1, old_price + price_change), 2)
self.stock_info["price"] = new_price
self.stock_info["change"] = round(new_price - self.stock_info["close"], 2)
self.stock_info["change_percent"] = (
round(
self.stock_info["change"] / self.stock_info["close"] * 100,
2,
)
if self.stock_info["close"]
else 0
)
now = datetime.datetime.now(datetime.timezone.utc)
self.chart_data.append(
{
"time": now.strftime("%H:%M"),
"price": new_price,
}
)
if len(self.chart_data) > 60:
self.chart_data.pop(0)
if self.recent_orders:
order_index = random.randint(0, len(self.recent_orders) - 1)
statuses: List[
Literal[
"Sending",
"Working",
"Filled",
"Canceled | old_price = self.stock_info["price"] |
e in all_strikes
]
return combined
def _generate_initial_chart_data(self):
"""Generates some initial random chart data."""
if not self.chart_data:
now = datetime.datetime.now(datetime.timezone.utc)
start_price = self.stock_info["price"]
data = []
for i in range(60):
time = now - datetime.timedelta(minutes=59 - i)
price_change = random.uniform(-0.5, 0.5)
new_price = max(0.1, start_price + price_change)
data.append(
{
"time": time.strftime("%H:%M"),
"price": round(new_price, 2),
}
)
start_price = new_price
self.chart_data = data
def _update_data_simulation(self):
"""Simulates live data updates."""
price_change = random.uniform(-0.2, 0.2)
old_price = self.stock_info["price"]
|
self.stock_info["price"] = new_price
self.stock_info["change"] = round(new_price - self.stock_info["close"], 2)
self.stock_info["change_percent"] = (
round(
self.stock_info["change"] / self.stock_info["close"] * 100,
2,
)
if self.stock_info["close"]
else 0
)
now = datetime.datetime.now(datetime.timezone.utc)
self.chart_data.append(
{
"time": now.strftime("%H:%M"),
"price": new_price,
}
)
if len(self.chart_data) > 60:
self.chart_data.pop(0)
if self.recent_orders:
order_index = random.randint(0, len(self.recent_orders) - 1)
statuses: List[
Literal[
"Sending",
"Working",
"Filled",
"Canceled",
]
] = ["Sending", "Working", "Fill | new_price = round(max(0.1, old_price + price_change), 2) |
erate_initial_chart_data(self):
"""Generates some initial random chart data."""
if not self.chart_data:
now = datetime.datetime.now(datetime.timezone.utc)
start_price = self.stock_info["price"]
data = []
for i in range(60):
time = now - datetime.timedelta(minutes=59 - i)
price_change = random.uniform(-0.5, 0.5)
new_price = max(0.1, start_price + price_change)
data.append(
{
"time": time.strftime("%H:%M"),
"price": round(new_price, 2),
}
)
start_price = new_price
self.chart_data = data
def _update_data_simulation(self):
"""Simulates live data updates."""
price_change = random.uniform(-0.2, 0.2)
old_price = self.stock_info["price"]
new_price = round(max(0.1, old_price + price_change), 2)
|
self.stock_info["change"] = round(new_price - self.stock_info["close"], 2)
self.stock_info["change_percent"] = (
round(
self.stock_info["change"] / self.stock_info["close"] * 100,
2,
)
if self.stock_info["close"]
else 0
)
now = datetime.datetime.now(datetime.timezone.utc)
self.chart_data.append(
{
"time": now.strftime("%H:%M"),
"price": new_price,
}
)
if len(self.chart_data) > 60:
self.chart_data.pop(0)
if self.recent_orders:
order_index = random.randint(0, len(self.recent_orders) - 1)
statuses: List[
Literal[
"Sending",
"Working",
"Filled",
"Canceled",
]
] = ["Sending", "Working", "Filled", "Canceled"]
if (
| self.stock_info["price"] = new_price |
nerates some initial random chart data."""
if not self.chart_data:
now = datetime.datetime.now(datetime.timezone.utc)
start_price = self.stock_info["price"]
data = []
for i in range(60):
time = now - datetime.timedelta(minutes=59 - i)
price_change = random.uniform(-0.5, 0.5)
new_price = max(0.1, start_price + price_change)
data.append(
{
"time": time.strftime("%H:%M"),
"price": round(new_price, 2),
}
)
start_price = new_price
self.chart_data = data
def _update_data_simulation(self):
"""Simulates live data updates."""
price_change = random.uniform(-0.2, 0.2)
old_price = self.stock_info["price"]
new_price = round(max(0.1, old_price + price_change), 2)
self.stock_info["price"] = new_price
|
self.stock_info["change_percent"] = (
round(
self.stock_info["change"] / self.stock_info["close"] * 100,
2,
)
if self.stock_info["close"]
else 0
)
now = datetime.datetime.now(datetime.timezone.utc)
self.chart_data.append(
{
"time": now.strftime("%H:%M"),
"price": new_price,
}
)
if len(self.chart_data) > 60:
self.chart_data.pop(0)
if self.recent_orders:
order_index = random.randint(0, len(self.recent_orders) - 1)
statuses: List[
Literal[
"Sending",
"Working",
"Filled",
"Canceled",
]
] = ["Sending", "Working", "Filled", "Canceled"]
if (
self.recent_orders[order_index]["status"] not in ["Filled", "Canceled"]
| self.stock_info["change"] = round(new_price - self.stock_info["close"], 2) |
now = datetime.datetime.now(datetime.timezone.utc)
start_price = self.stock_info["price"]
data = []
for i in range(60):
time = now - datetime.timedelta(minutes=59 - i)
price_change = random.uniform(-0.5, 0.5)
new_price = max(0.1, start_price + price_change)
data.append(
{
"time": time.strftime("%H:%M"),
"price": round(new_price, 2),
}
)
start_price = new_price
self.chart_data = data
def _update_data_simulation(self):
"""Simulates live data updates."""
price_change = random.uniform(-0.2, 0.2)
old_price = self.stock_info["price"]
new_price = round(max(0.1, old_price + price_change), 2)
self.stock_info["price"] = new_price
self.stock_info["change"] = round(new_price - self.stock_info["close"], 2)
|
now = datetime.datetime.now(datetime.timezone.utc)
self.chart_data.append(
{
"time": now.strftime("%H:%M"),
"price": new_price,
}
)
if len(self.chart_data) > 60:
self.chart_data.pop(0)
if self.recent_orders:
order_index = random.randint(0, len(self.recent_orders) - 1)
statuses: List[
Literal[
"Sending",
"Working",
"Filled",
"Canceled",
]
] = ["Sending", "Working", "Filled", "Canceled"]
if (
self.recent_orders[order_index]["status"] not in ["Filled", "Canceled"]
or random.random() < 0.1
):
self.recent_orders[order_index]["status"] = random.choice(statuses)
if self.positions:
position_index = random.randint(0, len(self.positions) - 1)
| self.stock_info["change_percent"] = (
round(
self.stock_info["change"] / self.stock_info["close"] * 100,
2,
)
if self.stock_info["close"]
else 0
) |
ce_change = random.uniform(-0.5, 0.5)
new_price = max(0.1, start_price + price_change)
data.append(
{
"time": time.strftime("%H:%M"),
"price": round(new_price, 2),
}
)
start_price = new_price
self.chart_data = data
def _update_data_simulation(self):
"""Simulates live data updates."""
price_change = random.uniform(-0.2, 0.2)
old_price = self.stock_info["price"]
new_price = round(max(0.1, old_price + price_change), 2)
self.stock_info["price"] = new_price
self.stock_info["change"] = round(new_price - self.stock_info["close"], 2)
self.stock_info["change_percent"] = (
round(
self.stock_info["change"] / self.stock_info["close"] * 100,
2,
)
if self.stock_info["close"]
else 0
)
|
self.chart_data.append(
{
"time": now.strftime("%H:%M"),
"price": new_price,
}
)
if len(self.chart_data) > 60:
self.chart_data.pop(0)
if self.recent_orders:
order_index = random.randint(0, len(self.recent_orders) - 1)
statuses: List[
Literal[
"Sending",
"Working",
"Filled",
"Canceled",
]
] = ["Sending", "Working", "Filled", "Canceled"]
if (
self.recent_orders[order_index]["status"] not in ["Filled", "Canceled"]
or random.random() < 0.1
):
self.recent_orders[order_index]["status"] = random.choice(statuses)
if self.positions:
position_index = random.randint(0, len(self.positions) - 1)
change_factor = random.uniform(0.995, 1.005)
| now = datetime.datetime.now(datetime.timezone.utc) |
"price": round(new_price, 2),
}
)
start_price = new_price
self.chart_data = data
def _update_data_simulation(self):
"""Simulates live data updates."""
price_change = random.uniform(-0.2, 0.2)
old_price = self.stock_info["price"]
new_price = round(max(0.1, old_price + price_change), 2)
self.stock_info["price"] = new_price
self.stock_info["change"] = round(new_price - self.stock_info["close"], 2)
self.stock_info["change_percent"] = (
round(
self.stock_info["change"] / self.stock_info["close"] * 100,
2,
)
if self.stock_info["close"]
else 0
)
now = datetime.datetime.now(datetime.timezone.utc)
self.chart_data.append(
{
"time": now.strftime("%H:%M"),
"price": new_price,
}
)
|
if self.recent_orders:
order_index = random.randint(0, len(self.recent_orders) - 1)
statuses: List[
Literal[
"Sending",
"Working",
"Filled",
"Canceled",
]
] = ["Sending", "Working", "Filled", "Canceled"]
if (
self.recent_orders[order_index]["status"] not in ["Filled", "Canceled"]
or random.random() < 0.1
):
self.recent_orders[order_index]["status"] = random.choice(statuses)
if self.positions:
position_index = random.randint(0, len(self.positions) - 1)
change_factor = random.uniform(0.995, 1.005)
old_mkt_val = self.positions[position_index]["mkt_val"]
new_mkt_val = round(old_mkt_val * change_factor, 2)
self.positions[position_index]["mkt_val"] = new_mkt_val
day_return_change = (new_m | if len(self.chart_data) > 60:
self.chart_data.pop(0) |
)
start_price = new_price
self.chart_data = data
def _update_data_simulation(self):
"""Simulates live data updates."""
price_change = random.uniform(-0.2, 0.2)
old_price = self.stock_info["price"]
new_price = round(max(0.1, old_price + price_change), 2)
self.stock_info["price"] = new_price
self.stock_info["change"] = round(new_price - self.stock_info["close"], 2)
self.stock_info["change_percent"] = (
round(
self.stock_info["change"] / self.stock_info["close"] * 100,
2,
)
if self.stock_info["close"]
else 0
)
now = datetime.datetime.now(datetime.timezone.utc)
self.chart_data.append(
{
"time": now.strftime("%H:%M"),
"price": new_price,
}
)
if len(self.chart_data) > 60:
self.chart_data.pop(0)
|
if self.positions:
position_index = random.randint(0, len(self.positions) - 1)
change_factor = random.uniform(0.995, 1.005)
old_mkt_val = self.positions[position_index]["mkt_val"]
new_mkt_val = round(old_mkt_val * change_factor, 2)
self.positions[position_index]["mkt_val"] = new_mkt_val
day_return_change = (new_mkt_val - old_mkt_val) * random.uniform(0.8, 1.2)
self.positions[position_index]["day_return"] = round(
self.positions[position_index]["day_return"] + day_return_change,
2,
)
self.positions[position_index]["total_ret"] = round(
self.positions[position_index]["total_ret"] + day_return_change,
2,
)
self.positions[position_index]["mark"] = round(
self.positions[position_index]["mark"] * change_factor,
2,
)
for option_list in [
| if self.recent_orders:
order_index = random.randint(0, len(self.recent_orders) - 1)
statuses: List[
Literal[
"Sending",
"Working",
"Filled",
"Canceled",
]
] = ["Sending", "Working", "Filled", "Canceled"]
if (
self.recent_orders[order_index]["status"] not in ["Filled", "Canceled"]
or random.random() < 0.1
):
self.recent_orders[order_index]["status"] = random.choice(statuses) |
start_price = new_price
self.chart_data = data
def _update_data_simulation(self):
"""Simulates live data updates."""
price_change = random.uniform(-0.2, 0.2)
old_price = self.stock_info["price"]
new_price = round(max(0.1, old_price + price_change), 2)
self.stock_info["price"] = new_price
self.stock_info["change"] = round(new_price - self.stock_info["close"], 2)
self.stock_info["change_percent"] = (
round(
self.stock_info["change"] / self.stock_info["close"] * 100,
2,
)
if self.stock_info["close"]
else 0
)
now = datetime.datetime.now(datetime.timezone.utc)
self.chart_data.append(
{
"time": now.strftime("%H:%M"),
"price": new_price,
}
)
if len(self.chart_data) > 60:
self.chart_data.pop(0)
if self.recent_orders:
|
statuses: List[
Literal[
"Sending",
"Working",
"Filled",
"Canceled",
]
] = ["Sending", "Working", "Filled", "Canceled"]
if (
self.recent_orders[order_index]["status"] not in ["Filled", "Canceled"]
or random.random() < 0.1
):
self.recent_orders[order_index]["status"] = random.choice(statuses)
if self.positions:
position_index = random.randint(0, len(self.positions) - 1)
change_factor = random.uniform(0.995, 1.005)
old_mkt_val = self.positions[position_index]["mkt_val"]
new_mkt_val = round(old_mkt_val * change_factor, 2)
self.positions[position_index]["mkt_val"] = new_mkt_val
day_return_change = (new_mkt_val - old_mkt_val) * random.uniform(0.8, 1.2)
self.positions[position_index]["day_return" | order_index = random.randint(0, len(self.recent_orders) - 1) |
ce"] = new_price
self.stock_info["change"] = round(new_price - self.stock_info["close"], 2)
self.stock_info["change_percent"] = (
round(
self.stock_info["change"] / self.stock_info["close"] * 100,
2,
)
if self.stock_info["close"]
else 0
)
now = datetime.datetime.now(datetime.timezone.utc)
self.chart_data.append(
{
"time": now.strftime("%H:%M"),
"price": new_price,
}
)
if len(self.chart_data) > 60:
self.chart_data.pop(0)
if self.recent_orders:
order_index = random.randint(0, len(self.recent_orders) - 1)
statuses: List[
Literal[
"Sending",
"Working",
"Filled",
"Canceled",
]
] = ["Sending", "Working", "Filled", "Canceled"]
|
if self.positions:
position_index = random.randint(0, len(self.positions) - 1)
change_factor = random.uniform(0.995, 1.005)
old_mkt_val = self.positions[position_index]["mkt_val"]
new_mkt_val = round(old_mkt_val * change_factor, 2)
self.positions[position_index]["mkt_val"] = new_mkt_val
day_return_change = (new_mkt_val - old_mkt_val) * random.uniform(0.8, 1.2)
self.positions[position_index]["day_return"] = round(
self.positions[position_index]["day_return"] + day_return_change,
2,
)
self.positions[position_index]["total_ret"] = round(
self.positions[position_index]["total_ret"] + day_return_change,
2,
)
self.positions[position_index]["mark"] = round(
self.positions[position_index]["mark"] * change_factor,
2,
)
for option_list in [
| if (
self.recent_orders[order_index]["status"] not in ["Filled", "Canceled"]
or random.random() < 0.1
):
self.recent_orders[order_index]["status"] = random.choice(statuses) |
self.stock_info["change"] / self.stock_info["close"] * 100,
2,
)
if self.stock_info["close"]
else 0
)
now = datetime.datetime.now(datetime.timezone.utc)
self.chart_data.append(
{
"time": now.strftime("%H:%M"),
"price": new_price,
}
)
if len(self.chart_data) > 60:
self.chart_data.pop(0)
if self.recent_orders:
order_index = random.randint(0, len(self.recent_orders) - 1)
statuses: List[
Literal[
"Sending",
"Working",
"Filled",
"Canceled",
]
] = ["Sending", "Working", "Filled", "Canceled"]
if (
self.recent_orders[order_index]["status"] not in ["Filled", "Canceled"]
or random.random() < 0.1
):
|
if self.positions:
position_index = random.randint(0, len(self.positions) - 1)
change_factor = random.uniform(0.995, 1.005)
old_mkt_val = self.positions[position_index]["mkt_val"]
new_mkt_val = round(old_mkt_val * change_factor, 2)
self.positions[position_index]["mkt_val"] = new_mkt_val
day_return_change = (new_mkt_val - old_mkt_val) * random.uniform(0.8, 1.2)
self.positions[position_index]["day_return"] = round(
self.positions[position_index]["day_return"] + day_return_change,
2,
)
self.positions[position_index]["total_ret"] = round(
self.positions[position_index]["total_ret"] + day_return_change,
2,
)
self.positions[position_index]["mark"] = round(
self.positions[position_index]["mark"] * change_factor,
2,
)
for option_list in [
| self.recent_orders[order_index]["status"] = random.choice(statuses) |
)
if self.stock_info["close"]
else 0
)
now = datetime.datetime.now(datetime.timezone.utc)
self.chart_data.append(
{
"time": now.strftime("%H:%M"),
"price": new_price,
}
)
if len(self.chart_data) > 60:
self.chart_data.pop(0)
if self.recent_orders:
order_index = random.randint(0, len(self.recent_orders) - 1)
statuses: List[
Literal[
"Sending",
"Working",
"Filled",
"Canceled",
]
] = ["Sending", "Working", "Filled", "Canceled"]
if (
self.recent_orders[order_index]["status"] not in ["Filled", "Canceled"]
or random.random() < 0.1
):
self.recent_orders[order_index]["status"] = random.choice(statuses)
if self.positions:
|
change_factor = random.uniform(0.995, 1.005)
old_mkt_val = self.positions[position_index]["mkt_val"]
new_mkt_val = round(old_mkt_val * change_factor, 2)
self.positions[position_index]["mkt_val"] = new_mkt_val
day_return_change = (new_mkt_val - old_mkt_val) * random.uniform(0.8, 1.2)
self.positions[position_index]["day_return"] = round(
self.positions[position_index]["day_return"] + day_return_change,
2,
)
self.positions[position_index]["total_ret"] = round(
self.positions[position_index]["total_ret"] + day_return_change,
2,
)
self.positions[position_index]["mark"] = round(
self.positions[position_index]["mark"] * change_factor,
2,
)
for option_list in [
self.options_calls,
self.options_puts,
]:
for option in o | position_index = random.randint(0, len(self.positions) - 1) |
now = datetime.datetime.now(datetime.timezone.utc)
self.chart_data.append(
{
"time": now.strftime("%H:%M"),
"price": new_price,
}
)
if len(self.chart_data) > 60:
self.chart_data.pop(0)
if self.recent_orders:
order_index = random.randint(0, len(self.recent_orders) - 1)
statuses: List[
Literal[
"Sending",
"Working",
"Filled",
"Canceled",
]
] = ["Sending", "Working", "Filled", "Canceled"]
if (
self.recent_orders[order_index]["status"] not in ["Filled", "Canceled"]
or random.random() < 0.1
):
self.recent_orders[order_index]["status"] = random.choice(statuses)
if self.positions:
position_index = random.randint(0, len(self.positions) - 1)
|
old_mkt_val = self.positions[position_index]["mkt_val"]
new_mkt_val = round(old_mkt_val * change_factor, 2)
self.positions[position_index]["mkt_val"] = new_mkt_val
day_return_change = (new_mkt_val - old_mkt_val) * random.uniform(0.8, 1.2)
self.positions[position_index]["day_return"] = round(
self.positions[position_index]["day_return"] + day_return_change,
2,
)
self.positions[position_index]["total_ret"] = round(
self.positions[position_index]["total_ret"] + day_return_change,
2,
)
self.positions[position_index]["mark"] = round(
self.positions[position_index]["mark"] * change_factor,
2,
)
for option_list in [
self.options_calls,
self.options_puts,
]:
for option in option_list:
change_factor = random.unifor | change_factor = random.uniform(0.995, 1.005) |
self.chart_data.append(
{
"time": now.strftime("%H:%M"),
"price": new_price,
}
)
if len(self.chart_data) > 60:
self.chart_data.pop(0)
if self.recent_orders:
order_index = random.randint(0, len(self.recent_orders) - 1)
statuses: List[
Literal[
"Sending",
"Working",
"Filled",
"Canceled",
]
] = ["Sending", "Working", "Filled", "Canceled"]
if (
self.recent_orders[order_index]["status"] not in ["Filled", "Canceled"]
or random.random() < 0.1
):
self.recent_orders[order_index]["status"] = random.choice(statuses)
if self.positions:
position_index = random.randint(0, len(self.positions) - 1)
change_factor = random.uniform(0.995, 1.005)
|
new_mkt_val = round(old_mkt_val * change_factor, 2)
self.positions[position_index]["mkt_val"] = new_mkt_val
day_return_change = (new_mkt_val - old_mkt_val) * random.uniform(0.8, 1.2)
self.positions[position_index]["day_return"] = round(
self.positions[position_index]["day_return"] + day_return_change,
2,
)
self.positions[position_index]["total_ret"] = round(
self.positions[position_index]["total_ret"] + day_return_change,
2,
)
self.positions[position_index]["mark"] = round(
self.positions[position_index]["mark"] * change_factor,
2,
)
for option_list in [
self.options_calls,
self.options_puts,
]:
for option in option_list:
change_factor = random.uniform(0.98, 1.02)
option["mark"] = round(option["mark"] | old_mkt_val = self.positions[position_index]["mkt_val"] |
": now.strftime("%H:%M"),
"price": new_price,
}
)
if len(self.chart_data) > 60:
self.chart_data.pop(0)
if self.recent_orders:
order_index = random.randint(0, len(self.recent_orders) - 1)
statuses: List[
Literal[
"Sending",
"Working",
"Filled",
"Canceled",
]
] = ["Sending", "Working", "Filled", "Canceled"]
if (
self.recent_orders[order_index]["status"] not in ["Filled", "Canceled"]
or random.random() < 0.1
):
self.recent_orders[order_index]["status"] = random.choice(statuses)
if self.positions:
position_index = random.randint(0, len(self.positions) - 1)
change_factor = random.uniform(0.995, 1.005)
old_mkt_val = self.positions[position_index]["mkt_val"]
|
self.positions[position_index]["mkt_val"] = new_mkt_val
day_return_change = (new_mkt_val - old_mkt_val) * random.uniform(0.8, 1.2)
self.positions[position_index]["day_return"] = round(
self.positions[position_index]["day_return"] + day_return_change,
2,
)
self.positions[position_index]["total_ret"] = round(
self.positions[position_index]["total_ret"] + day_return_change,
2,
)
self.positions[position_index]["mark"] = round(
self.positions[position_index]["mark"] * change_factor,
2,
)
for option_list in [
self.options_calls,
self.options_puts,
]:
for option in option_list:
change_factor = random.uniform(0.98, 1.02)
option["mark"] = round(option["mark"] * change_factor, 2)
option["bid"] = round(option | new_mkt_val = round(old_mkt_val * change_factor, 2) |
}
)
if len(self.chart_data) > 60:
self.chart_data.pop(0)
if self.recent_orders:
order_index = random.randint(0, len(self.recent_orders) - 1)
statuses: List[
Literal[
"Sending",
"Working",
"Filled",
"Canceled",
]
] = ["Sending", "Working", "Filled", "Canceled"]
if (
self.recent_orders[order_index]["status"] not in ["Filled", "Canceled"]
or random.random() < 0.1
):
self.recent_orders[order_index]["status"] = random.choice(statuses)
if self.positions:
position_index = random.randint(0, len(self.positions) - 1)
change_factor = random.uniform(0.995, 1.005)
old_mkt_val = self.positions[position_index]["mkt_val"]
new_mkt_val = round(old_mkt_val * change_factor, 2)
|
day_return_change = (new_mkt_val - old_mkt_val) * random.uniform(0.8, 1.2)
self.positions[position_index]["day_return"] = round(
self.positions[position_index]["day_return"] + day_return_change,
2,
)
self.positions[position_index]["total_ret"] = round(
self.positions[position_index]["total_ret"] + day_return_change,
2,
)
self.positions[position_index]["mark"] = round(
self.positions[position_index]["mark"] * change_factor,
2,
)
for option_list in [
self.options_calls,
self.options_puts,
]:
for option in option_list:
change_factor = random.uniform(0.98, 1.02)
option["mark"] = round(option["mark"] * change_factor, 2)
option["bid"] = round(option["bid"] * change_factor, 2)
option["ask"] = round(op | self.positions[position_index]["mkt_val"] = new_mkt_val |
self.chart_data.pop(0)
if self.recent_orders:
order_index = random.randint(0, len(self.recent_orders) - 1)
statuses: List[
Literal[
"Sending",
"Working",
"Filled",
"Canceled",
]
] = ["Sending", "Working", "Filled", "Canceled"]
if (
self.recent_orders[order_index]["status"] not in ["Filled", "Canceled"]
or random.random() < 0.1
):
self.recent_orders[order_index]["status"] = random.choice(statuses)
if self.positions:
position_index = random.randint(0, len(self.positions) - 1)
change_factor = random.uniform(0.995, 1.005)
old_mkt_val = self.positions[position_index]["mkt_val"]
new_mkt_val = round(old_mkt_val * change_factor, 2)
self.positions[position_index]["mkt_val"] = new_mkt_val
|
self.positions[position_index]["day_return"] = round(
self.positions[position_index]["day_return"] + day_return_change,
2,
)
self.positions[position_index]["total_ret"] = round(
self.positions[position_index]["total_ret"] + day_return_change,
2,
)
self.positions[position_index]["mark"] = round(
self.positions[position_index]["mark"] * change_factor,
2,
)
for option_list in [
self.options_calls,
self.options_puts,
]:
for option in option_list:
change_factor = random.uniform(0.98, 1.02)
option["mark"] = round(option["mark"] * change_factor, 2)
option["bid"] = round(option["bid"] * change_factor, 2)
option["ask"] = round(option["ask"] * change_factor * 1.01, 2)
option["delta"] = round(
| day_return_change = (new_mkt_val - old_mkt_val) * random.uniform(0.8, 1.2) |
dom.randint(0, len(self.recent_orders) - 1)
statuses: List[
Literal[
"Sending",
"Working",
"Filled",
"Canceled",
]
] = ["Sending", "Working", "Filled", "Canceled"]
if (
self.recent_orders[order_index]["status"] not in ["Filled", "Canceled"]
or random.random() < 0.1
):
self.recent_orders[order_index]["status"] = random.choice(statuses)
if self.positions:
position_index = random.randint(0, len(self.positions) - 1)
change_factor = random.uniform(0.995, 1.005)
old_mkt_val = self.positions[position_index]["mkt_val"]
new_mkt_val = round(old_mkt_val * change_factor, 2)
self.positions[position_index]["mkt_val"] = new_mkt_val
day_return_change = (new_mkt_val - old_mkt_val) * random.uniform(0.8, 1.2)
|
self.positions[position_index]["total_ret"] = round(
self.positions[position_index]["total_ret"] + day_return_change,
2,
)
self.positions[position_index]["mark"] = round(
self.positions[position_index]["mark"] * change_factor,
2,
)
for option_list in [
self.options_calls,
self.options_puts,
]:
for option in option_list:
change_factor = random.uniform(0.98, 1.02)
option["mark"] = round(option["mark"] * change_factor, 2)
option["bid"] = round(option["bid"] * change_factor, 2)
option["ask"] = round(option["ask"] * change_factor * 1.01, 2)
option["delta"] = round(
option["delta"] * random.uniform(0.95, 1.05),
4,
)
option["iv"] = round(
option["iv"] * random.u | self.positions[position_index]["day_return"] = round(
self.positions[position_index]["day_return"] + day_return_change,
2,
) |
illed",
"Canceled",
]
] = ["Sending", "Working", "Filled", "Canceled"]
if (
self.recent_orders[order_index]["status"] not in ["Filled", "Canceled"]
or random.random() < 0.1
):
self.recent_orders[order_index]["status"] = random.choice(statuses)
if self.positions:
position_index = random.randint(0, len(self.positions) - 1)
change_factor = random.uniform(0.995, 1.005)
old_mkt_val = self.positions[position_index]["mkt_val"]
new_mkt_val = round(old_mkt_val * change_factor, 2)
self.positions[position_index]["mkt_val"] = new_mkt_val
day_return_change = (new_mkt_val - old_mkt_val) * random.uniform(0.8, 1.2)
self.positions[position_index]["day_return"] = round(
self.positions[position_index]["day_return"] + day_return_change,
2,
)
|
self.positions[position_index]["mark"] = round(
self.positions[position_index]["mark"] * change_factor,
2,
)
for option_list in [
self.options_calls,
self.options_puts,
]:
for option in option_list:
change_factor = random.uniform(0.98, 1.02)
option["mark"] = round(option["mark"] * change_factor, 2)
option["bid"] = round(option["bid"] * change_factor, 2)
option["ask"] = round(option["ask"] * change_factor * 1.01, 2)
option["delta"] = round(
option["delta"] * random.uniform(0.95, 1.05),
4,
)
option["iv"] = round(
option["iv"] * random.uniform(0.97, 1.03),
2,
)
@rx.event
def set_active_main_tab(self, tab_name: str):
self.active_main_tab = tab_name
@rx.even | self.positions[position_index]["total_ret"] = round(
self.positions[position_index]["total_ret"] + day_return_change,
2,
) |
dex]["status"] not in ["Filled", "Canceled"]
or random.random() < 0.1
):
self.recent_orders[order_index]["status"] = random.choice(statuses)
if self.positions:
position_index = random.randint(0, len(self.positions) - 1)
change_factor = random.uniform(0.995, 1.005)
old_mkt_val = self.positions[position_index]["mkt_val"]
new_mkt_val = round(old_mkt_val * change_factor, 2)
self.positions[position_index]["mkt_val"] = new_mkt_val
day_return_change = (new_mkt_val - old_mkt_val) * random.uniform(0.8, 1.2)
self.positions[position_index]["day_return"] = round(
self.positions[position_index]["day_return"] + day_return_change,
2,
)
self.positions[position_index]["total_ret"] = round(
self.positions[position_index]["total_ret"] + day_return_change,
2,
)
|
for option_list in [
self.options_calls,
self.options_puts,
]:
for option in option_list:
change_factor = random.uniform(0.98, 1.02)
option["mark"] = round(option["mark"] * change_factor, 2)
option["bid"] = round(option["bid"] * change_factor, 2)
option["ask"] = round(option["ask"] * change_factor * 1.01, 2)
option["delta"] = round(
option["delta"] * random.uniform(0.95, 1.05),
4,
)
option["iv"] = round(
option["iv"] * random.uniform(0.97, 1.03),
2,
)
@rx.event
def set_active_main_tab(self, tab_name: str):
self.active_main_tab = tab_name
@rx.event
def set_active_sub_tab(self, tab_name: str):
self.active_sub_tab = tab_name
@rx.event(background=True)
async def start_simulation(self):
| self.positions[position_index]["mark"] = round(
self.positions[position_index]["mark"] * change_factor,
2,
) |
positions) - 1)
change_factor = random.uniform(0.995, 1.005)
old_mkt_val = self.positions[position_index]["mkt_val"]
new_mkt_val = round(old_mkt_val * change_factor, 2)
self.positions[position_index]["mkt_val"] = new_mkt_val
day_return_change = (new_mkt_val - old_mkt_val) * random.uniform(0.8, 1.2)
self.positions[position_index]["day_return"] = round(
self.positions[position_index]["day_return"] + day_return_change,
2,
)
self.positions[position_index]["total_ret"] = round(
self.positions[position_index]["total_ret"] + day_return_change,
2,
)
self.positions[position_index]["mark"] = round(
self.positions[position_index]["mark"] * change_factor,
2,
)
for option_list in [
self.options_calls,
self.options_puts,
]:
|
@rx.event
def set_active_main_tab(self, tab_name: str):
self.active_main_tab = tab_name
@rx.event
def set_active_sub_tab(self, tab_name: str):
self.active_sub_tab = tab_name
@rx.event(background=True)
async def start_simulation(self):
"""Starts the data simulation loop."""
async with self:
if self.running_simulation:
return
self.running_simulation = True
self._generate_initial_chart_data()
while True:
async with self:
if not self.running_simulation:
break
self._update_data_simulation()
yield
if not self.running_simulation:
break
await asyncio.sleep(2)
@rx.event
def stop_simulation(self):
"""Stops the data simulation loop."""
self.running_simulation = False
| for option in option_list:
change_factor = random.uniform(0.98, 1.02)
option["mark"] = round(option["mark"] * change_factor, 2)
option["bid"] = round(option["bid"] * change_factor, 2)
option["ask"] = round(option["ask"] * change_factor * 1.01, 2)
option["delta"] = round(
option["delta"] * random.uniform(0.95, 1.05),
4,
)
option["iv"] = round(
option["iv"] * random.uniform(0.97, 1.03),
2,
) |
random.uniform(0.995, 1.005)
old_mkt_val = self.positions[position_index]["mkt_val"]
new_mkt_val = round(old_mkt_val * change_factor, 2)
self.positions[position_index]["mkt_val"] = new_mkt_val
day_return_change = (new_mkt_val - old_mkt_val) * random.uniform(0.8, 1.2)
self.positions[position_index]["day_return"] = round(
self.positions[position_index]["day_return"] + day_return_change,
2,
)
self.positions[position_index]["total_ret"] = round(
self.positions[position_index]["total_ret"] + day_return_change,
2,
)
self.positions[position_index]["mark"] = round(
self.positions[position_index]["mark"] * change_factor,
2,
)
for option_list in [
self.options_calls,
self.options_puts,
]:
for option in option_list:
|
option["mark"] = round(option["mark"] * change_factor, 2)
option["bid"] = round(option["bid"] * change_factor, 2)
option["ask"] = round(option["ask"] * change_factor * 1.01, 2)
option["delta"] = round(
option["delta"] * random.uniform(0.95, 1.05),
4,
)
option["iv"] = round(
option["iv"] * random.uniform(0.97, 1.03),
2,
)
@rx.event
def set_active_main_tab(self, tab_name: str):
self.active_main_tab = tab_name
@rx.event
def set_active_sub_tab(self, tab_name: str):
self.active_sub_tab = tab_name
@rx.event(background=True)
async def start_simulation(self):
"""Starts the data simulation loop."""
async with self:
if self.running_simulation:
return
self.running_simulation = True
self._generate_i | change_factor = random.uniform(0.98, 1.02) |
f.positions[position_index]["mkt_val"]
new_mkt_val = round(old_mkt_val * change_factor, 2)
self.positions[position_index]["mkt_val"] = new_mkt_val
day_return_change = (new_mkt_val - old_mkt_val) * random.uniform(0.8, 1.2)
self.positions[position_index]["day_return"] = round(
self.positions[position_index]["day_return"] + day_return_change,
2,
)
self.positions[position_index]["total_ret"] = round(
self.positions[position_index]["total_ret"] + day_return_change,
2,
)
self.positions[position_index]["mark"] = round(
self.positions[position_index]["mark"] * change_factor,
2,
)
for option_list in [
self.options_calls,
self.options_puts,
]:
for option in option_list:
change_factor = random.uniform(0.98, 1.02)
|
option["bid"] = round(option["bid"] * change_factor, 2)
option["ask"] = round(option["ask"] * change_factor * 1.01, 2)
option["delta"] = round(
option["delta"] * random.uniform(0.95, 1.05),
4,
)
option["iv"] = round(
option["iv"] * random.uniform(0.97, 1.03),
2,
)
@rx.event
def set_active_main_tab(self, tab_name: str):
self.active_main_tab = tab_name
@rx.event
def set_active_sub_tab(self, tab_name: str):
self.active_sub_tab = tab_name
@rx.event(background=True)
async def start_simulation(self):
"""Starts the data simulation loop."""
async with self:
if self.running_simulation:
return
self.running_simulation = True
self._generate_initial_chart_data()
while True:
async with self:
| option["mark"] = round(option["mark"] * change_factor, 2) |
_mkt_val * change_factor, 2)
self.positions[position_index]["mkt_val"] = new_mkt_val
day_return_change = (new_mkt_val - old_mkt_val) * random.uniform(0.8, 1.2)
self.positions[position_index]["day_return"] = round(
self.positions[position_index]["day_return"] + day_return_change,
2,
)
self.positions[position_index]["total_ret"] = round(
self.positions[position_index]["total_ret"] + day_return_change,
2,
)
self.positions[position_index]["mark"] = round(
self.positions[position_index]["mark"] * change_factor,
2,
)
for option_list in [
self.options_calls,
self.options_puts,
]:
for option in option_list:
change_factor = random.uniform(0.98, 1.02)
option["mark"] = round(option["mark"] * change_factor, 2)
|
option["ask"] = round(option["ask"] * change_factor * 1.01, 2)
option["delta"] = round(
option["delta"] * random.uniform(0.95, 1.05),
4,
)
option["iv"] = round(
option["iv"] * random.uniform(0.97, 1.03),
2,
)
@rx.event
def set_active_main_tab(self, tab_name: str):
self.active_main_tab = tab_name
@rx.event
def set_active_sub_tab(self, tab_name: str):
self.active_sub_tab = tab_name
@rx.event(background=True)
async def start_simulation(self):
"""Starts the data simulation loop."""
async with self:
if self.running_simulation:
return
self.running_simulation = True
self._generate_initial_chart_data()
while True:
async with self:
if not self.running_simulation:
break
| option["bid"] = round(option["bid"] * change_factor, 2) |
"mkt_val"] = new_mkt_val
day_return_change = (new_mkt_val - old_mkt_val) * random.uniform(0.8, 1.2)
self.positions[position_index]["day_return"] = round(
self.positions[position_index]["day_return"] + day_return_change,
2,
)
self.positions[position_index]["total_ret"] = round(
self.positions[position_index]["total_ret"] + day_return_change,
2,
)
self.positions[position_index]["mark"] = round(
self.positions[position_index]["mark"] * change_factor,
2,
)
for option_list in [
self.options_calls,
self.options_puts,
]:
for option in option_list:
change_factor = random.uniform(0.98, 1.02)
option["mark"] = round(option["mark"] * change_factor, 2)
option["bid"] = round(option["bid"] * change_factor, 2)
|
option["delta"] = round(
option["delta"] * random.uniform(0.95, 1.05),
4,
)
option["iv"] = round(
option["iv"] * random.uniform(0.97, 1.03),
2,
)
@rx.event
def set_active_main_tab(self, tab_name: str):
self.active_main_tab = tab_name
@rx.event
def set_active_sub_tab(self, tab_name: str):
self.active_sub_tab = tab_name
@rx.event(background=True)
async def start_simulation(self):
"""Starts the data simulation loop."""
async with self:
if self.running_simulation:
return
self.running_simulation = True
self._generate_initial_chart_data()
while True:
async with self:
if not self.running_simulation:
break
self._update_data_simulation()
yield
if no | option["ask"] = round(option["ask"] * change_factor * 1.01, 2) |
_val) * random.uniform(0.8, 1.2)
self.positions[position_index]["day_return"] = round(
self.positions[position_index]["day_return"] + day_return_change,
2,
)
self.positions[position_index]["total_ret"] = round(
self.positions[position_index]["total_ret"] + day_return_change,
2,
)
self.positions[position_index]["mark"] = round(
self.positions[position_index]["mark"] * change_factor,
2,
)
for option_list in [
self.options_calls,
self.options_puts,
]:
for option in option_list:
change_factor = random.uniform(0.98, 1.02)
option["mark"] = round(option["mark"] * change_factor, 2)
option["bid"] = round(option["bid"] * change_factor, 2)
option["ask"] = round(option["ask"] * change_factor * 1.01, 2)
|
option["iv"] = round(
option["iv"] * random.uniform(0.97, 1.03),
2,
)
@rx.event
def set_active_main_tab(self, tab_name: str):
self.active_main_tab = tab_name
@rx.event
def set_active_sub_tab(self, tab_name: str):
self.active_sub_tab = tab_name
@rx.event(background=True)
async def start_simulation(self):
"""Starts the data simulation loop."""
async with self:
if self.running_simulation:
return
self.running_simulation = True
self._generate_initial_chart_data()
while True:
async with self:
if not self.running_simulation:
break
self._update_data_simulation()
yield
if not self.running_simulation:
break
await asyncio.sleep(2)
@rx.event
def stop_simulation(self):
"""Stops t | option["delta"] = round(
option["delta"] * random.uniform(0.95, 1.05),
4,
) |
ay_return"] + day_return_change,
2,
)
self.positions[position_index]["total_ret"] = round(
self.positions[position_index]["total_ret"] + day_return_change,
2,
)
self.positions[position_index]["mark"] = round(
self.positions[position_index]["mark"] * change_factor,
2,
)
for option_list in [
self.options_calls,
self.options_puts,
]:
for option in option_list:
change_factor = random.uniform(0.98, 1.02)
option["mark"] = round(option["mark"] * change_factor, 2)
option["bid"] = round(option["bid"] * change_factor, 2)
option["ask"] = round(option["ask"] * change_factor * 1.01, 2)
option["delta"] = round(
option["delta"] * random.uniform(0.95, 1.05),
4,
)
|
@rx.event
def set_active_main_tab(self, tab_name: str):
self.active_main_tab = tab_name
@rx.event
def set_active_sub_tab(self, tab_name: str):
self.active_sub_tab = tab_name
@rx.event(background=True)
async def start_simulation(self):
"""Starts the data simulation loop."""
async with self:
if self.running_simulation:
return
self.running_simulation = True
self._generate_initial_chart_data()
while True:
async with self:
if not self.running_simulation:
break
self._update_data_simulation()
yield
if not self.running_simulation:
break
await asyncio.sleep(2)
@rx.event
def stop_simulation(self):
"""Stops the data simulation loop."""
self.running_simulation = False
| option["iv"] = round(
option["iv"] * random.uniform(0.97, 1.03),
2,
) |
self.positions[position_index]["total_ret"] + day_return_change,
2,
)
self.positions[position_index]["mark"] = round(
self.positions[position_index]["mark"] * change_factor,
2,
)
for option_list in [
self.options_calls,
self.options_puts,
]:
for option in option_list:
change_factor = random.uniform(0.98, 1.02)
option["mark"] = round(option["mark"] * change_factor, 2)
option["bid"] = round(option["bid"] * change_factor, 2)
option["ask"] = round(option["ask"] * change_factor * 1.01, 2)
option["delta"] = round(
option["delta"] * random.uniform(0.95, 1.05),
4,
)
option["iv"] = round(
option["iv"] * random.uniform(0.97, 1.03),
2,
)
@rx.event
|
@rx.event
def set_active_sub_tab(self, tab_name: str):
self.active_sub_tab = tab_name
@rx.event(background=True)
async def start_simulation(self):
"""Starts the data simulation loop."""
async with self:
if self.running_simulation:
return
self.running_simulation = True
self._generate_initial_chart_data()
while True:
async with self:
if not self.running_simulation:
break
self._update_data_simulation()
yield
if not self.running_simulation:
break
await asyncio.sleep(2)
@rx.event
def stop_simulation(self):
"""Stops the data simulation loop."""
self.running_simulation = False
| def set_active_main_tab(self, tab_name: str):
self.active_main_tab = tab_name |
turn_change,
2,
)
self.positions[position_index]["mark"] = round(
self.positions[position_index]["mark"] * change_factor,
2,
)
for option_list in [
self.options_calls,
self.options_puts,
]:
for option in option_list:
change_factor = random.uniform(0.98, 1.02)
option["mark"] = round(option["mark"] * change_factor, 2)
option["bid"] = round(option["bid"] * change_factor, 2)
option["ask"] = round(option["ask"] * change_factor * 1.01, 2)
option["delta"] = round(
option["delta"] * random.uniform(0.95, 1.05),
4,
)
option["iv"] = round(
option["iv"] * random.uniform(0.97, 1.03),
2,
)
@rx.event
def set_active_main_tab(self, tab_name: str):
|
@rx.event
def set_active_sub_tab(self, tab_name: str):
self.active_sub_tab = tab_name
@rx.event(background=True)
async def start_simulation(self):
"""Starts the data simulation loop."""
async with self:
if self.running_simulation:
return
self.running_simulation = True
self._generate_initial_chart_data()
while True:
async with self:
if not self.running_simulation:
break
self._update_data_simulation()
yield
if not self.running_simulation:
break
await asyncio.sleep(2)
@rx.event
def stop_simulation(self):
"""Stops the data simulation loop."""
self.running_simulation = False
| self.active_main_tab = tab_name |
self.positions[position_index]["mark"] = round(
self.positions[position_index]["mark"] * change_factor,
2,
)
for option_list in [
self.options_calls,
self.options_puts,
]:
for option in option_list:
change_factor = random.uniform(0.98, 1.02)
option["mark"] = round(option["mark"] * change_factor, 2)
option["bid"] = round(option["bid"] * change_factor, 2)
option["ask"] = round(option["ask"] * change_factor * 1.01, 2)
option["delta"] = round(
option["delta"] * random.uniform(0.95, 1.05),
4,
)
option["iv"] = round(
option["iv"] * random.uniform(0.97, 1.03),
2,
)
@rx.event
def set_active_main_tab(self, tab_name: str):
self.active_main_tab = tab_name
@rx.event
|
@rx.event(background=True)
async def start_simulation(self):
"""Starts the data simulation loop."""
async with self:
if self.running_simulation:
return
self.running_simulation = True
self._generate_initial_chart_data()
while True:
async with self:
if not self.running_simulation:
break
self._update_data_simulation()
yield
if not self.running_simulation:
break
await asyncio.sleep(2)
@rx.event
def stop_simulation(self):
"""Stops the data simulation loop."""
self.running_simulation = False
| def set_active_sub_tab(self, tab_name: str):
self.active_sub_tab = tab_name |
(
self.positions[position_index]["mark"] * change_factor,
2,
)
for option_list in [
self.options_calls,
self.options_puts,
]:
for option in option_list:
change_factor = random.uniform(0.98, 1.02)
option["mark"] = round(option["mark"] * change_factor, 2)
option["bid"] = round(option["bid"] * change_factor, 2)
option["ask"] = round(option["ask"] * change_factor * 1.01, 2)
option["delta"] = round(
option["delta"] * random.uniform(0.95, 1.05),
4,
)
option["iv"] = round(
option["iv"] * random.uniform(0.97, 1.03),
2,
)
@rx.event
def set_active_main_tab(self, tab_name: str):
self.active_main_tab = tab_name
@rx.event
def set_active_sub_tab(self, tab_name: str):
|
@rx.event(background=True)
async def start_simulation(self):
"""Starts the data simulation loop."""
async with self:
if self.running_simulation:
return
self.running_simulation = True
self._generate_initial_chart_data()
while True:
async with self:
if not self.running_simulation:
break
self._update_data_simulation()
yield
if not self.running_simulation:
break
await asyncio.sleep(2)
@rx.event
def stop_simulation(self):
"""Stops the data simulation loop."""
self.running_simulation = False
| self.active_sub_tab = tab_name |
options_puts,
]:
for option in option_list:
change_factor = random.uniform(0.98, 1.02)
option["mark"] = round(option["mark"] * change_factor, 2)
option["bid"] = round(option["bid"] * change_factor, 2)
option["ask"] = round(option["ask"] * change_factor * 1.01, 2)
option["delta"] = round(
option["delta"] * random.uniform(0.95, 1.05),
4,
)
option["iv"] = round(
option["iv"] * random.uniform(0.97, 1.03),
2,
)
@rx.event
def set_active_main_tab(self, tab_name: str):
self.active_main_tab = tab_name
@rx.event
def set_active_sub_tab(self, tab_name: str):
self.active_sub_tab = tab_name
@rx.event(background=True)
async def start_simulation(self):
"""Starts the data simulation loop."""
async with self:
|
self.running_simulation = True
self._generate_initial_chart_data()
while True:
async with self:
if not self.running_simulation:
break
self._update_data_simulation()
yield
if not self.running_simulation:
break
await asyncio.sleep(2)
@rx.event
def stop_simulation(self):
"""Stops the data simulation loop."""
self.running_simulation = False
| if self.running_simulation:
return |
change_factor = random.uniform(0.98, 1.02)
option["mark"] = round(option["mark"] * change_factor, 2)
option["bid"] = round(option["bid"] * change_factor, 2)
option["ask"] = round(option["ask"] * change_factor * 1.01, 2)
option["delta"] = round(
option["delta"] * random.uniform(0.95, 1.05),
4,
)
option["iv"] = round(
option["iv"] * random.uniform(0.97, 1.03),
2,
)
@rx.event
def set_active_main_tab(self, tab_name: str):
self.active_main_tab = tab_name
@rx.event
def set_active_sub_tab(self, tab_name: str):
self.active_sub_tab = tab_name
@rx.event(background=True)
async def start_simulation(self):
"""Starts the data simulation loop."""
async with self:
if self.running_simulation:
return
|
self._generate_initial_chart_data()
while True:
async with self:
if not self.running_simulation:
break
self._update_data_simulation()
yield
if not self.running_simulation:
break
await asyncio.sleep(2)
@rx.event
def stop_simulation(self):
"""Stops the data simulation loop."""
self.running_simulation = False
| self.running_simulation = True |
k"] = round(option["mark"] * change_factor, 2)
option["bid"] = round(option["bid"] * change_factor, 2)
option["ask"] = round(option["ask"] * change_factor * 1.01, 2)
option["delta"] = round(
option["delta"] * random.uniform(0.95, 1.05),
4,
)
option["iv"] = round(
option["iv"] * random.uniform(0.97, 1.03),
2,
)
@rx.event
def set_active_main_tab(self, tab_name: str):
self.active_main_tab = tab_name
@rx.event
def set_active_sub_tab(self, tab_name: str):
self.active_sub_tab = tab_name
@rx.event(background=True)
async def start_simulation(self):
"""Starts the data simulation loop."""
async with self:
if self.running_simulation:
return
self.running_simulation = True
self._generate_initial_chart_data()
|
@rx.event
def stop_simulation(self):
"""Stops the data simulation loop."""
self.running_simulation = False
| while True:
async with self:
if not self.running_simulation:
break
self._update_data_simulation()
yield
if not self.running_simulation:
break
await asyncio.sleep(2) |
option["bid"] = round(option["bid"] * change_factor, 2)
option["ask"] = round(option["ask"] * change_factor * 1.01, 2)
option["delta"] = round(
option["delta"] * random.uniform(0.95, 1.05),
4,
)
option["iv"] = round(
option["iv"] * random.uniform(0.97, 1.03),
2,
)
@rx.event
def set_active_main_tab(self, tab_name: str):
self.active_main_tab = tab_name
@rx.event
def set_active_sub_tab(self, tab_name: str):
self.active_sub_tab = tab_name
@rx.event(background=True)
async def start_simulation(self):
"""Starts the data simulation loop."""
async with self:
if self.running_simulation:
return
self.running_simulation = True
self._generate_initial_chart_data()
while True:
async with self:
|
self._update_data_simulation()
yield
if not self.running_simulation:
break
await asyncio.sleep(2)
@rx.event
def stop_simulation(self):
"""Stops the data simulation loop."""
self.running_simulation = False
| if not self.running_simulation:
break |
1, 2)
option["delta"] = round(
option["delta"] * random.uniform(0.95, 1.05),
4,
)
option["iv"] = round(
option["iv"] * random.uniform(0.97, 1.03),
2,
)
@rx.event
def set_active_main_tab(self, tab_name: str):
self.active_main_tab = tab_name
@rx.event
def set_active_sub_tab(self, tab_name: str):
self.active_sub_tab = tab_name
@rx.event(background=True)
async def start_simulation(self):
"""Starts the data simulation loop."""
async with self:
if self.running_simulation:
return
self.running_simulation = True
self._generate_initial_chart_data()
while True:
async with self:
if not self.running_simulation:
break
self._update_data_simulation()
yield
|
await asyncio.sleep(2)
@rx.event
def stop_simulation(self):
"""Stops the data simulation loop."""
self.running_simulation = False
| if not self.running_simulation:
break |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.