instruction stringlengths 0 1k | input stringlengths 1 1k | output stringlengths 10 6.51k |
|---|---|---|
import reflex as rx
from reflex_img_comparison_slider import img_comparison_slider
from .. import styles
|
from ..components.options_ui import mobile_header
from ..components.react_zoom import image_zoom
from ..views.mobile_ui import mobile_ui
from ..views.sidebar import sidebar
def _image_ui() -> rx.Component:
return rx.cond(
GeneratorState.upscaled_image
& ~GeneratorState.is_generating, # If upscaled image is available and not generating
img_comparison_slider(
rx.image(
src=GeneratorState.output_image, slot="first", **styles.image_props
),
rx.image(
src=GeneratorState.upscaled_image, slot="second", **styles.image_props
),
),
rx.cond(
~GeneratorState.is_generating
& ~GeneratorState.is_upscaling, # If not generating and not upscaling
image_zoom(rx.image(src=GeneratorState.output_image, **styles.image_props)),
rx.skeleton(
rx.box(rx.image(src=GeneratorState.output_image, **styles.image_props)),
| from ..backend.generation import CopyLocalState, GeneratorState, copy_script |
import reflex as rx
from reflex_img_comparison_slider import img_comparison_slider
from .. import styles
from ..backend.generation import CopyLocalState, GeneratorState, copy_script
|
from ..components.react_zoom import image_zoom
from ..views.mobile_ui import mobile_ui
from ..views.sidebar import sidebar
def _image_ui() -> rx.Component:
return rx.cond(
GeneratorState.upscaled_image
& ~GeneratorState.is_generating, # If upscaled image is available and not generating
img_comparison_slider(
rx.image(
src=GeneratorState.output_image, slot="first", **styles.image_props
),
rx.image(
src=GeneratorState.upscaled_image, slot="second", **styles.image_props
),
),
rx.cond(
~GeneratorState.is_generating
& ~GeneratorState.is_upscaling, # If not generating and not upscaling
image_zoom(rx.image(src=GeneratorState.output_image, **styles.image_props)),
rx.skeleton(
rx.box(rx.image(src=GeneratorState.output_image, **styles.image_props)),
loading=GeneratorState.is_generating | Ge | from ..components.options_ui import mobile_header |
import reflex as rx
from reflex_img_comparison_slider import img_comparison_slider
from .. import styles
from ..backend.generation import CopyLocalState, GeneratorState, copy_script
from ..components.options_ui import mobile_header
|
from ..views.mobile_ui import mobile_ui
from ..views.sidebar import sidebar
def _image_ui() -> rx.Component:
return rx.cond(
GeneratorState.upscaled_image
& ~GeneratorState.is_generating, # If upscaled image is available and not generating
img_comparison_slider(
rx.image(
src=GeneratorState.output_image, slot="first", **styles.image_props
),
rx.image(
src=GeneratorState.upscaled_image, slot="second", **styles.image_props
),
),
rx.cond(
~GeneratorState.is_generating
& ~GeneratorState.is_upscaling, # If not generating and not upscaling
image_zoom(rx.image(src=GeneratorState.output_image, **styles.image_props)),
rx.skeleton(
rx.box(rx.image(src=GeneratorState.output_image, **styles.image_props)),
loading=GeneratorState.is_generating | GeneratorState.is_upscaling,
),
| from ..components.react_zoom import image_zoom |
import reflex as rx
from reflex_img_comparison_slider import img_comparison_slider
from .. import styles
from ..backend.generation import CopyLocalState, GeneratorState, copy_script
from ..components.options_ui import mobile_header
from ..components.react_zoom import image_zoom
|
from ..views.sidebar import sidebar
def _image_ui() -> rx.Component:
return rx.cond(
GeneratorState.upscaled_image
& ~GeneratorState.is_generating, # If upscaled image is available and not generating
img_comparison_slider(
rx.image(
src=GeneratorState.output_image, slot="first", **styles.image_props
),
rx.image(
src=GeneratorState.upscaled_image, slot="second", **styles.image_props
),
),
rx.cond(
~GeneratorState.is_generating
& ~GeneratorState.is_upscaling, # If not generating and not upscaling
image_zoom(rx.image(src=GeneratorState.output_image, **styles.image_props)),
rx.skeleton(
rx.box(rx.image(src=GeneratorState.output_image, **styles.image_props)),
loading=GeneratorState.is_generating | GeneratorState.is_upscaling,
),
),
)
def _image_list_item(image | from ..views.mobile_ui import mobile_ui |
import reflex as rx
from reflex_img_comparison_slider import img_comparison_slider
from .. import styles
from ..backend.generation import CopyLocalState, GeneratorState, copy_script
from ..components.options_ui import mobile_header
from ..components.react_zoom import image_zoom
from ..views.mobile_ui import mobile_ui
|
def _image_ui() -> rx.Component:
return rx.cond(
GeneratorState.upscaled_image
& ~GeneratorState.is_generating, # If upscaled image is available and not generating
img_comparison_slider(
rx.image(
src=GeneratorState.output_image, slot="first", **styles.image_props
),
rx.image(
src=GeneratorState.upscaled_image, slot="second", **styles.image_props
),
),
rx.cond(
~GeneratorState.is_generating
& ~GeneratorState.is_upscaling, # If not generating and not upscaling
image_zoom(rx.image(src=GeneratorState.output_image, **styles.image_props)),
rx.skeleton(
rx.box(rx.image(src=GeneratorState.output_image, **styles.image_props)),
loading=GeneratorState.is_generating | GeneratorState.is_upscaling,
),
),
)
def _image_list_item(image: str) -> rx.Component:
return r | from ..views.sidebar import sidebar |
height="100%",
decoding="auto",
style={
"transform": rx.cond(
image == GeneratorState.output_image,
"scale(0.875)",
"",
),
"filter": rx.cond(
image == GeneratorState.output_image,
"",
"brightness(.75)",
),
},
loading="lazy",
alt="Output image option",
transition="all 0.2s ease",
object_fit="cover",
),
width="auto",
aspect_ratio="1/1",
max_height="5em",
max_width="5em",
cursor="pointer",
background=rx.color("accent", 9),
on_click=GeneratorState.set_output_image(image),
),
loading=GeneratorState.is_generating | GeneratorState.is_upscaling,
)
|
def _upscale_button() -> rx.Component:
return rx.cond(
~GeneratorState.is_upscaling,
rx.button(
rx.icon("scaling", size=20),
"Upscale",
**styles.button_props,
on_click=GeneratorState.upscale_image,
),
rx.button(
rx.spinner(size="3"),
"Cancel",
**styles.button_props,
color_scheme="tomato",
on_click=GeneratorState.cancel_generation,
),
)
def _download_button():
return rx.cond(
GeneratorState.is_downloading,
rx.icon_button(
rx.spinner(size="3"),
**styles.button_props,
color_scheme="blue",
),
rx.icon_button(
rx.icon("download", size=20),
**styles.button_props,
color_scheme="gray",
on_click=GeneratorState.download_image,
),
)
def _copy_button():
return rx.cond(
CopyLocalState.value,
| def _image_list() -> rx.Component:
return rx.scroll_area(
rx.hstack(
rx.foreach(
GeneratorState.output_list,
_image_list_item,
),
spacing="4",
width="100%",
align="center",
),
display=rx.cond(
GeneratorState.output_list,
"flex",
"none",
),
type="auto",
scrollbars="horizontal",
) |
},
loading="lazy",
alt="Output image option",
transition="all 0.2s ease",
object_fit="cover",
),
width="auto",
aspect_ratio="1/1",
max_height="5em",
max_width="5em",
cursor="pointer",
background=rx.color("accent", 9),
on_click=GeneratorState.set_output_image(image),
),
loading=GeneratorState.is_generating | GeneratorState.is_upscaling,
)
def _image_list() -> rx.Component:
return rx.scroll_area(
rx.hstack(
rx.foreach(
GeneratorState.output_list,
_image_list_item,
),
spacing="4",
width="100%",
align="center",
),
display=rx.cond(
GeneratorState.output_list,
"flex",
"none",
),
type="auto",
scrollbars="horizontal",
)
|
def _download_button():
return rx.cond(
GeneratorState.is_downloading,
rx.icon_button(
rx.spinner(size="3"),
**styles.button_props,
color_scheme="blue",
),
rx.icon_button(
rx.icon("download", size=20),
**styles.button_props,
color_scheme="gray",
on_click=GeneratorState.download_image,
),
)
def _copy_button():
return rx.cond(
CopyLocalState.value,
rx.tooltip(
rx.icon_button(
rx.icon("clipboard-check", size=20),
**styles.button_props,
color_scheme="green",
),
content="Copied",
open=CopyLocalState.value,
side="top",
),
rx.icon_button(
rx.icon("clipboard", size=20),
**styles.button_props,
color_scheme="gray",
on_click=[copy_script(), GeneratorState.copy_image],
| def _upscale_button() -> rx.Component:
return rx.cond(
~GeneratorState.is_upscaling,
rx.button(
rx.icon("scaling", size=20),
"Upscale",
**styles.button_props,
on_click=GeneratorState.upscale_image,
),
rx.button(
rx.spinner(size="3"),
"Cancel",
**styles.button_props,
color_scheme="tomato",
on_click=GeneratorState.cancel_generation,
),
) |
GeneratorState.is_upscaling,
)
def _image_list() -> rx.Component:
return rx.scroll_area(
rx.hstack(
rx.foreach(
GeneratorState.output_list,
_image_list_item,
),
spacing="4",
width="100%",
align="center",
),
display=rx.cond(
GeneratorState.output_list,
"flex",
"none",
),
type="auto",
scrollbars="horizontal",
)
def _upscale_button() -> rx.Component:
return rx.cond(
~GeneratorState.is_upscaling,
rx.button(
rx.icon("scaling", size=20),
"Upscale",
**styles.button_props,
on_click=GeneratorState.upscale_image,
),
rx.button(
rx.spinner(size="3"),
"Cancel",
**styles.button_props,
color_scheme="tomato",
on_click=GeneratorState.cancel_generation,
),
)
|
def _copy_button():
return rx.cond(
CopyLocalState.value,
rx.tooltip(
rx.icon_button(
rx.icon("clipboard-check", size=20),
**styles.button_props,
color_scheme="green",
),
content="Copied",
open=CopyLocalState.value,
side="top",
),
rx.icon_button(
rx.icon("clipboard", size=20),
**styles.button_props,
color_scheme="gray",
on_click=[copy_script(), GeneratorState.copy_image],
),
)
@rx.page(
"/",
title="AI Image Generator - Reflex",
description="Generate an image using AI with Reflex",
)
def index():
return rx.flex(
CopyLocalState,
sidebar(),
mobile_header(),
rx.center(
rx.vstack(
_image_ui(),
rx.hstack(
_upscale_button(),
_download_button(),
| def _download_button():
return rx.cond(
GeneratorState.is_downloading,
rx.icon_button(
rx.spinner(size="3"),
**styles.button_props,
color_scheme="blue",
),
rx.icon_button(
rx.icon("download", size=20),
**styles.button_props,
color_scheme="gray",
on_click=GeneratorState.download_image,
),
) |
from .. import styles
from ..components.options_ui import (
advanced_options,
generate_button,
output_selector,
prompt_input,
size_selector,
style_selector,
)
def mobile_ui():
return rx.box(
rx.vstack(
rx.vstack(
prompt_input(),
size_selector(),
output_selector(),
style_selector(),
advanced_options(),
width="100%",
height="100%",
align_items="flex-start",
padding="1em",
spacing="6",
),
generate_button(),
width="100%",
spacing="0",
),
display=["block", "block", "block", "none"],
width="100%",
height="100%",
bg=rx.color("gray", 2),
border_top=styles.border,
)
| import reflex as rx | |
import reflex as rx
|
from ..components.options_ui import (
advanced_options,
generate_button,
output_selector,
prompt_input,
size_selector,
style_selector,
)
def mobile_ui():
return rx.box(
rx.vstack(
rx.vstack(
prompt_input(),
size_selector(),
output_selector(),
style_selector(),
advanced_options(),
width="100%",
height="100%",
align_items="flex-start",
padding="1em",
spacing="6",
),
generate_button(),
width="100%",
spacing="0",
),
display=["block", "block", "block", "none"],
width="100%",
height="100%",
bg=rx.color("gray", 2),
border_top=styles.border,
)
| from .. import styles |
from .. import styles
from ..components.options_ui import (
advanced_options,
generate_button,
output_selector,
prompt_input,
sidebar_header,
size_selector,
style_selector,
)
def sidebar():
return rx.box(
rx.vstack(
sidebar_header(),
rx.flex(
rx.vstack(
prompt_input(),
size_selector(),
output_selector(),
style_selector(),
advanced_options(),
width="100%",
overflow_y="auto",
align="start",
padding="1em",
spacing="6",
),
overflow_y="auto",
flex="1",
height="100%",
width="100%",
),
generate_button(),
width="100%",
height="100%",
spacing="0",
),
display=["no | import reflex as rx | |
import reflex as rx
|
from ..components.options_ui import (
advanced_options,
generate_button,
output_selector,
prompt_input,
sidebar_header,
size_selector,
style_selector,
)
def sidebar():
return rx.box(
rx.vstack(
sidebar_header(),
rx.flex(
rx.vstack(
prompt_input(),
size_selector(),
output_selector(),
style_selector(),
advanced_options(),
width="100%",
overflow_y="auto",
align="start",
padding="1em",
spacing="6",
),
overflow_y="auto",
flex="1",
height="100%",
width="100%",
),
generate_button(),
width="100%",
height="100%",
spacing="0",
),
display=["none", "none", "none", "b | from .. import styles |
import reflex as rx
from api_admin_panel.pages import *
class State(rx.State):
"""Define empty state to allow access to rx.State.router."""
| app = rx.App() | |
from api_admin_panel.states.queries import QueryAPI
def render_data(data: tuple[str, str]):
return rx.vstack(
rx.text(data[0], weight="bold"),
rx.input(
value=data[1],
width="100%",
on_change=lambda value: QueryAPI.update_data(value, data),
),
width="100%",
spacing="2",
)
def render_drawer_buttons(name: str, color: str, function: callable):
return rx.badge(
rx.text(name, width="100%", text_align="center"),
color_scheme=color,
on_click=function,
variant="surface",
padding="0.75em 1.25em",
width="100%",
cursor="pointer",
)
def render_drawer():
return rx.drawer.root(
rx.drawer.overlay(z_index="5"),
rx.drawer.portal(
rx.drawer.content(
rx.vstack(
rx.foreach(QueryAPI.selected_entry, render_data),
rx.vstack(
render_drawer_button | import reflex as rx | |
import reflex as rx
|
def render_data(data: tuple[str, str]):
return rx.vstack(
rx.text(data[0], weight="bold"),
rx.input(
value=data[1],
width="100%",
on_change=lambda value: QueryAPI.update_data(value, data),
),
width="100%",
spacing="2",
)
def render_drawer_buttons(name: str, color: str, function: callable):
return rx.badge(
rx.text(name, width="100%", text_align="center"),
color_scheme=color,
on_click=function,
variant="surface",
padding="0.75em 1.25em",
width="100%",
cursor="pointer",
)
def render_drawer():
return rx.drawer.root(
rx.drawer.overlay(z_index="5"),
rx.drawer.portal(
rx.drawer.content(
rx.vstack(
rx.foreach(QueryAPI.selected_entry, render_data),
rx.vstack(
render_drawer_buttons(
"Commit", "grass", Que | from api_admin_panel.states.queries import QueryAPI |
from api_admin_panel.states.base import BaseState
from api_admin_panel.styles import text
navbar: dict[str, str] = {
"width": "100%",
"padding": "1em 1.15em",
"justify_content": "space-between",
"bg": rx.color_mode_cond(
"rgba(255, 255, 255, 0.81)",
"rgba(18, 17, 19, 0.81)",
),
"align_items": "center",
"border_bottom": "1px solid rgba(46, 46, 46, 0.51)",
}
def render_navbar():
return rx.hstack(
rx.hstack(
rx.box(
rx.text(
"REST API Admin Panel",
font_size="var(--chakra-fontSizes-lg)",
**text,
),
),
display="flex",
align_items="center",
),
rx.hstack(
rx.button(
BaseState.is_request, on_click=BaseState.toggle_query, cursor="pointer"
),
rx.color_mode.button(),
align_items="center",
),
**navbar,
| import reflex as rx | |
import reflex as rx
|
from api_admin_panel.styles import text
navbar: dict[str, str] = {
"width": "100%",
"padding": "1em 1.15em",
"justify_content": "space-between",
"bg": rx.color_mode_cond(
"rgba(255, 255, 255, 0.81)",
"rgba(18, 17, 19, 0.81)",
),
"align_items": "center",
"border_bottom": "1px solid rgba(46, 46, 46, 0.51)",
}
def render_navbar():
return rx.hstack(
rx.hstack(
rx.box(
rx.text(
"REST API Admin Panel",
font_size="var(--chakra-fontSizes-lg)",
**text,
),
),
display="flex",
align_items="center",
),
rx.hstack(
rx.button(
BaseState.is_request, on_click=BaseState.toggle_query, cursor="pointer"
),
rx.color_mode.button(),
align_items="center",
),
**navbar,
)
| from api_admin_panel.states.base import BaseState |
import reflex as rx
from api_admin_panel.states.base import BaseState
|
navbar: dict[str, str] = {
"width": "100%",
"padding": "1em 1.15em",
"justify_content": "space-between",
"bg": rx.color_mode_cond(
"rgba(255, 255, 255, 0.81)",
"rgba(18, 17, 19, 0.81)",
),
"align_items": "center",
"border_bottom": "1px solid rgba(46, 46, 46, 0.51)",
}
def render_navbar():
return rx.hstack(
rx.hstack(
rx.box(
rx.text(
"REST API Admin Panel",
font_size="var(--chakra-fontSizes-lg)",
**text,
),
),
display="flex",
align_items="center",
),
rx.hstack(
rx.button(
BaseState.is_request, on_click=BaseState.toggle_query, cursor="pointer"
),
rx.color_mode.button(),
align_items="center",
),
**navbar,
)
| from api_admin_panel.styles import text |
from api_admin_panel.components.drawer import render_drawer
from api_admin_panel.states.queries import QueryAPI
def create_table_header(title: str):
return rx.table.column_header_cell(title)
def create_query_rows(data: dict[str, str]):
def fill_rows_with_data(data_):
return rx.table.cell(
f"{data_[1]}",
on_click=QueryAPI.display_selected_row(data),
cursor="pointer",
)
return rx.table.row(
rx.foreach(data, fill_rows_with_data),
_hover={"bg": rx.color(color="gray", shade=4)},
)
def create_pagination():
return rx.hstack(
rx.hstack(
rx.text("Entries per page", weight="bold"),
rx.select(
QueryAPI.limits, default_value="10", on_change=QueryAPI.delta_limit
),
align_items="center",
),
rx.hstack(
rx.text(
f"Page {QueryAPI.current_page}/{QueryAPI.total_pages}",
width="10 | import reflex as rx | |
import reflex as rx
|
from api_admin_panel.states.queries import QueryAPI
def create_table_header(title: str):
return rx.table.column_header_cell(title)
def create_query_rows(data: dict[str, str]):
def fill_rows_with_data(data_):
return rx.table.cell(
f"{data_[1]}",
on_click=QueryAPI.display_selected_row(data),
cursor="pointer",
)
return rx.table.row(
rx.foreach(data, fill_rows_with_data),
_hover={"bg": rx.color(color="gray", shade=4)},
)
def create_pagination():
return rx.hstack(
rx.hstack(
rx.text("Entries per page", weight="bold"),
rx.select(
QueryAPI.limits, default_value="10", on_change=QueryAPI.delta_limit
),
align_items="center",
),
rx.hstack(
rx.text(
f"Page {QueryAPI.current_page}/{QueryAPI.total_pages}",
width="100px",
weight="bold",
),
| from api_admin_panel.components.drawer import render_drawer |
import reflex as rx
from api_admin_panel.components.drawer import render_drawer
|
def create_table_header(title: str):
return rx.table.column_header_cell(title)
def create_query_rows(data: dict[str, str]):
def fill_rows_with_data(data_):
return rx.table.cell(
f"{data_[1]}",
on_click=QueryAPI.display_selected_row(data),
cursor="pointer",
)
return rx.table.row(
rx.foreach(data, fill_rows_with_data),
_hover={"bg": rx.color(color="gray", shade=4)},
)
def create_pagination():
return rx.hstack(
rx.hstack(
rx.text("Entries per page", weight="bold"),
rx.select(
QueryAPI.limits, default_value="10", on_change=QueryAPI.delta_limit
),
align_items="center",
),
rx.hstack(
rx.text(
f"Page {QueryAPI.current_page}/{QueryAPI.total_pages}",
width="100px",
weight="bold",
),
rx.hstack(
rx.icon(
| from api_admin_panel.states.queries import QueryAPI |
import reflex as rx
from api_admin_panel.components.drawer import render_drawer
from api_admin_panel.states.queries import QueryAPI
|
def create_query_rows(data: dict[str, str]):
def fill_rows_with_data(data_):
return rx.table.cell(
f"{data_[1]}",
on_click=QueryAPI.display_selected_row(data),
cursor="pointer",
)
return rx.table.row(
rx.foreach(data, fill_rows_with_data),
_hover={"bg": rx.color(color="gray", shade=4)},
)
def create_pagination():
return rx.hstack(
rx.hstack(
rx.text("Entries per page", weight="bold"),
rx.select(
QueryAPI.limits, default_value="10", on_change=QueryAPI.delta_limit
),
align_items="center",
),
rx.hstack(
rx.text(
f"Page {QueryAPI.current_page}/{QueryAPI.total_pages}",
width="100px",
weight="bold",
),
rx.hstack(
rx.icon(
tag="chevron-left", on_click=QueryAPI.previous, cursor="pointer"
| def create_table_header(title: str):
return rx.table.column_header_cell(title) |
import reflex as rx
from api_admin_panel.components.drawer import render_drawer
from api_admin_panel.states.queries import QueryAPI
def create_table_header(title: str):
return rx.table.column_header_cell(title)
def create_query_rows(data: dict[str, str]):
|
return rx.table.row(
rx.foreach(data, fill_rows_with_data),
_hover={"bg": rx.color(color="gray", shade=4)},
)
def create_pagination():
return rx.hstack(
rx.hstack(
rx.text("Entries per page", weight="bold"),
rx.select(
QueryAPI.limits, default_value="10", on_change=QueryAPI.delta_limit
),
align_items="center",
),
rx.hstack(
rx.text(
f"Page {QueryAPI.current_page}/{QueryAPI.total_pages}",
width="100px",
weight="bold",
),
rx.hstack(
rx.icon(
tag="chevron-left", on_click=QueryAPI.previous, cursor="pointer"
),
rx.icon(tag="chevron-right", on_click=QueryAPI.next, cursor="pointer"),
),
align_items="center",
spacing="1",
),
align_items="center",
spacing="4",
)
| def fill_rows_with_data(data_):
return rx.table.cell(
f"{data_[1]}",
on_click=QueryAPI.display_selected_row(data),
cursor="pointer",
) |
from api_admin_panel.states.base import BaseState
from api_admin_panel.states.queries import QueryAPI, QueryState
from api_admin_panel.styles import text
def item_title(title: str):
return rx.hstack(
rx.text(title, font_size="var(--chakra-fontSizes-sm)", **text),
width="100%",
justify_content="space-between",
)
def item_add_event(event_trigger: callable):
return rx.button(
rx.hstack(
rx.text("+"),
rx.text("add", weight="bold"),
width="100%",
justify_content="space-between",
),
size="1",
on_click=event_trigger,
padding="0.35em 0.75em",
cursor="pointer",
color_scheme="gray",
)
def form_item_entry(data: dict[str, str]):
def create_entry(title: str, function: callable):
return (
rx.input(
placeholder=title,
width="100%",
on_change=function,
variant="surf | import reflex as rx | |
import reflex as rx
|
from api_admin_panel.states.queries import QueryAPI, QueryState
from api_admin_panel.styles import text
def item_title(title: str):
return rx.hstack(
rx.text(title, font_size="var(--chakra-fontSizes-sm)", **text),
width="100%",
justify_content="space-between",
)
def item_add_event(event_trigger: callable):
return rx.button(
rx.hstack(
rx.text("+"),
rx.text("add", weight="bold"),
width="100%",
justify_content="space-between",
),
size="1",
on_click=event_trigger,
padding="0.35em 0.75em",
cursor="pointer",
color_scheme="gray",
)
def form_item_entry(data: dict[str, str]):
def create_entry(title: str, function: callable):
return (
rx.input(
placeholder=title,
width="100%",
on_change=function,
variant="surface",
),
)
return rx.hstac | from api_admin_panel.states.base import BaseState |
import reflex as rx
from api_admin_panel.states.base import BaseState
|
from api_admin_panel.styles import text
def item_title(title: str):
return rx.hstack(
rx.text(title, font_size="var(--chakra-fontSizes-sm)", **text),
width="100%",
justify_content="space-between",
)
def item_add_event(event_trigger: callable):
return rx.button(
rx.hstack(
rx.text("+"),
rx.text("add", weight="bold"),
width="100%",
justify_content="space-between",
),
size="1",
on_click=event_trigger,
padding="0.35em 0.75em",
cursor="pointer",
color_scheme="gray",
)
def form_item_entry(data: dict[str, str]):
def create_entry(title: str, function: callable):
return (
rx.input(
placeholder=title,
width="100%",
on_change=function,
variant="surface",
),
)
return rx.hstack(
create_entry("key", lambda key: QueryState.update_key | from api_admin_panel.states.queries import QueryAPI, QueryState |
import reflex as rx
from api_admin_panel.states.base import BaseState
from api_admin_panel.states.queries import QueryAPI, QueryState
|
def item_title(title: str):
return rx.hstack(
rx.text(title, font_size="var(--chakra-fontSizes-sm)", **text),
width="100%",
justify_content="space-between",
)
def item_add_event(event_trigger: callable):
return rx.button(
rx.hstack(
rx.text("+"),
rx.text("add", weight="bold"),
width="100%",
justify_content="space-between",
),
size="1",
on_click=event_trigger,
padding="0.35em 0.75em",
cursor="pointer",
color_scheme="gray",
)
def form_item_entry(data: dict[str, str]):
def create_entry(title: str, function: callable):
return (
rx.input(
placeholder=title,
width="100%",
on_change=function,
variant="surface",
),
)
return rx.hstack(
create_entry("key", lambda key: QueryState.update_keyy(key, data)),
create_entry("val | from api_admin_panel.styles import text |
import reflex as rx
from api_admin_panel.states.base import BaseState
from api_admin_panel.states.queries import QueryAPI, QueryState
from api_admin_panel.styles import text
|
def item_add_event(event_trigger: callable):
return rx.button(
rx.hstack(
rx.text("+"),
rx.text("add", weight="bold"),
width="100%",
justify_content="space-between",
),
size="1",
on_click=event_trigger,
padding="0.35em 0.75em",
cursor="pointer",
color_scheme="gray",
)
def form_item_entry(data: dict[str, str]):
def create_entry(title: str, function: callable):
return (
rx.input(
placeholder=title,
width="100%",
on_change=function,
variant="surface",
),
)
return rx.hstack(
create_entry("key", lambda key: QueryState.update_keyy(key, data)),
create_entry("value", lambda value: QueryState.update_value(value, data)),
rx.button(
"DEL",
on_click=QueryState.remove_entry(data),
color_scheme="ruby",
| def item_title(title: str):
return rx.hstack(
rx.text(title, font_size="var(--chakra-fontSizes-sm)", **text),
width="100%",
justify_content="space-between",
) |
import reflex as rx
from api_admin_panel.states.base import BaseState
from api_admin_panel.states.queries import QueryAPI, QueryState
from api_admin_panel.styles import text
def item_title(title: str):
return rx.hstack(
rx.text(title, font_size="var(--chakra-fontSizes-sm)", **text),
width="100%",
justify_content="space-between",
)
|
def form_item_entry(data: dict[str, str]):
def create_entry(title: str, function: callable):
return (
rx.input(
placeholder=title,
width="100%",
on_change=function,
variant="surface",
),
)
return rx.hstack(
create_entry("key", lambda key: QueryState.update_keyy(key, data)),
create_entry("value", lambda value: QueryState.update_value(value, data)),
rx.button(
"DEL",
on_click=QueryState.remove_entry(data),
color_scheme="ruby",
variant="surface",
cursor="pointer",
),
width="100%",
spacing="1",
)
def form_item(
title: str, state: list[dict[str, str]], func: callable, event_trigger: callable
):
return rx.accordion.root(
rx.accordion.item(
rx.accordion.header(rx.accordion.trigger(item_title(title))),
rx.accordion.content(
| def item_add_event(event_trigger: callable):
return rx.button(
rx.hstack(
rx.text("+"),
rx.text("add", weight="bold"),
width="100%",
justify_content="space-between",
),
size="1",
on_click=event_trigger,
padding="0.35em 0.75em",
cursor="pointer",
color_scheme="gray",
) |
import reflex as rx
from api_admin_panel.states.base import BaseState
from api_admin_panel.states.queries import QueryAPI, QueryState
from api_admin_panel.styles import text
def item_title(title: str):
return rx.hstack(
rx.text(title, font_size="var(--chakra-fontSizes-sm)", **text),
width="100%",
justify_content="space-between",
)
def item_add_event(event_trigger: callable):
return rx.button(
rx.hstack(
rx.text("+"),
rx.text("add", weight="bold"),
width="100%",
justify_content="space-between",
),
size="1",
on_click=event_trigger,
padding="0.35em 0.75em",
cursor="pointer",
color_scheme="gray",
)
def form_item_entry(data: dict[str, str]):
|
return rx.hstack(
create_entry("key", lambda key: QueryState.update_keyy(key, data)),
create_entry("value", lambda value: QueryState.update_value(value, data)),
rx.button(
"DEL",
on_click=QueryState.remove_entry(data),
color_scheme="ruby",
variant="surface",
cursor="pointer",
),
width="100%",
spacing="1",
)
def form_item(
title: str, state: list[dict[str, str]], func: callable, event_trigger: callable
):
return rx.accordion.root(
rx.accordion.item(
rx.accordion.header(rx.accordion.trigger(item_title(title))),
rx.accordion.content(
item_add_event(event_trigger),
width="100%",
display="flex",
justify_content="end",
),
rx.accordion.content(
rx.vstack(rx.foreach(state, func), width="100%", spacing="1")
),
),
| def create_entry(title: str, function: callable):
return (
rx.input(
placeholder=title,
width="100%",
on_change=function,
variant="surface",
),
) |
allow_toggle=True,
width="100%",
border="transparent",
)
def form_request_item():
return rx.accordion.root(
rx.accordion.item(
rx.accordion.header(rx.accordion.trigger(item_title("Requests"))),
rx.accordion.content(
rx.hstack(
rx.select(
QueryState.req_methods,
width="120px",
default_value="GET",
on_change=QueryState.get_request,
),
rx.input(
value=QueryState.req_url,
width="100%",
on_change=QueryState.set_req_url,
placeholder="https://example_site.com/api/v2/endpoint.json",
),
width="100%",
)
),
),
allow_toggle=True,
width="100%",
border="transparent",
)
|
def render_query_header():
return rx.hstack(
rx.hstack(
rx.select(
QueryState.req_methods,
width="100px",
default_value="GET",
on_change=QueryState.get_request,
),
rx.input(
value=QueryState.req_url,
width="100%",
on_change=QueryState.set_req_url,
placeholder="https://example_site.com/api/v2/endpoint.json",
),
width="100%",
spacing="1",
),
rx.button(
"Send", size="2", on_click=QueryAPI.run_get_request, cursor="pointer"
),
width="100%",
border_bottom=rx.color_mode_cond(
"1px solid rgba(45, 45, 45, 0.05)", "1px solid rgba(45, 45, 45, 0.51)"
),
padding="1em 0.75em",
justify_content="end",
)
def render_query_component():
return rx.vstack(
render_query_header(),
rende | def render_query_form():
return rx.vstack(
form_item(
"Headers", QueryState.headers, form_item_entry, QueryState.add_header
),
form_body_param_item(QueryState.body, form_item_entry, QueryState.add_body),
form_item(
"Cookies", QueryState.cookies, form_item_entry, QueryState.add_cookies
),
width="100%",
spacing="2",
padding="0em 0.75em",
) |
ookies
),
width="100%",
spacing="2",
padding="0em 0.75em",
)
def render_query_header():
return rx.hstack(
rx.hstack(
rx.select(
QueryState.req_methods,
width="100px",
default_value="GET",
on_change=QueryState.get_request,
),
rx.input(
value=QueryState.req_url,
width="100%",
on_change=QueryState.set_req_url,
placeholder="https://example_site.com/api/v2/endpoint.json",
),
width="100%",
spacing="1",
),
rx.button(
"Send", size="2", on_click=QueryAPI.run_get_request, cursor="pointer"
),
width="100%",
border_bottom=rx.color_mode_cond(
"1px solid rgba(45, 45, 45, 0.05)", "1px solid rgba(45, 45, 45, 0.51)"
),
padding="1em 0.75em",
justify_content="end",
)
| def render_query_component():
return rx.vstack(
render_query_header(),
render_query_form(),
flex=["100%", "100%", "100%", "100%", "30%"],
display=BaseState.query_component_toggle,
padding_bottom="0.75em",
border_radius="10px",
bg=rx.color_mode_cond(
"#faf9fb",
"#1a181a",
),
) | |
"""The dashboard page."""
|
from api_admin_panel.components.navbar import render_navbar
from api_admin_panel.components.output import render_output
from api_admin_panel.components.query import render_query_component
from api_admin_panel.states.queries import QueryAPI
@rx.page("/", on_load=QueryAPI.run_get_request)
def dashboard() -> rx.Component:
"""The dashboard page.
Returns:
The UI for the dashboard page.
"""
return rx.vstack(
render_navbar(),
rx.hstack(
render_query_component(),
render_output(),
width="100%",
display="flex",
flex_wrap="wrap",
spacing="6",
padding="2em 1em",
),
spacing="4",
)
| import reflex as rx |
"""The dashboard page."""
import reflex as rx
|
from api_admin_panel.components.output import render_output
from api_admin_panel.components.query import render_query_component
from api_admin_panel.states.queries import QueryAPI
@rx.page("/", on_load=QueryAPI.run_get_request)
def dashboard() -> rx.Component:
"""The dashboard page.
Returns:
The UI for the dashboard page.
"""
return rx.vstack(
render_navbar(),
rx.hstack(
render_query_component(),
render_output(),
width="100%",
display="flex",
flex_wrap="wrap",
spacing="6",
padding="2em 1em",
),
spacing="4",
)
| from api_admin_panel.components.navbar import render_navbar |
"""The dashboard page."""
import reflex as rx
from api_admin_panel.components.navbar import render_navbar
|
from api_admin_panel.components.query import render_query_component
from api_admin_panel.states.queries import QueryAPI
@rx.page("/", on_load=QueryAPI.run_get_request)
def dashboard() -> rx.Component:
"""The dashboard page.
Returns:
The UI for the dashboard page.
"""
return rx.vstack(
render_navbar(),
rx.hstack(
render_query_component(),
render_output(),
width="100%",
display="flex",
flex_wrap="wrap",
spacing="6",
padding="2em 1em",
),
spacing="4",
)
| from api_admin_panel.components.output import render_output |
"""The dashboard page."""
import reflex as rx
from api_admin_panel.components.navbar import render_navbar
from api_admin_panel.components.output import render_output
|
from api_admin_panel.states.queries import QueryAPI
@rx.page("/", on_load=QueryAPI.run_get_request)
def dashboard() -> rx.Component:
"""The dashboard page.
Returns:
The UI for the dashboard page.
"""
return rx.vstack(
render_navbar(),
rx.hstack(
render_query_component(),
render_output(),
width="100%",
display="flex",
flex_wrap="wrap",
spacing="6",
padding="2em 1em",
),
spacing="4",
)
| from api_admin_panel.components.query import render_query_component |
"""The dashboard page."""
import reflex as rx
from api_admin_panel.components.navbar import render_navbar
from api_admin_panel.components.output import render_output
from api_admin_panel.components.query import render_query_component
|
@rx.page("/", on_load=QueryAPI.run_get_request)
def dashboard() -> rx.Component:
"""The dashboard page.
Returns:
The UI for the dashboard page.
"""
return rx.vstack(
render_navbar(),
rx.hstack(
render_query_component(),
render_output(),
width="100%",
display="flex",
flex_wrap="wrap",
spacing="6",
padding="2em 1em",
),
spacing="4",
)
| from api_admin_panel.states.queries import QueryAPI |
class BaseState(rx.State):
query_component_toggle: str = "none"
is_request: str = "New Request"
def toggle_query(self):
self.query_component_toggle = (
"flex" if self.query_component_toggle == "none" else "none"
)
self.is_request = (
"New Request" if self.query_component_toggle == "none" else "Close Request"
)
| import reflex as rx | |
import httpx
import reflex as rx
from api_admin_panel.states.base import BaseState
# test URL: str = https://jsonplaceholder.typicode.com/posts
# test URL: str = https://jsonplaceholder.typicode.com/todos
class QueryState(BaseState):
# vars for handling request calls ...
req_methods: list[str] = ["GET", "POST"]
req_url: str = "https://jsonplaceholder.typicode.com/posts"
current_req: str = "GET"
get_params_body: list[str] = ["JSON", "Raw", "None"]
post_params_body: list[str] = [
"JSON",
"Raw",
"x-www-form-urlencoded",
"Form Data",
"Binary",
"None",
]
# params. for triggering API calls ...
url_param: dict[str, str]
headers: list[dict[str, str]]
body: list[dict[str, str]]
cookies: list[dict[str, str]]
# vars for GET request ...
get_data: list[dict[str, str]]
get_table_headers: list[str]
paginated_data: list[dict[str, str]]
# vars for pagination ...
number_of_row | import uuid | |
import uuid
|
import reflex as rx
from api_admin_panel.states.base import BaseState
# test URL: str = https://jsonplaceholder.typicode.com/posts
# test URL: str = https://jsonplaceholder.typicode.com/todos
class QueryState(BaseState):
# vars for handling request calls ...
req_methods: list[str] = ["GET", "POST"]
req_url: str = "https://jsonplaceholder.typicode.com/posts"
current_req: str = "GET"
get_params_body: list[str] = ["JSON", "Raw", "None"]
post_params_body: list[str] = [
"JSON",
"Raw",
"x-www-form-urlencoded",
"Form Data",
"Binary",
"None",
]
# params. for triggering API calls ...
url_param: dict[str, str]
headers: list[dict[str, str]]
body: list[dict[str, str]]
cookies: list[dict[str, str]]
# vars for GET request ...
get_data: list[dict[str, str]]
get_table_headers: list[str]
paginated_data: list[dict[str, str]]
# vars for pagination ...
number_of_rows: int
lim | import httpx |
import uuid
import httpx
|
from api_admin_panel.states.base import BaseState
# test URL: str = https://jsonplaceholder.typicode.com/posts
# test URL: str = https://jsonplaceholder.typicode.com/todos
class QueryState(BaseState):
# vars for handling request calls ...
req_methods: list[str] = ["GET", "POST"]
req_url: str = "https://jsonplaceholder.typicode.com/posts"
current_req: str = "GET"
get_params_body: list[str] = ["JSON", "Raw", "None"]
post_params_body: list[str] = [
"JSON",
"Raw",
"x-www-form-urlencoded",
"Form Data",
"Binary",
"None",
]
# params. for triggering API calls ...
url_param: dict[str, str]
headers: list[dict[str, str]]
body: list[dict[str, str]]
cookies: list[dict[str, str]]
# vars for GET request ...
get_data: list[dict[str, str]]
get_table_headers: list[str]
paginated_data: list[dict[str, str]]
# vars for pagination ...
number_of_rows: int
limits: list[str] = ["1 | import reflex as rx |
import uuid
import httpx
import reflex as rx
|
# test URL: str = https://jsonplaceholder.typicode.com/posts
# test URL: str = https://jsonplaceholder.typicode.com/todos
class QueryState(BaseState):
# vars for handling request calls ...
req_methods: list[str] = ["GET", "POST"]
req_url: str = "https://jsonplaceholder.typicode.com/posts"
current_req: str = "GET"
get_params_body: list[str] = ["JSON", "Raw", "None"]
post_params_body: list[str] = [
"JSON",
"Raw",
"x-www-form-urlencoded",
"Form Data",
"Binary",
"None",
]
# params. for triggering API calls ...
url_param: dict[str, str]
headers: list[dict[str, str]]
body: list[dict[str, str]]
cookies: list[dict[str, str]]
# vars for GET request ...
get_data: list[dict[str, str]]
get_table_headers: list[str]
paginated_data: list[dict[str, str]]
# vars for pagination ...
number_of_rows: int
limits: list[str] = ["10", "20", "50"]
current_limit: int = 10
off | from api_admin_panel.states.base import BaseState |
de.com/todos
class QueryState(BaseState):
# vars for handling request calls ...
req_methods: list[str] = ["GET", "POST"]
req_url: str = "https://jsonplaceholder.typicode.com/posts"
current_req: str = "GET"
get_params_body: list[str] = ["JSON", "Raw", "None"]
post_params_body: list[str] = [
"JSON",
"Raw",
"x-www-form-urlencoded",
"Form Data",
"Binary",
"None",
]
# params. for triggering API calls ...
url_param: dict[str, str]
headers: list[dict[str, str]]
body: list[dict[str, str]]
cookies: list[dict[str, str]]
# vars for GET request ...
get_data: list[dict[str, str]]
get_table_headers: list[str]
paginated_data: list[dict[str, str]]
# vars for pagination ...
number_of_rows: int
limits: list[str] = ["10", "20", "50"]
current_limit: int = 10
offset: int = 0
current_page: int = 1
total_pages: int = 1
formatted_headers: dict
@rx.event
|
@rx.event
def get_request(self, method: str):
self.current_req = method
@rx.event
def add_header(self):
self.headers.append(
{"id": str(uuid.uuid4()), "identifier": "headers", "key": "", "value": ""}
)
@rx.event
def add_body(self):
self.body.append(
{"id": str(uuid.uuid4()), "identifier": "body", "key": "", "value": ""}
)
@rx.event
def add_cookies(self):
self.cookies.append(
{"id": str(uuid.uuid4()), "identifier": "cookies", "key": "", "value": ""}
)
@rx.event
def remove_entry(self, data: dict[str, str]):
if data["identifier"] == "headers":
self.headers = [item for item in self.headers if item["id"] != data["id"]]
if data["identifier"] == "body":
self.body = [item for item in self.body if item["id"] != data["id"]]
if data["identifier"] == "cookies":
self.cookies = [item for item in self.co | def set_req_url(self, url: str):
self.req_url = url |
):
# vars for handling request calls ...
req_methods: list[str] = ["GET", "POST"]
req_url: str = "https://jsonplaceholder.typicode.com/posts"
current_req: str = "GET"
get_params_body: list[str] = ["JSON", "Raw", "None"]
post_params_body: list[str] = [
"JSON",
"Raw",
"x-www-form-urlencoded",
"Form Data",
"Binary",
"None",
]
# params. for triggering API calls ...
url_param: dict[str, str]
headers: list[dict[str, str]]
body: list[dict[str, str]]
cookies: list[dict[str, str]]
# vars for GET request ...
get_data: list[dict[str, str]]
get_table_headers: list[str]
paginated_data: list[dict[str, str]]
# vars for pagination ...
number_of_rows: int
limits: list[str] = ["10", "20", "50"]
current_limit: int = 10
offset: int = 0
current_page: int = 1
total_pages: int = 1
formatted_headers: dict
@rx.event
def set_req_url(self, url: str):
|
@rx.event
def get_request(self, method: str):
self.current_req = method
@rx.event
def add_header(self):
self.headers.append(
{"id": str(uuid.uuid4()), "identifier": "headers", "key": "", "value": ""}
)
@rx.event
def add_body(self):
self.body.append(
{"id": str(uuid.uuid4()), "identifier": "body", "key": "", "value": ""}
)
@rx.event
def add_cookies(self):
self.cookies.append(
{"id": str(uuid.uuid4()), "identifier": "cookies", "key": "", "value": ""}
)
@rx.event
def remove_entry(self, data: dict[str, str]):
if data["identifier"] == "headers":
self.headers = [item for item in self.headers if item["id"] != data["id"]]
if data["identifier"] == "body":
self.body = [item for item in self.body if item["id"] != data["id"]]
if data["identifier"] == "cookies":
self.cookies = [item for item in self.co | self.req_url = url |
ls ...
req_methods: list[str] = ["GET", "POST"]
req_url: str = "https://jsonplaceholder.typicode.com/posts"
current_req: str = "GET"
get_params_body: list[str] = ["JSON", "Raw", "None"]
post_params_body: list[str] = [
"JSON",
"Raw",
"x-www-form-urlencoded",
"Form Data",
"Binary",
"None",
]
# params. for triggering API calls ...
url_param: dict[str, str]
headers: list[dict[str, str]]
body: list[dict[str, str]]
cookies: list[dict[str, str]]
# vars for GET request ...
get_data: list[dict[str, str]]
get_table_headers: list[str]
paginated_data: list[dict[str, str]]
# vars for pagination ...
number_of_rows: int
limits: list[str] = ["10", "20", "50"]
current_limit: int = 10
offset: int = 0
current_page: int = 1
total_pages: int = 1
formatted_headers: dict
@rx.event
def set_req_url(self, url: str):
self.req_url = url
@rx.event
|
@rx.event
def add_header(self):
self.headers.append(
{"id": str(uuid.uuid4()), "identifier": "headers", "key": "", "value": ""}
)
@rx.event
def add_body(self):
self.body.append(
{"id": str(uuid.uuid4()), "identifier": "body", "key": "", "value": ""}
)
@rx.event
def add_cookies(self):
self.cookies.append(
{"id": str(uuid.uuid4()), "identifier": "cookies", "key": "", "value": ""}
)
@rx.event
def remove_entry(self, data: dict[str, str]):
if data["identifier"] == "headers":
self.headers = [item for item in self.headers if item["id"] != data["id"]]
if data["identifier"] == "body":
self.body = [item for item in self.body if item["id"] != data["id"]]
if data["identifier"] == "cookies":
self.cookies = [item for item in self.cookies if item["id"] != data["id"]]
@rx.event
async def update_attribute(self, da | def get_request(self, method: str):
self.current_req = method |
"POST"]
req_url: str = "https://jsonplaceholder.typicode.com/posts"
current_req: str = "GET"
get_params_body: list[str] = ["JSON", "Raw", "None"]
post_params_body: list[str] = [
"JSON",
"Raw",
"x-www-form-urlencoded",
"Form Data",
"Binary",
"None",
]
# params. for triggering API calls ...
url_param: dict[str, str]
headers: list[dict[str, str]]
body: list[dict[str, str]]
cookies: list[dict[str, str]]
# vars for GET request ...
get_data: list[dict[str, str]]
get_table_headers: list[str]
paginated_data: list[dict[str, str]]
# vars for pagination ...
number_of_rows: int
limits: list[str] = ["10", "20", "50"]
current_limit: int = 10
offset: int = 0
current_page: int = 1
total_pages: int = 1
formatted_headers: dict
@rx.event
def set_req_url(self, url: str):
self.req_url = url
@rx.event
def get_request(self, method: str):
|
@rx.event
def add_header(self):
self.headers.append(
{"id": str(uuid.uuid4()), "identifier": "headers", "key": "", "value": ""}
)
@rx.event
def add_body(self):
self.body.append(
{"id": str(uuid.uuid4()), "identifier": "body", "key": "", "value": ""}
)
@rx.event
def add_cookies(self):
self.cookies.append(
{"id": str(uuid.uuid4()), "identifier": "cookies", "key": "", "value": ""}
)
@rx.event
def remove_entry(self, data: dict[str, str]):
if data["identifier"] == "headers":
self.headers = [item for item in self.headers if item["id"] != data["id"]]
if data["identifier"] == "body":
self.body = [item for item in self.body if item["id"] != data["id"]]
if data["identifier"] == "cookies":
self.cookies = [item for item in self.cookies if item["id"] != data["id"]]
@rx.event
async def update_attribute(self, da | self.current_req = method |
holder.typicode.com/posts"
current_req: str = "GET"
get_params_body: list[str] = ["JSON", "Raw", "None"]
post_params_body: list[str] = [
"JSON",
"Raw",
"x-www-form-urlencoded",
"Form Data",
"Binary",
"None",
]
# params. for triggering API calls ...
url_param: dict[str, str]
headers: list[dict[str, str]]
body: list[dict[str, str]]
cookies: list[dict[str, str]]
# vars for GET request ...
get_data: list[dict[str, str]]
get_table_headers: list[str]
paginated_data: list[dict[str, str]]
# vars for pagination ...
number_of_rows: int
limits: list[str] = ["10", "20", "50"]
current_limit: int = 10
offset: int = 0
current_page: int = 1
total_pages: int = 1
formatted_headers: dict
@rx.event
def set_req_url(self, url: str):
self.req_url = url
@rx.event
def get_request(self, method: str):
self.current_req = method
@rx.event
|
@rx.event
def add_body(self):
self.body.append(
{"id": str(uuid.uuid4()), "identifier": "body", "key": "", "value": ""}
)
@rx.event
def add_cookies(self):
self.cookies.append(
{"id": str(uuid.uuid4()), "identifier": "cookies", "key": "", "value": ""}
)
@rx.event
def remove_entry(self, data: dict[str, str]):
if data["identifier"] == "headers":
self.headers = [item for item in self.headers if item["id"] != data["id"]]
if data["identifier"] == "body":
self.body = [item for item in self.body if item["id"] != data["id"]]
if data["identifier"] == "cookies":
self.cookies = [item for item in self.cookies if item["id"] != data["id"]]
@rx.event
async def update_attribute(self, data: dict[str, str], attribute: str, value: str):
data[attribute] = value
if data["identifier"] == "headers":
self.headers = [
| def add_header(self):
self.headers.append(
{"id": str(uuid.uuid4()), "identifier": "headers", "key": "", "value": ""}
) |
"Raw",
"x-www-form-urlencoded",
"Form Data",
"Binary",
"None",
]
# params. for triggering API calls ...
url_param: dict[str, str]
headers: list[dict[str, str]]
body: list[dict[str, str]]
cookies: list[dict[str, str]]
# vars for GET request ...
get_data: list[dict[str, str]]
get_table_headers: list[str]
paginated_data: list[dict[str, str]]
# vars for pagination ...
number_of_rows: int
limits: list[str] = ["10", "20", "50"]
current_limit: int = 10
offset: int = 0
current_page: int = 1
total_pages: int = 1
formatted_headers: dict
@rx.event
def set_req_url(self, url: str):
self.req_url = url
@rx.event
def get_request(self, method: str):
self.current_req = method
@rx.event
def add_header(self):
self.headers.append(
{"id": str(uuid.uuid4()), "identifier": "headers", "key": "", "value": ""}
)
@rx.event
|
@rx.event
def add_cookies(self):
self.cookies.append(
{"id": str(uuid.uuid4()), "identifier": "cookies", "key": "", "value": ""}
)
@rx.event
def remove_entry(self, data: dict[str, str]):
if data["identifier"] == "headers":
self.headers = [item for item in self.headers if item["id"] != data["id"]]
if data["identifier"] == "body":
self.body = [item for item in self.body if item["id"] != data["id"]]
if data["identifier"] == "cookies":
self.cookies = [item for item in self.cookies if item["id"] != data["id"]]
@rx.event
async def update_attribute(self, data: dict[str, str], attribute: str, value: str):
data[attribute] = value
if data["identifier"] == "headers":
self.headers = [
data if item["id"] == data["id"] else item for item in self.headers
]
if data["identifier"] == "body":
self.body = [
| def add_body(self):
self.body.append(
{"id": str(uuid.uuid4()), "identifier": "body", "key": "", "value": ""}
) |
param: dict[str, str]
headers: list[dict[str, str]]
body: list[dict[str, str]]
cookies: list[dict[str, str]]
# vars for GET request ...
get_data: list[dict[str, str]]
get_table_headers: list[str]
paginated_data: list[dict[str, str]]
# vars for pagination ...
number_of_rows: int
limits: list[str] = ["10", "20", "50"]
current_limit: int = 10
offset: int = 0
current_page: int = 1
total_pages: int = 1
formatted_headers: dict
@rx.event
def set_req_url(self, url: str):
self.req_url = url
@rx.event
def get_request(self, method: str):
self.current_req = method
@rx.event
def add_header(self):
self.headers.append(
{"id": str(uuid.uuid4()), "identifier": "headers", "key": "", "value": ""}
)
@rx.event
def add_body(self):
self.body.append(
{"id": str(uuid.uuid4()), "identifier": "body", "key": "", "value": ""}
)
@rx.event
|
@rx.event
def remove_entry(self, data: dict[str, str]):
if data["identifier"] == "headers":
self.headers = [item for item in self.headers if item["id"] != data["id"]]
if data["identifier"] == "body":
self.body = [item for item in self.body if item["id"] != data["id"]]
if data["identifier"] == "cookies":
self.cookies = [item for item in self.cookies if item["id"] != data["id"]]
@rx.event
async def update_attribute(self, data: dict[str, str], attribute: str, value: str):
data[attribute] = value
if data["identifier"] == "headers":
self.headers = [
data if item["id"] == data["id"] else item for item in self.headers
]
if data["identifier"] == "body":
self.body = [
data if item["id"] == data["id"] else item for item in self.body
]
if data["identifier"] == "cookies":
self.cookies = [
| def add_cookies(self):
self.cookies.append(
{"id": str(uuid.uuid4()), "identifier": "cookies", "key": "", "value": ""}
) |
paginated_data: list[dict[str, str]]
# vars for pagination ...
number_of_rows: int
limits: list[str] = ["10", "20", "50"]
current_limit: int = 10
offset: int = 0
current_page: int = 1
total_pages: int = 1
formatted_headers: dict
@rx.event
def set_req_url(self, url: str):
self.req_url = url
@rx.event
def get_request(self, method: str):
self.current_req = method
@rx.event
def add_header(self):
self.headers.append(
{"id": str(uuid.uuid4()), "identifier": "headers", "key": "", "value": ""}
)
@rx.event
def add_body(self):
self.body.append(
{"id": str(uuid.uuid4()), "identifier": "body", "key": "", "value": ""}
)
@rx.event
def add_cookies(self):
self.cookies.append(
{"id": str(uuid.uuid4()), "identifier": "cookies", "key": "", "value": ""}
)
@rx.event
def remove_entry(self, data: dict[str, str]):
|
if data["identifier"] == "body":
self.body = [item for item in self.body if item["id"] != data["id"]]
if data["identifier"] == "cookies":
self.cookies = [item for item in self.cookies if item["id"] != data["id"]]
@rx.event
async def update_attribute(self, data: dict[str, str], attribute: str, value: str):
data[attribute] = value
if data["identifier"] == "headers":
self.headers = [
data if item["id"] == data["id"] else item for item in self.headers
]
if data["identifier"] == "body":
self.body = [
data if item["id"] == data["id"] else item for item in self.body
]
if data["identifier"] == "cookies":
self.cookies = [
data if item["id"] == data["id"] else item for item in self.cookies
]
@rx.event
async def update_keyy(self, key: str, data: dict[str, str]):
await self.upd | if data["identifier"] == "headers":
self.headers = [item for item in self.headers if item["id"] != data["id"]] |
ars for pagination ...
number_of_rows: int
limits: list[str] = ["10", "20", "50"]
current_limit: int = 10
offset: int = 0
current_page: int = 1
total_pages: int = 1
formatted_headers: dict
@rx.event
def set_req_url(self, url: str):
self.req_url = url
@rx.event
def get_request(self, method: str):
self.current_req = method
@rx.event
def add_header(self):
self.headers.append(
{"id": str(uuid.uuid4()), "identifier": "headers", "key": "", "value": ""}
)
@rx.event
def add_body(self):
self.body.append(
{"id": str(uuid.uuid4()), "identifier": "body", "key": "", "value": ""}
)
@rx.event
def add_cookies(self):
self.cookies.append(
{"id": str(uuid.uuid4()), "identifier": "cookies", "key": "", "value": ""}
)
@rx.event
def remove_entry(self, data: dict[str, str]):
if data["identifier"] == "headers":
|
if data["identifier"] == "body":
self.body = [item for item in self.body if item["id"] != data["id"]]
if data["identifier"] == "cookies":
self.cookies = [item for item in self.cookies if item["id"] != data["id"]]
@rx.event
async def update_attribute(self, data: dict[str, str], attribute: str, value: str):
data[attribute] = value
if data["identifier"] == "headers":
self.headers = [
data if item["id"] == data["id"] else item for item in self.headers
]
if data["identifier"] == "body":
self.body = [
data if item["id"] == data["id"] else item for item in self.body
]
if data["identifier"] == "cookies":
self.cookies = [
data if item["id"] == data["id"] else item for item in self.cookies
]
@rx.event
async def update_keyy(self, key: str, data: dict[str, str]):
await self.upd | self.headers = [item for item in self.headers if item["id"] != data["id"]] |
"50"]
current_limit: int = 10
offset: int = 0
current_page: int = 1
total_pages: int = 1
formatted_headers: dict
@rx.event
def set_req_url(self, url: str):
self.req_url = url
@rx.event
def get_request(self, method: str):
self.current_req = method
@rx.event
def add_header(self):
self.headers.append(
{"id": str(uuid.uuid4()), "identifier": "headers", "key": "", "value": ""}
)
@rx.event
def add_body(self):
self.body.append(
{"id": str(uuid.uuid4()), "identifier": "body", "key": "", "value": ""}
)
@rx.event
def add_cookies(self):
self.cookies.append(
{"id": str(uuid.uuid4()), "identifier": "cookies", "key": "", "value": ""}
)
@rx.event
def remove_entry(self, data: dict[str, str]):
if data["identifier"] == "headers":
self.headers = [item for item in self.headers if item["id"] != data["id"]]
|
if data["identifier"] == "cookies":
self.cookies = [item for item in self.cookies if item["id"] != data["id"]]
@rx.event
async def update_attribute(self, data: dict[str, str], attribute: str, value: str):
data[attribute] = value
if data["identifier"] == "headers":
self.headers = [
data if item["id"] == data["id"] else item for item in self.headers
]
if data["identifier"] == "body":
self.body = [
data if item["id"] == data["id"] else item for item in self.body
]
if data["identifier"] == "cookies":
self.cookies = [
data if item["id"] == data["id"] else item for item in self.cookies
]
@rx.event
async def update_keyy(self, key: str, data: dict[str, str]):
await self.update_attribute(data, "key", key)
@rx.event
async def update_value(self, value: str, data: dict[str, str]):
| if data["identifier"] == "body":
self.body = [item for item in self.body if item["id"] != data["id"]] |
int = 0
current_page: int = 1
total_pages: int = 1
formatted_headers: dict
@rx.event
def set_req_url(self, url: str):
self.req_url = url
@rx.event
def get_request(self, method: str):
self.current_req = method
@rx.event
def add_header(self):
self.headers.append(
{"id": str(uuid.uuid4()), "identifier": "headers", "key": "", "value": ""}
)
@rx.event
def add_body(self):
self.body.append(
{"id": str(uuid.uuid4()), "identifier": "body", "key": "", "value": ""}
)
@rx.event
def add_cookies(self):
self.cookies.append(
{"id": str(uuid.uuid4()), "identifier": "cookies", "key": "", "value": ""}
)
@rx.event
def remove_entry(self, data: dict[str, str]):
if data["identifier"] == "headers":
self.headers = [item for item in self.headers if item["id"] != data["id"]]
if data["identifier"] == "body":
|
if data["identifier"] == "cookies":
self.cookies = [item for item in self.cookies if item["id"] != data["id"]]
@rx.event
async def update_attribute(self, data: dict[str, str], attribute: str, value: str):
data[attribute] = value
if data["identifier"] == "headers":
self.headers = [
data if item["id"] == data["id"] else item for item in self.headers
]
if data["identifier"] == "body":
self.body = [
data if item["id"] == data["id"] else item for item in self.body
]
if data["identifier"] == "cookies":
self.cookies = [
data if item["id"] == data["id"] else item for item in self.cookies
]
@rx.event
async def update_keyy(self, key: str, data: dict[str, str]):
await self.update_attribute(data, "key", key)
@rx.event
async def update_value(self, value: str, data: dict[str, str]):
| self.body = [item for item in self.body if item["id"] != data["id"]] |
ers: dict
@rx.event
def set_req_url(self, url: str):
self.req_url = url
@rx.event
def get_request(self, method: str):
self.current_req = method
@rx.event
def add_header(self):
self.headers.append(
{"id": str(uuid.uuid4()), "identifier": "headers", "key": "", "value": ""}
)
@rx.event
def add_body(self):
self.body.append(
{"id": str(uuid.uuid4()), "identifier": "body", "key": "", "value": ""}
)
@rx.event
def add_cookies(self):
self.cookies.append(
{"id": str(uuid.uuid4()), "identifier": "cookies", "key": "", "value": ""}
)
@rx.event
def remove_entry(self, data: dict[str, str]):
if data["identifier"] == "headers":
self.headers = [item for item in self.headers if item["id"] != data["id"]]
if data["identifier"] == "body":
self.body = [item for item in self.body if item["id"] != data["id"]]
|
@rx.event
async def update_attribute(self, data: dict[str, str], attribute: str, value: str):
data[attribute] = value
if data["identifier"] == "headers":
self.headers = [
data if item["id"] == data["id"] else item for item in self.headers
]
if data["identifier"] == "body":
self.body = [
data if item["id"] == data["id"] else item for item in self.body
]
if data["identifier"] == "cookies":
self.cookies = [
data if item["id"] == data["id"] else item for item in self.cookies
]
@rx.event
async def update_keyy(self, key: str, data: dict[str, str]):
await self.update_attribute(data, "key", key)
@rx.event
async def update_value(self, value: str, data: dict[str, str]):
await self.update_attribute(data, "value", value)
class QueryAPI(QueryState):
# vars to update row entries ...
is_open: bo | if data["identifier"] == "cookies":
self.cookies = [item for item in self.cookies if item["id"] != data["id"]] |
f, url: str):
self.req_url = url
@rx.event
def get_request(self, method: str):
self.current_req = method
@rx.event
def add_header(self):
self.headers.append(
{"id": str(uuid.uuid4()), "identifier": "headers", "key": "", "value": ""}
)
@rx.event
def add_body(self):
self.body.append(
{"id": str(uuid.uuid4()), "identifier": "body", "key": "", "value": ""}
)
@rx.event
def add_cookies(self):
self.cookies.append(
{"id": str(uuid.uuid4()), "identifier": "cookies", "key": "", "value": ""}
)
@rx.event
def remove_entry(self, data: dict[str, str]):
if data["identifier"] == "headers":
self.headers = [item for item in self.headers if item["id"] != data["id"]]
if data["identifier"] == "body":
self.body = [item for item in self.body if item["id"] != data["id"]]
if data["identifier"] == "cookies":
|
@rx.event
async def update_attribute(self, data: dict[str, str], attribute: str, value: str):
data[attribute] = value
if data["identifier"] == "headers":
self.headers = [
data if item["id"] == data["id"] else item for item in self.headers
]
if data["identifier"] == "body":
self.body = [
data if item["id"] == data["id"] else item for item in self.body
]
if data["identifier"] == "cookies":
self.cookies = [
data if item["id"] == data["id"] else item for item in self.cookies
]
@rx.event
async def update_keyy(self, key: str, data: dict[str, str]):
await self.update_attribute(data, "key", key)
@rx.event
async def update_value(self, value: str, data: dict[str, str]):
await self.update_attribute(data, "value", value)
class QueryAPI(QueryState):
# vars to update row entries ...
is_open: bo | self.cookies = [item for item in self.cookies if item["id"] != data["id"]] |
aders.append(
{"id": str(uuid.uuid4()), "identifier": "headers", "key": "", "value": ""}
)
@rx.event
def add_body(self):
self.body.append(
{"id": str(uuid.uuid4()), "identifier": "body", "key": "", "value": ""}
)
@rx.event
def add_cookies(self):
self.cookies.append(
{"id": str(uuid.uuid4()), "identifier": "cookies", "key": "", "value": ""}
)
@rx.event
def remove_entry(self, data: dict[str, str]):
if data["identifier"] == "headers":
self.headers = [item for item in self.headers if item["id"] != data["id"]]
if data["identifier"] == "body":
self.body = [item for item in self.body if item["id"] != data["id"]]
if data["identifier"] == "cookies":
self.cookies = [item for item in self.cookies if item["id"] != data["id"]]
@rx.event
async def update_attribute(self, data: dict[str, str], attribute: str, value: str):
|
if data["identifier"] == "headers":
self.headers = [
data if item["id"] == data["id"] else item for item in self.headers
]
if data["identifier"] == "body":
self.body = [
data if item["id"] == data["id"] else item for item in self.body
]
if data["identifier"] == "cookies":
self.cookies = [
data if item["id"] == data["id"] else item for item in self.cookies
]
@rx.event
async def update_keyy(self, key: str, data: dict[str, str]):
await self.update_attribute(data, "key", key)
@rx.event
async def update_value(self, value: str, data: dict[str, str]):
await self.update_attribute(data, "value", value)
class QueryAPI(QueryState):
# vars to update row entries ...
is_open: bool = False
selected_entry: dict[str, str]
original_entry: dict[str, str]
async def process_headers(self):
for item | data[attribute] = value |
str(uuid.uuid4()), "identifier": "headers", "key": "", "value": ""}
)
@rx.event
def add_body(self):
self.body.append(
{"id": str(uuid.uuid4()), "identifier": "body", "key": "", "value": ""}
)
@rx.event
def add_cookies(self):
self.cookies.append(
{"id": str(uuid.uuid4()), "identifier": "cookies", "key": "", "value": ""}
)
@rx.event
def remove_entry(self, data: dict[str, str]):
if data["identifier"] == "headers":
self.headers = [item for item in self.headers if item["id"] != data["id"]]
if data["identifier"] == "body":
self.body = [item for item in self.body if item["id"] != data["id"]]
if data["identifier"] == "cookies":
self.cookies = [item for item in self.cookies if item["id"] != data["id"]]
@rx.event
async def update_attribute(self, data: dict[str, str], attribute: str, value: str):
data[attribute] = value
|
if data["identifier"] == "body":
self.body = [
data if item["id"] == data["id"] else item for item in self.body
]
if data["identifier"] == "cookies":
self.cookies = [
data if item["id"] == data["id"] else item for item in self.cookies
]
@rx.event
async def update_keyy(self, key: str, data: dict[str, str]):
await self.update_attribute(data, "key", key)
@rx.event
async def update_value(self, value: str, data: dict[str, str]):
await self.update_attribute(data, "value", value)
class QueryAPI(QueryState):
# vars to update row entries ...
is_open: bool = False
selected_entry: dict[str, str]
original_entry: dict[str, str]
async def process_headers(self):
for item in self.headers:
if item["key"]:
self.formatted_headers[item["key"]] = item["value"]
async def run_get_request(self):
await self.p | if data["identifier"] == "headers":
self.headers = [
data if item["id"] == data["id"] else item for item in self.headers
] |
": "", "value": ""}
)
@rx.event
def add_body(self):
self.body.append(
{"id": str(uuid.uuid4()), "identifier": "body", "key": "", "value": ""}
)
@rx.event
def add_cookies(self):
self.cookies.append(
{"id": str(uuid.uuid4()), "identifier": "cookies", "key": "", "value": ""}
)
@rx.event
def remove_entry(self, data: dict[str, str]):
if data["identifier"] == "headers":
self.headers = [item for item in self.headers if item["id"] != data["id"]]
if data["identifier"] == "body":
self.body = [item for item in self.body if item["id"] != data["id"]]
if data["identifier"] == "cookies":
self.cookies = [item for item in self.cookies if item["id"] != data["id"]]
@rx.event
async def update_attribute(self, data: dict[str, str], attribute: str, value: str):
data[attribute] = value
if data["identifier"] == "headers":
|
if data["identifier"] == "body":
self.body = [
data if item["id"] == data["id"] else item for item in self.body
]
if data["identifier"] == "cookies":
self.cookies = [
data if item["id"] == data["id"] else item for item in self.cookies
]
@rx.event
async def update_keyy(self, key: str, data: dict[str, str]):
await self.update_attribute(data, "key", key)
@rx.event
async def update_value(self, value: str, data: dict[str, str]):
await self.update_attribute(data, "value", value)
class QueryAPI(QueryState):
# vars to update row entries ...
is_open: bool = False
selected_entry: dict[str, str]
original_entry: dict[str, str]
async def process_headers(self):
for item in self.headers:
if item["key"]:
self.formatted_headers[item["key"]] = item["value"]
async def run_get_request(self):
await self.p | self.headers = [
data if item["id"] == data["id"] else item for item in self.headers
] |
uid4()), "identifier": "body", "key": "", "value": ""}
)
@rx.event
def add_cookies(self):
self.cookies.append(
{"id": str(uuid.uuid4()), "identifier": "cookies", "key": "", "value": ""}
)
@rx.event
def remove_entry(self, data: dict[str, str]):
if data["identifier"] == "headers":
self.headers = [item for item in self.headers if item["id"] != data["id"]]
if data["identifier"] == "body":
self.body = [item for item in self.body if item["id"] != data["id"]]
if data["identifier"] == "cookies":
self.cookies = [item for item in self.cookies if item["id"] != data["id"]]
@rx.event
async def update_attribute(self, data: dict[str, str], attribute: str, value: str):
data[attribute] = value
if data["identifier"] == "headers":
self.headers = [
data if item["id"] == data["id"] else item for item in self.headers
]
|
if data["identifier"] == "cookies":
self.cookies = [
data if item["id"] == data["id"] else item for item in self.cookies
]
@rx.event
async def update_keyy(self, key: str, data: dict[str, str]):
await self.update_attribute(data, "key", key)
@rx.event
async def update_value(self, value: str, data: dict[str, str]):
await self.update_attribute(data, "value", value)
class QueryAPI(QueryState):
# vars to update row entries ...
is_open: bool = False
selected_entry: dict[str, str]
original_entry: dict[str, str]
async def process_headers(self):
for item in self.headers:
if item["key"]:
self.formatted_headers[item["key"]] = item["value"]
async def run_get_request(self):
await self.process_headers()
async with httpx.AsyncClient() as client:
res = await client.get(self.req_url, headers=self.formatted_headers)
se | if data["identifier"] == "body":
self.body = [
data if item["id"] == data["id"] else item for item in self.body
] |
lue": ""}
)
@rx.event
def add_cookies(self):
self.cookies.append(
{"id": str(uuid.uuid4()), "identifier": "cookies", "key": "", "value": ""}
)
@rx.event
def remove_entry(self, data: dict[str, str]):
if data["identifier"] == "headers":
self.headers = [item for item in self.headers if item["id"] != data["id"]]
if data["identifier"] == "body":
self.body = [item for item in self.body if item["id"] != data["id"]]
if data["identifier"] == "cookies":
self.cookies = [item for item in self.cookies if item["id"] != data["id"]]
@rx.event
async def update_attribute(self, data: dict[str, str], attribute: str, value: str):
data[attribute] = value
if data["identifier"] == "headers":
self.headers = [
data if item["id"] == data["id"] else item for item in self.headers
]
if data["identifier"] == "body":
|
if data["identifier"] == "cookies":
self.cookies = [
data if item["id"] == data["id"] else item for item in self.cookies
]
@rx.event
async def update_keyy(self, key: str, data: dict[str, str]):
await self.update_attribute(data, "key", key)
@rx.event
async def update_value(self, value: str, data: dict[str, str]):
await self.update_attribute(data, "value", value)
class QueryAPI(QueryState):
# vars to update row entries ...
is_open: bool = False
selected_entry: dict[str, str]
original_entry: dict[str, str]
async def process_headers(self):
for item in self.headers:
if item["key"]:
self.formatted_headers[item["key"]] = item["value"]
async def run_get_request(self):
await self.process_headers()
async with httpx.AsyncClient() as client:
res = await client.get(self.req_url, headers=self.formatted_headers)
se | self.body = [
data if item["id"] == data["id"] else item for item in self.body
] |
.uuid4()), "identifier": "cookies", "key": "", "value": ""}
)
@rx.event
def remove_entry(self, data: dict[str, str]):
if data["identifier"] == "headers":
self.headers = [item for item in self.headers if item["id"] != data["id"]]
if data["identifier"] == "body":
self.body = [item for item in self.body if item["id"] != data["id"]]
if data["identifier"] == "cookies":
self.cookies = [item for item in self.cookies if item["id"] != data["id"]]
@rx.event
async def update_attribute(self, data: dict[str, str], attribute: str, value: str):
data[attribute] = value
if data["identifier"] == "headers":
self.headers = [
data if item["id"] == data["id"] else item for item in self.headers
]
if data["identifier"] == "body":
self.body = [
data if item["id"] == data["id"] else item for item in self.body
]
|
@rx.event
async def update_keyy(self, key: str, data: dict[str, str]):
await self.update_attribute(data, "key", key)
@rx.event
async def update_value(self, value: str, data: dict[str, str]):
await self.update_attribute(data, "value", value)
class QueryAPI(QueryState):
# vars to update row entries ...
is_open: bool = False
selected_entry: dict[str, str]
original_entry: dict[str, str]
async def process_headers(self):
for item in self.headers:
if item["key"]:
self.formatted_headers[item["key"]] = item["value"]
async def run_get_request(self):
await self.process_headers()
async with httpx.AsyncClient() as client:
res = await client.get(self.req_url, headers=self.formatted_headers)
self.get_data = res.json()
self.number_of_rows = len(self.get_data)
self.get_table_headers = list(self.get_data[0].keys())
# Calculate th | if data["identifier"] == "cookies":
self.cookies = [
data if item["id"] == data["id"] else item for item in self.cookies
] |
value": ""}
)
@rx.event
def remove_entry(self, data: dict[str, str]):
if data["identifier"] == "headers":
self.headers = [item for item in self.headers if item["id"] != data["id"]]
if data["identifier"] == "body":
self.body = [item for item in self.body if item["id"] != data["id"]]
if data["identifier"] == "cookies":
self.cookies = [item for item in self.cookies if item["id"] != data["id"]]
@rx.event
async def update_attribute(self, data: dict[str, str], attribute: str, value: str):
data[attribute] = value
if data["identifier"] == "headers":
self.headers = [
data if item["id"] == data["id"] else item for item in self.headers
]
if data["identifier"] == "body":
self.body = [
data if item["id"] == data["id"] else item for item in self.body
]
if data["identifier"] == "cookies":
|
@rx.event
async def update_keyy(self, key: str, data: dict[str, str]):
await self.update_attribute(data, "key", key)
@rx.event
async def update_value(self, value: str, data: dict[str, str]):
await self.update_attribute(data, "value", value)
class QueryAPI(QueryState):
# vars to update row entries ...
is_open: bool = False
selected_entry: dict[str, str]
original_entry: dict[str, str]
async def process_headers(self):
for item in self.headers:
if item["key"]:
self.formatted_headers[item["key"]] = item["value"]
async def run_get_request(self):
await self.process_headers()
async with httpx.AsyncClient() as client:
res = await client.get(self.req_url, headers=self.formatted_headers)
self.get_data = res.json()
self.number_of_rows = len(self.get_data)
self.get_table_headers = list(self.get_data[0].keys())
# Calculate th | self.cookies = [
data if item["id"] == data["id"] else item for item in self.cookies
] |
= value
if data["identifier"] == "headers":
self.headers = [
data if item["id"] == data["id"] else item for item in self.headers
]
if data["identifier"] == "body":
self.body = [
data if item["id"] == data["id"] else item for item in self.body
]
if data["identifier"] == "cookies":
self.cookies = [
data if item["id"] == data["id"] else item for item in self.cookies
]
@rx.event
async def update_keyy(self, key: str, data: dict[str, str]):
await self.update_attribute(data, "key", key)
@rx.event
async def update_value(self, value: str, data: dict[str, str]):
await self.update_attribute(data, "value", value)
class QueryAPI(QueryState):
# vars to update row entries ...
is_open: bool = False
selected_entry: dict[str, str]
original_entry: dict[str, str]
async def process_headers(self):
|
async def run_get_request(self):
await self.process_headers()
async with httpx.AsyncClient() as client:
res = await client.get(self.req_url, headers=self.formatted_headers)
self.get_data = res.json()
self.number_of_rows = len(self.get_data)
self.get_table_headers = list(self.get_data[0].keys())
# Calculate the total number of pages
self.total_pages = (
self.number_of_rows + self.current_limit - 1
) // self.current_limit
# Initialize the data to the first page
self.paginate()
def paginate(self):
start = self.offset
end = start + self.current_limit
self.paginated_data = self.get_data[start:end]
self.current_page = (self.offset // self.current_limit) + 1
def delta_limit(self, limit: str):
self.current_limit = int(limit)
self.offset = 0
self.total_pages = (
self.numb | for item in self.headers:
if item["key"]:
self.formatted_headers[item["key"]] = item["value"] |
] == "headers":
self.headers = [
data if item["id"] == data["id"] else item for item in self.headers
]
if data["identifier"] == "body":
self.body = [
data if item["id"] == data["id"] else item for item in self.body
]
if data["identifier"] == "cookies":
self.cookies = [
data if item["id"] == data["id"] else item for item in self.cookies
]
@rx.event
async def update_keyy(self, key: str, data: dict[str, str]):
await self.update_attribute(data, "key", key)
@rx.event
async def update_value(self, value: str, data: dict[str, str]):
await self.update_attribute(data, "value", value)
class QueryAPI(QueryState):
# vars to update row entries ...
is_open: bool = False
selected_entry: dict[str, str]
original_entry: dict[str, str]
async def process_headers(self):
for item in self.headers:
|
async def run_get_request(self):
await self.process_headers()
async with httpx.AsyncClient() as client:
res = await client.get(self.req_url, headers=self.formatted_headers)
self.get_data = res.json()
self.number_of_rows = len(self.get_data)
self.get_table_headers = list(self.get_data[0].keys())
# Calculate the total number of pages
self.total_pages = (
self.number_of_rows + self.current_limit - 1
) // self.current_limit
# Initialize the data to the first page
self.paginate()
def paginate(self):
start = self.offset
end = start + self.current_limit
self.paginated_data = self.get_data[start:end]
self.current_page = (self.offset // self.current_limit) + 1
def delta_limit(self, limit: str):
self.current_limit = int(limit)
self.offset = 0
self.total_pages = (
self.numb | if item["key"]:
self.formatted_headers[item["key"]] = item["value"] |
.headers = [
data if item["id"] == data["id"] else item for item in self.headers
]
if data["identifier"] == "body":
self.body = [
data if item["id"] == data["id"] else item for item in self.body
]
if data["identifier"] == "cookies":
self.cookies = [
data if item["id"] == data["id"] else item for item in self.cookies
]
@rx.event
async def update_keyy(self, key: str, data: dict[str, str]):
await self.update_attribute(data, "key", key)
@rx.event
async def update_value(self, value: str, data: dict[str, str]):
await self.update_attribute(data, "value", value)
class QueryAPI(QueryState):
# vars to update row entries ...
is_open: bool = False
selected_entry: dict[str, str]
original_entry: dict[str, str]
async def process_headers(self):
for item in self.headers:
if item["key"]:
|
async def run_get_request(self):
await self.process_headers()
async with httpx.AsyncClient() as client:
res = await client.get(self.req_url, headers=self.formatted_headers)
self.get_data = res.json()
self.number_of_rows = len(self.get_data)
self.get_table_headers = list(self.get_data[0].keys())
# Calculate the total number of pages
self.total_pages = (
self.number_of_rows + self.current_limit - 1
) // self.current_limit
# Initialize the data to the first page
self.paginate()
def paginate(self):
start = self.offset
end = start + self.current_limit
self.paginated_data = self.get_data[start:end]
self.current_page = (self.offset // self.current_limit) + 1
def delta_limit(self, limit: str):
self.current_limit = int(limit)
self.offset = 0
self.total_pages = (
self.numb | self.formatted_headers[item["key"]] = item["value"] |
data if item["id"] == data["id"] else item for item in self.body
]
if data["identifier"] == "cookies":
self.cookies = [
data if item["id"] == data["id"] else item for item in self.cookies
]
@rx.event
async def update_keyy(self, key: str, data: dict[str, str]):
await self.update_attribute(data, "key", key)
@rx.event
async def update_value(self, value: str, data: dict[str, str]):
await self.update_attribute(data, "value", value)
class QueryAPI(QueryState):
# vars to update row entries ...
is_open: bool = False
selected_entry: dict[str, str]
original_entry: dict[str, str]
async def process_headers(self):
for item in self.headers:
if item["key"]:
self.formatted_headers[item["key"]] = item["value"]
async def run_get_request(self):
await self.process_headers()
async with httpx.AsyncClient() as client:
|
self.get_data = res.json()
self.number_of_rows = len(self.get_data)
self.get_table_headers = list(self.get_data[0].keys())
# Calculate the total number of pages
self.total_pages = (
self.number_of_rows + self.current_limit - 1
) // self.current_limit
# Initialize the data to the first page
self.paginate()
def paginate(self):
start = self.offset
end = start + self.current_limit
self.paginated_data = self.get_data[start:end]
self.current_page = (self.offset // self.current_limit) + 1
def delta_limit(self, limit: str):
self.current_limit = int(limit)
self.offset = 0
self.total_pages = (
self.number_of_rows + self.current_limit - 1
) // self.current_limit
self.paginate()
def previous(self):
if self.offset >= self.current_limit:
self.offset -= self.current_lim | res = await client.get(self.req_url, headers=self.formatted_headers) |
]
if data["identifier"] == "cookies":
self.cookies = [
data if item["id"] == data["id"] else item for item in self.cookies
]
@rx.event
async def update_keyy(self, key: str, data: dict[str, str]):
await self.update_attribute(data, "key", key)
@rx.event
async def update_value(self, value: str, data: dict[str, str]):
await self.update_attribute(data, "value", value)
class QueryAPI(QueryState):
# vars to update row entries ...
is_open: bool = False
selected_entry: dict[str, str]
original_entry: dict[str, str]
async def process_headers(self):
for item in self.headers:
if item["key"]:
self.formatted_headers[item["key"]] = item["value"]
async def run_get_request(self):
await self.process_headers()
async with httpx.AsyncClient() as client:
res = await client.get(self.req_url, headers=self.formatted_headers)
|
self.number_of_rows = len(self.get_data)
self.get_table_headers = list(self.get_data[0].keys())
# Calculate the total number of pages
self.total_pages = (
self.number_of_rows + self.current_limit - 1
) // self.current_limit
# Initialize the data to the first page
self.paginate()
def paginate(self):
start = self.offset
end = start + self.current_limit
self.paginated_data = self.get_data[start:end]
self.current_page = (self.offset // self.current_limit) + 1
def delta_limit(self, limit: str):
self.current_limit = int(limit)
self.offset = 0
self.total_pages = (
self.number_of_rows + self.current_limit - 1
) // self.current_limit
self.paginate()
def previous(self):
if self.offset >= self.current_limit:
self.offset -= self.current_limit
else:
self.offset | self.get_data = res.json() |
ookies":
self.cookies = [
data if item["id"] == data["id"] else item for item in self.cookies
]
@rx.event
async def update_keyy(self, key: str, data: dict[str, str]):
await self.update_attribute(data, "key", key)
@rx.event
async def update_value(self, value: str, data: dict[str, str]):
await self.update_attribute(data, "value", value)
class QueryAPI(QueryState):
# vars to update row entries ...
is_open: bool = False
selected_entry: dict[str, str]
original_entry: dict[str, str]
async def process_headers(self):
for item in self.headers:
if item["key"]:
self.formatted_headers[item["key"]] = item["value"]
async def run_get_request(self):
await self.process_headers()
async with httpx.AsyncClient() as client:
res = await client.get(self.req_url, headers=self.formatted_headers)
self.get_data = res.json()
|
self.get_table_headers = list(self.get_data[0].keys())
# Calculate the total number of pages
self.total_pages = (
self.number_of_rows + self.current_limit - 1
) // self.current_limit
# Initialize the data to the first page
self.paginate()
def paginate(self):
start = self.offset
end = start + self.current_limit
self.paginated_data = self.get_data[start:end]
self.current_page = (self.offset // self.current_limit) + 1
def delta_limit(self, limit: str):
self.current_limit = int(limit)
self.offset = 0
self.total_pages = (
self.number_of_rows + self.current_limit - 1
) // self.current_limit
self.paginate()
def previous(self):
if self.offset >= self.current_limit:
self.offset -= self.current_limit
else:
self.offset = 0
self.paginate()
def next(self):
| self.number_of_rows = len(self.get_data) |
data if item["id"] == data["id"] else item for item in self.cookies
]
@rx.event
async def update_keyy(self, key: str, data: dict[str, str]):
await self.update_attribute(data, "key", key)
@rx.event
async def update_value(self, value: str, data: dict[str, str]):
await self.update_attribute(data, "value", value)
class QueryAPI(QueryState):
# vars to update row entries ...
is_open: bool = False
selected_entry: dict[str, str]
original_entry: dict[str, str]
async def process_headers(self):
for item in self.headers:
if item["key"]:
self.formatted_headers[item["key"]] = item["value"]
async def run_get_request(self):
await self.process_headers()
async with httpx.AsyncClient() as client:
res = await client.get(self.req_url, headers=self.formatted_headers)
self.get_data = res.json()
self.number_of_rows = len(self.get_data)
|
# Calculate the total number of pages
self.total_pages = (
self.number_of_rows + self.current_limit - 1
) // self.current_limit
# Initialize the data to the first page
self.paginate()
def paginate(self):
start = self.offset
end = start + self.current_limit
self.paginated_data = self.get_data[start:end]
self.current_page = (self.offset // self.current_limit) + 1
def delta_limit(self, limit: str):
self.current_limit = int(limit)
self.offset = 0
self.total_pages = (
self.number_of_rows + self.current_limit - 1
) // self.current_limit
self.paginate()
def previous(self):
if self.offset >= self.current_limit:
self.offset -= self.current_limit
else:
self.offset = 0
self.paginate()
def next(self):
if self.offset + self.current_limit < self.number_of_rows:
| self.get_table_headers = list(self.get_data[0].keys()) |
_keyy(self, key: str, data: dict[str, str]):
await self.update_attribute(data, "key", key)
@rx.event
async def update_value(self, value: str, data: dict[str, str]):
await self.update_attribute(data, "value", value)
class QueryAPI(QueryState):
# vars to update row entries ...
is_open: bool = False
selected_entry: dict[str, str]
original_entry: dict[str, str]
async def process_headers(self):
for item in self.headers:
if item["key"]:
self.formatted_headers[item["key"]] = item["value"]
async def run_get_request(self):
await self.process_headers()
async with httpx.AsyncClient() as client:
res = await client.get(self.req_url, headers=self.formatted_headers)
self.get_data = res.json()
self.number_of_rows = len(self.get_data)
self.get_table_headers = list(self.get_data[0].keys())
# Calculate the total number of pages
|
# Initialize the data to the first page
self.paginate()
def paginate(self):
start = self.offset
end = start + self.current_limit
self.paginated_data = self.get_data[start:end]
self.current_page = (self.offset // self.current_limit) + 1
def delta_limit(self, limit: str):
self.current_limit = int(limit)
self.offset = 0
self.total_pages = (
self.number_of_rows + self.current_limit - 1
) // self.current_limit
self.paginate()
def previous(self):
if self.offset >= self.current_limit:
self.offset -= self.current_limit
else:
self.offset = 0
self.paginate()
def next(self):
if self.offset + self.current_limit < self.number_of_rows:
self.offset += self.current_limit
self.paginate()
def delta_drawer(self):
self.is_open = not self.is_open
def display_selected_row(self, data: d | self.total_pages = (
self.number_of_rows + self.current_limit - 1
) // self.current_limit |
ate_attribute(data, "value", value)
class QueryAPI(QueryState):
# vars to update row entries ...
is_open: bool = False
selected_entry: dict[str, str]
original_entry: dict[str, str]
async def process_headers(self):
for item in self.headers:
if item["key"]:
self.formatted_headers[item["key"]] = item["value"]
async def run_get_request(self):
await self.process_headers()
async with httpx.AsyncClient() as client:
res = await client.get(self.req_url, headers=self.formatted_headers)
self.get_data = res.json()
self.number_of_rows = len(self.get_data)
self.get_table_headers = list(self.get_data[0].keys())
# Calculate the total number of pages
self.total_pages = (
self.number_of_rows + self.current_limit - 1
) // self.current_limit
# Initialize the data to the first page
self.paginate()
|
def delta_limit(self, limit: str):
self.current_limit = int(limit)
self.offset = 0
self.total_pages = (
self.number_of_rows + self.current_limit - 1
) // self.current_limit
self.paginate()
def previous(self):
if self.offset >= self.current_limit:
self.offset -= self.current_limit
else:
self.offset = 0
self.paginate()
def next(self):
if self.offset + self.current_limit < self.number_of_rows:
self.offset += self.current_limit
self.paginate()
def delta_drawer(self):
self.is_open = not self.is_open
def display_selected_row(self, data: dict[str, str]):
self.delta_drawer()
self.selected_entry = data.copy()
self.original_entry = data
def update_data(self, value: str, data: tuple[str, str]):
self.selected_entry[data[0]] = value
def commit_changes(self):
self.get_data = [
| def paginate(self):
start = self.offset
end = start + self.current_limit
self.paginated_data = self.get_data[start:end]
self.current_page = (self.offset // self.current_limit) + 1 |
value)
class QueryAPI(QueryState):
# vars to update row entries ...
is_open: bool = False
selected_entry: dict[str, str]
original_entry: dict[str, str]
async def process_headers(self):
for item in self.headers:
if item["key"]:
self.formatted_headers[item["key"]] = item["value"]
async def run_get_request(self):
await self.process_headers()
async with httpx.AsyncClient() as client:
res = await client.get(self.req_url, headers=self.formatted_headers)
self.get_data = res.json()
self.number_of_rows = len(self.get_data)
self.get_table_headers = list(self.get_data[0].keys())
# Calculate the total number of pages
self.total_pages = (
self.number_of_rows + self.current_limit - 1
) // self.current_limit
# Initialize the data to the first page
self.paginate()
def paginate(self):
|
end = start + self.current_limit
self.paginated_data = self.get_data[start:end]
self.current_page = (self.offset // self.current_limit) + 1
def delta_limit(self, limit: str):
self.current_limit = int(limit)
self.offset = 0
self.total_pages = (
self.number_of_rows + self.current_limit - 1
) // self.current_limit
self.paginate()
def previous(self):
if self.offset >= self.current_limit:
self.offset -= self.current_limit
else:
self.offset = 0
self.paginate()
def next(self):
if self.offset + self.current_limit < self.number_of_rows:
self.offset += self.current_limit
self.paginate()
def delta_drawer(self):
self.is_open = not self.is_open
def display_selected_row(self, data: dict[str, str]):
self.delta_drawer()
self.selected_entry = data.copy()
self.original_entry = data
def upda | start = self.offset |
ryState):
# vars to update row entries ...
is_open: bool = False
selected_entry: dict[str, str]
original_entry: dict[str, str]
async def process_headers(self):
for item in self.headers:
if item["key"]:
self.formatted_headers[item["key"]] = item["value"]
async def run_get_request(self):
await self.process_headers()
async with httpx.AsyncClient() as client:
res = await client.get(self.req_url, headers=self.formatted_headers)
self.get_data = res.json()
self.number_of_rows = len(self.get_data)
self.get_table_headers = list(self.get_data[0].keys())
# Calculate the total number of pages
self.total_pages = (
self.number_of_rows + self.current_limit - 1
) // self.current_limit
# Initialize the data to the first page
self.paginate()
def paginate(self):
start = self.offset
|
self.paginated_data = self.get_data[start:end]
self.current_page = (self.offset // self.current_limit) + 1
def delta_limit(self, limit: str):
self.current_limit = int(limit)
self.offset = 0
self.total_pages = (
self.number_of_rows + self.current_limit - 1
) // self.current_limit
self.paginate()
def previous(self):
if self.offset >= self.current_limit:
self.offset -= self.current_limit
else:
self.offset = 0
self.paginate()
def next(self):
if self.offset + self.current_limit < self.number_of_rows:
self.offset += self.current_limit
self.paginate()
def delta_drawer(self):
self.is_open = not self.is_open
def display_selected_row(self, data: dict[str, str]):
self.delta_drawer()
self.selected_entry = data.copy()
self.original_entry = data
def update_data(self, value: str, data: tuple[str | end = start + self.current_limit |
s ...
is_open: bool = False
selected_entry: dict[str, str]
original_entry: dict[str, str]
async def process_headers(self):
for item in self.headers:
if item["key"]:
self.formatted_headers[item["key"]] = item["value"]
async def run_get_request(self):
await self.process_headers()
async with httpx.AsyncClient() as client:
res = await client.get(self.req_url, headers=self.formatted_headers)
self.get_data = res.json()
self.number_of_rows = len(self.get_data)
self.get_table_headers = list(self.get_data[0].keys())
# Calculate the total number of pages
self.total_pages = (
self.number_of_rows + self.current_limit - 1
) // self.current_limit
# Initialize the data to the first page
self.paginate()
def paginate(self):
start = self.offset
end = start + self.current_limit
|
self.current_page = (self.offset // self.current_limit) + 1
def delta_limit(self, limit: str):
self.current_limit = int(limit)
self.offset = 0
self.total_pages = (
self.number_of_rows + self.current_limit - 1
) // self.current_limit
self.paginate()
def previous(self):
if self.offset >= self.current_limit:
self.offset -= self.current_limit
else:
self.offset = 0
self.paginate()
def next(self):
if self.offset + self.current_limit < self.number_of_rows:
self.offset += self.current_limit
self.paginate()
def delta_drawer(self):
self.is_open = not self.is_open
def display_selected_row(self, data: dict[str, str]):
self.delta_drawer()
self.selected_entry = data.copy()
self.original_entry = data
def update_data(self, value: str, data: tuple[str, str]):
self.selected_entry[data[0]] = value
| self.paginated_data = self.get_data[start:end] |
t[str, str]
original_entry: dict[str, str]
async def process_headers(self):
for item in self.headers:
if item["key"]:
self.formatted_headers[item["key"]] = item["value"]
async def run_get_request(self):
await self.process_headers()
async with httpx.AsyncClient() as client:
res = await client.get(self.req_url, headers=self.formatted_headers)
self.get_data = res.json()
self.number_of_rows = len(self.get_data)
self.get_table_headers = list(self.get_data[0].keys())
# Calculate the total number of pages
self.total_pages = (
self.number_of_rows + self.current_limit - 1
) // self.current_limit
# Initialize the data to the first page
self.paginate()
def paginate(self):
start = self.offset
end = start + self.current_limit
self.paginated_data = self.get_data[start:end]
|
def delta_limit(self, limit: str):
self.current_limit = int(limit)
self.offset = 0
self.total_pages = (
self.number_of_rows + self.current_limit - 1
) // self.current_limit
self.paginate()
def previous(self):
if self.offset >= self.current_limit:
self.offset -= self.current_limit
else:
self.offset = 0
self.paginate()
def next(self):
if self.offset + self.current_limit < self.number_of_rows:
self.offset += self.current_limit
self.paginate()
def delta_drawer(self):
self.is_open = not self.is_open
def display_selected_row(self, data: dict[str, str]):
self.delta_drawer()
self.selected_entry = data.copy()
self.original_entry = data
def update_data(self, value: str, data: tuple[str, str]):
self.selected_entry[data[0]] = value
def commit_changes(self):
self.get_data = [
| self.current_page = (self.offset // self.current_limit) + 1 |
cess_headers(self):
for item in self.headers:
if item["key"]:
self.formatted_headers[item["key"]] = item["value"]
async def run_get_request(self):
await self.process_headers()
async with httpx.AsyncClient() as client:
res = await client.get(self.req_url, headers=self.formatted_headers)
self.get_data = res.json()
self.number_of_rows = len(self.get_data)
self.get_table_headers = list(self.get_data[0].keys())
# Calculate the total number of pages
self.total_pages = (
self.number_of_rows + self.current_limit - 1
) // self.current_limit
# Initialize the data to the first page
self.paginate()
def paginate(self):
start = self.offset
end = start + self.current_limit
self.paginated_data = self.get_data[start:end]
self.current_page = (self.offset // self.current_limit) + 1
|
def previous(self):
if self.offset >= self.current_limit:
self.offset -= self.current_limit
else:
self.offset = 0
self.paginate()
def next(self):
if self.offset + self.current_limit < self.number_of_rows:
self.offset += self.current_limit
self.paginate()
def delta_drawer(self):
self.is_open = not self.is_open
def display_selected_row(self, data: dict[str, str]):
self.delta_drawer()
self.selected_entry = data.copy()
self.original_entry = data
def update_data(self, value: str, data: tuple[str, str]):
self.selected_entry[data[0]] = value
def commit_changes(self):
self.get_data = [
self.selected_entry if item == self.original_entry else item
for item in self.get_data
]
self.paginate()
self.delta_drawer()
| def delta_limit(self, limit: str):
self.current_limit = int(limit)
self.offset = 0
self.total_pages = (
self.number_of_rows + self.current_limit - 1
) // self.current_limit
self.paginate() |
f.headers:
if item["key"]:
self.formatted_headers[item["key"]] = item["value"]
async def run_get_request(self):
await self.process_headers()
async with httpx.AsyncClient() as client:
res = await client.get(self.req_url, headers=self.formatted_headers)
self.get_data = res.json()
self.number_of_rows = len(self.get_data)
self.get_table_headers = list(self.get_data[0].keys())
# Calculate the total number of pages
self.total_pages = (
self.number_of_rows + self.current_limit - 1
) // self.current_limit
# Initialize the data to the first page
self.paginate()
def paginate(self):
start = self.offset
end = start + self.current_limit
self.paginated_data = self.get_data[start:end]
self.current_page = (self.offset // self.current_limit) + 1
def delta_limit(self, limit: str):
|
self.offset = 0
self.total_pages = (
self.number_of_rows + self.current_limit - 1
) // self.current_limit
self.paginate()
def previous(self):
if self.offset >= self.current_limit:
self.offset -= self.current_limit
else:
self.offset = 0
self.paginate()
def next(self):
if self.offset + self.current_limit < self.number_of_rows:
self.offset += self.current_limit
self.paginate()
def delta_drawer(self):
self.is_open = not self.is_open
def display_selected_row(self, data: dict[str, str]):
self.delta_drawer()
self.selected_entry = data.copy()
self.original_entry = data
def update_data(self, value: str, data: tuple[str, str]):
self.selected_entry[data[0]] = value
def commit_changes(self):
self.get_data = [
self.selected_entry if item == self.original_entry else item
for ite | self.current_limit = int(limit) |
self.formatted_headers[item["key"]] = item["value"]
async def run_get_request(self):
await self.process_headers()
async with httpx.AsyncClient() as client:
res = await client.get(self.req_url, headers=self.formatted_headers)
self.get_data = res.json()
self.number_of_rows = len(self.get_data)
self.get_table_headers = list(self.get_data[0].keys())
# Calculate the total number of pages
self.total_pages = (
self.number_of_rows + self.current_limit - 1
) // self.current_limit
# Initialize the data to the first page
self.paginate()
def paginate(self):
start = self.offset
end = start + self.current_limit
self.paginated_data = self.get_data[start:end]
self.current_page = (self.offset // self.current_limit) + 1
def delta_limit(self, limit: str):
self.current_limit = int(limit)
|
self.total_pages = (
self.number_of_rows + self.current_limit - 1
) // self.current_limit
self.paginate()
def previous(self):
if self.offset >= self.current_limit:
self.offset -= self.current_limit
else:
self.offset = 0
self.paginate()
def next(self):
if self.offset + self.current_limit < self.number_of_rows:
self.offset += self.current_limit
self.paginate()
def delta_drawer(self):
self.is_open = not self.is_open
def display_selected_row(self, data: dict[str, str]):
self.delta_drawer()
self.selected_entry = data.copy()
self.original_entry = data
def update_data(self, value: str, data: tuple[str, str]):
self.selected_entry[data[0]] = value
def commit_changes(self):
self.get_data = [
self.selected_entry if item == self.original_entry else item
for item in self.get_data
| self.offset = 0 |
atted_headers[item["key"]] = item["value"]
async def run_get_request(self):
await self.process_headers()
async with httpx.AsyncClient() as client:
res = await client.get(self.req_url, headers=self.formatted_headers)
self.get_data = res.json()
self.number_of_rows = len(self.get_data)
self.get_table_headers = list(self.get_data[0].keys())
# Calculate the total number of pages
self.total_pages = (
self.number_of_rows + self.current_limit - 1
) // self.current_limit
# Initialize the data to the first page
self.paginate()
def paginate(self):
start = self.offset
end = start + self.current_limit
self.paginated_data = self.get_data[start:end]
self.current_page = (self.offset // self.current_limit) + 1
def delta_limit(self, limit: str):
self.current_limit = int(limit)
self.offset = 0
|
self.paginate()
def previous(self):
if self.offset >= self.current_limit:
self.offset -= self.current_limit
else:
self.offset = 0
self.paginate()
def next(self):
if self.offset + self.current_limit < self.number_of_rows:
self.offset += self.current_limit
self.paginate()
def delta_drawer(self):
self.is_open = not self.is_open
def display_selected_row(self, data: dict[str, str]):
self.delta_drawer()
self.selected_entry = data.copy()
self.original_entry = data
def update_data(self, value: str, data: tuple[str, str]):
self.selected_entry[data[0]] = value
def commit_changes(self):
self.get_data = [
self.selected_entry if item == self.original_entry else item
for item in self.get_data
]
self.paginate()
self.delta_drawer()
| self.total_pages = (
self.number_of_rows + self.current_limit - 1
) // self.current_limit |
tpx.AsyncClient() as client:
res = await client.get(self.req_url, headers=self.formatted_headers)
self.get_data = res.json()
self.number_of_rows = len(self.get_data)
self.get_table_headers = list(self.get_data[0].keys())
# Calculate the total number of pages
self.total_pages = (
self.number_of_rows + self.current_limit - 1
) // self.current_limit
# Initialize the data to the first page
self.paginate()
def paginate(self):
start = self.offset
end = start + self.current_limit
self.paginated_data = self.get_data[start:end]
self.current_page = (self.offset // self.current_limit) + 1
def delta_limit(self, limit: str):
self.current_limit = int(limit)
self.offset = 0
self.total_pages = (
self.number_of_rows + self.current_limit - 1
) // self.current_limit
self.paginate()
|
def next(self):
if self.offset + self.current_limit < self.number_of_rows:
self.offset += self.current_limit
self.paginate()
def delta_drawer(self):
self.is_open = not self.is_open
def display_selected_row(self, data: dict[str, str]):
self.delta_drawer()
self.selected_entry = data.copy()
self.original_entry = data
def update_data(self, value: str, data: tuple[str, str]):
self.selected_entry[data[0]] = value
def commit_changes(self):
self.get_data = [
self.selected_entry if item == self.original_entry else item
for item in self.get_data
]
self.paginate()
self.delta_drawer()
| def previous(self):
if self.offset >= self.current_limit:
self.offset -= self.current_limit
else:
self.offset = 0
self.paginate() |
res = await client.get(self.req_url, headers=self.formatted_headers)
self.get_data = res.json()
self.number_of_rows = len(self.get_data)
self.get_table_headers = list(self.get_data[0].keys())
# Calculate the total number of pages
self.total_pages = (
self.number_of_rows + self.current_limit - 1
) // self.current_limit
# Initialize the data to the first page
self.paginate()
def paginate(self):
start = self.offset
end = start + self.current_limit
self.paginated_data = self.get_data[start:end]
self.current_page = (self.offset // self.current_limit) + 1
def delta_limit(self, limit: str):
self.current_limit = int(limit)
self.offset = 0
self.total_pages = (
self.number_of_rows + self.current_limit - 1
) // self.current_limit
self.paginate()
def previous(self):
|
self.paginate()
def next(self):
if self.offset + self.current_limit < self.number_of_rows:
self.offset += self.current_limit
self.paginate()
def delta_drawer(self):
self.is_open = not self.is_open
def display_selected_row(self, data: dict[str, str]):
self.delta_drawer()
self.selected_entry = data.copy()
self.original_entry = data
def update_data(self, value: str, data: tuple[str, str]):
self.selected_entry[data[0]] = value
def commit_changes(self):
self.get_data = [
self.selected_entry if item == self.original_entry else item
for item in self.get_data
]
self.paginate()
self.delta_drawer()
| if self.offset >= self.current_limit:
self.offset -= self.current_limit
else:
self.offset = 0 |
res.json()
self.number_of_rows = len(self.get_data)
self.get_table_headers = list(self.get_data[0].keys())
# Calculate the total number of pages
self.total_pages = (
self.number_of_rows + self.current_limit - 1
) // self.current_limit
# Initialize the data to the first page
self.paginate()
def paginate(self):
start = self.offset
end = start + self.current_limit
self.paginated_data = self.get_data[start:end]
self.current_page = (self.offset // self.current_limit) + 1
def delta_limit(self, limit: str):
self.current_limit = int(limit)
self.offset = 0
self.total_pages = (
self.number_of_rows + self.current_limit - 1
) // self.current_limit
self.paginate()
def previous(self):
if self.offset >= self.current_limit:
self.offset -= self.current_limit
else:
|
self.paginate()
def next(self):
if self.offset + self.current_limit < self.number_of_rows:
self.offset += self.current_limit
self.paginate()
def delta_drawer(self):
self.is_open = not self.is_open
def display_selected_row(self, data: dict[str, str]):
self.delta_drawer()
self.selected_entry = data.copy()
self.original_entry = data
def update_data(self, value: str, data: tuple[str, str]):
self.selected_entry[data[0]] = value
def commit_changes(self):
self.get_data = [
self.selected_entry if item == self.original_entry else item
for item in self.get_data
]
self.paginate()
self.delta_drawer()
| self.offset = 0 |
len(self.get_data)
self.get_table_headers = list(self.get_data[0].keys())
# Calculate the total number of pages
self.total_pages = (
self.number_of_rows + self.current_limit - 1
) // self.current_limit
# Initialize the data to the first page
self.paginate()
def paginate(self):
start = self.offset
end = start + self.current_limit
self.paginated_data = self.get_data[start:end]
self.current_page = (self.offset // self.current_limit) + 1
def delta_limit(self, limit: str):
self.current_limit = int(limit)
self.offset = 0
self.total_pages = (
self.number_of_rows + self.current_limit - 1
) // self.current_limit
self.paginate()
def previous(self):
if self.offset >= self.current_limit:
self.offset -= self.current_limit
else:
self.offset = 0
self.paginate()
|
def delta_drawer(self):
self.is_open = not self.is_open
def display_selected_row(self, data: dict[str, str]):
self.delta_drawer()
self.selected_entry = data.copy()
self.original_entry = data
def update_data(self, value: str, data: tuple[str, str]):
self.selected_entry[data[0]] = value
def commit_changes(self):
self.get_data = [
self.selected_entry if item == self.original_entry else item
for item in self.get_data
]
self.paginate()
self.delta_drawer()
| def next(self):
if self.offset + self.current_limit < self.number_of_rows:
self.offset += self.current_limit
self.paginate() |
self.get_table_headers = list(self.get_data[0].keys())
# Calculate the total number of pages
self.total_pages = (
self.number_of_rows + self.current_limit - 1
) // self.current_limit
# Initialize the data to the first page
self.paginate()
def paginate(self):
start = self.offset
end = start + self.current_limit
self.paginated_data = self.get_data[start:end]
self.current_page = (self.offset // self.current_limit) + 1
def delta_limit(self, limit: str):
self.current_limit = int(limit)
self.offset = 0
self.total_pages = (
self.number_of_rows + self.current_limit - 1
) // self.current_limit
self.paginate()
def previous(self):
if self.offset >= self.current_limit:
self.offset -= self.current_limit
else:
self.offset = 0
self.paginate()
def next(self):
|
self.paginate()
def delta_drawer(self):
self.is_open = not self.is_open
def display_selected_row(self, data: dict[str, str]):
self.delta_drawer()
self.selected_entry = data.copy()
self.original_entry = data
def update_data(self, value: str, data: tuple[str, str]):
self.selected_entry[data[0]] = value
def commit_changes(self):
self.get_data = [
self.selected_entry if item == self.original_entry else item
for item in self.get_data
]
self.paginate()
self.delta_drawer()
| if self.offset + self.current_limit < self.number_of_rows:
self.offset += self.current_limit |
_pages = (
self.number_of_rows + self.current_limit - 1
) // self.current_limit
# Initialize the data to the first page
self.paginate()
def paginate(self):
start = self.offset
end = start + self.current_limit
self.paginated_data = self.get_data[start:end]
self.current_page = (self.offset // self.current_limit) + 1
def delta_limit(self, limit: str):
self.current_limit = int(limit)
self.offset = 0
self.total_pages = (
self.number_of_rows + self.current_limit - 1
) // self.current_limit
self.paginate()
def previous(self):
if self.offset >= self.current_limit:
self.offset -= self.current_limit
else:
self.offset = 0
self.paginate()
def next(self):
if self.offset + self.current_limit < self.number_of_rows:
self.offset += self.current_limit
self.paginate()
|
def display_selected_row(self, data: dict[str, str]):
self.delta_drawer()
self.selected_entry = data.copy()
self.original_entry = data
def update_data(self, value: str, data: tuple[str, str]):
self.selected_entry[data[0]] = value
def commit_changes(self):
self.get_data = [
self.selected_entry if item == self.original_entry else item
for item in self.get_data
]
self.paginate()
self.delta_drawer()
| def delta_drawer(self):
self.is_open = not self.is_open |
number_of_rows + self.current_limit - 1
) // self.current_limit
# Initialize the data to the first page
self.paginate()
def paginate(self):
start = self.offset
end = start + self.current_limit
self.paginated_data = self.get_data[start:end]
self.current_page = (self.offset // self.current_limit) + 1
def delta_limit(self, limit: str):
self.current_limit = int(limit)
self.offset = 0
self.total_pages = (
self.number_of_rows + self.current_limit - 1
) // self.current_limit
self.paginate()
def previous(self):
if self.offset >= self.current_limit:
self.offset -= self.current_limit
else:
self.offset = 0
self.paginate()
def next(self):
if self.offset + self.current_limit < self.number_of_rows:
self.offset += self.current_limit
self.paginate()
def delta_drawer(self):
|
def display_selected_row(self, data: dict[str, str]):
self.delta_drawer()
self.selected_entry = data.copy()
self.original_entry = data
def update_data(self, value: str, data: tuple[str, str]):
self.selected_entry[data[0]] = value
def commit_changes(self):
self.get_data = [
self.selected_entry if item == self.original_entry else item
for item in self.get_data
]
self.paginate()
self.delta_drawer()
| self.is_open = not self.is_open |
1
) // self.current_limit
# Initialize the data to the first page
self.paginate()
def paginate(self):
start = self.offset
end = start + self.current_limit
self.paginated_data = self.get_data[start:end]
self.current_page = (self.offset // self.current_limit) + 1
def delta_limit(self, limit: str):
self.current_limit = int(limit)
self.offset = 0
self.total_pages = (
self.number_of_rows + self.current_limit - 1
) // self.current_limit
self.paginate()
def previous(self):
if self.offset >= self.current_limit:
self.offset -= self.current_limit
else:
self.offset = 0
self.paginate()
def next(self):
if self.offset + self.current_limit < self.number_of_rows:
self.offset += self.current_limit
self.paginate()
def delta_drawer(self):
self.is_open = not self.is_open
|
def update_data(self, value: str, data: tuple[str, str]):
self.selected_entry[data[0]] = value
def commit_changes(self):
self.get_data = [
self.selected_entry if item == self.original_entry else item
for item in self.get_data
]
self.paginate()
self.delta_drawer()
| def display_selected_row(self, data: dict[str, str]):
self.delta_drawer()
self.selected_entry = data.copy()
self.original_entry = data |
e
self.paginate()
def paginate(self):
start = self.offset
end = start + self.current_limit
self.paginated_data = self.get_data[start:end]
self.current_page = (self.offset // self.current_limit) + 1
def delta_limit(self, limit: str):
self.current_limit = int(limit)
self.offset = 0
self.total_pages = (
self.number_of_rows + self.current_limit - 1
) // self.current_limit
self.paginate()
def previous(self):
if self.offset >= self.current_limit:
self.offset -= self.current_limit
else:
self.offset = 0
self.paginate()
def next(self):
if self.offset + self.current_limit < self.number_of_rows:
self.offset += self.current_limit
self.paginate()
def delta_drawer(self):
self.is_open = not self.is_open
def display_selected_row(self, data: dict[str, str]):
self.delta_drawer()
|
self.original_entry = data
def update_data(self, value: str, data: tuple[str, str]):
self.selected_entry[data[0]] = value
def commit_changes(self):
self.get_data = [
self.selected_entry if item == self.original_entry else item
for item in self.get_data
]
self.paginate()
self.delta_drawer()
| self.selected_entry = data.copy() |
inate(self):
start = self.offset
end = start + self.current_limit
self.paginated_data = self.get_data[start:end]
self.current_page = (self.offset // self.current_limit) + 1
def delta_limit(self, limit: str):
self.current_limit = int(limit)
self.offset = 0
self.total_pages = (
self.number_of_rows + self.current_limit - 1
) // self.current_limit
self.paginate()
def previous(self):
if self.offset >= self.current_limit:
self.offset -= self.current_limit
else:
self.offset = 0
self.paginate()
def next(self):
if self.offset + self.current_limit < self.number_of_rows:
self.offset += self.current_limit
self.paginate()
def delta_drawer(self):
self.is_open = not self.is_open
def display_selected_row(self, data: dict[str, str]):
self.delta_drawer()
self.selected_entry = data.copy()
|
def update_data(self, value: str, data: tuple[str, str]):
self.selected_entry[data[0]] = value
def commit_changes(self):
self.get_data = [
self.selected_entry if item == self.original_entry else item
for item in self.get_data
]
self.paginate()
self.delta_drawer()
| self.original_entry = data |
f.offset
end = start + self.current_limit
self.paginated_data = self.get_data[start:end]
self.current_page = (self.offset // self.current_limit) + 1
def delta_limit(self, limit: str):
self.current_limit = int(limit)
self.offset = 0
self.total_pages = (
self.number_of_rows + self.current_limit - 1
) // self.current_limit
self.paginate()
def previous(self):
if self.offset >= self.current_limit:
self.offset -= self.current_limit
else:
self.offset = 0
self.paginate()
def next(self):
if self.offset + self.current_limit < self.number_of_rows:
self.offset += self.current_limit
self.paginate()
def delta_drawer(self):
self.is_open = not self.is_open
def display_selected_row(self, data: dict[str, str]):
self.delta_drawer()
self.selected_entry = data.copy()
self.original_entry = data
|
def commit_changes(self):
self.get_data = [
self.selected_entry if item == self.original_entry else item
for item in self.get_data
]
self.paginate()
self.delta_drawer()
| def update_data(self, value: str, data: tuple[str, str]):
self.selected_entry[data[0]] = value |
inated_data = self.get_data[start:end]
self.current_page = (self.offset // self.current_limit) + 1
def delta_limit(self, limit: str):
self.current_limit = int(limit)
self.offset = 0
self.total_pages = (
self.number_of_rows + self.current_limit - 1
) // self.current_limit
self.paginate()
def previous(self):
if self.offset >= self.current_limit:
self.offset -= self.current_limit
else:
self.offset = 0
self.paginate()
def next(self):
if self.offset + self.current_limit < self.number_of_rows:
self.offset += self.current_limit
self.paginate()
def delta_drawer(self):
self.is_open = not self.is_open
def display_selected_row(self, data: dict[str, str]):
self.delta_drawer()
self.selected_entry = data.copy()
self.original_entry = data
def update_data(self, value: str, data: tuple[str, str]):
|
def commit_changes(self):
self.get_data = [
self.selected_entry if item == self.original_entry else item
for item in self.get_data
]
self.paginate()
self.delta_drawer()
| self.selected_entry[data[0]] = value |
self.current_page = (self.offset // self.current_limit) + 1
def delta_limit(self, limit: str):
self.current_limit = int(limit)
self.offset = 0
self.total_pages = (
self.number_of_rows + self.current_limit - 1
) // self.current_limit
self.paginate()
def previous(self):
if self.offset >= self.current_limit:
self.offset -= self.current_limit
else:
self.offset = 0
self.paginate()
def next(self):
if self.offset + self.current_limit < self.number_of_rows:
self.offset += self.current_limit
self.paginate()
def delta_drawer(self):
self.is_open = not self.is_open
def display_selected_row(self, data: dict[str, str]):
self.delta_drawer()
self.selected_entry = data.copy()
self.original_entry = data
def update_data(self, value: str, data: tuple[str, str]):
self.selected_entry[data[0]] = value
| def commit_changes(self):
self.get_data = [
self.selected_entry if item == self.original_entry else item
for item in self.get_data
]
self.paginate()
self.delta_drawer() | |
set // self.current_limit) + 1
def delta_limit(self, limit: str):
self.current_limit = int(limit)
self.offset = 0
self.total_pages = (
self.number_of_rows + self.current_limit - 1
) // self.current_limit
self.paginate()
def previous(self):
if self.offset >= self.current_limit:
self.offset -= self.current_limit
else:
self.offset = 0
self.paginate()
def next(self):
if self.offset + self.current_limit < self.number_of_rows:
self.offset += self.current_limit
self.paginate()
def delta_drawer(self):
self.is_open = not self.is_open
def display_selected_row(self, data: dict[str, str]):
self.delta_drawer()
self.selected_entry = data.copy()
self.original_entry = data
def update_data(self, value: str, data: tuple[str, str]):
self.selected_entry[data[0]] = value
def commit_changes(self):
|
self.paginate()
self.delta_drawer()
| self.get_data = [
self.selected_entry if item == self.original_entry else item
for item in self.get_data
] |
"""Basic Dashboard App"""
|
from business_analytics_dashboard.components.account_executive_metrics import (
account_executive_metrics_table,
)
from business_analytics_dashboard.components.average_salary_chart import (
average_salary_bar_chart,
)
from business_analytics_dashboard.components.department_pie_chart import (
department_pie_chart,
)
from business_analytics_dashboard.components.sidebar import sidebar
from business_analytics_dashboard.states.dashboard_state import DashboardState
def index() -> rx.Component:
"""The main dashboard page."""
return rx.el.div(
sidebar(),
rx.el.main(
rx.el.h1(
"Business Analytics Dashboard",
class_name="text-3xl font-bold text-gray-800 mb-6",
),
rx.el.div(
department_pie_chart(),
average_salary_bar_chart(),
class_name="grid grid-cols-1 lg:grid-cols-2 gap-6 mb-6",
),
account_executive_metrics_table(),
| import reflex as rx |
"""Basic Dashboard App"""
import reflex as rx
|
from business_analytics_dashboard.components.average_salary_chart import (
average_salary_bar_chart,
)
from business_analytics_dashboard.components.department_pie_chart import (
department_pie_chart,
)
from business_analytics_dashboard.components.sidebar import sidebar
from business_analytics_dashboard.states.dashboard_state import DashboardState
def index() -> rx.Component:
"""The main dashboard page."""
return rx.el.div(
sidebar(),
rx.el.main(
rx.el.h1(
"Business Analytics Dashboard",
class_name="text-3xl font-bold text-gray-800 mb-6",
),
rx.el.div(
department_pie_chart(),
average_salary_bar_chart(),
class_name="grid grid-cols-1 lg:grid-cols-2 gap-6 mb-6",
),
account_executive_metrics_table(),
class_name="p-4 bg-gray-100 h-[100vh] w-full overflow-y-auto",
on_mount=DashboardState.fetch_das | from business_analytics_dashboard.components.account_executive_metrics import (
account_executive_metrics_table,
) |
"""Basic Dashboard App"""
import reflex as rx
from business_analytics_dashboard.components.account_executive_metrics import (
account_executive_metrics_table,
)
|
from business_analytics_dashboard.components.department_pie_chart import (
department_pie_chart,
)
from business_analytics_dashboard.components.sidebar import sidebar
from business_analytics_dashboard.states.dashboard_state import DashboardState
def index() -> rx.Component:
"""The main dashboard page."""
return rx.el.div(
sidebar(),
rx.el.main(
rx.el.h1(
"Business Analytics Dashboard",
class_name="text-3xl font-bold text-gray-800 mb-6",
),
rx.el.div(
department_pie_chart(),
average_salary_bar_chart(),
class_name="grid grid-cols-1 lg:grid-cols-2 gap-6 mb-6",
),
account_executive_metrics_table(),
class_name="p-4 bg-gray-100 h-[100vh] w-full overflow-y-auto",
on_mount=DashboardState.fetch_dashboard_data,
),
class_name="flex w-full min-h-screen",
)
app = rx.App(theme=rx.theme( | from business_analytics_dashboard.components.average_salary_chart import (
average_salary_bar_chart,
) |
"""Basic Dashboard App"""
import reflex as rx
from business_analytics_dashboard.components.account_executive_metrics import (
account_executive_metrics_table,
)
from business_analytics_dashboard.components.average_salary_chart import (
average_salary_bar_chart,
)
|
from business_analytics_dashboard.components.sidebar import sidebar
from business_analytics_dashboard.states.dashboard_state import DashboardState
def index() -> rx.Component:
"""The main dashboard page."""
return rx.el.div(
sidebar(),
rx.el.main(
rx.el.h1(
"Business Analytics Dashboard",
class_name="text-3xl font-bold text-gray-800 mb-6",
),
rx.el.div(
department_pie_chart(),
average_salary_bar_chart(),
class_name="grid grid-cols-1 lg:grid-cols-2 gap-6 mb-6",
),
account_executive_metrics_table(),
class_name="p-4 bg-gray-100 h-[100vh] w-full overflow-y-auto",
on_mount=DashboardState.fetch_dashboard_data,
),
class_name="flex w-full min-h-screen",
)
app = rx.App(theme=rx.theme(appearance="light"))
app.add_page(index)
| from business_analytics_dashboard.components.department_pie_chart import (
department_pie_chart,
) |
"""Basic Dashboard App"""
import reflex as rx
from business_analytics_dashboard.components.account_executive_metrics import (
account_executive_metrics_table,
)
from business_analytics_dashboard.components.average_salary_chart import (
average_salary_bar_chart,
)
from business_analytics_dashboard.components.department_pie_chart import (
department_pie_chart,
)
|
from business_analytics_dashboard.states.dashboard_state import DashboardState
def index() -> rx.Component:
"""The main dashboard page."""
return rx.el.div(
sidebar(),
rx.el.main(
rx.el.h1(
"Business Analytics Dashboard",
class_name="text-3xl font-bold text-gray-800 mb-6",
),
rx.el.div(
department_pie_chart(),
average_salary_bar_chart(),
class_name="grid grid-cols-1 lg:grid-cols-2 gap-6 mb-6",
),
account_executive_metrics_table(),
class_name="p-4 bg-gray-100 h-[100vh] w-full overflow-y-auto",
on_mount=DashboardState.fetch_dashboard_data,
),
class_name="flex w-full min-h-screen",
)
app = rx.App(theme=rx.theme(appearance="light"))
app.add_page(index)
| from business_analytics_dashboard.components.sidebar import sidebar |
"""Basic Dashboard App"""
import reflex as rx
from business_analytics_dashboard.components.account_executive_metrics import (
account_executive_metrics_table,
)
from business_analytics_dashboard.components.average_salary_chart import (
average_salary_bar_chart,
)
from business_analytics_dashboard.components.department_pie_chart import (
department_pie_chart,
)
from business_analytics_dashboard.components.sidebar import sidebar
|
def index() -> rx.Component:
"""The main dashboard page."""
return rx.el.div(
sidebar(),
rx.el.main(
rx.el.h1(
"Business Analytics Dashboard",
class_name="text-3xl font-bold text-gray-800 mb-6",
),
rx.el.div(
department_pie_chart(),
average_salary_bar_chart(),
class_name="grid grid-cols-1 lg:grid-cols-2 gap-6 mb-6",
),
account_executive_metrics_table(),
class_name="p-4 bg-gray-100 h-[100vh] w-full overflow-y-auto",
on_mount=DashboardState.fetch_dashboard_data,
),
class_name="flex w-full min-h-screen",
)
app = rx.App(theme=rx.theme(appearance="light"))
app.add_page(index)
| from business_analytics_dashboard.states.dashboard_state import DashboardState |
average_salary_bar_chart,
)
from business_analytics_dashboard.components.department_pie_chart import (
department_pie_chart,
)
from business_analytics_dashboard.components.sidebar import sidebar
from business_analytics_dashboard.states.dashboard_state import DashboardState
def index() -> rx.Component:
"""The main dashboard page."""
return rx.el.div(
sidebar(),
rx.el.main(
rx.el.h1(
"Business Analytics Dashboard",
class_name="text-3xl font-bold text-gray-800 mb-6",
),
rx.el.div(
department_pie_chart(),
average_salary_bar_chart(),
class_name="grid grid-cols-1 lg:grid-cols-2 gap-6 mb-6",
),
account_executive_metrics_table(),
class_name="p-4 bg-gray-100 h-[100vh] w-full overflow-y-auto",
on_mount=DashboardState.fetch_dashboard_data,
),
class_name="flex w-full min-h-screen",
)
|
app.add_page(index)
| app = rx.App(theme=rx.theme(appearance="light")) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.