instruction stringlengths 0 1k | input stringlengths 1 1k | output stringlengths 10 6.51k |
|---|---|---|
import reflex as rx
from .components.stats_cards import stats_cards_group
|
from .views.table import main_table
def index() -> rx.Component:
return rx.vstack(
navbar(),
stats_cards_group(),
rx.box(
main_table(),
width="100%",
),
width="100%",
spacing="6",
padding_x=["1.5em", "1.5em", "3em"],
)
app = rx.App(
theme=rx.theme(
appearance="dark", has_background=True, radius="large", accent_color="grass"
),
)
app.add_page(
index,
title="Customer Data App",
description="A simple app to manage customer data.",
)
| from .views.navbar import navbar |
import reflex as rx
from .components.stats_cards import stats_cards_group
from .views.navbar import navbar
|
def index() -> rx.Component:
return rx.vstack(
navbar(),
stats_cards_group(),
rx.box(
main_table(),
width="100%",
),
width="100%",
spacing="6",
padding_x=["1.5em", "1.5em", "3em"],
)
app = rx.App(
theme=rx.theme(
appearance="dark", has_background=True, radius="large", accent_color="grass"
),
)
app.add_page(
index,
title="Customer Data App",
description="A simple app to manage customer data.",
)
| from .views.table import main_table |
from typing import Union
import reflex as rx
from sqlmodel import String, asc, cast, desc, func, or_, select
def _get_percentage_change(
value: Union[int, float], prev_value: Union[int, float]
) -> float:
percentage_change = (
round(((value - prev_value) / prev_value) * 100, 2)
if prev_value != 0
else 0.0
if value == 0
else float("inf")
)
return percentage_change
class Customer(rx.Model, table=True):
"""The customer model."""
name: str
email: str
phone: str
address: str
date: str
payments: float
status: str
class MonthValues(rx.Base):
"""Values for a month."""
num_customers: int = 0
total_payments: float = 0.0
num_delivers: int = 0
class State(rx.State):
"""The app state."""
users: list[Customer] = []
sort_value: str = ""
sort_reverse: bool = False
search_value: str = ""
current_user: Customer = Customer()
# Values for current and previous mon | from datetime import datetime, timedelta | |
from datetime import datetime, timedelta
|
import reflex as rx
from sqlmodel import String, asc, cast, desc, func, or_, select
def _get_percentage_change(
value: Union[int, float], prev_value: Union[int, float]
) -> float:
percentage_change = (
round(((value - prev_value) / prev_value) * 100, 2)
if prev_value != 0
else 0.0
if value == 0
else float("inf")
)
return percentage_change
class Customer(rx.Model, table=True):
"""The customer model."""
name: str
email: str
phone: str
address: str
date: str
payments: float
status: str
class MonthValues(rx.Base):
"""Values for a month."""
num_customers: int = 0
total_payments: float = 0.0
num_delivers: int = 0
class State(rx.State):
"""The app state."""
users: list[Customer] = []
sort_value: str = ""
sort_reverse: bool = False
search_value: str = ""
current_user: Customer = Customer()
# Values for current and previous month
current_month_valu | from typing import Union |
from datetime import datetime, timedelta
from typing import Union
|
from sqlmodel import String, asc, cast, desc, func, or_, select
def _get_percentage_change(
value: Union[int, float], prev_value: Union[int, float]
) -> float:
percentage_change = (
round(((value - prev_value) / prev_value) * 100, 2)
if prev_value != 0
else 0.0
if value == 0
else float("inf")
)
return percentage_change
class Customer(rx.Model, table=True):
"""The customer model."""
name: str
email: str
phone: str
address: str
date: str
payments: float
status: str
class MonthValues(rx.Base):
"""Values for a month."""
num_customers: int = 0
total_payments: float = 0.0
num_delivers: int = 0
class State(rx.State):
"""The app state."""
users: list[Customer] = []
sort_value: str = ""
sort_reverse: bool = False
search_value: str = ""
current_user: Customer = Customer()
# Values for current and previous month
current_month_values: MonthValues = Mon | import reflex as rx |
from datetime import datetime, timedelta
from typing import Union
import reflex as rx
|
def _get_percentage_change(
value: Union[int, float], prev_value: Union[int, float]
) -> float:
percentage_change = (
round(((value - prev_value) / prev_value) * 100, 2)
if prev_value != 0
else 0.0
if value == 0
else float("inf")
)
return percentage_change
class Customer(rx.Model, table=True):
"""The customer model."""
name: str
email: str
phone: str
address: str
date: str
payments: float
status: str
class MonthValues(rx.Base):
"""Values for a month."""
num_customers: int = 0
total_payments: float = 0.0
num_delivers: int = 0
class State(rx.State):
"""The app state."""
users: list[Customer] = []
sort_value: str = ""
sort_reverse: bool = False
search_value: str = ""
current_user: Customer = Customer()
# Values for current and previous month
current_month_values: MonthValues = MonthValues()
previous_month_values: MonthValues = MonthValues( | from sqlmodel import String, asc, cast, desc, func, or_, select |
from datetime import datetime, timedelta
from typing import Union
import reflex as rx
from sqlmodel import String, asc, cast, desc, func, or_, select
|
class Customer(rx.Model, table=True):
"""The customer model."""
name: str
email: str
phone: str
address: str
date: str
payments: float
status: str
class MonthValues(rx.Base):
"""Values for a month."""
num_customers: int = 0
total_payments: float = 0.0
num_delivers: int = 0
class State(rx.State):
"""The app state."""
users: list[Customer] = []
sort_value: str = ""
sort_reverse: bool = False
search_value: str = ""
current_user: Customer = Customer()
# Values for current and previous month
current_month_values: MonthValues = MonthValues()
previous_month_values: MonthValues = MonthValues()
def load_entries(self) -> list[Customer]:
"""Get all users from the database."""
with rx.session() as session:
query = select(Customer)
if self.search_value:
search_value = f"%{str(self.search_value).lower()}%"
query = query.where(
| def _get_percentage_change(
value: Union[int, float], prev_value: Union[int, float]
) -> float:
percentage_change = (
round(((value - prev_value) / prev_value) * 100, 2)
if prev_value != 0
else 0.0
if value == 0
else float("inf")
)
return percentage_change |
from datetime import datetime, timedelta
from typing import Union
import reflex as rx
from sqlmodel import String, asc, cast, desc, func, or_, select
def _get_percentage_change(
value: Union[int, float], prev_value: Union[int, float]
) -> float:
|
return percentage_change
class Customer(rx.Model, table=True):
"""The customer model."""
name: str
email: str
phone: str
address: str
date: str
payments: float
status: str
class MonthValues(rx.Base):
"""Values for a month."""
num_customers: int = 0
total_payments: float = 0.0
num_delivers: int = 0
class State(rx.State):
"""The app state."""
users: list[Customer] = []
sort_value: str = ""
sort_reverse: bool = False
search_value: str = ""
current_user: Customer = Customer()
# Values for current and previous month
current_month_values: MonthValues = MonthValues()
previous_month_values: MonthValues = MonthValues()
def load_entries(self) -> list[Customer]:
"""Get all users from the database."""
with rx.session() as session:
query = select(Customer)
if self.search_value:
search_value = f"%{str(self.search_value).lower()}%"
| percentage_change = (
round(((value - prev_value) / prev_value) * 100, 2)
if prev_value != 0
else 0.0
if value == 0
else float("inf")
) |
from datetime import datetime, timedelta
from typing import Union
import reflex as rx
from sqlmodel import String, asc, cast, desc, func, or_, select
def _get_percentage_change(
value: Union[int, float], prev_value: Union[int, float]
) -> float:
percentage_change = (
round(((value - prev_value) / prev_value) * 100, 2)
if prev_value != 0
else 0.0
if value == 0
else float("inf")
)
return percentage_change
|
class MonthValues(rx.Base):
"""Values for a month."""
num_customers: int = 0
total_payments: float = 0.0
num_delivers: int = 0
class State(rx.State):
"""The app state."""
users: list[Customer] = []
sort_value: str = ""
sort_reverse: bool = False
search_value: str = ""
current_user: Customer = Customer()
# Values for current and previous month
current_month_values: MonthValues = MonthValues()
previous_month_values: MonthValues = MonthValues()
def load_entries(self) -> list[Customer]:
"""Get all users from the database."""
with rx.session() as session:
query = select(Customer)
if self.search_value:
search_value = f"%{str(self.search_value).lower()}%"
query = query.where(
or_(
*[
getattr(Customer, field).ilike(search_value)
for field in Customer.get_fields( | class Customer(rx.Model, table=True):
"""The customer model."""
name: str
email: str
phone: str
address: str
date: str
payments: float
status: str |
from datetime import datetime, timedelta
from typing import Union
import reflex as rx
from sqlmodel import String, asc, cast, desc, func, or_, select
def _get_percentage_change(
value: Union[int, float], prev_value: Union[int, float]
) -> float:
percentage_change = (
round(((value - prev_value) / prev_value) * 100, 2)
if prev_value != 0
else 0.0
if value == 0
else float("inf")
)
return percentage_change
class Customer(rx.Model, table=True):
"""The customer model."""
name: str
email: str
phone: str
address: str
date: str
payments: float
status: str
|
class State(rx.State):
"""The app state."""
users: list[Customer] = []
sort_value: str = ""
sort_reverse: bool = False
search_value: str = ""
current_user: Customer = Customer()
# Values for current and previous month
current_month_values: MonthValues = MonthValues()
previous_month_values: MonthValues = MonthValues()
def load_entries(self) -> list[Customer]:
"""Get all users from the database."""
with rx.session() as session:
query = select(Customer)
if self.search_value:
search_value = f"%{str(self.search_value).lower()}%"
query = query.where(
or_(
*[
getattr(Customer, field).ilike(search_value)
for field in Customer.get_fields()
if field not in ["id", "payments"]
],
# ensures that payments is cas | class MonthValues(rx.Base):
"""Values for a month."""
num_customers: int = 0
total_payments: float = 0.0
num_delivers: int = 0 |
alue - prev_value) / prev_value) * 100, 2)
if prev_value != 0
else 0.0
if value == 0
else float("inf")
)
return percentage_change
class Customer(rx.Model, table=True):
"""The customer model."""
name: str
email: str
phone: str
address: str
date: str
payments: float
status: str
class MonthValues(rx.Base):
"""Values for a month."""
num_customers: int = 0
total_payments: float = 0.0
num_delivers: int = 0
class State(rx.State):
"""The app state."""
users: list[Customer] = []
sort_value: str = ""
sort_reverse: bool = False
search_value: str = ""
current_user: Customer = Customer()
# Values for current and previous month
current_month_values: MonthValues = MonthValues()
previous_month_values: MonthValues = MonthValues()
def load_entries(self) -> list[Customer]:
"""Get all users from the database."""
with rx.session() as session:
|
if self.search_value:
search_value = f"%{str(self.search_value).lower()}%"
query = query.where(
or_(
*[
getattr(Customer, field).ilike(search_value)
for field in Customer.get_fields()
if field not in ["id", "payments"]
],
# ensures that payments is cast to a string before applying the ilike operator
cast(Customer.payments, String).ilike(search_value),
)
)
if self.sort_value:
sort_column = getattr(Customer, self.sort_value)
if self.sort_value == "payments":
order = desc(sort_column) if self.sort_reverse else asc(sort_column)
else:
order = (
desc(func.lower(sort_column))
| query = select(Customer) |
0, 2)
if prev_value != 0
else 0.0
if value == 0
else float("inf")
)
return percentage_change
class Customer(rx.Model, table=True):
"""The customer model."""
name: str
email: str
phone: str
address: str
date: str
payments: float
status: str
class MonthValues(rx.Base):
"""Values for a month."""
num_customers: int = 0
total_payments: float = 0.0
num_delivers: int = 0
class State(rx.State):
"""The app state."""
users: list[Customer] = []
sort_value: str = ""
sort_reverse: bool = False
search_value: str = ""
current_user: Customer = Customer()
# Values for current and previous month
current_month_values: MonthValues = MonthValues()
previous_month_values: MonthValues = MonthValues()
def load_entries(self) -> list[Customer]:
"""Get all users from the database."""
with rx.session() as session:
query = select(Customer)
|
if self.sort_value:
sort_column = getattr(Customer, self.sort_value)
if self.sort_value == "payments":
order = desc(sort_column) if self.sort_reverse else asc(sort_column)
else:
order = (
desc(func.lower(sort_column))
if self.sort_reverse
else asc(func.lower(sort_column))
)
query = query.order_by(order)
self.users = session.exec(query).all()
self.get_current_month_values()
self.get_previous_month_values()
def get_current_month_values(self):
"""Calculate current month's values."""
now = datetime.now()
start_of_month = datetime(now.year, now.month, 1)
current_month_users = [
user
for user in self.users
if datetime.strptime(user.date, "%Y-%m-%d %H:%M:%S") >= start_of_month
| if self.search_value:
search_value = f"%{str(self.search_value).lower()}%"
query = query.where(
or_(
*[
getattr(Customer, field).ilike(search_value)
for field in Customer.get_fields()
if field not in ["id", "payments"]
],
# ensures that payments is cast to a string before applying the ilike operator
cast(Customer.payments, String).ilike(search_value),
)
) |
else 0.0
if value == 0
else float("inf")
)
return percentage_change
class Customer(rx.Model, table=True):
"""The customer model."""
name: str
email: str
phone: str
address: str
date: str
payments: float
status: str
class MonthValues(rx.Base):
"""Values for a month."""
num_customers: int = 0
total_payments: float = 0.0
num_delivers: int = 0
class State(rx.State):
"""The app state."""
users: list[Customer] = []
sort_value: str = ""
sort_reverse: bool = False
search_value: str = ""
current_user: Customer = Customer()
# Values for current and previous month
current_month_values: MonthValues = MonthValues()
previous_month_values: MonthValues = MonthValues()
def load_entries(self) -> list[Customer]:
"""Get all users from the database."""
with rx.session() as session:
query = select(Customer)
if self.search_value:
|
query = query.where(
or_(
*[
getattr(Customer, field).ilike(search_value)
for field in Customer.get_fields()
if field not in ["id", "payments"]
],
# ensures that payments is cast to a string before applying the ilike operator
cast(Customer.payments, String).ilike(search_value),
)
)
if self.sort_value:
sort_column = getattr(Customer, self.sort_value)
if self.sort_value == "payments":
order = desc(sort_column) if self.sort_reverse else asc(sort_column)
else:
order = (
desc(func.lower(sort_column))
if self.sort_reverse
else asc(func.lower(sort_column))
| search_value = f"%{str(self.search_value).lower()}%" |
return percentage_change
class Customer(rx.Model, table=True):
"""The customer model."""
name: str
email: str
phone: str
address: str
date: str
payments: float
status: str
class MonthValues(rx.Base):
"""Values for a month."""
num_customers: int = 0
total_payments: float = 0.0
num_delivers: int = 0
class State(rx.State):
"""The app state."""
users: list[Customer] = []
sort_value: str = ""
sort_reverse: bool = False
search_value: str = ""
current_user: Customer = Customer()
# Values for current and previous month
current_month_values: MonthValues = MonthValues()
previous_month_values: MonthValues = MonthValues()
def load_entries(self) -> list[Customer]:
"""Get all users from the database."""
with rx.session() as session:
query = select(Customer)
if self.search_value:
search_value = f"%{str(self.search_value).lower()}%"
|
if self.sort_value:
sort_column = getattr(Customer, self.sort_value)
if self.sort_value == "payments":
order = desc(sort_column) if self.sort_reverse else asc(sort_column)
else:
order = (
desc(func.lower(sort_column))
if self.sort_reverse
else asc(func.lower(sort_column))
)
query = query.order_by(order)
self.users = session.exec(query).all()
self.get_current_month_values()
self.get_previous_month_values()
def get_current_month_values(self):
"""Calculate current month's values."""
now = datetime.now()
start_of_month = datetime(now.year, now.month, 1)
current_month_users = [
user
for user in self.users
if datetime.strptime(user.date, "%Y-%m-%d %H:%M:%S") >= start_of_month
| query = query.where(
or_(
*[
getattr(Customer, field).ilike(search_value)
for field in Customer.get_fields()
if field not in ["id", "payments"]
],
# ensures that payments is cast to a string before applying the ilike operator
cast(Customer.payments, String).ilike(search_value),
)
) |
ser: Customer = Customer()
# Values for current and previous month
current_month_values: MonthValues = MonthValues()
previous_month_values: MonthValues = MonthValues()
def load_entries(self) -> list[Customer]:
"""Get all users from the database."""
with rx.session() as session:
query = select(Customer)
if self.search_value:
search_value = f"%{str(self.search_value).lower()}%"
query = query.where(
or_(
*[
getattr(Customer, field).ilike(search_value)
for field in Customer.get_fields()
if field not in ["id", "payments"]
],
# ensures that payments is cast to a string before applying the ilike operator
cast(Customer.payments, String).ilike(search_value),
)
)
|
self.users = session.exec(query).all()
self.get_current_month_values()
self.get_previous_month_values()
def get_current_month_values(self):
"""Calculate current month's values."""
now = datetime.now()
start_of_month = datetime(now.year, now.month, 1)
current_month_users = [
user
for user in self.users
if datetime.strptime(user.date, "%Y-%m-%d %H:%M:%S") >= start_of_month
]
num_customers = len(current_month_users)
total_payments = sum(user.payments for user in current_month_users)
num_delivers = len(
[user for user in current_month_users if user.status == "Delivered"]
)
self.current_month_values = MonthValues(
num_customers=num_customers,
total_payments=total_payments,
num_delivers=num_delivers,
)
def get_previous_month_values(self):
"""Calculate previous month's value | if self.sort_value:
sort_column = getattr(Customer, self.sort_value)
if self.sort_value == "payments":
order = desc(sort_column) if self.sort_reverse else asc(sort_column)
else:
order = (
desc(func.lower(sort_column))
if self.sort_reverse
else asc(func.lower(sort_column))
)
query = query.order_by(order) |
ues for current and previous month
current_month_values: MonthValues = MonthValues()
previous_month_values: MonthValues = MonthValues()
def load_entries(self) -> list[Customer]:
"""Get all users from the database."""
with rx.session() as session:
query = select(Customer)
if self.search_value:
search_value = f"%{str(self.search_value).lower()}%"
query = query.where(
or_(
*[
getattr(Customer, field).ilike(search_value)
for field in Customer.get_fields()
if field not in ["id", "payments"]
],
# ensures that payments is cast to a string before applying the ilike operator
cast(Customer.payments, String).ilike(search_value),
)
)
if self.sort_value:
|
if self.sort_value == "payments":
order = desc(sort_column) if self.sort_reverse else asc(sort_column)
else:
order = (
desc(func.lower(sort_column))
if self.sort_reverse
else asc(func.lower(sort_column))
)
query = query.order_by(order)
self.users = session.exec(query).all()
self.get_current_month_values()
self.get_previous_month_values()
def get_current_month_values(self):
"""Calculate current month's values."""
now = datetime.now()
start_of_month = datetime(now.year, now.month, 1)
current_month_users = [
user
for user in self.users
if datetime.strptime(user.date, "%Y-%m-%d %H:%M:%S") >= start_of_month
]
num_customers = len(current_month_users)
total_payments = sum(user.payments for | sort_column = getattr(Customer, self.sort_value) |
hValues = MonthValues()
previous_month_values: MonthValues = MonthValues()
def load_entries(self) -> list[Customer]:
"""Get all users from the database."""
with rx.session() as session:
query = select(Customer)
if self.search_value:
search_value = f"%{str(self.search_value).lower()}%"
query = query.where(
or_(
*[
getattr(Customer, field).ilike(search_value)
for field in Customer.get_fields()
if field not in ["id", "payments"]
],
# ensures that payments is cast to a string before applying the ilike operator
cast(Customer.payments, String).ilike(search_value),
)
)
if self.sort_value:
sort_column = getattr(Customer, self.sort_value)
|
query = query.order_by(order)
self.users = session.exec(query).all()
self.get_current_month_values()
self.get_previous_month_values()
def get_current_month_values(self):
"""Calculate current month's values."""
now = datetime.now()
start_of_month = datetime(now.year, now.month, 1)
current_month_users = [
user
for user in self.users
if datetime.strptime(user.date, "%Y-%m-%d %H:%M:%S") >= start_of_month
]
num_customers = len(current_month_users)
total_payments = sum(user.payments for user in current_month_users)
num_delivers = len(
[user for user in current_month_users if user.status == "Delivered"]
)
self.current_month_values = MonthValues(
num_customers=num_customers,
total_payments=total_payments,
num_delivers=num_delivers,
)
def get_previous_month_values(self | if self.sort_value == "payments":
order = desc(sort_column) if self.sort_reverse else asc(sort_column)
else:
order = (
desc(func.lower(sort_column))
if self.sort_reverse
else asc(func.lower(sort_column))
) |
thValues = MonthValues()
def load_entries(self) -> list[Customer]:
"""Get all users from the database."""
with rx.session() as session:
query = select(Customer)
if self.search_value:
search_value = f"%{str(self.search_value).lower()}%"
query = query.where(
or_(
*[
getattr(Customer, field).ilike(search_value)
for field in Customer.get_fields()
if field not in ["id", "payments"]
],
# ensures that payments is cast to a string before applying the ilike operator
cast(Customer.payments, String).ilike(search_value),
)
)
if self.sort_value:
sort_column = getattr(Customer, self.sort_value)
if self.sort_value == "payments":
|
else:
order = (
desc(func.lower(sort_column))
if self.sort_reverse
else asc(func.lower(sort_column))
)
query = query.order_by(order)
self.users = session.exec(query).all()
self.get_current_month_values()
self.get_previous_month_values()
def get_current_month_values(self):
"""Calculate current month's values."""
now = datetime.now()
start_of_month = datetime(now.year, now.month, 1)
current_month_users = [
user
for user in self.users
if datetime.strptime(user.date, "%Y-%m-%d %H:%M:%S") >= start_of_month
]
num_customers = len(current_month_users)
total_payments = sum(user.payments for user in current_month_users)
num_delivers = len(
[user for user in current_month_users if user.status == "Delivered"]
| order = desc(sort_column) if self.sort_reverse else asc(sort_column) |
ase."""
with rx.session() as session:
query = select(Customer)
if self.search_value:
search_value = f"%{str(self.search_value).lower()}%"
query = query.where(
or_(
*[
getattr(Customer, field).ilike(search_value)
for field in Customer.get_fields()
if field not in ["id", "payments"]
],
# ensures that payments is cast to a string before applying the ilike operator
cast(Customer.payments, String).ilike(search_value),
)
)
if self.sort_value:
sort_column = getattr(Customer, self.sort_value)
if self.sort_value == "payments":
order = desc(sort_column) if self.sort_reverse else asc(sort_column)
else:
|
query = query.order_by(order)
self.users = session.exec(query).all()
self.get_current_month_values()
self.get_previous_month_values()
def get_current_month_values(self):
"""Calculate current month's values."""
now = datetime.now()
start_of_month = datetime(now.year, now.month, 1)
current_month_users = [
user
for user in self.users
if datetime.strptime(user.date, "%Y-%m-%d %H:%M:%S") >= start_of_month
]
num_customers = len(current_month_users)
total_payments = sum(user.payments for user in current_month_users)
num_delivers = len(
[user for user in current_month_users if user.status == "Delivered"]
)
self.current_month_values = MonthValues(
num_customers=num_customers,
total_payments=total_payments,
num_delivers=num_delivers,
)
def get_previous_month_values(self | order = (
desc(func.lower(sort_column))
if self.sort_reverse
else asc(func.lower(sort_column))
) |
ry = query.where(
or_(
*[
getattr(Customer, field).ilike(search_value)
for field in Customer.get_fields()
if field not in ["id", "payments"]
],
# ensures that payments is cast to a string before applying the ilike operator
cast(Customer.payments, String).ilike(search_value),
)
)
if self.sort_value:
sort_column = getattr(Customer, self.sort_value)
if self.sort_value == "payments":
order = desc(sort_column) if self.sort_reverse else asc(sort_column)
else:
order = (
desc(func.lower(sort_column))
if self.sort_reverse
else asc(func.lower(sort_column))
)
|
self.users = session.exec(query).all()
self.get_current_month_values()
self.get_previous_month_values()
def get_current_month_values(self):
"""Calculate current month's values."""
now = datetime.now()
start_of_month = datetime(now.year, now.month, 1)
current_month_users = [
user
for user in self.users
if datetime.strptime(user.date, "%Y-%m-%d %H:%M:%S") >= start_of_month
]
num_customers = len(current_month_users)
total_payments = sum(user.payments for user in current_month_users)
num_delivers = len(
[user for user in current_month_users if user.status == "Delivered"]
)
self.current_month_values = MonthValues(
num_customers=num_customers,
total_payments=total_payments,
num_delivers=num_delivers,
)
def get_previous_month_values(self):
"""Calculate previous month's value | query = query.order_by(order) |
*[
getattr(Customer, field).ilike(search_value)
for field in Customer.get_fields()
if field not in ["id", "payments"]
],
# ensures that payments is cast to a string before applying the ilike operator
cast(Customer.payments, String).ilike(search_value),
)
)
if self.sort_value:
sort_column = getattr(Customer, self.sort_value)
if self.sort_value == "payments":
order = desc(sort_column) if self.sort_reverse else asc(sort_column)
else:
order = (
desc(func.lower(sort_column))
if self.sort_reverse
else asc(func.lower(sort_column))
)
query = query.order_by(order)
|
self.get_current_month_values()
self.get_previous_month_values()
def get_current_month_values(self):
"""Calculate current month's values."""
now = datetime.now()
start_of_month = datetime(now.year, now.month, 1)
current_month_users = [
user
for user in self.users
if datetime.strptime(user.date, "%Y-%m-%d %H:%M:%S") >= start_of_month
]
num_customers = len(current_month_users)
total_payments = sum(user.payments for user in current_month_users)
num_delivers = len(
[user for user in current_month_users if user.status == "Delivered"]
)
self.current_month_values = MonthValues(
num_customers=num_customers,
total_payments=total_payments,
num_delivers=num_delivers,
)
def get_previous_month_values(self):
"""Calculate previous month's values."""
now = datetime.now()
first_day | self.users = session.exec(query).all() |
ments"]
],
# ensures that payments is cast to a string before applying the ilike operator
cast(Customer.payments, String).ilike(search_value),
)
)
if self.sort_value:
sort_column = getattr(Customer, self.sort_value)
if self.sort_value == "payments":
order = desc(sort_column) if self.sort_reverse else asc(sort_column)
else:
order = (
desc(func.lower(sort_column))
if self.sort_reverse
else asc(func.lower(sort_column))
)
query = query.order_by(order)
self.users = session.exec(query).all()
self.get_current_month_values()
self.get_previous_month_values()
def get_current_month_values(self):
"""Calculate current month's values."""
|
start_of_month = datetime(now.year, now.month, 1)
current_month_users = [
user
for user in self.users
if datetime.strptime(user.date, "%Y-%m-%d %H:%M:%S") >= start_of_month
]
num_customers = len(current_month_users)
total_payments = sum(user.payments for user in current_month_users)
num_delivers = len(
[user for user in current_month_users if user.status == "Delivered"]
)
self.current_month_values = MonthValues(
num_customers=num_customers,
total_payments=total_payments,
num_delivers=num_delivers,
)
def get_previous_month_values(self):
"""Calculate previous month's values."""
now = datetime.now()
first_day_of_current_month = datetime(now.year, now.month, 1)
last_day_of_last_month = first_day_of_current_month - timedelta(days=1)
start_of_last_month = datetime(
last_day_of_las | now = datetime.now() |
],
# ensures that payments is cast to a string before applying the ilike operator
cast(Customer.payments, String).ilike(search_value),
)
)
if self.sort_value:
sort_column = getattr(Customer, self.sort_value)
if self.sort_value == "payments":
order = desc(sort_column) if self.sort_reverse else asc(sort_column)
else:
order = (
desc(func.lower(sort_column))
if self.sort_reverse
else asc(func.lower(sort_column))
)
query = query.order_by(order)
self.users = session.exec(query).all()
self.get_current_month_values()
self.get_previous_month_values()
def get_current_month_values(self):
"""Calculate current month's values."""
now = datetime.now()
|
current_month_users = [
user
for user in self.users
if datetime.strptime(user.date, "%Y-%m-%d %H:%M:%S") >= start_of_month
]
num_customers = len(current_month_users)
total_payments = sum(user.payments for user in current_month_users)
num_delivers = len(
[user for user in current_month_users if user.status == "Delivered"]
)
self.current_month_values = MonthValues(
num_customers=num_customers,
total_payments=total_payments,
num_delivers=num_delivers,
)
def get_previous_month_values(self):
"""Calculate previous month's values."""
now = datetime.now()
first_day_of_current_month = datetime(now.year, now.month, 1)
last_day_of_last_month = first_day_of_current_month - timedelta(days=1)
start_of_last_month = datetime(
last_day_of_last_month.year, last_day_of_last_month.month, 1
)
| start_of_month = datetime(now.year, now.month, 1) |
st to a string before applying the ilike operator
cast(Customer.payments, String).ilike(search_value),
)
)
if self.sort_value:
sort_column = getattr(Customer, self.sort_value)
if self.sort_value == "payments":
order = desc(sort_column) if self.sort_reverse else asc(sort_column)
else:
order = (
desc(func.lower(sort_column))
if self.sort_reverse
else asc(func.lower(sort_column))
)
query = query.order_by(order)
self.users = session.exec(query).all()
self.get_current_month_values()
self.get_previous_month_values()
def get_current_month_values(self):
"""Calculate current month's values."""
now = datetime.now()
start_of_month = datetime(now.year, now.month, 1)
|
num_customers = len(current_month_users)
total_payments = sum(user.payments for user in current_month_users)
num_delivers = len(
[user for user in current_month_users if user.status == "Delivered"]
)
self.current_month_values = MonthValues(
num_customers=num_customers,
total_payments=total_payments,
num_delivers=num_delivers,
)
def get_previous_month_values(self):
"""Calculate previous month's values."""
now = datetime.now()
first_day_of_current_month = datetime(now.year, now.month, 1)
last_day_of_last_month = first_day_of_current_month - timedelta(days=1)
start_of_last_month = datetime(
last_day_of_last_month.year, last_day_of_last_month.month, 1
)
previous_month_users = [
user
for user in self.users
if start_of_last_month
<= datetime.strptime(user.date, "%Y-%m-%d %H:%M | current_month_users = [
user
for user in self.users
if datetime.strptime(user.date, "%Y-%m-%d %H:%M:%S") >= start_of_month
] |
if self.sort_value:
sort_column = getattr(Customer, self.sort_value)
if self.sort_value == "payments":
order = desc(sort_column) if self.sort_reverse else asc(sort_column)
else:
order = (
desc(func.lower(sort_column))
if self.sort_reverse
else asc(func.lower(sort_column))
)
query = query.order_by(order)
self.users = session.exec(query).all()
self.get_current_month_values()
self.get_previous_month_values()
def get_current_month_values(self):
"""Calculate current month's values."""
now = datetime.now()
start_of_month = datetime(now.year, now.month, 1)
current_month_users = [
user
for user in self.users
if datetime.strptime(user.date, "%Y-%m-%d %H:%M:%S") >= start_of_month
]
|
total_payments = sum(user.payments for user in current_month_users)
num_delivers = len(
[user for user in current_month_users if user.status == "Delivered"]
)
self.current_month_values = MonthValues(
num_customers=num_customers,
total_payments=total_payments,
num_delivers=num_delivers,
)
def get_previous_month_values(self):
"""Calculate previous month's values."""
now = datetime.now()
first_day_of_current_month = datetime(now.year, now.month, 1)
last_day_of_last_month = first_day_of_current_month - timedelta(days=1)
start_of_last_month = datetime(
last_day_of_last_month.year, last_day_of_last_month.month, 1
)
previous_month_users = [
user
for user in self.users
if start_of_last_month
<= datetime.strptime(user.date, "%Y-%m-%d %H:%M:%S")
<= last_day_of_last_month
| num_customers = len(current_month_users) |
n = getattr(Customer, self.sort_value)
if self.sort_value == "payments":
order = desc(sort_column) if self.sort_reverse else asc(sort_column)
else:
order = (
desc(func.lower(sort_column))
if self.sort_reverse
else asc(func.lower(sort_column))
)
query = query.order_by(order)
self.users = session.exec(query).all()
self.get_current_month_values()
self.get_previous_month_values()
def get_current_month_values(self):
"""Calculate current month's values."""
now = datetime.now()
start_of_month = datetime(now.year, now.month, 1)
current_month_users = [
user
for user in self.users
if datetime.strptime(user.date, "%Y-%m-%d %H:%M:%S") >= start_of_month
]
num_customers = len(current_month_users)
|
num_delivers = len(
[user for user in current_month_users if user.status == "Delivered"]
)
self.current_month_values = MonthValues(
num_customers=num_customers,
total_payments=total_payments,
num_delivers=num_delivers,
)
def get_previous_month_values(self):
"""Calculate previous month's values."""
now = datetime.now()
first_day_of_current_month = datetime(now.year, now.month, 1)
last_day_of_last_month = first_day_of_current_month - timedelta(days=1)
start_of_last_month = datetime(
last_day_of_last_month.year, last_day_of_last_month.month, 1
)
previous_month_users = [
user
for user in self.users
if start_of_last_month
<= datetime.strptime(user.date, "%Y-%m-%d %H:%M:%S")
<= last_day_of_last_month
]
# We add some dummy values to simulate growth/decline. Remove t | total_payments = sum(user.payments for user in current_month_users) |
"payments":
order = desc(sort_column) if self.sort_reverse else asc(sort_column)
else:
order = (
desc(func.lower(sort_column))
if self.sort_reverse
else asc(func.lower(sort_column))
)
query = query.order_by(order)
self.users = session.exec(query).all()
self.get_current_month_values()
self.get_previous_month_values()
def get_current_month_values(self):
"""Calculate current month's values."""
now = datetime.now()
start_of_month = datetime(now.year, now.month, 1)
current_month_users = [
user
for user in self.users
if datetime.strptime(user.date, "%Y-%m-%d %H:%M:%S") >= start_of_month
]
num_customers = len(current_month_users)
total_payments = sum(user.payments for user in current_month_users)
|
self.current_month_values = MonthValues(
num_customers=num_customers,
total_payments=total_payments,
num_delivers=num_delivers,
)
def get_previous_month_values(self):
"""Calculate previous month's values."""
now = datetime.now()
first_day_of_current_month = datetime(now.year, now.month, 1)
last_day_of_last_month = first_day_of_current_month - timedelta(days=1)
start_of_last_month = datetime(
last_day_of_last_month.year, last_day_of_last_month.month, 1
)
previous_month_users = [
user
for user in self.users
if start_of_last_month
<= datetime.strptime(user.date, "%Y-%m-%d %H:%M:%S")
<= last_day_of_last_month
]
# We add some dummy values to simulate growth/decline. Remove them in production.
num_customers = len(previous_month_users) + 3
total_payments = sum(user.payments for | num_delivers = len(
[user for user in current_month_users if user.status == "Delivered"]
) |
lse:
order = (
desc(func.lower(sort_column))
if self.sort_reverse
else asc(func.lower(sort_column))
)
query = query.order_by(order)
self.users = session.exec(query).all()
self.get_current_month_values()
self.get_previous_month_values()
def get_current_month_values(self):
"""Calculate current month's values."""
now = datetime.now()
start_of_month = datetime(now.year, now.month, 1)
current_month_users = [
user
for user in self.users
if datetime.strptime(user.date, "%Y-%m-%d %H:%M:%S") >= start_of_month
]
num_customers = len(current_month_users)
total_payments = sum(user.payments for user in current_month_users)
num_delivers = len(
[user for user in current_month_users if user.status == "Delivered"]
)
|
def get_previous_month_values(self):
"""Calculate previous month's values."""
now = datetime.now()
first_day_of_current_month = datetime(now.year, now.month, 1)
last_day_of_last_month = first_day_of_current_month - timedelta(days=1)
start_of_last_month = datetime(
last_day_of_last_month.year, last_day_of_last_month.month, 1
)
previous_month_users = [
user
for user in self.users
if start_of_last_month
<= datetime.strptime(user.date, "%Y-%m-%d %H:%M:%S")
<= last_day_of_last_month
]
# We add some dummy values to simulate growth/decline. Remove them in production.
num_customers = len(previous_month_users) + 3
total_payments = sum(user.payments for user in previous_month_users) + 240
num_delivers = (
len([user for user in previous_month_users if user.status == "Delivered"])
+ 5
)
| self.current_month_values = MonthValues(
num_customers=num_customers,
total_payments=total_payments,
num_delivers=num_delivers,
) |
self.users = session.exec(query).all()
self.get_current_month_values()
self.get_previous_month_values()
def get_current_month_values(self):
"""Calculate current month's values."""
now = datetime.now()
start_of_month = datetime(now.year, now.month, 1)
current_month_users = [
user
for user in self.users
if datetime.strptime(user.date, "%Y-%m-%d %H:%M:%S") >= start_of_month
]
num_customers = len(current_month_users)
total_payments = sum(user.payments for user in current_month_users)
num_delivers = len(
[user for user in current_month_users if user.status == "Delivered"]
)
self.current_month_values = MonthValues(
num_customers=num_customers,
total_payments=total_payments,
num_delivers=num_delivers,
)
def get_previous_month_values(self):
"""Calculate previous month's values."""
|
first_day_of_current_month = datetime(now.year, now.month, 1)
last_day_of_last_month = first_day_of_current_month - timedelta(days=1)
start_of_last_month = datetime(
last_day_of_last_month.year, last_day_of_last_month.month, 1
)
previous_month_users = [
user
for user in self.users
if start_of_last_month
<= datetime.strptime(user.date, "%Y-%m-%d %H:%M:%S")
<= last_day_of_last_month
]
# We add some dummy values to simulate growth/decline. Remove them in production.
num_customers = len(previous_month_users) + 3
total_payments = sum(user.payments for user in previous_month_users) + 240
num_delivers = (
len([user for user in previous_month_users if user.status == "Delivered"])
+ 5
)
self.previous_month_values = MonthValues(
num_customers=num_customers,
total_payments=total_pa | now = datetime.now() |
ry).all()
self.get_current_month_values()
self.get_previous_month_values()
def get_current_month_values(self):
"""Calculate current month's values."""
now = datetime.now()
start_of_month = datetime(now.year, now.month, 1)
current_month_users = [
user
for user in self.users
if datetime.strptime(user.date, "%Y-%m-%d %H:%M:%S") >= start_of_month
]
num_customers = len(current_month_users)
total_payments = sum(user.payments for user in current_month_users)
num_delivers = len(
[user for user in current_month_users if user.status == "Delivered"]
)
self.current_month_values = MonthValues(
num_customers=num_customers,
total_payments=total_payments,
num_delivers=num_delivers,
)
def get_previous_month_values(self):
"""Calculate previous month's values."""
now = datetime.now()
|
last_day_of_last_month = first_day_of_current_month - timedelta(days=1)
start_of_last_month = datetime(
last_day_of_last_month.year, last_day_of_last_month.month, 1
)
previous_month_users = [
user
for user in self.users
if start_of_last_month
<= datetime.strptime(user.date, "%Y-%m-%d %H:%M:%S")
<= last_day_of_last_month
]
# We add some dummy values to simulate growth/decline. Remove them in production.
num_customers = len(previous_month_users) + 3
total_payments = sum(user.payments for user in previous_month_users) + 240
num_delivers = (
len([user for user in previous_month_users if user.status == "Delivered"])
+ 5
)
self.previous_month_values = MonthValues(
num_customers=num_customers,
total_payments=total_payments,
num_delivers=num_delivers,
)
def sort | first_day_of_current_month = datetime(now.year, now.month, 1) |
evious_month_values()
def get_current_month_values(self):
"""Calculate current month's values."""
now = datetime.now()
start_of_month = datetime(now.year, now.month, 1)
current_month_users = [
user
for user in self.users
if datetime.strptime(user.date, "%Y-%m-%d %H:%M:%S") >= start_of_month
]
num_customers = len(current_month_users)
total_payments = sum(user.payments for user in current_month_users)
num_delivers = len(
[user for user in current_month_users if user.status == "Delivered"]
)
self.current_month_values = MonthValues(
num_customers=num_customers,
total_payments=total_payments,
num_delivers=num_delivers,
)
def get_previous_month_values(self):
"""Calculate previous month's values."""
now = datetime.now()
first_day_of_current_month = datetime(now.year, now.month, 1)
|
start_of_last_month = datetime(
last_day_of_last_month.year, last_day_of_last_month.month, 1
)
previous_month_users = [
user
for user in self.users
if start_of_last_month
<= datetime.strptime(user.date, "%Y-%m-%d %H:%M:%S")
<= last_day_of_last_month
]
# We add some dummy values to simulate growth/decline. Remove them in production.
num_customers = len(previous_month_users) + 3
total_payments = sum(user.payments for user in previous_month_users) + 240
num_delivers = (
len([user for user in previous_month_users if user.status == "Delivered"])
+ 5
)
self.previous_month_values = MonthValues(
num_customers=num_customers,
total_payments=total_payments,
num_delivers=num_delivers,
)
def sort_values(self, sort_value: str):
self.sort_value = sort_value
sel | last_day_of_last_month = first_day_of_current_month - timedelta(days=1) |
ate current month's values."""
now = datetime.now()
start_of_month = datetime(now.year, now.month, 1)
current_month_users = [
user
for user in self.users
if datetime.strptime(user.date, "%Y-%m-%d %H:%M:%S") >= start_of_month
]
num_customers = len(current_month_users)
total_payments = sum(user.payments for user in current_month_users)
num_delivers = len(
[user for user in current_month_users if user.status == "Delivered"]
)
self.current_month_values = MonthValues(
num_customers=num_customers,
total_payments=total_payments,
num_delivers=num_delivers,
)
def get_previous_month_values(self):
"""Calculate previous month's values."""
now = datetime.now()
first_day_of_current_month = datetime(now.year, now.month, 1)
last_day_of_last_month = first_day_of_current_month - timedelta(days=1)
|
previous_month_users = [
user
for user in self.users
if start_of_last_month
<= datetime.strptime(user.date, "%Y-%m-%d %H:%M:%S")
<= last_day_of_last_month
]
# We add some dummy values to simulate growth/decline. Remove them in production.
num_customers = len(previous_month_users) + 3
total_payments = sum(user.payments for user in previous_month_users) + 240
num_delivers = (
len([user for user in previous_month_users if user.status == "Delivered"])
+ 5
)
self.previous_month_values = MonthValues(
num_customers=num_customers,
total_payments=total_payments,
num_delivers=num_delivers,
)
def sort_values(self, sort_value: str):
self.sort_value = sort_value
self.load_entries()
def toggle_sort(self):
self.sort_reverse = not self.sort_reverse
self.load_entries()
| start_of_last_month = datetime(
last_day_of_last_month.year, last_day_of_last_month.month, 1
) |
current_month_users = [
user
for user in self.users
if datetime.strptime(user.date, "%Y-%m-%d %H:%M:%S") >= start_of_month
]
num_customers = len(current_month_users)
total_payments = sum(user.payments for user in current_month_users)
num_delivers = len(
[user for user in current_month_users if user.status == "Delivered"]
)
self.current_month_values = MonthValues(
num_customers=num_customers,
total_payments=total_payments,
num_delivers=num_delivers,
)
def get_previous_month_values(self):
"""Calculate previous month's values."""
now = datetime.now()
first_day_of_current_month = datetime(now.year, now.month, 1)
last_day_of_last_month = first_day_of_current_month - timedelta(days=1)
start_of_last_month = datetime(
last_day_of_last_month.year, last_day_of_last_month.month, 1
)
|
# We add some dummy values to simulate growth/decline. Remove them in production.
num_customers = len(previous_month_users) + 3
total_payments = sum(user.payments for user in previous_month_users) + 240
num_delivers = (
len([user for user in previous_month_users if user.status == "Delivered"])
+ 5
)
self.previous_month_values = MonthValues(
num_customers=num_customers,
total_payments=total_payments,
num_delivers=num_delivers,
)
def sort_values(self, sort_value: str):
self.sort_value = sort_value
self.load_entries()
def toggle_sort(self):
self.sort_reverse = not self.sort_reverse
self.load_entries()
def filter_values(self, search_value):
self.search_value = search_value
self.load_entries()
def get_user(self, user: Customer):
self.current_user = user
def add_customer_to_db(self, form_data: di | previous_month_users = [
user
for user in self.users
if start_of_last_month
<= datetime.strptime(user.date, "%Y-%m-%d %H:%M:%S")
<= last_day_of_last_month
] |
(
[user for user in current_month_users if user.status == "Delivered"]
)
self.current_month_values = MonthValues(
num_customers=num_customers,
total_payments=total_payments,
num_delivers=num_delivers,
)
def get_previous_month_values(self):
"""Calculate previous month's values."""
now = datetime.now()
first_day_of_current_month = datetime(now.year, now.month, 1)
last_day_of_last_month = first_day_of_current_month - timedelta(days=1)
start_of_last_month = datetime(
last_day_of_last_month.year, last_day_of_last_month.month, 1
)
previous_month_users = [
user
for user in self.users
if start_of_last_month
<= datetime.strptime(user.date, "%Y-%m-%d %H:%M:%S")
<= last_day_of_last_month
]
# We add some dummy values to simulate growth/decline. Remove them in production.
|
total_payments = sum(user.payments for user in previous_month_users) + 240
num_delivers = (
len([user for user in previous_month_users if user.status == "Delivered"])
+ 5
)
self.previous_month_values = MonthValues(
num_customers=num_customers,
total_payments=total_payments,
num_delivers=num_delivers,
)
def sort_values(self, sort_value: str):
self.sort_value = sort_value
self.load_entries()
def toggle_sort(self):
self.sort_reverse = not self.sort_reverse
self.load_entries()
def filter_values(self, search_value):
self.search_value = search_value
self.load_entries()
def get_user(self, user: Customer):
self.current_user = user
def add_customer_to_db(self, form_data: dict):
with rx.session() as session:
if session.exec(
select(Customer).where(Customer.email == form_data.get(" | num_customers = len(previous_month_users) + 3 |
user.status == "Delivered"]
)
self.current_month_values = MonthValues(
num_customers=num_customers,
total_payments=total_payments,
num_delivers=num_delivers,
)
def get_previous_month_values(self):
"""Calculate previous month's values."""
now = datetime.now()
first_day_of_current_month = datetime(now.year, now.month, 1)
last_day_of_last_month = first_day_of_current_month - timedelta(days=1)
start_of_last_month = datetime(
last_day_of_last_month.year, last_day_of_last_month.month, 1
)
previous_month_users = [
user
for user in self.users
if start_of_last_month
<= datetime.strptime(user.date, "%Y-%m-%d %H:%M:%S")
<= last_day_of_last_month
]
# We add some dummy values to simulate growth/decline. Remove them in production.
num_customers = len(previous_month_users) + 3
|
num_delivers = (
len([user for user in previous_month_users if user.status == "Delivered"])
+ 5
)
self.previous_month_values = MonthValues(
num_customers=num_customers,
total_payments=total_payments,
num_delivers=num_delivers,
)
def sort_values(self, sort_value: str):
self.sort_value = sort_value
self.load_entries()
def toggle_sort(self):
self.sort_reverse = not self.sort_reverse
self.load_entries()
def filter_values(self, search_value):
self.search_value = search_value
self.load_entries()
def get_user(self, user: Customer):
self.current_user = user
def add_customer_to_db(self, form_data: dict):
with rx.session() as session:
if session.exec(
select(Customer).where(Customer.email == form_data.get("email"))
).first():
return rx.window_alert("User with t | total_payments = sum(user.payments for user in previous_month_users) + 240 |
ues(
num_customers=num_customers,
total_payments=total_payments,
num_delivers=num_delivers,
)
def get_previous_month_values(self):
"""Calculate previous month's values."""
now = datetime.now()
first_day_of_current_month = datetime(now.year, now.month, 1)
last_day_of_last_month = first_day_of_current_month - timedelta(days=1)
start_of_last_month = datetime(
last_day_of_last_month.year, last_day_of_last_month.month, 1
)
previous_month_users = [
user
for user in self.users
if start_of_last_month
<= datetime.strptime(user.date, "%Y-%m-%d %H:%M:%S")
<= last_day_of_last_month
]
# We add some dummy values to simulate growth/decline. Remove them in production.
num_customers = len(previous_month_users) + 3
total_payments = sum(user.payments for user in previous_month_users) + 240
|
self.previous_month_values = MonthValues(
num_customers=num_customers,
total_payments=total_payments,
num_delivers=num_delivers,
)
def sort_values(self, sort_value: str):
self.sort_value = sort_value
self.load_entries()
def toggle_sort(self):
self.sort_reverse = not self.sort_reverse
self.load_entries()
def filter_values(self, search_value):
self.search_value = search_value
self.load_entries()
def get_user(self, user: Customer):
self.current_user = user
def add_customer_to_db(self, form_data: dict):
with rx.session() as session:
if session.exec(
select(Customer).where(Customer.email == form_data.get("email"))
).first():
return rx.window_alert("User with this email already exists")
self.current_user = Customer(
date=datetime.now().strftime("%Y-%m-%d %H:%M:%S"), ** | num_delivers = (
len([user for user in previous_month_users if user.status == "Delivered"])
+ 5
) |
def get_previous_month_values(self):
"""Calculate previous month's values."""
now = datetime.now()
first_day_of_current_month = datetime(now.year, now.month, 1)
last_day_of_last_month = first_day_of_current_month - timedelta(days=1)
start_of_last_month = datetime(
last_day_of_last_month.year, last_day_of_last_month.month, 1
)
previous_month_users = [
user
for user in self.users
if start_of_last_month
<= datetime.strptime(user.date, "%Y-%m-%d %H:%M:%S")
<= last_day_of_last_month
]
# We add some dummy values to simulate growth/decline. Remove them in production.
num_customers = len(previous_month_users) + 3
total_payments = sum(user.payments for user in previous_month_users) + 240
num_delivers = (
len([user for user in previous_month_users if user.status == "Delivered"])
+ 5
)
|
def sort_values(self, sort_value: str):
self.sort_value = sort_value
self.load_entries()
def toggle_sort(self):
self.sort_reverse = not self.sort_reverse
self.load_entries()
def filter_values(self, search_value):
self.search_value = search_value
self.load_entries()
def get_user(self, user: Customer):
self.current_user = user
def add_customer_to_db(self, form_data: dict):
with rx.session() as session:
if session.exec(
select(Customer).where(Customer.email == form_data.get("email"))
).first():
return rx.window_alert("User with this email already exists")
self.current_user = Customer(
date=datetime.now().strftime("%Y-%m-%d %H:%M:%S"), **form_data
)
session.add(self.current_user)
session.commit()
session.refresh(self.current_user)
self.load_entries()
retur | self.previous_month_values = MonthValues(
num_customers=num_customers,
total_payments=total_payments,
num_delivers=num_delivers,
) |
onth, 1)
last_day_of_last_month = first_day_of_current_month - timedelta(days=1)
start_of_last_month = datetime(
last_day_of_last_month.year, last_day_of_last_month.month, 1
)
previous_month_users = [
user
for user in self.users
if start_of_last_month
<= datetime.strptime(user.date, "%Y-%m-%d %H:%M:%S")
<= last_day_of_last_month
]
# We add some dummy values to simulate growth/decline. Remove them in production.
num_customers = len(previous_month_users) + 3
total_payments = sum(user.payments for user in previous_month_users) + 240
num_delivers = (
len([user for user in previous_month_users if user.status == "Delivered"])
+ 5
)
self.previous_month_values = MonthValues(
num_customers=num_customers,
total_payments=total_payments,
num_delivers=num_delivers,
)
|
def toggle_sort(self):
self.sort_reverse = not self.sort_reverse
self.load_entries()
def filter_values(self, search_value):
self.search_value = search_value
self.load_entries()
def get_user(self, user: Customer):
self.current_user = user
def add_customer_to_db(self, form_data: dict):
with rx.session() as session:
if session.exec(
select(Customer).where(Customer.email == form_data.get("email"))
).first():
return rx.window_alert("User with this email already exists")
self.current_user = Customer(
date=datetime.now().strftime("%Y-%m-%d %H:%M:%S"), **form_data
)
session.add(self.current_user)
session.commit()
session.refresh(self.current_user)
self.load_entries()
return rx.toast.info(
f"User {self.current_user.name} has been added.", position="bottom-right"
| def sort_values(self, sort_value: str):
self.sort_value = sort_value
self.load_entries() |
day_of_current_month - timedelta(days=1)
start_of_last_month = datetime(
last_day_of_last_month.year, last_day_of_last_month.month, 1
)
previous_month_users = [
user
for user in self.users
if start_of_last_month
<= datetime.strptime(user.date, "%Y-%m-%d %H:%M:%S")
<= last_day_of_last_month
]
# We add some dummy values to simulate growth/decline. Remove them in production.
num_customers = len(previous_month_users) + 3
total_payments = sum(user.payments for user in previous_month_users) + 240
num_delivers = (
len([user for user in previous_month_users if user.status == "Delivered"])
+ 5
)
self.previous_month_values = MonthValues(
num_customers=num_customers,
total_payments=total_payments,
num_delivers=num_delivers,
)
def sort_values(self, sort_value: str):
|
self.load_entries()
def toggle_sort(self):
self.sort_reverse = not self.sort_reverse
self.load_entries()
def filter_values(self, search_value):
self.search_value = search_value
self.load_entries()
def get_user(self, user: Customer):
self.current_user = user
def add_customer_to_db(self, form_data: dict):
with rx.session() as session:
if session.exec(
select(Customer).where(Customer.email == form_data.get("email"))
).first():
return rx.window_alert("User with this email already exists")
self.current_user = Customer(
date=datetime.now().strftime("%Y-%m-%d %H:%M:%S"), **form_data
)
session.add(self.current_user)
session.commit()
session.refresh(self.current_user)
self.load_entries()
return rx.toast.info(
f"User {self.current_user.name} has been added.", pos | self.sort_value = sort_value |
_month = datetime(
last_day_of_last_month.year, last_day_of_last_month.month, 1
)
previous_month_users = [
user
for user in self.users
if start_of_last_month
<= datetime.strptime(user.date, "%Y-%m-%d %H:%M:%S")
<= last_day_of_last_month
]
# We add some dummy values to simulate growth/decline. Remove them in production.
num_customers = len(previous_month_users) + 3
total_payments = sum(user.payments for user in previous_month_users) + 240
num_delivers = (
len([user for user in previous_month_users if user.status == "Delivered"])
+ 5
)
self.previous_month_values = MonthValues(
num_customers=num_customers,
total_payments=total_payments,
num_delivers=num_delivers,
)
def sort_values(self, sort_value: str):
self.sort_value = sort_value
self.load_entries()
|
def filter_values(self, search_value):
self.search_value = search_value
self.load_entries()
def get_user(self, user: Customer):
self.current_user = user
def add_customer_to_db(self, form_data: dict):
with rx.session() as session:
if session.exec(
select(Customer).where(Customer.email == form_data.get("email"))
).first():
return rx.window_alert("User with this email already exists")
self.current_user = Customer(
date=datetime.now().strftime("%Y-%m-%d %H:%M:%S"), **form_data
)
session.add(self.current_user)
session.commit()
session.refresh(self.current_user)
self.load_entries()
return rx.toast.info(
f"User {self.current_user.name} has been added.", position="bottom-right"
)
def update_customer_to_db(self, form_data: dict):
with rx.session() as session:
| def toggle_sort(self):
self.sort_reverse = not self.sort_reverse
self.load_entries() |
last_day_of_last_month.year, last_day_of_last_month.month, 1
)
previous_month_users = [
user
for user in self.users
if start_of_last_month
<= datetime.strptime(user.date, "%Y-%m-%d %H:%M:%S")
<= last_day_of_last_month
]
# We add some dummy values to simulate growth/decline. Remove them in production.
num_customers = len(previous_month_users) + 3
total_payments = sum(user.payments for user in previous_month_users) + 240
num_delivers = (
len([user for user in previous_month_users if user.status == "Delivered"])
+ 5
)
self.previous_month_values = MonthValues(
num_customers=num_customers,
total_payments=total_payments,
num_delivers=num_delivers,
)
def sort_values(self, sort_value: str):
self.sort_value = sort_value
self.load_entries()
def toggle_sort(self):
|
self.load_entries()
def filter_values(self, search_value):
self.search_value = search_value
self.load_entries()
def get_user(self, user: Customer):
self.current_user = user
def add_customer_to_db(self, form_data: dict):
with rx.session() as session:
if session.exec(
select(Customer).where(Customer.email == form_data.get("email"))
).first():
return rx.window_alert("User with this email already exists")
self.current_user = Customer(
date=datetime.now().strftime("%Y-%m-%d %H:%M:%S"), **form_data
)
session.add(self.current_user)
session.commit()
session.refresh(self.current_user)
self.load_entries()
return rx.toast.info(
f"User {self.current_user.name} has been added.", position="bottom-right"
)
def update_customer_to_db(self, form_data: dict):
with rx.sess | self.sort_reverse = not self.sort_reverse |
previous_month_users = [
user
for user in self.users
if start_of_last_month
<= datetime.strptime(user.date, "%Y-%m-%d %H:%M:%S")
<= last_day_of_last_month
]
# We add some dummy values to simulate growth/decline. Remove them in production.
num_customers = len(previous_month_users) + 3
total_payments = sum(user.payments for user in previous_month_users) + 240
num_delivers = (
len([user for user in previous_month_users if user.status == "Delivered"])
+ 5
)
self.previous_month_values = MonthValues(
num_customers=num_customers,
total_payments=total_payments,
num_delivers=num_delivers,
)
def sort_values(self, sort_value: str):
self.sort_value = sort_value
self.load_entries()
def toggle_sort(self):
self.sort_reverse = not self.sort_reverse
self.load_entries()
|
def get_user(self, user: Customer):
self.current_user = user
def add_customer_to_db(self, form_data: dict):
with rx.session() as session:
if session.exec(
select(Customer).where(Customer.email == form_data.get("email"))
).first():
return rx.window_alert("User with this email already exists")
self.current_user = Customer(
date=datetime.now().strftime("%Y-%m-%d %H:%M:%S"), **form_data
)
session.add(self.current_user)
session.commit()
session.refresh(self.current_user)
self.load_entries()
return rx.toast.info(
f"User {self.current_user.name} has been added.", position="bottom-right"
)
def update_customer_to_db(self, form_data: dict):
with rx.session() as session:
customer = session.exec(
select(Customer).where(Customer.id == self.current_user.id)
| def filter_values(self, search_value):
self.search_value = search_value
self.load_entries() |
for user in self.users
if start_of_last_month
<= datetime.strptime(user.date, "%Y-%m-%d %H:%M:%S")
<= last_day_of_last_month
]
# We add some dummy values to simulate growth/decline. Remove them in production.
num_customers = len(previous_month_users) + 3
total_payments = sum(user.payments for user in previous_month_users) + 240
num_delivers = (
len([user for user in previous_month_users if user.status == "Delivered"])
+ 5
)
self.previous_month_values = MonthValues(
num_customers=num_customers,
total_payments=total_payments,
num_delivers=num_delivers,
)
def sort_values(self, sort_value: str):
self.sort_value = sort_value
self.load_entries()
def toggle_sort(self):
self.sort_reverse = not self.sort_reverse
self.load_entries()
def filter_values(self, search_value):
|
self.load_entries()
def get_user(self, user: Customer):
self.current_user = user
def add_customer_to_db(self, form_data: dict):
with rx.session() as session:
if session.exec(
select(Customer).where(Customer.email == form_data.get("email"))
).first():
return rx.window_alert("User with this email already exists")
self.current_user = Customer(
date=datetime.now().strftime("%Y-%m-%d %H:%M:%S"), **form_data
)
session.add(self.current_user)
session.commit()
session.refresh(self.current_user)
self.load_entries()
return rx.toast.info(
f"User {self.current_user.name} has been added.", position="bottom-right"
)
def update_customer_to_db(self, form_data: dict):
with rx.session() as session:
customer = session.exec(
select(Customer).where(Customer.id == self | self.search_value = search_value |
nth
<= datetime.strptime(user.date, "%Y-%m-%d %H:%M:%S")
<= last_day_of_last_month
]
# We add some dummy values to simulate growth/decline. Remove them in production.
num_customers = len(previous_month_users) + 3
total_payments = sum(user.payments for user in previous_month_users) + 240
num_delivers = (
len([user for user in previous_month_users if user.status == "Delivered"])
+ 5
)
self.previous_month_values = MonthValues(
num_customers=num_customers,
total_payments=total_payments,
num_delivers=num_delivers,
)
def sort_values(self, sort_value: str):
self.sort_value = sort_value
self.load_entries()
def toggle_sort(self):
self.sort_reverse = not self.sort_reverse
self.load_entries()
def filter_values(self, search_value):
self.search_value = search_value
self.load_entries()
|
def add_customer_to_db(self, form_data: dict):
with rx.session() as session:
if session.exec(
select(Customer).where(Customer.email == form_data.get("email"))
).first():
return rx.window_alert("User with this email already exists")
self.current_user = Customer(
date=datetime.now().strftime("%Y-%m-%d %H:%M:%S"), **form_data
)
session.add(self.current_user)
session.commit()
session.refresh(self.current_user)
self.load_entries()
return rx.toast.info(
f"User {self.current_user.name} has been added.", position="bottom-right"
)
def update_customer_to_db(self, form_data: dict):
with rx.session() as session:
customer = session.exec(
select(Customer).where(Customer.id == self.current_user.id)
).first()
form_data.pop("id", None)
customer.set | def get_user(self, user: Customer):
self.current_user = user |
te, "%Y-%m-%d %H:%M:%S")
<= last_day_of_last_month
]
# We add some dummy values to simulate growth/decline. Remove them in production.
num_customers = len(previous_month_users) + 3
total_payments = sum(user.payments for user in previous_month_users) + 240
num_delivers = (
len([user for user in previous_month_users if user.status == "Delivered"])
+ 5
)
self.previous_month_values = MonthValues(
num_customers=num_customers,
total_payments=total_payments,
num_delivers=num_delivers,
)
def sort_values(self, sort_value: str):
self.sort_value = sort_value
self.load_entries()
def toggle_sort(self):
self.sort_reverse = not self.sort_reverse
self.load_entries()
def filter_values(self, search_value):
self.search_value = search_value
self.load_entries()
def get_user(self, user: Customer):
|
def add_customer_to_db(self, form_data: dict):
with rx.session() as session:
if session.exec(
select(Customer).where(Customer.email == form_data.get("email"))
).first():
return rx.window_alert("User with this email already exists")
self.current_user = Customer(
date=datetime.now().strftime("%Y-%m-%d %H:%M:%S"), **form_data
)
session.add(self.current_user)
session.commit()
session.refresh(self.current_user)
self.load_entries()
return rx.toast.info(
f"User {self.current_user.name} has been added.", position="bottom-right"
)
def update_customer_to_db(self, form_data: dict):
with rx.session() as session:
customer = session.exec(
select(Customer).where(Customer.id == self.current_user.id)
).first()
form_data.pop("id", None)
customer.set | self.current_user = user |
<= last_day_of_last_month
]
# We add some dummy values to simulate growth/decline. Remove them in production.
num_customers = len(previous_month_users) + 3
total_payments = sum(user.payments for user in previous_month_users) + 240
num_delivers = (
len([user for user in previous_month_users if user.status == "Delivered"])
+ 5
)
self.previous_month_values = MonthValues(
num_customers=num_customers,
total_payments=total_payments,
num_delivers=num_delivers,
)
def sort_values(self, sort_value: str):
self.sort_value = sort_value
self.load_entries()
def toggle_sort(self):
self.sort_reverse = not self.sort_reverse
self.load_entries()
def filter_values(self, search_value):
self.search_value = search_value
self.load_entries()
def get_user(self, user: Customer):
self.current_user = user
|
def update_customer_to_db(self, form_data: dict):
with rx.session() as session:
customer = session.exec(
select(Customer).where(Customer.id == self.current_user.id)
).first()
form_data.pop("id", None)
customer.set(**form_data)
session.add(customer)
session.commit()
self.load_entries()
return rx.toast.info(
f"User {self.current_user.name} has been modified.",
position="bottom-right",
)
def delete_customer(self, id: int):
"""Delete a customer from the database."""
with rx.session() as session:
customer = session.exec(select(Customer).where(Customer.id == id)).first()
session.delete(customer)
session.commit()
self.load_entries()
return rx.toast.info(
f"User {customer.name} has been deleted.", position="bottom-right"
)
@rx.var(cache=True)
def | def add_customer_to_db(self, form_data: dict):
with rx.session() as session:
if session.exec(
select(Customer).where(Customer.email == form_data.get("email"))
).first():
return rx.window_alert("User with this email already exists")
self.current_user = Customer(
date=datetime.now().strftime("%Y-%m-%d %H:%M:%S"), **form_data
)
session.add(self.current_user)
session.commit()
session.refresh(self.current_user)
self.load_entries()
return rx.toast.info(
f"User {self.current_user.name} has been added.", position="bottom-right"
) |
decline. Remove them in production.
num_customers = len(previous_month_users) + 3
total_payments = sum(user.payments for user in previous_month_users) + 240
num_delivers = (
len([user for user in previous_month_users if user.status == "Delivered"])
+ 5
)
self.previous_month_values = MonthValues(
num_customers=num_customers,
total_payments=total_payments,
num_delivers=num_delivers,
)
def sort_values(self, sort_value: str):
self.sort_value = sort_value
self.load_entries()
def toggle_sort(self):
self.sort_reverse = not self.sort_reverse
self.load_entries()
def filter_values(self, search_value):
self.search_value = search_value
self.load_entries()
def get_user(self, user: Customer):
self.current_user = user
def add_customer_to_db(self, form_data: dict):
with rx.session() as session:
|
self.current_user = Customer(
date=datetime.now().strftime("%Y-%m-%d %H:%M:%S"), **form_data
)
session.add(self.current_user)
session.commit()
session.refresh(self.current_user)
self.load_entries()
return rx.toast.info(
f"User {self.current_user.name} has been added.", position="bottom-right"
)
def update_customer_to_db(self, form_data: dict):
with rx.session() as session:
customer = session.exec(
select(Customer).where(Customer.id == self.current_user.id)
).first()
form_data.pop("id", None)
customer.set(**form_data)
session.add(customer)
session.commit()
self.load_entries()
return rx.toast.info(
f"User {self.current_user.name} has been modified.",
position="bottom-right",
)
def delete_customer(self, id: int):
"""De | if session.exec(
select(Customer).where(Customer.email == form_data.get("email"))
).first():
return rx.window_alert("User with this email already exists") |
en([user for user in previous_month_users if user.status == "Delivered"])
+ 5
)
self.previous_month_values = MonthValues(
num_customers=num_customers,
total_payments=total_payments,
num_delivers=num_delivers,
)
def sort_values(self, sort_value: str):
self.sort_value = sort_value
self.load_entries()
def toggle_sort(self):
self.sort_reverse = not self.sort_reverse
self.load_entries()
def filter_values(self, search_value):
self.search_value = search_value
self.load_entries()
def get_user(self, user: Customer):
self.current_user = user
def add_customer_to_db(self, form_data: dict):
with rx.session() as session:
if session.exec(
select(Customer).where(Customer.email == form_data.get("email"))
).first():
return rx.window_alert("User with this email already exists")
|
session.add(self.current_user)
session.commit()
session.refresh(self.current_user)
self.load_entries()
return rx.toast.info(
f"User {self.current_user.name} has been added.", position="bottom-right"
)
def update_customer_to_db(self, form_data: dict):
with rx.session() as session:
customer = session.exec(
select(Customer).where(Customer.id == self.current_user.id)
).first()
form_data.pop("id", None)
customer.set(**form_data)
session.add(customer)
session.commit()
self.load_entries()
return rx.toast.info(
f"User {self.current_user.name} has been modified.",
position="bottom-right",
)
def delete_customer(self, id: int):
"""Delete a customer from the database."""
with rx.session() as session:
customer = session.exec(select(Customer).where( | self.current_user = Customer(
date=datetime.now().strftime("%Y-%m-%d %H:%M:%S"), **form_data
) |
f toggle_sort(self):
self.sort_reverse = not self.sort_reverse
self.load_entries()
def filter_values(self, search_value):
self.search_value = search_value
self.load_entries()
def get_user(self, user: Customer):
self.current_user = user
def add_customer_to_db(self, form_data: dict):
with rx.session() as session:
if session.exec(
select(Customer).where(Customer.email == form_data.get("email"))
).first():
return rx.window_alert("User with this email already exists")
self.current_user = Customer(
date=datetime.now().strftime("%Y-%m-%d %H:%M:%S"), **form_data
)
session.add(self.current_user)
session.commit()
session.refresh(self.current_user)
self.load_entries()
return rx.toast.info(
f"User {self.current_user.name} has been added.", position="bottom-right"
)
|
def delete_customer(self, id: int):
"""Delete a customer from the database."""
with rx.session() as session:
customer = session.exec(select(Customer).where(Customer.id == id)).first()
session.delete(customer)
session.commit()
self.load_entries()
return rx.toast.info(
f"User {customer.name} has been deleted.", position="bottom-right"
)
@rx.var(cache=True)
def payments_change(self) -> float:
return _get_percentage_change(
self.current_month_values.total_payments,
self.previous_month_values.total_payments,
)
@rx.var(cache=True)
def customers_change(self) -> float:
return _get_percentage_change(
self.current_month_values.num_customers,
self.previous_month_values.num_customers,
)
@rx.var(cache=True)
def delivers_change(self) -> float:
return _get_percentage_change(
self.cur | def update_customer_to_db(self, form_data: dict):
with rx.session() as session:
customer = session.exec(
select(Customer).where(Customer.id == self.current_user.id)
).first()
form_data.pop("id", None)
customer.set(**form_data)
session.add(customer)
session.commit()
self.load_entries()
return rx.toast.info(
f"User {self.current_user.name} has been modified.",
position="bottom-right",
) |
def filter_values(self, search_value):
self.search_value = search_value
self.load_entries()
def get_user(self, user: Customer):
self.current_user = user
def add_customer_to_db(self, form_data: dict):
with rx.session() as session:
if session.exec(
select(Customer).where(Customer.email == form_data.get("email"))
).first():
return rx.window_alert("User with this email already exists")
self.current_user = Customer(
date=datetime.now().strftime("%Y-%m-%d %H:%M:%S"), **form_data
)
session.add(self.current_user)
session.commit()
session.refresh(self.current_user)
self.load_entries()
return rx.toast.info(
f"User {self.current_user.name} has been added.", position="bottom-right"
)
def update_customer_to_db(self, form_data: dict):
with rx.session() as session:
|
form_data.pop("id", None)
customer.set(**form_data)
session.add(customer)
session.commit()
self.load_entries()
return rx.toast.info(
f"User {self.current_user.name} has been modified.",
position="bottom-right",
)
def delete_customer(self, id: int):
"""Delete a customer from the database."""
with rx.session() as session:
customer = session.exec(select(Customer).where(Customer.id == id)).first()
session.delete(customer)
session.commit()
self.load_entries()
return rx.toast.info(
f"User {customer.name} has been deleted.", position="bottom-right"
)
@rx.var(cache=True)
def payments_change(self) -> float:
return _get_percentage_change(
self.current_month_values.total_payments,
self.previous_month_values.total_payments,
)
@rx.var(cache=True)
def cust | customer = session.exec(
select(Customer).where(Customer.id == self.current_user.id)
).first() |
ndow_alert("User with this email already exists")
self.current_user = Customer(
date=datetime.now().strftime("%Y-%m-%d %H:%M:%S"), **form_data
)
session.add(self.current_user)
session.commit()
session.refresh(self.current_user)
self.load_entries()
return rx.toast.info(
f"User {self.current_user.name} has been added.", position="bottom-right"
)
def update_customer_to_db(self, form_data: dict):
with rx.session() as session:
customer = session.exec(
select(Customer).where(Customer.id == self.current_user.id)
).first()
form_data.pop("id", None)
customer.set(**form_data)
session.add(customer)
session.commit()
self.load_entries()
return rx.toast.info(
f"User {self.current_user.name} has been modified.",
position="bottom-right",
)
|
@rx.var(cache=True)
def payments_change(self) -> float:
return _get_percentage_change(
self.current_month_values.total_payments,
self.previous_month_values.total_payments,
)
@rx.var(cache=True)
def customers_change(self) -> float:
return _get_percentage_change(
self.current_month_values.num_customers,
self.previous_month_values.num_customers,
)
@rx.var(cache=True)
def delivers_change(self) -> float:
return _get_percentage_change(
self.current_month_values.num_delivers,
self.previous_month_values.num_delivers,
)
| def delete_customer(self, id: int):
"""Delete a customer from the database."""
with rx.session() as session:
customer = session.exec(select(Customer).where(Customer.id == id)).first()
session.delete(customer)
session.commit()
self.load_entries()
return rx.toast.info(
f"User {customer.name} has been deleted.", position="bottom-right"
) |
"%Y-%m-%d %H:%M:%S"), **form_data
)
session.add(self.current_user)
session.commit()
session.refresh(self.current_user)
self.load_entries()
return rx.toast.info(
f"User {self.current_user.name} has been added.", position="bottom-right"
)
def update_customer_to_db(self, form_data: dict):
with rx.session() as session:
customer = session.exec(
select(Customer).where(Customer.id == self.current_user.id)
).first()
form_data.pop("id", None)
customer.set(**form_data)
session.add(customer)
session.commit()
self.load_entries()
return rx.toast.info(
f"User {self.current_user.name} has been modified.",
position="bottom-right",
)
def delete_customer(self, id: int):
"""Delete a customer from the database."""
with rx.session() as session:
|
session.delete(customer)
session.commit()
self.load_entries()
return rx.toast.info(
f"User {customer.name} has been deleted.", position="bottom-right"
)
@rx.var(cache=True)
def payments_change(self) -> float:
return _get_percentage_change(
self.current_month_values.total_payments,
self.previous_month_values.total_payments,
)
@rx.var(cache=True)
def customers_change(self) -> float:
return _get_percentage_change(
self.current_month_values.num_customers,
self.previous_month_values.num_customers,
)
@rx.var(cache=True)
def delivers_change(self) -> float:
return _get_percentage_change(
self.current_month_values.num_delivers,
self.previous_month_values.num_delivers,
)
| customer = session.exec(select(Customer).where(Customer.id == id)).first() |
)
def update_customer_to_db(self, form_data: dict):
with rx.session() as session:
customer = session.exec(
select(Customer).where(Customer.id == self.current_user.id)
).first()
form_data.pop("id", None)
customer.set(**form_data)
session.add(customer)
session.commit()
self.load_entries()
return rx.toast.info(
f"User {self.current_user.name} has been modified.",
position="bottom-right",
)
def delete_customer(self, id: int):
"""Delete a customer from the database."""
with rx.session() as session:
customer = session.exec(select(Customer).where(Customer.id == id)).first()
session.delete(customer)
session.commit()
self.load_entries()
return rx.toast.info(
f"User {customer.name} has been deleted.", position="bottom-right"
)
@rx.var(cache=True)
|
@rx.var(cache=True)
def customers_change(self) -> float:
return _get_percentage_change(
self.current_month_values.num_customers,
self.previous_month_values.num_customers,
)
@rx.var(cache=True)
def delivers_change(self) -> float:
return _get_percentage_change(
self.current_month_values.num_delivers,
self.previous_month_values.num_delivers,
)
| def payments_change(self) -> float:
return _get_percentage_change(
self.current_month_values.total_payments,
self.previous_month_values.total_payments,
) |
.first()
form_data.pop("id", None)
customer.set(**form_data)
session.add(customer)
session.commit()
self.load_entries()
return rx.toast.info(
f"User {self.current_user.name} has been modified.",
position="bottom-right",
)
def delete_customer(self, id: int):
"""Delete a customer from the database."""
with rx.session() as session:
customer = session.exec(select(Customer).where(Customer.id == id)).first()
session.delete(customer)
session.commit()
self.load_entries()
return rx.toast.info(
f"User {customer.name} has been deleted.", position="bottom-right"
)
@rx.var(cache=True)
def payments_change(self) -> float:
return _get_percentage_change(
self.current_month_values.total_payments,
self.previous_month_values.total_payments,
)
@rx.var(cache=True)
|
@rx.var(cache=True)
def delivers_change(self) -> float:
return _get_percentage_change(
self.current_month_values.num_delivers,
self.previous_month_values.num_delivers,
)
| def customers_change(self) -> float:
return _get_percentage_change(
self.current_month_values.num_customers,
self.previous_month_values.num_customers,
) |
er {self.current_user.name} has been modified.",
position="bottom-right",
)
def delete_customer(self, id: int):
"""Delete a customer from the database."""
with rx.session() as session:
customer = session.exec(select(Customer).where(Customer.id == id)).first()
session.delete(customer)
session.commit()
self.load_entries()
return rx.toast.info(
f"User {customer.name} has been deleted.", position="bottom-right"
)
@rx.var(cache=True)
def payments_change(self) -> float:
return _get_percentage_change(
self.current_month_values.total_payments,
self.previous_month_values.total_payments,
)
@rx.var(cache=True)
def customers_change(self) -> float:
return _get_percentage_change(
self.current_month_values.num_customers,
self.previous_month_values.num_customers,
)
@rx.var(cache=True)
| def delivers_change(self) -> float:
return _get_percentage_change(
self.current_month_values.num_delivers,
self.previous_month_values.num_delivers,
) | |
def form_field(
label: str,
placeholder: str,
type: str,
name: str,
icon: str,
default_value: str = "",
) -> rx.Component:
return rx.form.field(
rx.flex(
rx.hstack(
rx.icon(icon, size=16, stroke_width=1.5),
rx.form.label(label),
align="center",
spacing="2",
),
rx.form.control(
rx.input(
placeholder=placeholder, type=type, default_value=default_value
),
as_child=True,
),
direction="column",
spacing="1",
),
name=name,
width="100%",
)
| import reflex as rx | |
from reflex.components.radix.themes.base import (
LiteralAccentColor,
)
from ..backend.backend import State
def _arrow_badge(arrow_icon: str, percentage_change: float, arrow_color: str):
return rx.badge(
rx.icon(
tag=arrow_icon,
color=rx.color(arrow_color, 9),
),
rx.text(
f"{percentage_change}%",
size="2",
color=rx.color(arrow_color, 9),
weight="medium",
),
color_scheme=arrow_color,
radius="large",
align_items="center",
)
def stats_card(
stat_name: str,
value: int,
prev_value: int,
percentage_change: float,
icon: str,
icon_color: LiteralAccentColor,
extra_char: str = "",
) -> rx.Component:
return rx.card(
rx.hstack(
rx.vstack(
rx.hstack(
rx.hstack(
rx.icon(
tag=icon,
size=22,
| import reflex as rx | |
import reflex as rx
|
from ..backend.backend import State
def _arrow_badge(arrow_icon: str, percentage_change: float, arrow_color: str):
return rx.badge(
rx.icon(
tag=arrow_icon,
color=rx.color(arrow_color, 9),
),
rx.text(
f"{percentage_change}%",
size="2",
color=rx.color(arrow_color, 9),
weight="medium",
),
color_scheme=arrow_color,
radius="large",
align_items="center",
)
def stats_card(
stat_name: str,
value: int,
prev_value: int,
percentage_change: float,
icon: str,
icon_color: LiteralAccentColor,
extra_char: str = "",
) -> rx.Component:
return rx.card(
rx.hstack(
rx.vstack(
rx.hstack(
rx.hstack(
rx.icon(
tag=icon,
size=22,
color=rx.color(icon_color, 11),
| from reflex.components.radix.themes.base import (
LiteralAccentColor,
) |
import reflex as rx
from reflex.components.radix.themes.base import (
LiteralAccentColor,
)
|
def _arrow_badge(arrow_icon: str, percentage_change: float, arrow_color: str):
return rx.badge(
rx.icon(
tag=arrow_icon,
color=rx.color(arrow_color, 9),
),
rx.text(
f"{percentage_change}%",
size="2",
color=rx.color(arrow_color, 9),
weight="medium",
),
color_scheme=arrow_color,
radius="large",
align_items="center",
)
def stats_card(
stat_name: str,
value: int,
prev_value: int,
percentage_change: float,
icon: str,
icon_color: LiteralAccentColor,
extra_char: str = "",
) -> rx.Component:
return rx.card(
rx.hstack(
rx.vstack(
rx.hstack(
rx.hstack(
rx.icon(
tag=icon,
size=22,
color=rx.color(icon_color, 11),
),
rx. | from ..backend.backend import State |
def _badge(icon: str, text: str, color_scheme: str):
return rx.badge(
rx.icon(icon, size=16),
text,
color_scheme=color_scheme,
radius="full",
variant="soft",
size="3",
)
def status_badge(status: str):
badge_mapping = {
"Delivered": ("check", "Delivered", "green"),
"Pending": ("loader", "Pending", "yellow"),
"Cancelled": ("ban", "Cancelled", "red"),
}
return _badge(*badge_mapping.get(status, ("loader", "Pending", "yellow")))
| import reflex as rx | |
def navbar():
return rx.flex(
rx.badge(
rx.icon(tag="table-2", size=28),
rx.heading("Customer Data App", size="6"),
color_scheme="green",
radius="large",
align="center",
variant="surface",
padding="0.65rem",
),
rx.spacer(),
rx.hstack(
rx.logo(),
rx.color_mode.button(),
align="center",
spacing="3",
),
spacing="2",
flex_direction=["column", "column", "row"],
align="center",
width="100%",
top="0px",
padding_top="2em",
)
| import reflex as rx | |
from ..backend.backend import Customer, State
from ..components.form_field import form_field
from ..components.status_badges import status_badge
def show_customer(user: Customer):
"""Show a customer in a table row."""
return rx.table.row(
rx.table.cell(user.name),
rx.table.cell(user.email),
rx.table.cell(user.phone),
rx.table.cell(user.address),
rx.table.cell(f"${user.payments}"),
rx.table.cell(user.date),
rx.table.cell(
rx.match(
user.status,
("Delivered", status_badge("Delivered")),
("Pending", status_badge("Pending")),
("Cancelled", status_badge("Cancelled")),
status_badge("Pending"),
)
),
rx.table.cell(
rx.hstack(
update_customer_dialog(user),
rx.icon_button(
rx.icon("trash-2", size=22),
on_click=lambda: State.dele | import reflex as rx | |
import reflex as rx
|
from ..components.form_field import form_field
from ..components.status_badges import status_badge
def show_customer(user: Customer):
"""Show a customer in a table row."""
return rx.table.row(
rx.table.cell(user.name),
rx.table.cell(user.email),
rx.table.cell(user.phone),
rx.table.cell(user.address),
rx.table.cell(f"${user.payments}"),
rx.table.cell(user.date),
rx.table.cell(
rx.match(
user.status,
("Delivered", status_badge("Delivered")),
("Pending", status_badge("Pending")),
("Cancelled", status_badge("Cancelled")),
status_badge("Pending"),
)
),
rx.table.cell(
rx.hstack(
update_customer_dialog(user),
rx.icon_button(
rx.icon("trash-2", size=22),
on_click=lambda: State.delete_customer(user.id),
size= | from ..backend.backend import Customer, State |
import reflex as rx
from ..backend.backend import Customer, State
|
from ..components.status_badges import status_badge
def show_customer(user: Customer):
"""Show a customer in a table row."""
return rx.table.row(
rx.table.cell(user.name),
rx.table.cell(user.email),
rx.table.cell(user.phone),
rx.table.cell(user.address),
rx.table.cell(f"${user.payments}"),
rx.table.cell(user.date),
rx.table.cell(
rx.match(
user.status,
("Delivered", status_badge("Delivered")),
("Pending", status_badge("Pending")),
("Cancelled", status_badge("Cancelled")),
status_badge("Pending"),
)
),
rx.table.cell(
rx.hstack(
update_customer_dialog(user),
rx.icon_button(
rx.icon("trash-2", size=22),
on_click=lambda: State.delete_customer(user.id),
size="2",
variant="solid",
| from ..components.form_field import form_field |
import reflex as rx
from ..backend.backend import Customer, State
from ..components.form_field import form_field
|
def show_customer(user: Customer):
"""Show a customer in a table row."""
return rx.table.row(
rx.table.cell(user.name),
rx.table.cell(user.email),
rx.table.cell(user.phone),
rx.table.cell(user.address),
rx.table.cell(f"${user.payments}"),
rx.table.cell(user.date),
rx.table.cell(
rx.match(
user.status,
("Delivered", status_badge("Delivered")),
("Pending", status_badge("Pending")),
("Cancelled", status_badge("Cancelled")),
status_badge("Pending"),
)
),
rx.table.cell(
rx.hstack(
update_customer_dialog(user),
rx.icon_button(
rx.icon("trash-2", size=22),
on_click=lambda: State.delete_customer(user.id),
size="2",
variant="solid",
color_scheme="red",
) | from ..components.status_badges import status_badge |
import reflex as rx
from ..backend.backend import Customer, State
from ..components.form_field import form_field
from ..components.status_badges import status_badge
|
def add_customer_button() -> rx.Component:
return rx.dialog.root(
rx.dialog.trigger(
rx.button(
rx.icon("plus", size=26),
rx.text("Add Customer", size="4", display=["none", "none", "block"]),
size="3",
),
),
rx.dialog.content(
rx.hstack(
rx.badge(
rx.icon(tag="users", size=34),
color_scheme="grass",
radius="full",
padding="0.65rem",
),
rx.vstack(
rx.dialog.title(
"Add New Customer",
weight="bold",
margin="0",
),
rx.dialog.description(
"Fill the form with the customer's info",
),
spacing="1",
height="100%",
align_ite | def show_customer(user: Customer):
"""Show a customer in a table row."""
return rx.table.row(
rx.table.cell(user.name),
rx.table.cell(user.email),
rx.table.cell(user.phone),
rx.table.cell(user.address),
rx.table.cell(f"${user.payments}"),
rx.table.cell(user.date),
rx.table.cell(
rx.match(
user.status,
("Delivered", status_badge("Delivered")),
("Pending", status_badge("Pending")),
("Cancelled", status_badge("Cancelled")),
status_badge("Pending"),
)
),
rx.table.cell(
rx.hstack(
update_customer_dialog(user),
rx.icon_button(
rx.icon("trash-2", size=22),
on_click=lambda: State.delete_customer(user.id),
size="2",
variant="solid",
color_scheme="red",
),
)
),
style={"_hover": {"bg": rx.color("gray", 3)}},
align="center",
) |
"Cancel",
variant="soft",
color_scheme="gray",
),
),
rx.form.submit(
rx.dialog.close(
rx.button("Update Customer"),
),
as_child=True,
),
padding_top="2em",
spacing="3",
mt="4",
justify="end",
),
on_submit=State.update_customer_to_db,
reset_on_submit=False,
),
width="100%",
direction="column",
spacing="4",
),
max_width="450px",
padding="1.5em",
border=f"2px solid {rx.color('accent', 7)}",
border_radius="25px",
),
)
|
def main_table():
return rx.fragment(
rx.flex(
add_customer_button(),
rx.spacer(),
rx.cond(
State.sort_reverse,
rx.icon(
"arrow-down-z-a",
size=28,
stroke_width=1.5,
cursor="pointer",
on_click=State.toggle_sort,
),
rx.icon(
"arrow-down-a-z",
size=28,
stroke_width=1.5,
cursor="pointer",
on_click=State.toggle_sort,
),
),
rx.select(
["name", "email", "phone", "address", "payments", "date", "status"],
placeholder="Sort By: Name",
size="3",
on_change=lambda sort_value: State.sort_values(sort_value),
),
rx.input(
rx.input.slot(rx.icon("searc | def _header_cell(text: str, icon: str):
return rx.table.column_header_cell(
rx.hstack(
rx.icon(icon, size=18),
rx.text(text),
align="center",
spacing="2",
),
) |
"""Welcome to Reflex! This file outlines the steps to create a basic app."""
import os
|
import reflex as rx
_client = None
def get_openai_client():
global _client
if _client is None:
_client = openai.OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
return _client
class State(rx.State):
"""The app state."""
image_url = ""
image_processing = False
image_made = False
def get_dalle_result(self, form_data: dict[str, str]):
prompt_text: str = form_data["prompt_text"]
self.image_made = False
self.image_processing = True
# Yield here so the image_processing take effects and the circular progress is shown.
yield
try:
response = get_openai_client().images.generate(
prompt=prompt_text, n=1, size="1024x1024"
)
self.image_url = response.data[0].url
self.image_processing = False
self.image_made = True
yield
except Exception as ex:
self.image_processing = False
yield rx.window_a | import openai |
"""Welcome to Reflex! This file outlines the steps to create a basic app."""
import os
import openai
|
_client = None
def get_openai_client():
global _client
if _client is None:
_client = openai.OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
return _client
class State(rx.State):
"""The app state."""
image_url = ""
image_processing = False
image_made = False
def get_dalle_result(self, form_data: dict[str, str]):
prompt_text: str = form_data["prompt_text"]
self.image_made = False
self.image_processing = True
# Yield here so the image_processing take effects and the circular progress is shown.
yield
try:
response = get_openai_client().images.generate(
prompt=prompt_text, n=1, size="1024x1024"
)
self.image_url = response.data[0].url
self.image_processing = False
self.image_made = True
yield
except Exception as ex:
self.image_processing = False
yield rx.window_alert(f"Error with Op | import reflex as rx |
"""Welcome to Reflex! This file outlines the steps to create a basic app."""
import os
import openai
import reflex as rx
|
def get_openai_client():
global _client
if _client is None:
_client = openai.OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
return _client
class State(rx.State):
"""The app state."""
image_url = ""
image_processing = False
image_made = False
def get_dalle_result(self, form_data: dict[str, str]):
prompt_text: str = form_data["prompt_text"]
self.image_made = False
self.image_processing = True
# Yield here so the image_processing take effects and the circular progress is shown.
yield
try:
response = get_openai_client().images.generate(
prompt=prompt_text, n=1, size="1024x1024"
)
self.image_url = response.data[0].url
self.image_processing = False
self.image_made = True
yield
except Exception as ex:
self.image_processing = False
yield rx.window_alert(f"Error with OpenAI Execution. | _client = None |
"""Welcome to Reflex! This file outlines the steps to create a basic app."""
import os
import openai
import reflex as rx
_client = None
|
class State(rx.State):
"""The app state."""
image_url = ""
image_processing = False
image_made = False
def get_dalle_result(self, form_data: dict[str, str]):
prompt_text: str = form_data["prompt_text"]
self.image_made = False
self.image_processing = True
# Yield here so the image_processing take effects and the circular progress is shown.
yield
try:
response = get_openai_client().images.generate(
prompt=prompt_text, n=1, size="1024x1024"
)
self.image_url = response.data[0].url
self.image_processing = False
self.image_made = True
yield
except Exception as ex:
self.image_processing = False
yield rx.window_alert(f"Error with OpenAI Execution. {ex}")
def index():
return rx.center(
rx.vstack(
rx.heading("DALL-E", font_size="1.5em"),
rx.form(
rx.vst | def get_openai_client():
global _client
if _client is None:
_client = openai.OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
return _client |
"""Welcome to Reflex! This file outlines the steps to create a basic app."""
import os
import openai
import reflex as rx
_client = None
def get_openai_client():
global _client
|
return _client
class State(rx.State):
"""The app state."""
image_url = ""
image_processing = False
image_made = False
def get_dalle_result(self, form_data: dict[str, str]):
prompt_text: str = form_data["prompt_text"]
self.image_made = False
self.image_processing = True
# Yield here so the image_processing take effects and the circular progress is shown.
yield
try:
response = get_openai_client().images.generate(
prompt=prompt_text, n=1, size="1024x1024"
)
self.image_url = response.data[0].url
self.image_processing = False
self.image_made = True
yield
except Exception as ex:
self.image_processing = False
yield rx.window_alert(f"Error with OpenAI Execution. {ex}")
def index():
return rx.center(
rx.vstack(
rx.heading("DALL-E", font_size="1.5em"),
rx.form(
| if _client is None:
_client = openai.OpenAI(api_key=os.getenv("OPENAI_API_KEY")) |
"""Welcome to Reflex! This file outlines the steps to create a basic app."""
import os
import openai
import reflex as rx
_client = None
def get_openai_client():
global _client
if _client is None:
|
return _client
class State(rx.State):
"""The app state."""
image_url = ""
image_processing = False
image_made = False
def get_dalle_result(self, form_data: dict[str, str]):
prompt_text: str = form_data["prompt_text"]
self.image_made = False
self.image_processing = True
# Yield here so the image_processing take effects and the circular progress is shown.
yield
try:
response = get_openai_client().images.generate(
prompt=prompt_text, n=1, size="1024x1024"
)
self.image_url = response.data[0].url
self.image_processing = False
self.image_made = True
yield
except Exception as ex:
self.image_processing = False
yield rx.window_alert(f"Error with OpenAI Execution. {ex}")
def index():
return rx.center(
rx.vstack(
rx.heading("DALL-E", font_size="1.5em"),
rx.form(
| _client = openai.OpenAI(api_key=os.getenv("OPENAI_API_KEY")) |
"""Welcome to Reflex! This file outlines the steps to create a basic app."""
import os
import openai
import reflex as rx
_client = None
def get_openai_client():
global _client
if _client is None:
_client = openai.OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
return _client
class State(rx.State):
"""The app state."""
image_url = ""
|
image_made = False
def get_dalle_result(self, form_data: dict[str, str]):
prompt_text: str = form_data["prompt_text"]
self.image_made = False
self.image_processing = True
# Yield here so the image_processing take effects and the circular progress is shown.
yield
try:
response = get_openai_client().images.generate(
prompt=prompt_text, n=1, size="1024x1024"
)
self.image_url = response.data[0].url
self.image_processing = False
self.image_made = True
yield
except Exception as ex:
self.image_processing = False
yield rx.window_alert(f"Error with OpenAI Execution. {ex}")
def index():
return rx.center(
rx.vstack(
rx.heading("DALL-E", font_size="1.5em"),
rx.form(
rx.vstack(
rx.input(
id="prompt_text",
| image_processing = False |
"""Welcome to Reflex! This file outlines the steps to create a basic app."""
import os
import openai
import reflex as rx
_client = None
def get_openai_client():
global _client
if _client is None:
_client = openai.OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
return _client
class State(rx.State):
"""The app state."""
image_url = ""
image_processing = False
|
def get_dalle_result(self, form_data: dict[str, str]):
prompt_text: str = form_data["prompt_text"]
self.image_made = False
self.image_processing = True
# Yield here so the image_processing take effects and the circular progress is shown.
yield
try:
response = get_openai_client().images.generate(
prompt=prompt_text, n=1, size="1024x1024"
)
self.image_url = response.data[0].url
self.image_processing = False
self.image_made = True
yield
except Exception as ex:
self.image_processing = False
yield rx.window_alert(f"Error with OpenAI Execution. {ex}")
def index():
return rx.center(
rx.vstack(
rx.heading("DALL-E", font_size="1.5em"),
rx.form(
rx.vstack(
rx.input(
id="prompt_text",
placeholder="Enter a | image_made = False |
"""Welcome to Reflex! This file outlines the steps to create a basic app."""
import os
import openai
import reflex as rx
_client = None
def get_openai_client():
global _client
if _client is None:
_client = openai.OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
return _client
class State(rx.State):
"""The app state."""
image_url = ""
image_processing = False
image_made = False
def get_dalle_result(self, form_data: dict[str, str]):
prompt_text: str = form_data["prompt_text"]
|
self.image_processing = True
# Yield here so the image_processing take effects and the circular progress is shown.
yield
try:
response = get_openai_client().images.generate(
prompt=prompt_text, n=1, size="1024x1024"
)
self.image_url = response.data[0].url
self.image_processing = False
self.image_made = True
yield
except Exception as ex:
self.image_processing = False
yield rx.window_alert(f"Error with OpenAI Execution. {ex}")
def index():
return rx.center(
rx.vstack(
rx.heading("DALL-E", font_size="1.5em"),
rx.form(
rx.vstack(
rx.input(
id="prompt_text",
placeholder="Enter a prompt..",
size="3",
),
rx.button(
"Generate Image",
| self.image_made = False |
"""Welcome to Reflex! This file outlines the steps to create a basic app."""
import os
import openai
import reflex as rx
_client = None
def get_openai_client():
global _client
if _client is None:
_client = openai.OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
return _client
class State(rx.State):
"""The app state."""
image_url = ""
image_processing = False
image_made = False
def get_dalle_result(self, form_data: dict[str, str]):
prompt_text: str = form_data["prompt_text"]
self.image_made = False
|
# Yield here so the image_processing take effects and the circular progress is shown.
yield
try:
response = get_openai_client().images.generate(
prompt=prompt_text, n=1, size="1024x1024"
)
self.image_url = response.data[0].url
self.image_processing = False
self.image_made = True
yield
except Exception as ex:
self.image_processing = False
yield rx.window_alert(f"Error with OpenAI Execution. {ex}")
def index():
return rx.center(
rx.vstack(
rx.heading("DALL-E", font_size="1.5em"),
rx.form(
rx.vstack(
rx.input(
id="prompt_text",
placeholder="Enter a prompt..",
size="3",
),
rx.button(
"Generate Image",
type="submit",
| self.image_processing = True |
"""Welcome to Reflex! This file outlines the steps to create a basic app."""
import os
import openai
import reflex as rx
_client = None
def get_openai_client():
global _client
if _client is None:
_client = openai.OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
return _client
class State(rx.State):
"""The app state."""
image_url = ""
image_processing = False
image_made = False
def get_dalle_result(self, form_data: dict[str, str]):
prompt_text: str = form_data["prompt_text"]
self.image_made = False
self.image_processing = True
# Yield here so the image_processing take effects and the circular progress is shown.
yield
try:
|
self.image_url = response.data[0].url
self.image_processing = False
self.image_made = True
yield
except Exception as ex:
self.image_processing = False
yield rx.window_alert(f"Error with OpenAI Execution. {ex}")
def index():
return rx.center(
rx.vstack(
rx.heading("DALL-E", font_size="1.5em"),
rx.form(
rx.vstack(
rx.input(
id="prompt_text",
placeholder="Enter a prompt..",
size="3",
),
rx.button(
"Generate Image",
type="submit",
size="3",
),
align="stretch",
spacing="2",
),
width="100%",
on_submit=State.get_dalle_result,
),
r | response = get_openai_client().images.generate(
prompt=prompt_text, n=1, size="1024x1024"
) |
"""Welcome to Reflex! This file outlines the steps to create a basic app."""
import os
import openai
import reflex as rx
_client = None
def get_openai_client():
global _client
if _client is None:
_client = openai.OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
return _client
class State(rx.State):
"""The app state."""
image_url = ""
image_processing = False
image_made = False
def get_dalle_result(self, form_data: dict[str, str]):
prompt_text: str = form_data["prompt_text"]
self.image_made = False
self.image_processing = True
# Yield here so the image_processing take effects and the circular progress is shown.
yield
try:
response = get_openai_client().images.generate(
prompt=prompt_text, n=1, size="1024x1024"
)
|
self.image_processing = False
self.image_made = True
yield
except Exception as ex:
self.image_processing = False
yield rx.window_alert(f"Error with OpenAI Execution. {ex}")
def index():
return rx.center(
rx.vstack(
rx.heading("DALL-E", font_size="1.5em"),
rx.form(
rx.vstack(
rx.input(
id="prompt_text",
placeholder="Enter a prompt..",
size="3",
),
rx.button(
"Generate Image",
type="submit",
size="3",
),
align="stretch",
spacing="2",
),
width="100%",
on_submit=State.get_dalle_result,
),
rx.divider(),
rx.cond(
| self.image_url = response.data[0].url |
"""Welcome to Reflex! This file outlines the steps to create a basic app."""
import os
import openai
import reflex as rx
_client = None
def get_openai_client():
global _client
if _client is None:
_client = openai.OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
return _client
class State(rx.State):
"""The app state."""
image_url = ""
image_processing = False
image_made = False
def get_dalle_result(self, form_data: dict[str, str]):
prompt_text: str = form_data["prompt_text"]
self.image_made = False
self.image_processing = True
# Yield here so the image_processing take effects and the circular progress is shown.
yield
try:
response = get_openai_client().images.generate(
prompt=prompt_text, n=1, size="1024x1024"
)
self.image_url = response.data[0].url
|
self.image_made = True
yield
except Exception as ex:
self.image_processing = False
yield rx.window_alert(f"Error with OpenAI Execution. {ex}")
def index():
return rx.center(
rx.vstack(
rx.heading("DALL-E", font_size="1.5em"),
rx.form(
rx.vstack(
rx.input(
id="prompt_text",
placeholder="Enter a prompt..",
size="3",
),
rx.button(
"Generate Image",
type="submit",
size="3",
),
align="stretch",
spacing="2",
),
width="100%",
on_submit=State.get_dalle_result,
),
rx.divider(),
rx.cond(
State.image_processing,
rx | self.image_processing = False |
"""Welcome to Reflex! This file outlines the steps to create a basic app."""
import os
import openai
import reflex as rx
_client = None
def get_openai_client():
global _client
if _client is None:
_client = openai.OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
return _client
class State(rx.State):
"""The app state."""
image_url = ""
image_processing = False
image_made = False
def get_dalle_result(self, form_data: dict[str, str]):
prompt_text: str = form_data["prompt_text"]
self.image_made = False
self.image_processing = True
# Yield here so the image_processing take effects and the circular progress is shown.
yield
try:
response = get_openai_client().images.generate(
prompt=prompt_text, n=1, size="1024x1024"
)
self.image_url = response.data[0].url
self.image_processing = False
|
yield
except Exception as ex:
self.image_processing = False
yield rx.window_alert(f"Error with OpenAI Execution. {ex}")
def index():
return rx.center(
rx.vstack(
rx.heading("DALL-E", font_size="1.5em"),
rx.form(
rx.vstack(
rx.input(
id="prompt_text",
placeholder="Enter a prompt..",
size="3",
),
rx.button(
"Generate Image",
type="submit",
size="3",
),
align="stretch",
spacing="2",
),
width="100%",
on_submit=State.get_dalle_result,
),
rx.divider(),
rx.cond(
State.image_processing,
rx.spinner(),
rx.cond | self.image_made = True |
e steps to create a basic app."""
import os
import openai
import reflex as rx
_client = None
def get_openai_client():
global _client
if _client is None:
_client = openai.OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
return _client
class State(rx.State):
"""The app state."""
image_url = ""
image_processing = False
image_made = False
def get_dalle_result(self, form_data: dict[str, str]):
prompt_text: str = form_data["prompt_text"]
self.image_made = False
self.image_processing = True
# Yield here so the image_processing take effects and the circular progress is shown.
yield
try:
response = get_openai_client().images.generate(
prompt=prompt_text, n=1, size="1024x1024"
)
self.image_url = response.data[0].url
self.image_processing = False
self.image_made = True
yield
except Exception as ex:
|
yield rx.window_alert(f"Error with OpenAI Execution. {ex}")
def index():
return rx.center(
rx.vstack(
rx.heading("DALL-E", font_size="1.5em"),
rx.form(
rx.vstack(
rx.input(
id="prompt_text",
placeholder="Enter a prompt..",
size="3",
),
rx.button(
"Generate Image",
type="submit",
size="3",
),
align="stretch",
spacing="2",
),
width="100%",
on_submit=State.get_dalle_result,
),
rx.divider(),
rx.cond(
State.image_processing,
rx.spinner(),
rx.cond(
State.image_made,
rx.image(
| self.image_processing = False |
size="3",
),
align="stretch",
spacing="2",
),
width="100%",
on_submit=State.get_dalle_result,
),
rx.divider(),
rx.cond(
State.image_processing,
rx.spinner(),
rx.cond(
State.image_made,
rx.image(
src=State.image_url,
),
),
),
width="25em",
bg="white",
padding="2em",
align="center",
),
width="100%",
height="100vh",
background="radial-gradient(circle at 22% 11%,rgba(62, 180, 137,.20),hsla(0,0%,100%,0) 19%),radial-gradient(circle at 82% 25%,rgba(33,150,243,.18),hsla(0,0%,100%,0) 35%),radial-gradient(circle at 25% 61%,rgba(250, 128, 114, .28),hsla(0,0%,100%,0) 55%)",
)
# Add state and page to the app.
|
app.add_page(index, title="Reflex:DALL-E")
| app = rx.App(
theme=rx.theme(
appearance="light", has_background=True, radius="medium", accent_color="mint"
),
) |
"""Welcome to Reflex!."""
# Import all the pages.
|
from . import styles
from .pages import *
# Create the app.
app = rx.App(
style=styles.base_style,
stylesheets=styles.base_stylesheets,
)
| import reflex as rx |
"""Welcome to Reflex!."""
# Import all the pages.
import reflex as rx
|
from .pages import *
# Create the app.
app = rx.App(
style=styles.base_style,
stylesheets=styles.base_stylesheets,
)
| from . import styles |
"""Welcome to Reflex!."""
# Import all the pages.
import reflex as rx
from . import styles
|
# Create the app.
app = rx.App(
style=styles.base_style,
stylesheets=styles.base_stylesheets,
)
| from .pages import * |
"""Styles for the app."""
|
border_radius = "var(--radius-2)"
border = f"1px solid {rx.color('gray', 5)}"
text_color = rx.color("gray", 11)
gray_color = rx.color("gray", 11)
gray_bg_color = rx.color("gray", 3)
accent_text_color = rx.color("accent", 10)
accent_color = rx.color("accent", 1)
accent_bg_color = rx.color("accent", 3)
hover_accent_color = {"_hover": {"color": accent_text_color}}
hover_accent_bg = {"_hover": {"background_color": accent_color}}
content_width_vw = "90vw"
sidebar_width = "32em"
sidebar_content_width = "16em"
max_width = "1480px"
color_box_size = ["2.25rem", "2.25rem", "2.5rem"]
template_page_style = {
"padding_top": ["1em", "1em", "2em"],
"padding_x": ["auto", "auto", "2em"],
}
template_content_style = {
"padding": "1em",
"margin_bottom": "2em",
"min_height": "90vh",
}
link_style = {
"color": accent_text_color,
"text_decoration": "none",
**hover_accent_color,
}
overlapping_button_style = {
"background_color": "white",
"border_radius": border_ra | import reflex as rx |
"""Styles for the app."""
import reflex as rx
|
border = f"1px solid {rx.color('gray', 5)}"
text_color = rx.color("gray", 11)
gray_color = rx.color("gray", 11)
gray_bg_color = rx.color("gray", 3)
accent_text_color = rx.color("accent", 10)
accent_color = rx.color("accent", 1)
accent_bg_color = rx.color("accent", 3)
hover_accent_color = {"_hover": {"color": accent_text_color}}
hover_accent_bg = {"_hover": {"background_color": accent_color}}
content_width_vw = "90vw"
sidebar_width = "32em"
sidebar_content_width = "16em"
max_width = "1480px"
color_box_size = ["2.25rem", "2.25rem", "2.5rem"]
template_page_style = {
"padding_top": ["1em", "1em", "2em"],
"padding_x": ["auto", "auto", "2em"],
}
template_content_style = {
"padding": "1em",
"margin_bottom": "2em",
"min_height": "90vh",
}
link_style = {
"color": accent_text_color,
"text_decoration": "none",
**hover_accent_color,
}
overlapping_button_style = {
"background_color": "white",
"border_radius": border_radius,
}
markdown_style = {
"co | border_radius = "var(--radius-2)" |
"""Styles for the app."""
import reflex as rx
border_radius = "var(--radius-2)"
|
text_color = rx.color("gray", 11)
gray_color = rx.color("gray", 11)
gray_bg_color = rx.color("gray", 3)
accent_text_color = rx.color("accent", 10)
accent_color = rx.color("accent", 1)
accent_bg_color = rx.color("accent", 3)
hover_accent_color = {"_hover": {"color": accent_text_color}}
hover_accent_bg = {"_hover": {"background_color": accent_color}}
content_width_vw = "90vw"
sidebar_width = "32em"
sidebar_content_width = "16em"
max_width = "1480px"
color_box_size = ["2.25rem", "2.25rem", "2.5rem"]
template_page_style = {
"padding_top": ["1em", "1em", "2em"],
"padding_x": ["auto", "auto", "2em"],
}
template_content_style = {
"padding": "1em",
"margin_bottom": "2em",
"min_height": "90vh",
}
link_style = {
"color": accent_text_color,
"text_decoration": "none",
**hover_accent_color,
}
overlapping_button_style = {
"background_color": "white",
"border_radius": border_radius,
}
markdown_style = {
"code": lambda text: rx.code(text, color_scheme | border = f"1px solid {rx.color('gray', 5)}" |
"""Styles for the app."""
import reflex as rx
border_radius = "var(--radius-2)"
border = f"1px solid {rx.color('gray', 5)}"
|
gray_color = rx.color("gray", 11)
gray_bg_color = rx.color("gray", 3)
accent_text_color = rx.color("accent", 10)
accent_color = rx.color("accent", 1)
accent_bg_color = rx.color("accent", 3)
hover_accent_color = {"_hover": {"color": accent_text_color}}
hover_accent_bg = {"_hover": {"background_color": accent_color}}
content_width_vw = "90vw"
sidebar_width = "32em"
sidebar_content_width = "16em"
max_width = "1480px"
color_box_size = ["2.25rem", "2.25rem", "2.5rem"]
template_page_style = {
"padding_top": ["1em", "1em", "2em"],
"padding_x": ["auto", "auto", "2em"],
}
template_content_style = {
"padding": "1em",
"margin_bottom": "2em",
"min_height": "90vh",
}
link_style = {
"color": accent_text_color,
"text_decoration": "none",
**hover_accent_color,
}
overlapping_button_style = {
"background_color": "white",
"border_radius": border_radius,
}
markdown_style = {
"code": lambda text: rx.code(text, color_scheme="gray"),
"codeblock": lambda | text_color = rx.color("gray", 11) |
"""Styles for the app."""
import reflex as rx
border_radius = "var(--radius-2)"
border = f"1px solid {rx.color('gray', 5)}"
text_color = rx.color("gray", 11)
|
gray_bg_color = rx.color("gray", 3)
accent_text_color = rx.color("accent", 10)
accent_color = rx.color("accent", 1)
accent_bg_color = rx.color("accent", 3)
hover_accent_color = {"_hover": {"color": accent_text_color}}
hover_accent_bg = {"_hover": {"background_color": accent_color}}
content_width_vw = "90vw"
sidebar_width = "32em"
sidebar_content_width = "16em"
max_width = "1480px"
color_box_size = ["2.25rem", "2.25rem", "2.5rem"]
template_page_style = {
"padding_top": ["1em", "1em", "2em"],
"padding_x": ["auto", "auto", "2em"],
}
template_content_style = {
"padding": "1em",
"margin_bottom": "2em",
"min_height": "90vh",
}
link_style = {
"color": accent_text_color,
"text_decoration": "none",
**hover_accent_color,
}
overlapping_button_style = {
"background_color": "white",
"border_radius": border_radius,
}
markdown_style = {
"code": lambda text: rx.code(text, color_scheme="gray"),
"codeblock": lambda text, **props: rx.code_block(text, | gray_color = rx.color("gray", 11) |
"""Styles for the app."""
import reflex as rx
border_radius = "var(--radius-2)"
border = f"1px solid {rx.color('gray', 5)}"
text_color = rx.color("gray", 11)
gray_color = rx.color("gray", 11)
|
accent_text_color = rx.color("accent", 10)
accent_color = rx.color("accent", 1)
accent_bg_color = rx.color("accent", 3)
hover_accent_color = {"_hover": {"color": accent_text_color}}
hover_accent_bg = {"_hover": {"background_color": accent_color}}
content_width_vw = "90vw"
sidebar_width = "32em"
sidebar_content_width = "16em"
max_width = "1480px"
color_box_size = ["2.25rem", "2.25rem", "2.5rem"]
template_page_style = {
"padding_top": ["1em", "1em", "2em"],
"padding_x": ["auto", "auto", "2em"],
}
template_content_style = {
"padding": "1em",
"margin_bottom": "2em",
"min_height": "90vh",
}
link_style = {
"color": accent_text_color,
"text_decoration": "none",
**hover_accent_color,
}
overlapping_button_style = {
"background_color": "white",
"border_radius": border_radius,
}
markdown_style = {
"code": lambda text: rx.code(text, color_scheme="gray"),
"codeblock": lambda text, **props: rx.code_block(text, **props, margin_y="1em"),
"a": | gray_bg_color = rx.color("gray", 3) |
"""Styles for the app."""
import reflex as rx
border_radius = "var(--radius-2)"
border = f"1px solid {rx.color('gray', 5)}"
text_color = rx.color("gray", 11)
gray_color = rx.color("gray", 11)
gray_bg_color = rx.color("gray", 3)
|
accent_color = rx.color("accent", 1)
accent_bg_color = rx.color("accent", 3)
hover_accent_color = {"_hover": {"color": accent_text_color}}
hover_accent_bg = {"_hover": {"background_color": accent_color}}
content_width_vw = "90vw"
sidebar_width = "32em"
sidebar_content_width = "16em"
max_width = "1480px"
color_box_size = ["2.25rem", "2.25rem", "2.5rem"]
template_page_style = {
"padding_top": ["1em", "1em", "2em"],
"padding_x": ["auto", "auto", "2em"],
}
template_content_style = {
"padding": "1em",
"margin_bottom": "2em",
"min_height": "90vh",
}
link_style = {
"color": accent_text_color,
"text_decoration": "none",
**hover_accent_color,
}
overlapping_button_style = {
"background_color": "white",
"border_radius": border_radius,
}
markdown_style = {
"code": lambda text: rx.code(text, color_scheme="gray"),
"codeblock": lambda text, **props: rx.code_block(text, **props, margin_y="1em"),
"a": lambda text, **props: rx.link(
text | accent_text_color = rx.color("accent", 10) |
"""Styles for the app."""
import reflex as rx
border_radius = "var(--radius-2)"
border = f"1px solid {rx.color('gray', 5)}"
text_color = rx.color("gray", 11)
gray_color = rx.color("gray", 11)
gray_bg_color = rx.color("gray", 3)
accent_text_color = rx.color("accent", 10)
|
accent_bg_color = rx.color("accent", 3)
hover_accent_color = {"_hover": {"color": accent_text_color}}
hover_accent_bg = {"_hover": {"background_color": accent_color}}
content_width_vw = "90vw"
sidebar_width = "32em"
sidebar_content_width = "16em"
max_width = "1480px"
color_box_size = ["2.25rem", "2.25rem", "2.5rem"]
template_page_style = {
"padding_top": ["1em", "1em", "2em"],
"padding_x": ["auto", "auto", "2em"],
}
template_content_style = {
"padding": "1em",
"margin_bottom": "2em",
"min_height": "90vh",
}
link_style = {
"color": accent_text_color,
"text_decoration": "none",
**hover_accent_color,
}
overlapping_button_style = {
"background_color": "white",
"border_radius": border_radius,
}
markdown_style = {
"code": lambda text: rx.code(text, color_scheme="gray"),
"codeblock": lambda text, **props: rx.code_block(text, **props, margin_y="1em"),
"a": lambda text, **props: rx.link(
text,
**props,
font_weigh | accent_color = rx.color("accent", 1) |
"""Styles for the app."""
import reflex as rx
border_radius = "var(--radius-2)"
border = f"1px solid {rx.color('gray', 5)}"
text_color = rx.color("gray", 11)
gray_color = rx.color("gray", 11)
gray_bg_color = rx.color("gray", 3)
accent_text_color = rx.color("accent", 10)
accent_color = rx.color("accent", 1)
|
hover_accent_color = {"_hover": {"color": accent_text_color}}
hover_accent_bg = {"_hover": {"background_color": accent_color}}
content_width_vw = "90vw"
sidebar_width = "32em"
sidebar_content_width = "16em"
max_width = "1480px"
color_box_size = ["2.25rem", "2.25rem", "2.5rem"]
template_page_style = {
"padding_top": ["1em", "1em", "2em"],
"padding_x": ["auto", "auto", "2em"],
}
template_content_style = {
"padding": "1em",
"margin_bottom": "2em",
"min_height": "90vh",
}
link_style = {
"color": accent_text_color,
"text_decoration": "none",
**hover_accent_color,
}
overlapping_button_style = {
"background_color": "white",
"border_radius": border_radius,
}
markdown_style = {
"code": lambda text: rx.code(text, color_scheme="gray"),
"codeblock": lambda text, **props: rx.code_block(text, **props, margin_y="1em"),
"a": lambda text, **props: rx.link(
text,
**props,
font_weight="bold",
text_decoration="under | accent_bg_color = rx.color("accent", 3) |
"""Styles for the app."""
import reflex as rx
border_radius = "var(--radius-2)"
border = f"1px solid {rx.color('gray', 5)}"
text_color = rx.color("gray", 11)
gray_color = rx.color("gray", 11)
gray_bg_color = rx.color("gray", 3)
accent_text_color = rx.color("accent", 10)
accent_color = rx.color("accent", 1)
accent_bg_color = rx.color("accent", 3)
|
hover_accent_bg = {"_hover": {"background_color": accent_color}}
content_width_vw = "90vw"
sidebar_width = "32em"
sidebar_content_width = "16em"
max_width = "1480px"
color_box_size = ["2.25rem", "2.25rem", "2.5rem"]
template_page_style = {
"padding_top": ["1em", "1em", "2em"],
"padding_x": ["auto", "auto", "2em"],
}
template_content_style = {
"padding": "1em",
"margin_bottom": "2em",
"min_height": "90vh",
}
link_style = {
"color": accent_text_color,
"text_decoration": "none",
**hover_accent_color,
}
overlapping_button_style = {
"background_color": "white",
"border_radius": border_radius,
}
markdown_style = {
"code": lambda text: rx.code(text, color_scheme="gray"),
"codeblock": lambda text, **props: rx.code_block(text, **props, margin_y="1em"),
"a": lambda text, **props: rx.link(
text,
**props,
font_weight="bold",
text_decoration="underline",
text_decoration_color=accent_text_color,
), | hover_accent_color = {"_hover": {"color": accent_text_color}} |
"""Styles for the app."""
import reflex as rx
border_radius = "var(--radius-2)"
border = f"1px solid {rx.color('gray', 5)}"
text_color = rx.color("gray", 11)
gray_color = rx.color("gray", 11)
gray_bg_color = rx.color("gray", 3)
accent_text_color = rx.color("accent", 10)
accent_color = rx.color("accent", 1)
accent_bg_color = rx.color("accent", 3)
hover_accent_color = {"_hover": {"color": accent_text_color}}
|
content_width_vw = "90vw"
sidebar_width = "32em"
sidebar_content_width = "16em"
max_width = "1480px"
color_box_size = ["2.25rem", "2.25rem", "2.5rem"]
template_page_style = {
"padding_top": ["1em", "1em", "2em"],
"padding_x": ["auto", "auto", "2em"],
}
template_content_style = {
"padding": "1em",
"margin_bottom": "2em",
"min_height": "90vh",
}
link_style = {
"color": accent_text_color,
"text_decoration": "none",
**hover_accent_color,
}
overlapping_button_style = {
"background_color": "white",
"border_radius": border_radius,
}
markdown_style = {
"code": lambda text: rx.code(text, color_scheme="gray"),
"codeblock": lambda text, **props: rx.code_block(text, **props, margin_y="1em"),
"a": lambda text, **props: rx.link(
text,
**props,
font_weight="bold",
text_decoration="underline",
text_decoration_color=accent_text_color,
),
}
notification_badge_style = {
"width": "1.25rem",
"hei | hover_accent_bg = {"_hover": {"background_color": accent_color}} |
"""Styles for the app."""
import reflex as rx
border_radius = "var(--radius-2)"
border = f"1px solid {rx.color('gray', 5)}"
text_color = rx.color("gray", 11)
gray_color = rx.color("gray", 11)
gray_bg_color = rx.color("gray", 3)
accent_text_color = rx.color("accent", 10)
accent_color = rx.color("accent", 1)
accent_bg_color = rx.color("accent", 3)
hover_accent_color = {"_hover": {"color": accent_text_color}}
hover_accent_bg = {"_hover": {"background_color": accent_color}}
|
sidebar_width = "32em"
sidebar_content_width = "16em"
max_width = "1480px"
color_box_size = ["2.25rem", "2.25rem", "2.5rem"]
template_page_style = {
"padding_top": ["1em", "1em", "2em"],
"padding_x": ["auto", "auto", "2em"],
}
template_content_style = {
"padding": "1em",
"margin_bottom": "2em",
"min_height": "90vh",
}
link_style = {
"color": accent_text_color,
"text_decoration": "none",
**hover_accent_color,
}
overlapping_button_style = {
"background_color": "white",
"border_radius": border_radius,
}
markdown_style = {
"code": lambda text: rx.code(text, color_scheme="gray"),
"codeblock": lambda text, **props: rx.code_block(text, **props, margin_y="1em"),
"a": lambda text, **props: rx.link(
text,
**props,
font_weight="bold",
text_decoration="underline",
text_decoration_color=accent_text_color,
),
}
notification_badge_style = {
"width": "1.25rem",
"height": "1.25rem",
"disp | content_width_vw = "90vw" |
"""Styles for the app."""
import reflex as rx
border_radius = "var(--radius-2)"
border = f"1px solid {rx.color('gray', 5)}"
text_color = rx.color("gray", 11)
gray_color = rx.color("gray", 11)
gray_bg_color = rx.color("gray", 3)
accent_text_color = rx.color("accent", 10)
accent_color = rx.color("accent", 1)
accent_bg_color = rx.color("accent", 3)
hover_accent_color = {"_hover": {"color": accent_text_color}}
hover_accent_bg = {"_hover": {"background_color": accent_color}}
content_width_vw = "90vw"
|
sidebar_content_width = "16em"
max_width = "1480px"
color_box_size = ["2.25rem", "2.25rem", "2.5rem"]
template_page_style = {
"padding_top": ["1em", "1em", "2em"],
"padding_x": ["auto", "auto", "2em"],
}
template_content_style = {
"padding": "1em",
"margin_bottom": "2em",
"min_height": "90vh",
}
link_style = {
"color": accent_text_color,
"text_decoration": "none",
**hover_accent_color,
}
overlapping_button_style = {
"background_color": "white",
"border_radius": border_radius,
}
markdown_style = {
"code": lambda text: rx.code(text, color_scheme="gray"),
"codeblock": lambda text, **props: rx.code_block(text, **props, margin_y="1em"),
"a": lambda text, **props: rx.link(
text,
**props,
font_weight="bold",
text_decoration="underline",
text_decoration_color=accent_text_color,
),
}
notification_badge_style = {
"width": "1.25rem",
"height": "1.25rem",
"display": "flex",
"alig | sidebar_width = "32em" |
"""Styles for the app."""
import reflex as rx
border_radius = "var(--radius-2)"
border = f"1px solid {rx.color('gray', 5)}"
text_color = rx.color("gray", 11)
gray_color = rx.color("gray", 11)
gray_bg_color = rx.color("gray", 3)
accent_text_color = rx.color("accent", 10)
accent_color = rx.color("accent", 1)
accent_bg_color = rx.color("accent", 3)
hover_accent_color = {"_hover": {"color": accent_text_color}}
hover_accent_bg = {"_hover": {"background_color": accent_color}}
content_width_vw = "90vw"
sidebar_width = "32em"
|
max_width = "1480px"
color_box_size = ["2.25rem", "2.25rem", "2.5rem"]
template_page_style = {
"padding_top": ["1em", "1em", "2em"],
"padding_x": ["auto", "auto", "2em"],
}
template_content_style = {
"padding": "1em",
"margin_bottom": "2em",
"min_height": "90vh",
}
link_style = {
"color": accent_text_color,
"text_decoration": "none",
**hover_accent_color,
}
overlapping_button_style = {
"background_color": "white",
"border_radius": border_radius,
}
markdown_style = {
"code": lambda text: rx.code(text, color_scheme="gray"),
"codeblock": lambda text, **props: rx.code_block(text, **props, margin_y="1em"),
"a": lambda text, **props: rx.link(
text,
**props,
font_weight="bold",
text_decoration="underline",
text_decoration_color=accent_text_color,
),
}
notification_badge_style = {
"width": "1.25rem",
"height": "1.25rem",
"display": "flex",
"align_items": "center",
"justif | sidebar_content_width = "16em" |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.