instruction stringlengths 0 1k | input stringlengths 1 1k | output stringlengths 10 6.51k |
|---|---|---|
from business_analytics_dashboard.states.dashboard_state import DashboardState
def pagination_controls() -> rx.Component:
"""Component for table pagination controls."""
return rx.el.div(
rx.el.span(
f"Page {DashboardState.current_page} of {DashboardState.total_pages}",
class_name="text-sm text-gray-700 mr-4",
),
rx.el.button(
"Previous",
on_click=DashboardState.previous_page,
disabled=DashboardState.current_page <= 1,
class_name="px-4 py-2 text-sm font-medium text-gray-700 bg-white border border-gray-300 rounded-l-md hover:bg-gray-50 disabled:opacity-50 disabled:cursor-not-allowed",
),
rx.el.button(
"Next",
on_click=DashboardState.next_page,
disabled=DashboardState.current_page >= DashboardState.total_pages,
class_name="px-4 py-2 text-sm font-medium text-gray-700 bg-white border-t border-b border-r border-gray-300 ro | import reflex as rx | |
import reflex as rx
|
def pagination_controls() -> rx.Component:
"""Component for table pagination controls."""
return rx.el.div(
rx.el.span(
f"Page {DashboardState.current_page} of {DashboardState.total_pages}",
class_name="text-sm text-gray-700 mr-4",
),
rx.el.button(
"Previous",
on_click=DashboardState.previous_page,
disabled=DashboardState.current_page <= 1,
class_name="px-4 py-2 text-sm font-medium text-gray-700 bg-white border border-gray-300 rounded-l-md hover:bg-gray-50 disabled:opacity-50 disabled:cursor-not-allowed",
),
rx.el.button(
"Next",
on_click=DashboardState.next_page,
disabled=DashboardState.current_page >= DashboardState.total_pages,
class_name="px-4 py-2 text-sm font-medium text-gray-700 bg-white border-t border-b border-r border-gray-300 rounded-r-md hover:bg-gray-50 disabled:opacity-50 disabled:cursor-not-allowed",
| from business_analytics_dashboard.states.dashboard_state import DashboardState |
import reflex.components.recharts as recharts
from business_analytics_dashboard.components.tooltip_props import TOOLTIP_PROPS
from business_analytics_dashboard.states.dashboard_state import DashboardState
def average_salary_bar_chart() -> rx.Component:
"""A bar chart showing the average salary per department."""
return rx.el.div(
rx.el.h2(
"Average Salary by Department",
class_name="text-lg font-semibold text-gray-800 mb-4 text-center",
),
rx.cond(
DashboardState.loading,
rx.el.p(
"Loading chart data...",
class_name="text-gray-500 text-center",
),
rx.cond(
DashboardState.average_salary_by_department.length() > 0,
recharts.bar_chart(
recharts.graphing_tooltip(**TOOLTIP_PROPS),
recharts.cartesian_grid(
horizontal=True,
vertical=Fals | import reflex as rx | |
import reflex as rx
|
from business_analytics_dashboard.components.tooltip_props import TOOLTIP_PROPS
from business_analytics_dashboard.states.dashboard_state import DashboardState
def average_salary_bar_chart() -> rx.Component:
"""A bar chart showing the average salary per department."""
return rx.el.div(
rx.el.h2(
"Average Salary by Department",
class_name="text-lg font-semibold text-gray-800 mb-4 text-center",
),
rx.cond(
DashboardState.loading,
rx.el.p(
"Loading chart data...",
class_name="text-gray-500 text-center",
),
rx.cond(
DashboardState.average_salary_by_department.length() > 0,
recharts.bar_chart(
recharts.graphing_tooltip(**TOOLTIP_PROPS),
recharts.cartesian_grid(
horizontal=True,
vertical=False,
class_name="opacity | import reflex.components.recharts as recharts |
import reflex as rx
import reflex.components.recharts as recharts
|
from business_analytics_dashboard.states.dashboard_state import DashboardState
def average_salary_bar_chart() -> rx.Component:
"""A bar chart showing the average salary per department."""
return rx.el.div(
rx.el.h2(
"Average Salary by Department",
class_name="text-lg font-semibold text-gray-800 mb-4 text-center",
),
rx.cond(
DashboardState.loading,
rx.el.p(
"Loading chart data...",
class_name="text-gray-500 text-center",
),
rx.cond(
DashboardState.average_salary_by_department.length() > 0,
recharts.bar_chart(
recharts.graphing_tooltip(**TOOLTIP_PROPS),
recharts.cartesian_grid(
horizontal=True,
vertical=False,
class_name="opacity-25",
stroke=rx.color("gray", 7),
),
| from business_analytics_dashboard.components.tooltip_props import TOOLTIP_PROPS |
import reflex as rx
import reflex.components.recharts as recharts
from business_analytics_dashboard.components.tooltip_props import TOOLTIP_PROPS
|
def average_salary_bar_chart() -> rx.Component:
"""A bar chart showing the average salary per department."""
return rx.el.div(
rx.el.h2(
"Average Salary by Department",
class_name="text-lg font-semibold text-gray-800 mb-4 text-center",
),
rx.cond(
DashboardState.loading,
rx.el.p(
"Loading chart data...",
class_name="text-gray-500 text-center",
),
rx.cond(
DashboardState.average_salary_by_department.length() > 0,
recharts.bar_chart(
recharts.graphing_tooltip(**TOOLTIP_PROPS),
recharts.cartesian_grid(
horizontal=True,
vertical=False,
class_name="opacity-25",
stroke=rx.color("gray", 7),
),
recharts.bar(
rx.foreach(
| from business_analytics_dashboard.states.dashboard_state import DashboardState |
import reflex.components.recharts as recharts
from business_analytics_dashboard.components.tooltip_props import TOOLTIP_PROPS
from business_analytics_dashboard.states.dashboard_state import DashboardState
def department_pie_chart() -> rx.Component:
"""A pie chart showing the distribution of employees by department."""
return rx.el.div(
rx.el.h2(
"Department Distribution",
class_name="text-lg font-semibold text-gray-800 mb-4 text-center",
),
rx.cond(
DashboardState.loading,
rx.el.p(
"Loading chart data...",
class_name="text-gray-500 text-center",
),
rx.cond(
DashboardState.department_distribution.length() > 0,
recharts.pie_chart(
recharts.graphing_tooltip(**TOOLTIP_PROPS),
recharts.pie(
rx.foreach(
DashboardState.department_dis | import reflex as rx | |
import reflex as rx
|
from business_analytics_dashboard.components.tooltip_props import TOOLTIP_PROPS
from business_analytics_dashboard.states.dashboard_state import DashboardState
def department_pie_chart() -> rx.Component:
"""A pie chart showing the distribution of employees by department."""
return rx.el.div(
rx.el.h2(
"Department Distribution",
class_name="text-lg font-semibold text-gray-800 mb-4 text-center",
),
rx.cond(
DashboardState.loading,
rx.el.p(
"Loading chart data...",
class_name="text-gray-500 text-center",
),
rx.cond(
DashboardState.department_distribution.length() > 0,
recharts.pie_chart(
recharts.graphing_tooltip(**TOOLTIP_PROPS),
recharts.pie(
rx.foreach(
DashboardState.department_distribution,
lambda | import reflex.components.recharts as recharts |
import reflex as rx
import reflex.components.recharts as recharts
|
from business_analytics_dashboard.states.dashboard_state import DashboardState
def department_pie_chart() -> rx.Component:
"""A pie chart showing the distribution of employees by department."""
return rx.el.div(
rx.el.h2(
"Department Distribution",
class_name="text-lg font-semibold text-gray-800 mb-4 text-center",
),
rx.cond(
DashboardState.loading,
rx.el.p(
"Loading chart data...",
class_name="text-gray-500 text-center",
),
rx.cond(
DashboardState.department_distribution.length() > 0,
recharts.pie_chart(
recharts.graphing_tooltip(**TOOLTIP_PROPS),
recharts.pie(
rx.foreach(
DashboardState.department_distribution,
lambda data_point, _: recharts.cell(
fill=DashboardState | from business_analytics_dashboard.components.tooltip_props import TOOLTIP_PROPS |
import reflex as rx
import reflex.components.recharts as recharts
from business_analytics_dashboard.components.tooltip_props import TOOLTIP_PROPS
|
def department_pie_chart() -> rx.Component:
"""A pie chart showing the distribution of employees by department."""
return rx.el.div(
rx.el.h2(
"Department Distribution",
class_name="text-lg font-semibold text-gray-800 mb-4 text-center",
),
rx.cond(
DashboardState.loading,
rx.el.p(
"Loading chart data...",
class_name="text-gray-500 text-center",
),
rx.cond(
DashboardState.department_distribution.length() > 0,
recharts.pie_chart(
recharts.graphing_tooltip(**TOOLTIP_PROPS),
recharts.pie(
rx.foreach(
DashboardState.department_distribution,
lambda data_point, _: recharts.cell(
fill=DashboardState.department_color_map.get(
data_point["name | from business_analytics_dashboard.states.dashboard_state import DashboardState |
def sidebar_link(text: str, url: str, is_active: bool) -> rx.Component:
"""Creates a sidebar link component."""
return rx.el.a(
rx.el.div(
text,
class_name=rx.cond(
is_active,
"bg-gray-200 px-4 py-2 rounded-md cursor-pointer",
"hover:bg-gray-50 px-4 py-2 rounded-md cursor-pointer transition-colors",
),
),
href=url,
class_name="w-full",
)
def sidebar() -> rx.Component:
"""The sidebar component for the dashboard."""
return rx.el.div(
rx.el.div(
rx.el.label("Analytics", class_name="text-lg font-bold"),
class_name="px-6 py-2 mb-4 flex justify-start",
),
rx.el.nav(
sidebar_link("Sales Performance", "#", False),
sidebar_link("Business Analytics", "#", True),
sidebar_link("Financial Reporting", "#", False),
sidebar_link("Marketing Analytics", "#", False),
| import reflex as rx | |
TOOLTIP_PROPS = {
"separator": "",
"cursor": False,
"is_animation_active": False,
"label_style": {"fontWeight": "500"},
"item_style": {
"color": "currentColor",
"display": "flex",
"paddingBottom": "0px",
"justifyContent": "space-between",
"textTransform": "capitalize",
},
"content_style": {
"borderRadius": "5px",
"boxShadow": "0px 24px 12px 0px light-dark(rgba(28, 32, 36, 0.02), rgba(0, 0, 0, 0.00)), 0px 8px 8px 0px light-dark(rgba(28, 32, 36, 0.02), rgba(0, 0, 0, 0.00)), 0px 2px 6px 0px light-dark(rgba(28, 32, 36, 0.02), rgba(0, 0, 0, 0.00))",
"fontFamily": "var(--font-instrument-sans)",
"fontSize": "0.875rem",
"lineHeight": "1.25rem",
"fontWeight": "500",
"letterSpacing": "-0.01rem",
"minWidth": "8rem",
"width": "200px",
"padding": "0.375rem 0.625rem",
"position": "relative",
"background": rx.color("gray", 1),
"b | import reflex as rx | |
import math
import random
import statistics
from collections import Counter, defaultdict
from typing import Dict, List, TypedDict
import reflex as rx
from faker import Faker
from business_analytics_dashboard.models.employee import Employee
fake = Faker()
class DepartmentData(TypedDict):
name: str
value: int
class AverageSalaryData(TypedDict):
department: str
average_salary: float
class DashboardState(rx.State):
"""State for the dashboard."""
employees: List[Employee] = []
search_query: str = ""
selected_department: str = "All"
loading: bool = False
_base_department_colors: list[str] = [
"#FF6347",
"#4CAF50",
"#FFEB3B",
"#2196F3",
"#9C27B0",
"#FFC107",
"#8BC34A",
"#FF9800",
"#F44336",
"#00BCD4",
]
current_page: int = 1
items_per_page: int = 10
@rx.event(background=True)
async def fetch_dashboard_data(self):
"""Generate fake data | import asyncio | |
import asyncio
|
import random
import statistics
from collections import Counter, defaultdict
from typing import Dict, List, TypedDict
import reflex as rx
from faker import Faker
from business_analytics_dashboard.models.employee import Employee
fake = Faker()
class DepartmentData(TypedDict):
name: str
value: int
class AverageSalaryData(TypedDict):
department: str
average_salary: float
class DashboardState(rx.State):
"""State for the dashboard."""
employees: List[Employee] = []
search_query: str = ""
selected_department: str = "All"
loading: bool = False
_base_department_colors: list[str] = [
"#FF6347",
"#4CAF50",
"#FFEB3B",
"#2196F3",
"#9C27B0",
"#FFC107",
"#8BC34A",
"#FF9800",
"#F44336",
"#00BCD4",
]
current_page: int = 1
items_per_page: int = 10
@rx.event(background=True)
async def fetch_dashboard_data(self):
"""Generate fake data for the dash | import math |
import asyncio
import math
|
import statistics
from collections import Counter, defaultdict
from typing import Dict, List, TypedDict
import reflex as rx
from faker import Faker
from business_analytics_dashboard.models.employee import Employee
fake = Faker()
class DepartmentData(TypedDict):
name: str
value: int
class AverageSalaryData(TypedDict):
department: str
average_salary: float
class DashboardState(rx.State):
"""State for the dashboard."""
employees: List[Employee] = []
search_query: str = ""
selected_department: str = "All"
loading: bool = False
_base_department_colors: list[str] = [
"#FF6347",
"#4CAF50",
"#FFEB3B",
"#2196F3",
"#9C27B0",
"#FFC107",
"#8BC34A",
"#FF9800",
"#F44336",
"#00BCD4",
]
current_page: int = 1
items_per_page: int = 10
@rx.event(background=True)
async def fetch_dashboard_data(self):
"""Generate fake data for the dashboard."""
| import random |
import asyncio
import math
import random
|
from collections import Counter, defaultdict
from typing import Dict, List, TypedDict
import reflex as rx
from faker import Faker
from business_analytics_dashboard.models.employee import Employee
fake = Faker()
class DepartmentData(TypedDict):
name: str
value: int
class AverageSalaryData(TypedDict):
department: str
average_salary: float
class DashboardState(rx.State):
"""State for the dashboard."""
employees: List[Employee] = []
search_query: str = ""
selected_department: str = "All"
loading: bool = False
_base_department_colors: list[str] = [
"#FF6347",
"#4CAF50",
"#FFEB3B",
"#2196F3",
"#9C27B0",
"#FFC107",
"#8BC34A",
"#FF9800",
"#F44336",
"#00BCD4",
]
current_page: int = 1
items_per_page: int = 10
@rx.event(background=True)
async def fetch_dashboard_data(self):
"""Generate fake data for the dashboard."""
async with sel | import statistics |
import asyncio
import math
import random
import statistics
|
from typing import Dict, List, TypedDict
import reflex as rx
from faker import Faker
from business_analytics_dashboard.models.employee import Employee
fake = Faker()
class DepartmentData(TypedDict):
name: str
value: int
class AverageSalaryData(TypedDict):
department: str
average_salary: float
class DashboardState(rx.State):
"""State for the dashboard."""
employees: List[Employee] = []
search_query: str = ""
selected_department: str = "All"
loading: bool = False
_base_department_colors: list[str] = [
"#FF6347",
"#4CAF50",
"#FFEB3B",
"#2196F3",
"#9C27B0",
"#FFC107",
"#8BC34A",
"#FF9800",
"#F44336",
"#00BCD4",
]
current_page: int = 1
items_per_page: int = 10
@rx.event(background=True)
async def fetch_dashboard_data(self):
"""Generate fake data for the dashboard."""
async with self:
self.loading = True
| from collections import Counter, defaultdict |
import asyncio
import math
import random
import statistics
from collections import Counter, defaultdict
|
import reflex as rx
from faker import Faker
from business_analytics_dashboard.models.employee import Employee
fake = Faker()
class DepartmentData(TypedDict):
name: str
value: int
class AverageSalaryData(TypedDict):
department: str
average_salary: float
class DashboardState(rx.State):
"""State for the dashboard."""
employees: List[Employee] = []
search_query: str = ""
selected_department: str = "All"
loading: bool = False
_base_department_colors: list[str] = [
"#FF6347",
"#4CAF50",
"#FFEB3B",
"#2196F3",
"#9C27B0",
"#FFC107",
"#8BC34A",
"#FF9800",
"#F44336",
"#00BCD4",
]
current_page: int = 1
items_per_page: int = 10
@rx.event(background=True)
async def fetch_dashboard_data(self):
"""Generate fake data for the dashboard."""
async with self:
self.loading = True
self.current_page = 1
await asy | from typing import Dict, List, TypedDict |
import asyncio
import math
import random
import statistics
from collections import Counter, defaultdict
from typing import Dict, List, TypedDict
|
from faker import Faker
from business_analytics_dashboard.models.employee import Employee
fake = Faker()
class DepartmentData(TypedDict):
name: str
value: int
class AverageSalaryData(TypedDict):
department: str
average_salary: float
class DashboardState(rx.State):
"""State for the dashboard."""
employees: List[Employee] = []
search_query: str = ""
selected_department: str = "All"
loading: bool = False
_base_department_colors: list[str] = [
"#FF6347",
"#4CAF50",
"#FFEB3B",
"#2196F3",
"#9C27B0",
"#FFC107",
"#8BC34A",
"#FF9800",
"#F44336",
"#00BCD4",
]
current_page: int = 1
items_per_page: int = 10
@rx.event(background=True)
async def fetch_dashboard_data(self):
"""Generate fake data for the dashboard."""
async with self:
self.loading = True
self.current_page = 1
await asyncio.sleep(0.5)
| import reflex as rx |
import asyncio
import math
import random
import statistics
from collections import Counter, defaultdict
from typing import Dict, List, TypedDict
import reflex as rx
|
from business_analytics_dashboard.models.employee import Employee
fake = Faker()
class DepartmentData(TypedDict):
name: str
value: int
class AverageSalaryData(TypedDict):
department: str
average_salary: float
class DashboardState(rx.State):
"""State for the dashboard."""
employees: List[Employee] = []
search_query: str = ""
selected_department: str = "All"
loading: bool = False
_base_department_colors: list[str] = [
"#FF6347",
"#4CAF50",
"#FFEB3B",
"#2196F3",
"#9C27B0",
"#FFC107",
"#8BC34A",
"#FF9800",
"#F44336",
"#00BCD4",
]
current_page: int = 1
items_per_page: int = 10
@rx.event(background=True)
async def fetch_dashboard_data(self):
"""Generate fake data for the dashboard."""
async with self:
self.loading = True
self.current_page = 1
await asyncio.sleep(0.5)
await self._generate_ | from faker import Faker |
import asyncio
import math
import random
import statistics
from collections import Counter, defaultdict
from typing import Dict, List, TypedDict
import reflex as rx
from faker import Faker
|
fake = Faker()
class DepartmentData(TypedDict):
name: str
value: int
class AverageSalaryData(TypedDict):
department: str
average_salary: float
class DashboardState(rx.State):
"""State for the dashboard."""
employees: List[Employee] = []
search_query: str = ""
selected_department: str = "All"
loading: bool = False
_base_department_colors: list[str] = [
"#FF6347",
"#4CAF50",
"#FFEB3B",
"#2196F3",
"#9C27B0",
"#FFC107",
"#8BC34A",
"#FF9800",
"#F44336",
"#00BCD4",
]
current_page: int = 1
items_per_page: int = 10
@rx.event(background=True)
async def fetch_dashboard_data(self):
"""Generate fake data for the dashboard."""
async with self:
self.loading = True
self.current_page = 1
await asyncio.sleep(0.5)
await self._generate_fake_data()
async with self:
self.loading = Fal | from business_analytics_dashboard.models.employee import Employee |
import asyncio
import math
import random
import statistics
from collections import Counter, defaultdict
from typing import Dict, List, TypedDict
import reflex as rx
from faker import Faker
from business_analytics_dashboard.models.employee import Employee
|
class DepartmentData(TypedDict):
name: str
value: int
class AverageSalaryData(TypedDict):
department: str
average_salary: float
class DashboardState(rx.State):
"""State for the dashboard."""
employees: List[Employee] = []
search_query: str = ""
selected_department: str = "All"
loading: bool = False
_base_department_colors: list[str] = [
"#FF6347",
"#4CAF50",
"#FFEB3B",
"#2196F3",
"#9C27B0",
"#FFC107",
"#8BC34A",
"#FF9800",
"#F44336",
"#00BCD4",
]
current_page: int = 1
items_per_page: int = 10
@rx.event(background=True)
async def fetch_dashboard_data(self):
"""Generate fake data for the dashboard."""
async with self:
self.loading = True
self.current_page = 1
await asyncio.sleep(0.5)
await self._generate_fake_data()
async with self:
self.loading = False
async de | fake = Faker() |
import asyncio
import math
import random
import statistics
from collections import Counter, defaultdict
from typing import Dict, List, TypedDict
import reflex as rx
from faker import Faker
from business_analytics_dashboard.models.employee import Employee
fake = Faker()
|
class AverageSalaryData(TypedDict):
department: str
average_salary: float
class DashboardState(rx.State):
"""State for the dashboard."""
employees: List[Employee] = []
search_query: str = ""
selected_department: str = "All"
loading: bool = False
_base_department_colors: list[str] = [
"#FF6347",
"#4CAF50",
"#FFEB3B",
"#2196F3",
"#9C27B0",
"#FFC107",
"#8BC34A",
"#FF9800",
"#F44336",
"#00BCD4",
]
current_page: int = 1
items_per_page: int = 10
@rx.event(background=True)
async def fetch_dashboard_data(self):
"""Generate fake data for the dashboard."""
async with self:
self.loading = True
self.current_page = 1
await asyncio.sleep(0.5)
await self._generate_fake_data()
async with self:
self.loading = False
async def _generate_fake_data(self):
"""Helper method to generat | class DepartmentData(TypedDict):
name: str
value: int |
import asyncio
import math
import random
import statistics
from collections import Counter, defaultdict
from typing import Dict, List, TypedDict
import reflex as rx
from faker import Faker
from business_analytics_dashboard.models.employee import Employee
fake = Faker()
class DepartmentData(TypedDict):
name: str
value: int
|
class DashboardState(rx.State):
"""State for the dashboard."""
employees: List[Employee] = []
search_query: str = ""
selected_department: str = "All"
loading: bool = False
_base_department_colors: list[str] = [
"#FF6347",
"#4CAF50",
"#FFEB3B",
"#2196F3",
"#9C27B0",
"#FFC107",
"#8BC34A",
"#FF9800",
"#F44336",
"#00BCD4",
]
current_page: int = 1
items_per_page: int = 10
@rx.event(background=True)
async def fetch_dashboard_data(self):
"""Generate fake data for the dashboard."""
async with self:
self.loading = True
self.current_page = 1
await asyncio.sleep(0.5)
await self._generate_fake_data()
async with self:
self.loading = False
async def _generate_fake_data(self):
"""Helper method to generate fake employee data."""
departments = [
"Sales",
"M | class AverageSalaryData(TypedDict):
department: str
average_salary: float |
rom typing import Dict, List, TypedDict
import reflex as rx
from faker import Faker
from business_analytics_dashboard.models.employee import Employee
fake = Faker()
class DepartmentData(TypedDict):
name: str
value: int
class AverageSalaryData(TypedDict):
department: str
average_salary: float
class DashboardState(rx.State):
"""State for the dashboard."""
employees: List[Employee] = []
search_query: str = ""
selected_department: str = "All"
loading: bool = False
_base_department_colors: list[str] = [
"#FF6347",
"#4CAF50",
"#FFEB3B",
"#2196F3",
"#9C27B0",
"#FFC107",
"#8BC34A",
"#FF9800",
"#F44336",
"#00BCD4",
]
current_page: int = 1
items_per_page: int = 10
@rx.event(background=True)
async def fetch_dashboard_data(self):
"""Generate fake data for the dashboard."""
async with self:
self.loading = True
|
await asyncio.sleep(0.5)
await self._generate_fake_data()
async with self:
self.loading = False
async def _generate_fake_data(self):
"""Helper method to generate fake employee data."""
departments = [
"Sales",
"Marketing",
"Engineering",
"Support",
"HR",
"Finance",
"Product",
"Design",
"Operations",
"Legal",
]
employees_data = []
for i in range(1, 101):
first_name = fake.first_name()
last_name = fake.last_name()
department = random.choice(departments)
employees_data.append(
Employee(
employee_id=1000 + i,
first_name=first_name,
last_name=last_name,
email=fake.email(),
department=department,
salary=random.ra | self.current_page = 1 |
ee import Employee
fake = Faker()
class DepartmentData(TypedDict):
name: str
value: int
class AverageSalaryData(TypedDict):
department: str
average_salary: float
class DashboardState(rx.State):
"""State for the dashboard."""
employees: List[Employee] = []
search_query: str = ""
selected_department: str = "All"
loading: bool = False
_base_department_colors: list[str] = [
"#FF6347",
"#4CAF50",
"#FFEB3B",
"#2196F3",
"#9C27B0",
"#FFC107",
"#8BC34A",
"#FF9800",
"#F44336",
"#00BCD4",
]
current_page: int = 1
items_per_page: int = 10
@rx.event(background=True)
async def fetch_dashboard_data(self):
"""Generate fake data for the dashboard."""
async with self:
self.loading = True
self.current_page = 1
await asyncio.sleep(0.5)
await self._generate_fake_data()
async with self:
|
async def _generate_fake_data(self):
"""Helper method to generate fake employee data."""
departments = [
"Sales",
"Marketing",
"Engineering",
"Support",
"HR",
"Finance",
"Product",
"Design",
"Operations",
"Legal",
]
employees_data = []
for i in range(1, 101):
first_name = fake.first_name()
last_name = fake.last_name()
department = random.choice(departments)
employees_data.append(
Employee(
employee_id=1000 + i,
first_name=first_name,
last_name=last_name,
email=fake.email(),
department=department,
salary=random.randint(50000, 150000),
projects_closed=random.randint(0, 20),
pending_projects=random.randint | self.loading = False |
ment_colors: list[str] = [
"#FF6347",
"#4CAF50",
"#FFEB3B",
"#2196F3",
"#9C27B0",
"#FFC107",
"#8BC34A",
"#FF9800",
"#F44336",
"#00BCD4",
]
current_page: int = 1
items_per_page: int = 10
@rx.event(background=True)
async def fetch_dashboard_data(self):
"""Generate fake data for the dashboard."""
async with self:
self.loading = True
self.current_page = 1
await asyncio.sleep(0.5)
await self._generate_fake_data()
async with self:
self.loading = False
async def _generate_fake_data(self):
"""Helper method to generate fake employee data."""
departments = [
"Sales",
"Marketing",
"Engineering",
"Support",
"HR",
"Finance",
"Product",
"Design",
"Operations",
"Legal",
]
|
for i in range(1, 101):
first_name = fake.first_name()
last_name = fake.last_name()
department = random.choice(departments)
employees_data.append(
Employee(
employee_id=1000 + i,
first_name=first_name,
last_name=last_name,
email=fake.email(),
department=department,
salary=random.randint(50000, 150000),
projects_closed=random.randint(0, 20),
pending_projects=random.randint(0, 5),
)
)
async with self:
self.employees = employees_data
@rx.var
def available_departments(self) -> list[str]:
"""Get a sorted list of unique departments including 'All'."""
if not self.employees:
return ["All"]
departments = sorted({emp["department"] for emp in self.employees})
return [ | employees_data = [] |
"#FF6347",
"#4CAF50",
"#FFEB3B",
"#2196F3",
"#9C27B0",
"#FFC107",
"#8BC34A",
"#FF9800",
"#F44336",
"#00BCD4",
]
current_page: int = 1
items_per_page: int = 10
@rx.event(background=True)
async def fetch_dashboard_data(self):
"""Generate fake data for the dashboard."""
async with self:
self.loading = True
self.current_page = 1
await asyncio.sleep(0.5)
await self._generate_fake_data()
async with self:
self.loading = False
async def _generate_fake_data(self):
"""Helper method to generate fake employee data."""
departments = [
"Sales",
"Marketing",
"Engineering",
"Support",
"HR",
"Finance",
"Product",
"Design",
"Operations",
"Legal",
]
employees_data = []
|
async with self:
self.employees = employees_data
@rx.var
def available_departments(self) -> list[str]:
"""Get a sorted list of unique departments including 'All'."""
if not self.employees:
return ["All"]
departments = sorted({emp["department"] for emp in self.employees})
return ["All", *departments]
@rx.var
def departments_for_filter(self) -> list[str]:
"""Get a sorted list of unique departments excluding 'All'."""
return [dept for dept in self.available_departments if dept != "All"]
@rx.var
def department_color_map(self) -> Dict[str, str]:
"""Maps each department to a consistent color."""
departments = self.departments_for_filter
color_map = {}
num_colors = len(self._base_department_colors)
for i, dept in enumerate(departments):
color_map[dept] = self._base_department_colors[i % num_colors]
return color_map
@rx.var | for i in range(1, 101):
first_name = fake.first_name()
last_name = fake.last_name()
department = random.choice(departments)
employees_data.append(
Employee(
employee_id=1000 + i,
first_name=first_name,
last_name=last_name,
email=fake.email(),
department=department,
salary=random.randint(50000, 150000),
projects_closed=random.randint(0, 20),
pending_projects=random.randint(0, 5),
)
) |
"#FFEB3B",
"#2196F3",
"#9C27B0",
"#FFC107",
"#8BC34A",
"#FF9800",
"#F44336",
"#00BCD4",
]
current_page: int = 1
items_per_page: int = 10
@rx.event(background=True)
async def fetch_dashboard_data(self):
"""Generate fake data for the dashboard."""
async with self:
self.loading = True
self.current_page = 1
await asyncio.sleep(0.5)
await self._generate_fake_data()
async with self:
self.loading = False
async def _generate_fake_data(self):
"""Helper method to generate fake employee data."""
departments = [
"Sales",
"Marketing",
"Engineering",
"Support",
"HR",
"Finance",
"Product",
"Design",
"Operations",
"Legal",
]
employees_data = []
for i in range(1, 101):
|
last_name = fake.last_name()
department = random.choice(departments)
employees_data.append(
Employee(
employee_id=1000 + i,
first_name=first_name,
last_name=last_name,
email=fake.email(),
department=department,
salary=random.randint(50000, 150000),
projects_closed=random.randint(0, 20),
pending_projects=random.randint(0, 5),
)
)
async with self:
self.employees = employees_data
@rx.var
def available_departments(self) -> list[str]:
"""Get a sorted list of unique departments including 'All'."""
if not self.employees:
return ["All"]
departments = sorted({emp["department"] for emp in self.employees})
return ["All", *departments]
@rx.var
def departments_for_filter(self) -> l | first_name = fake.first_name() |
"#8BC34A",
"#FF9800",
"#F44336",
"#00BCD4",
]
current_page: int = 1
items_per_page: int = 10
@rx.event(background=True)
async def fetch_dashboard_data(self):
"""Generate fake data for the dashboard."""
async with self:
self.loading = True
self.current_page = 1
await asyncio.sleep(0.5)
await self._generate_fake_data()
async with self:
self.loading = False
async def _generate_fake_data(self):
"""Helper method to generate fake employee data."""
departments = [
"Sales",
"Marketing",
"Engineering",
"Support",
"HR",
"Finance",
"Product",
"Design",
"Operations",
"Legal",
]
employees_data = []
for i in range(1, 101):
first_name = fake.first_name()
last_name = fake.last_name()
|
employees_data.append(
Employee(
employee_id=1000 + i,
first_name=first_name,
last_name=last_name,
email=fake.email(),
department=department,
salary=random.randint(50000, 150000),
projects_closed=random.randint(0, 20),
pending_projects=random.randint(0, 5),
)
)
async with self:
self.employees = employees_data
@rx.var
def available_departments(self) -> list[str]:
"""Get a sorted list of unique departments including 'All'."""
if not self.employees:
return ["All"]
departments = sorted({emp["department"] for emp in self.employees})
return ["All", *departments]
@rx.var
def departments_for_filter(self) -> list[str]:
"""Get a sorted list of unique departments excluding 'All'."""
retu | department = random.choice(departments) |
te fake employee data."""
departments = [
"Sales",
"Marketing",
"Engineering",
"Support",
"HR",
"Finance",
"Product",
"Design",
"Operations",
"Legal",
]
employees_data = []
for i in range(1, 101):
first_name = fake.first_name()
last_name = fake.last_name()
department = random.choice(departments)
employees_data.append(
Employee(
employee_id=1000 + i,
first_name=first_name,
last_name=last_name,
email=fake.email(),
department=department,
salary=random.randint(50000, 150000),
projects_closed=random.randint(0, 20),
pending_projects=random.randint(0, 5),
)
)
async with self:
|
@rx.var
def available_departments(self) -> list[str]:
"""Get a sorted list of unique departments including 'All'."""
if not self.employees:
return ["All"]
departments = sorted({emp["department"] for emp in self.employees})
return ["All", *departments]
@rx.var
def departments_for_filter(self) -> list[str]:
"""Get a sorted list of unique departments excluding 'All'."""
return [dept for dept in self.available_departments if dept != "All"]
@rx.var
def department_color_map(self) -> Dict[str, str]:
"""Maps each department to a consistent color."""
departments = self.departments_for_filter
color_map = {}
num_colors = len(self._base_department_colors)
for i, dept in enumerate(departments):
color_map[dept] = self._base_department_colors[i % num_colors]
return color_map
@rx.var
def filtered_employees(self) -> List[Employee]:
"""Filte | self.employees = employees_data |
"Sales",
"Marketing",
"Engineering",
"Support",
"HR",
"Finance",
"Product",
"Design",
"Operations",
"Legal",
]
employees_data = []
for i in range(1, 101):
first_name = fake.first_name()
last_name = fake.last_name()
department = random.choice(departments)
employees_data.append(
Employee(
employee_id=1000 + i,
first_name=first_name,
last_name=last_name,
email=fake.email(),
department=department,
salary=random.randint(50000, 150000),
projects_closed=random.randint(0, 20),
pending_projects=random.randint(0, 5),
)
)
async with self:
self.employees = employees_data
@rx.var
|
@rx.var
def departments_for_filter(self) -> list[str]:
"""Get a sorted list of unique departments excluding 'All'."""
return [dept for dept in self.available_departments if dept != "All"]
@rx.var
def department_color_map(self) -> Dict[str, str]:
"""Maps each department to a consistent color."""
departments = self.departments_for_filter
color_map = {}
num_colors = len(self._base_department_colors)
for i, dept in enumerate(departments):
color_map[dept] = self._base_department_colors[i % num_colors]
return color_map
@rx.var
def filtered_employees(self) -> List[Employee]:
"""Filter employees based on search query and selected department."""
filtered = self.employees
if self.selected_department != "All":
filtered = [
emp for emp in filtered if emp["department"] == self.selected_department
]
if self.search_query:
| def available_departments(self) -> list[str]:
"""Get a sorted list of unique departments including 'All'."""
if not self.employees:
return ["All"]
departments = sorted({emp["department"] for emp in self.employees})
return ["All", *departments] |
"Finance",
"Product",
"Design",
"Operations",
"Legal",
]
employees_data = []
for i in range(1, 101):
first_name = fake.first_name()
last_name = fake.last_name()
department = random.choice(departments)
employees_data.append(
Employee(
employee_id=1000 + i,
first_name=first_name,
last_name=last_name,
email=fake.email(),
department=department,
salary=random.randint(50000, 150000),
projects_closed=random.randint(0, 20),
pending_projects=random.randint(0, 5),
)
)
async with self:
self.employees = employees_data
@rx.var
def available_departments(self) -> list[str]:
"""Get a sorted list of unique departments including 'All'."""
|
departments = sorted({emp["department"] for emp in self.employees})
return ["All", *departments]
@rx.var
def departments_for_filter(self) -> list[str]:
"""Get a sorted list of unique departments excluding 'All'."""
return [dept for dept in self.available_departments if dept != "All"]
@rx.var
def department_color_map(self) -> Dict[str, str]:
"""Maps each department to a consistent color."""
departments = self.departments_for_filter
color_map = {}
num_colors = len(self._base_department_colors)
for i, dept in enumerate(departments):
color_map[dept] = self._base_department_colors[i % num_colors]
return color_map
@rx.var
def filtered_employees(self) -> List[Employee]:
"""Filter employees based on search query and selected department."""
filtered = self.employees
if self.selected_department != "All":
filtered = [
emp for e | if not self.employees:
return ["All"] |
"Operations",
"Legal",
]
employees_data = []
for i in range(1, 101):
first_name = fake.first_name()
last_name = fake.last_name()
department = random.choice(departments)
employees_data.append(
Employee(
employee_id=1000 + i,
first_name=first_name,
last_name=last_name,
email=fake.email(),
department=department,
salary=random.randint(50000, 150000),
projects_closed=random.randint(0, 20),
pending_projects=random.randint(0, 5),
)
)
async with self:
self.employees = employees_data
@rx.var
def available_departments(self) -> list[str]:
"""Get a sorted list of unique departments including 'All'."""
if not self.employees:
return ["All"]
|
return ["All", *departments]
@rx.var
def departments_for_filter(self) -> list[str]:
"""Get a sorted list of unique departments excluding 'All'."""
return [dept for dept in self.available_departments if dept != "All"]
@rx.var
def department_color_map(self) -> Dict[str, str]:
"""Maps each department to a consistent color."""
departments = self.departments_for_filter
color_map = {}
num_colors = len(self._base_department_colors)
for i, dept in enumerate(departments):
color_map[dept] = self._base_department_colors[i % num_colors]
return color_map
@rx.var
def filtered_employees(self) -> List[Employee]:
"""Filter employees based on search query and selected department."""
filtered = self.employees
if self.selected_department != "All":
filtered = [
emp for emp in filtered if emp["department"] == self.selected_department
| departments = sorted({emp["department"] for emp in self.employees}) |
first_name = fake.first_name()
last_name = fake.last_name()
department = random.choice(departments)
employees_data.append(
Employee(
employee_id=1000 + i,
first_name=first_name,
last_name=last_name,
email=fake.email(),
department=department,
salary=random.randint(50000, 150000),
projects_closed=random.randint(0, 20),
pending_projects=random.randint(0, 5),
)
)
async with self:
self.employees = employees_data
@rx.var
def available_departments(self) -> list[str]:
"""Get a sorted list of unique departments including 'All'."""
if not self.employees:
return ["All"]
departments = sorted({emp["department"] for emp in self.employees})
return ["All", *departments]
@rx.var
|
@rx.var
def department_color_map(self) -> Dict[str, str]:
"""Maps each department to a consistent color."""
departments = self.departments_for_filter
color_map = {}
num_colors = len(self._base_department_colors)
for i, dept in enumerate(departments):
color_map[dept] = self._base_department_colors[i % num_colors]
return color_map
@rx.var
def filtered_employees(self) -> List[Employee]:
"""Filter employees based on search query and selected department."""
filtered = self.employees
if self.selected_department != "All":
filtered = [
emp for emp in filtered if emp["department"] == self.selected_department
]
if self.search_query:
search_lower = self.search_query.lower()
filtered = [
emp
for emp in filtered
if search_lower in emp["first_name"].lower()
or sear | def departments_for_filter(self) -> list[str]:
"""Get a sorted list of unique departments excluding 'All'."""
return [dept for dept in self.available_departments if dept != "All"] |
mployee_id=1000 + i,
first_name=first_name,
last_name=last_name,
email=fake.email(),
department=department,
salary=random.randint(50000, 150000),
projects_closed=random.randint(0, 20),
pending_projects=random.randint(0, 5),
)
)
async with self:
self.employees = employees_data
@rx.var
def available_departments(self) -> list[str]:
"""Get a sorted list of unique departments including 'All'."""
if not self.employees:
return ["All"]
departments = sorted({emp["department"] for emp in self.employees})
return ["All", *departments]
@rx.var
def departments_for_filter(self) -> list[str]:
"""Get a sorted list of unique departments excluding 'All'."""
return [dept for dept in self.available_departments if dept != "All"]
@rx.var
|
@rx.var
def filtered_employees(self) -> List[Employee]:
"""Filter employees based on search query and selected department."""
filtered = self.employees
if self.selected_department != "All":
filtered = [
emp for emp in filtered if emp["department"] == self.selected_department
]
if self.search_query:
search_lower = self.search_query.lower()
filtered = [
emp
for emp in filtered
if search_lower in emp["first_name"].lower()
or search_lower in emp["last_name"].lower()
or search_lower in emp["email"].lower()
or (search_lower in emp["department"].lower())
or (search_lower in str(emp["salary"]))
or (search_lower in str(emp["projects_closed"]))
or (search_lower in str(emp["pending_projects"]))
]
return filtered
@rx.var
de | def department_color_map(self) -> Dict[str, str]:
"""Maps each department to a consistent color."""
departments = self.departments_for_filter
color_map = {}
num_colors = len(self._base_department_colors)
for i, dept in enumerate(departments):
color_map[dept] = self._base_department_colors[i % num_colors]
return color_map |
email=fake.email(),
department=department,
salary=random.randint(50000, 150000),
projects_closed=random.randint(0, 20),
pending_projects=random.randint(0, 5),
)
)
async with self:
self.employees = employees_data
@rx.var
def available_departments(self) -> list[str]:
"""Get a sorted list of unique departments including 'All'."""
if not self.employees:
return ["All"]
departments = sorted({emp["department"] for emp in self.employees})
return ["All", *departments]
@rx.var
def departments_for_filter(self) -> list[str]:
"""Get a sorted list of unique departments excluding 'All'."""
return [dept for dept in self.available_departments if dept != "All"]
@rx.var
def department_color_map(self) -> Dict[str, str]:
"""Maps each department to a consistent color."""
|
color_map = {}
num_colors = len(self._base_department_colors)
for i, dept in enumerate(departments):
color_map[dept] = self._base_department_colors[i % num_colors]
return color_map
@rx.var
def filtered_employees(self) -> List[Employee]:
"""Filter employees based on search query and selected department."""
filtered = self.employees
if self.selected_department != "All":
filtered = [
emp for emp in filtered if emp["department"] == self.selected_department
]
if self.search_query:
search_lower = self.search_query.lower()
filtered = [
emp
for emp in filtered
if search_lower in emp["first_name"].lower()
or search_lower in emp["last_name"].lower()
or search_lower in emp["email"].lower()
or (search_lower in emp["department"].lower())
or | departments = self.departments_for_filter |
epartment=department,
salary=random.randint(50000, 150000),
projects_closed=random.randint(0, 20),
pending_projects=random.randint(0, 5),
)
)
async with self:
self.employees = employees_data
@rx.var
def available_departments(self) -> list[str]:
"""Get a sorted list of unique departments including 'All'."""
if not self.employees:
return ["All"]
departments = sorted({emp["department"] for emp in self.employees})
return ["All", *departments]
@rx.var
def departments_for_filter(self) -> list[str]:
"""Get a sorted list of unique departments excluding 'All'."""
return [dept for dept in self.available_departments if dept != "All"]
@rx.var
def department_color_map(self) -> Dict[str, str]:
"""Maps each department to a consistent color."""
departments = self.departments_for_filter
|
num_colors = len(self._base_department_colors)
for i, dept in enumerate(departments):
color_map[dept] = self._base_department_colors[i % num_colors]
return color_map
@rx.var
def filtered_employees(self) -> List[Employee]:
"""Filter employees based on search query and selected department."""
filtered = self.employees
if self.selected_department != "All":
filtered = [
emp for emp in filtered if emp["department"] == self.selected_department
]
if self.search_query:
search_lower = self.search_query.lower()
filtered = [
emp
for emp in filtered
if search_lower in emp["first_name"].lower()
or search_lower in emp["last_name"].lower()
or search_lower in emp["email"].lower()
or (search_lower in emp["department"].lower())
or (search_lower in str(em | color_map = {} |
salary=random.randint(50000, 150000),
projects_closed=random.randint(0, 20),
pending_projects=random.randint(0, 5),
)
)
async with self:
self.employees = employees_data
@rx.var
def available_departments(self) -> list[str]:
"""Get a sorted list of unique departments including 'All'."""
if not self.employees:
return ["All"]
departments = sorted({emp["department"] for emp in self.employees})
return ["All", *departments]
@rx.var
def departments_for_filter(self) -> list[str]:
"""Get a sorted list of unique departments excluding 'All'."""
return [dept for dept in self.available_departments if dept != "All"]
@rx.var
def department_color_map(self) -> Dict[str, str]:
"""Maps each department to a consistent color."""
departments = self.departments_for_filter
color_map = {}
|
for i, dept in enumerate(departments):
color_map[dept] = self._base_department_colors[i % num_colors]
return color_map
@rx.var
def filtered_employees(self) -> List[Employee]:
"""Filter employees based on search query and selected department."""
filtered = self.employees
if self.selected_department != "All":
filtered = [
emp for emp in filtered if emp["department"] == self.selected_department
]
if self.search_query:
search_lower = self.search_query.lower()
filtered = [
emp
for emp in filtered
if search_lower in emp["first_name"].lower()
or search_lower in emp["last_name"].lower()
or search_lower in emp["email"].lower()
or (search_lower in emp["department"].lower())
or (search_lower in str(emp["salary"]))
or (search_lower in str(e | num_colors = len(self._base_department_colors) |
,
projects_closed=random.randint(0, 20),
pending_projects=random.randint(0, 5),
)
)
async with self:
self.employees = employees_data
@rx.var
def available_departments(self) -> list[str]:
"""Get a sorted list of unique departments including 'All'."""
if not self.employees:
return ["All"]
departments = sorted({emp["department"] for emp in self.employees})
return ["All", *departments]
@rx.var
def departments_for_filter(self) -> list[str]:
"""Get a sorted list of unique departments excluding 'All'."""
return [dept for dept in self.available_departments if dept != "All"]
@rx.var
def department_color_map(self) -> Dict[str, str]:
"""Maps each department to a consistent color."""
departments = self.departments_for_filter
color_map = {}
num_colors = len(self._base_department_colors)
|
return color_map
@rx.var
def filtered_employees(self) -> List[Employee]:
"""Filter employees based on search query and selected department."""
filtered = self.employees
if self.selected_department != "All":
filtered = [
emp for emp in filtered if emp["department"] == self.selected_department
]
if self.search_query:
search_lower = self.search_query.lower()
filtered = [
emp
for emp in filtered
if search_lower in emp["first_name"].lower()
or search_lower in emp["last_name"].lower()
or search_lower in emp["email"].lower()
or (search_lower in emp["department"].lower())
or (search_lower in str(emp["salary"]))
or (search_lower in str(emp["projects_closed"]))
or (search_lower in str(emp["pending_projects"]))
]
return fil | for i, dept in enumerate(departments):
color_map[dept] = self._base_department_colors[i % num_colors] |
t(0, 20),
pending_projects=random.randint(0, 5),
)
)
async with self:
self.employees = employees_data
@rx.var
def available_departments(self) -> list[str]:
"""Get a sorted list of unique departments including 'All'."""
if not self.employees:
return ["All"]
departments = sorted({emp["department"] for emp in self.employees})
return ["All", *departments]
@rx.var
def departments_for_filter(self) -> list[str]:
"""Get a sorted list of unique departments excluding 'All'."""
return [dept for dept in self.available_departments if dept != "All"]
@rx.var
def department_color_map(self) -> Dict[str, str]:
"""Maps each department to a consistent color."""
departments = self.departments_for_filter
color_map = {}
num_colors = len(self._base_department_colors)
for i, dept in enumerate(departments):
|
return color_map
@rx.var
def filtered_employees(self) -> List[Employee]:
"""Filter employees based on search query and selected department."""
filtered = self.employees
if self.selected_department != "All":
filtered = [
emp for emp in filtered if emp["department"] == self.selected_department
]
if self.search_query:
search_lower = self.search_query.lower()
filtered = [
emp
for emp in filtered
if search_lower in emp["first_name"].lower()
or search_lower in emp["last_name"].lower()
or search_lower in emp["email"].lower()
or (search_lower in emp["department"].lower())
or (search_lower in str(emp["salary"]))
or (search_lower in str(emp["projects_closed"]))
or (search_lower in str(emp["pending_projects"]))
]
return fil | color_map[dept] = self._base_department_colors[i % num_colors] |
"""Get a sorted list of unique departments including 'All'."""
if not self.employees:
return ["All"]
departments = sorted({emp["department"] for emp in self.employees})
return ["All", *departments]
@rx.var
def departments_for_filter(self) -> list[str]:
"""Get a sorted list of unique departments excluding 'All'."""
return [dept for dept in self.available_departments if dept != "All"]
@rx.var
def department_color_map(self) -> Dict[str, str]:
"""Maps each department to a consistent color."""
departments = self.departments_for_filter
color_map = {}
num_colors = len(self._base_department_colors)
for i, dept in enumerate(departments):
color_map[dept] = self._base_department_colors[i % num_colors]
return color_map
@rx.var
def filtered_employees(self) -> List[Employee]:
"""Filter employees based on search query and selected department."""
|
if self.selected_department != "All":
filtered = [
emp for emp in filtered if emp["department"] == self.selected_department
]
if self.search_query:
search_lower = self.search_query.lower()
filtered = [
emp
for emp in filtered
if search_lower in emp["first_name"].lower()
or search_lower in emp["last_name"].lower()
or search_lower in emp["email"].lower()
or (search_lower in emp["department"].lower())
or (search_lower in str(emp["salary"]))
or (search_lower in str(emp["projects_closed"]))
or (search_lower in str(emp["pending_projects"]))
]
return filtered
@rx.var
def total_pages(self) -> int:
"""Calculate the total number of pages based on filtered employees."""
return math.ceil(len(self.filtered_employees) / self.items_per | filtered = self.employees |
epartments including 'All'."""
if not self.employees:
return ["All"]
departments = sorted({emp["department"] for emp in self.employees})
return ["All", *departments]
@rx.var
def departments_for_filter(self) -> list[str]:
"""Get a sorted list of unique departments excluding 'All'."""
return [dept for dept in self.available_departments if dept != "All"]
@rx.var
def department_color_map(self) -> Dict[str, str]:
"""Maps each department to a consistent color."""
departments = self.departments_for_filter
color_map = {}
num_colors = len(self._base_department_colors)
for i, dept in enumerate(departments):
color_map[dept] = self._base_department_colors[i % num_colors]
return color_map
@rx.var
def filtered_employees(self) -> List[Employee]:
"""Filter employees based on search query and selected department."""
filtered = self.employees
|
if self.search_query:
search_lower = self.search_query.lower()
filtered = [
emp
for emp in filtered
if search_lower in emp["first_name"].lower()
or search_lower in emp["last_name"].lower()
or search_lower in emp["email"].lower()
or (search_lower in emp["department"].lower())
or (search_lower in str(emp["salary"]))
or (search_lower in str(emp["projects_closed"]))
or (search_lower in str(emp["pending_projects"]))
]
return filtered
@rx.var
def total_pages(self) -> int:
"""Calculate the total number of pages based on filtered employees."""
return math.ceil(len(self.filtered_employees) / self.items_per_page)
@rx.var
def paginated_employees(self) -> List[Employee]:
"""Get the employees for the current page."""
start_index = (self.current_page - 1) * | if self.selected_department != "All":
filtered = [
emp for emp in filtered if emp["department"] == self.selected_department
] |
.employees:
return ["All"]
departments = sorted({emp["department"] for emp in self.employees})
return ["All", *departments]
@rx.var
def departments_for_filter(self) -> list[str]:
"""Get a sorted list of unique departments excluding 'All'."""
return [dept for dept in self.available_departments if dept != "All"]
@rx.var
def department_color_map(self) -> Dict[str, str]:
"""Maps each department to a consistent color."""
departments = self.departments_for_filter
color_map = {}
num_colors = len(self._base_department_colors)
for i, dept in enumerate(departments):
color_map[dept] = self._base_department_colors[i % num_colors]
return color_map
@rx.var
def filtered_employees(self) -> List[Employee]:
"""Filter employees based on search query and selected department."""
filtered = self.employees
if self.selected_department != "All":
|
if self.search_query:
search_lower = self.search_query.lower()
filtered = [
emp
for emp in filtered
if search_lower in emp["first_name"].lower()
or search_lower in emp["last_name"].lower()
or search_lower in emp["email"].lower()
or (search_lower in emp["department"].lower())
or (search_lower in str(emp["salary"]))
or (search_lower in str(emp["projects_closed"]))
or (search_lower in str(emp["pending_projects"]))
]
return filtered
@rx.var
def total_pages(self) -> int:
"""Calculate the total number of pages based on filtered employees."""
return math.ceil(len(self.filtered_employees) / self.items_per_page)
@rx.var
def paginated_employees(self) -> List[Employee]:
"""Get the employees for the current page."""
start_index = (self.current_page - 1) * | filtered = [
emp for emp in filtered if emp["department"] == self.selected_department
] |
eturn ["All", *departments]
@rx.var
def departments_for_filter(self) -> list[str]:
"""Get a sorted list of unique departments excluding 'All'."""
return [dept for dept in self.available_departments if dept != "All"]
@rx.var
def department_color_map(self) -> Dict[str, str]:
"""Maps each department to a consistent color."""
departments = self.departments_for_filter
color_map = {}
num_colors = len(self._base_department_colors)
for i, dept in enumerate(departments):
color_map[dept] = self._base_department_colors[i % num_colors]
return color_map
@rx.var
def filtered_employees(self) -> List[Employee]:
"""Filter employees based on search query and selected department."""
filtered = self.employees
if self.selected_department != "All":
filtered = [
emp for emp in filtered if emp["department"] == self.selected_department
]
|
return filtered
@rx.var
def total_pages(self) -> int:
"""Calculate the total number of pages based on filtered employees."""
return math.ceil(len(self.filtered_employees) / self.items_per_page)
@rx.var
def paginated_employees(self) -> List[Employee]:
"""Get the employees for the current page."""
start_index = (self.current_page - 1) * self.items_per_page
end_index = start_index + self.items_per_page
return self.filtered_employees[start_index:end_index]
@rx.var
def department_distribution(
self,
) -> List[DepartmentData]:
"""Calculate the distribution of employees by department based on filters."""
target_employees = self.filtered_employees
if not target_employees:
return []
dept_counts = Counter((emp["department"] for emp in target_employees))
return [
DepartmentData(name=dept, value=count)
for dept, count in dept_co | if self.search_query:
search_lower = self.search_query.lower()
filtered = [
emp
for emp in filtered
if search_lower in emp["first_name"].lower()
or search_lower in emp["last_name"].lower()
or search_lower in emp["email"].lower()
or (search_lower in emp["department"].lower())
or (search_lower in str(emp["salary"]))
or (search_lower in str(emp["projects_closed"]))
or (search_lower in str(emp["pending_projects"]))
] |
rx.var
def departments_for_filter(self) -> list[str]:
"""Get a sorted list of unique departments excluding 'All'."""
return [dept for dept in self.available_departments if dept != "All"]
@rx.var
def department_color_map(self) -> Dict[str, str]:
"""Maps each department to a consistent color."""
departments = self.departments_for_filter
color_map = {}
num_colors = len(self._base_department_colors)
for i, dept in enumerate(departments):
color_map[dept] = self._base_department_colors[i % num_colors]
return color_map
@rx.var
def filtered_employees(self) -> List[Employee]:
"""Filter employees based on search query and selected department."""
filtered = self.employees
if self.selected_department != "All":
filtered = [
emp for emp in filtered if emp["department"] == self.selected_department
]
if self.search_query:
|
filtered = [
emp
for emp in filtered
if search_lower in emp["first_name"].lower()
or search_lower in emp["last_name"].lower()
or search_lower in emp["email"].lower()
or (search_lower in emp["department"].lower())
or (search_lower in str(emp["salary"]))
or (search_lower in str(emp["projects_closed"]))
or (search_lower in str(emp["pending_projects"]))
]
return filtered
@rx.var
def total_pages(self) -> int:
"""Calculate the total number of pages based on filtered employees."""
return math.ceil(len(self.filtered_employees) / self.items_per_page)
@rx.var
def paginated_employees(self) -> List[Employee]:
"""Get the employees for the current page."""
start_index = (self.current_page - 1) * self.items_per_page
end_index = start_index + self.items_per_page
| search_lower = self.search_query.lower() |
tr]:
"""Get a sorted list of unique departments excluding 'All'."""
return [dept for dept in self.available_departments if dept != "All"]
@rx.var
def department_color_map(self) -> Dict[str, str]:
"""Maps each department to a consistent color."""
departments = self.departments_for_filter
color_map = {}
num_colors = len(self._base_department_colors)
for i, dept in enumerate(departments):
color_map[dept] = self._base_department_colors[i % num_colors]
return color_map
@rx.var
def filtered_employees(self) -> List[Employee]:
"""Filter employees based on search query and selected department."""
filtered = self.employees
if self.selected_department != "All":
filtered = [
emp for emp in filtered if emp["department"] == self.selected_department
]
if self.search_query:
search_lower = self.search_query.lower()
|
return filtered
@rx.var
def total_pages(self) -> int:
"""Calculate the total number of pages based on filtered employees."""
return math.ceil(len(self.filtered_employees) / self.items_per_page)
@rx.var
def paginated_employees(self) -> List[Employee]:
"""Get the employees for the current page."""
start_index = (self.current_page - 1) * self.items_per_page
end_index = start_index + self.items_per_page
return self.filtered_employees[start_index:end_index]
@rx.var
def department_distribution(
self,
) -> List[DepartmentData]:
"""Calculate the distribution of employees by department based on filters."""
target_employees = self.filtered_employees
if not target_employees:
return []
dept_counts = Counter((emp["department"] for emp in target_employees))
return [
DepartmentData(name=dept, value=count)
for dept, count in dept_co | filtered = [
emp
for emp in filtered
if search_lower in emp["first_name"].lower()
or search_lower in emp["last_name"].lower()
or search_lower in emp["email"].lower()
or (search_lower in emp["department"].lower())
or (search_lower in str(emp["salary"]))
or (search_lower in str(emp["projects_closed"]))
or (search_lower in str(emp["pending_projects"]))
] |
ap
@rx.var
def filtered_employees(self) -> List[Employee]:
"""Filter employees based on search query and selected department."""
filtered = self.employees
if self.selected_department != "All":
filtered = [
emp for emp in filtered if emp["department"] == self.selected_department
]
if self.search_query:
search_lower = self.search_query.lower()
filtered = [
emp
for emp in filtered
if search_lower in emp["first_name"].lower()
or search_lower in emp["last_name"].lower()
or search_lower in emp["email"].lower()
or (search_lower in emp["department"].lower())
or (search_lower in str(emp["salary"]))
or (search_lower in str(emp["projects_closed"]))
or (search_lower in str(emp["pending_projects"]))
]
return filtered
@rx.var
|
@rx.var
def paginated_employees(self) -> List[Employee]:
"""Get the employees for the current page."""
start_index = (self.current_page - 1) * self.items_per_page
end_index = start_index + self.items_per_page
return self.filtered_employees[start_index:end_index]
@rx.var
def department_distribution(
self,
) -> List[DepartmentData]:
"""Calculate the distribution of employees by department based on filters."""
target_employees = self.filtered_employees
if not target_employees:
return []
dept_counts = Counter((emp["department"] for emp in target_employees))
return [
DepartmentData(name=dept, value=count)
for dept, count in dept_counts.items()
]
@rx.var
def average_salary_by_department(
self,
) -> list[AverageSalaryData]:
"""Calculate the average salary for each department, considering filters."""
if not self. | def total_pages(self) -> int:
"""Calculate the total number of pages based on filtered employees."""
return math.ceil(len(self.filtered_employees) / self.items_per_page) |
d_department != "All":
filtered = [
emp for emp in filtered if emp["department"] == self.selected_department
]
if self.search_query:
search_lower = self.search_query.lower()
filtered = [
emp
for emp in filtered
if search_lower in emp["first_name"].lower()
or search_lower in emp["last_name"].lower()
or search_lower in emp["email"].lower()
or (search_lower in emp["department"].lower())
or (search_lower in str(emp["salary"]))
or (search_lower in str(emp["projects_closed"]))
or (search_lower in str(emp["pending_projects"]))
]
return filtered
@rx.var
def total_pages(self) -> int:
"""Calculate the total number of pages based on filtered employees."""
return math.ceil(len(self.filtered_employees) / self.items_per_page)
@rx.var
|
@rx.var
def department_distribution(
self,
) -> List[DepartmentData]:
"""Calculate the distribution of employees by department based on filters."""
target_employees = self.filtered_employees
if not target_employees:
return []
dept_counts = Counter((emp["department"] for emp in target_employees))
return [
DepartmentData(name=dept, value=count)
for dept, count in dept_counts.items()
]
@rx.var
def average_salary_by_department(
self,
) -> list[AverageSalaryData]:
"""Calculate the average salary for each department, considering filters."""
if not self.employees:
return []
dept_salaries = defaultdict(list)
for emp in self.employees:
dept_salaries[emp["department"]].append(emp["salary"])
avg_salaries = []
for dept in self.departments_for_filter:
salaries = dept_salaries.get(dept, [])
| def paginated_employees(self) -> List[Employee]:
"""Get the employees for the current page."""
start_index = (self.current_page - 1) * self.items_per_page
end_index = start_index + self.items_per_page
return self.filtered_employees[start_index:end_index] |
self.selected_department
]
if self.search_query:
search_lower = self.search_query.lower()
filtered = [
emp
for emp in filtered
if search_lower in emp["first_name"].lower()
or search_lower in emp["last_name"].lower()
or search_lower in emp["email"].lower()
or (search_lower in emp["department"].lower())
or (search_lower in str(emp["salary"]))
or (search_lower in str(emp["projects_closed"]))
or (search_lower in str(emp["pending_projects"]))
]
return filtered
@rx.var
def total_pages(self) -> int:
"""Calculate the total number of pages based on filtered employees."""
return math.ceil(len(self.filtered_employees) / self.items_per_page)
@rx.var
def paginated_employees(self) -> List[Employee]:
"""Get the employees for the current page."""
|
end_index = start_index + self.items_per_page
return self.filtered_employees[start_index:end_index]
@rx.var
def department_distribution(
self,
) -> List[DepartmentData]:
"""Calculate the distribution of employees by department based on filters."""
target_employees = self.filtered_employees
if not target_employees:
return []
dept_counts = Counter((emp["department"] for emp in target_employees))
return [
DepartmentData(name=dept, value=count)
for dept, count in dept_counts.items()
]
@rx.var
def average_salary_by_department(
self,
) -> list[AverageSalaryData]:
"""Calculate the average salary for each department, considering filters."""
if not self.employees:
return []
dept_salaries = defaultdict(list)
for emp in self.employees:
dept_salaries[emp["department"]].append(emp["salary"])
avg | start_index = (self.current_page - 1) * self.items_per_page |
:
search_lower = self.search_query.lower()
filtered = [
emp
for emp in filtered
if search_lower in emp["first_name"].lower()
or search_lower in emp["last_name"].lower()
or search_lower in emp["email"].lower()
or (search_lower in emp["department"].lower())
or (search_lower in str(emp["salary"]))
or (search_lower in str(emp["projects_closed"]))
or (search_lower in str(emp["pending_projects"]))
]
return filtered
@rx.var
def total_pages(self) -> int:
"""Calculate the total number of pages based on filtered employees."""
return math.ceil(len(self.filtered_employees) / self.items_per_page)
@rx.var
def paginated_employees(self) -> List[Employee]:
"""Get the employees for the current page."""
start_index = (self.current_page - 1) * self.items_per_page
|
return self.filtered_employees[start_index:end_index]
@rx.var
def department_distribution(
self,
) -> List[DepartmentData]:
"""Calculate the distribution of employees by department based on filters."""
target_employees = self.filtered_employees
if not target_employees:
return []
dept_counts = Counter((emp["department"] for emp in target_employees))
return [
DepartmentData(name=dept, value=count)
for dept, count in dept_counts.items()
]
@rx.var
def average_salary_by_department(
self,
) -> list[AverageSalaryData]:
"""Calculate the average salary for each department, considering filters."""
if not self.employees:
return []
dept_salaries = defaultdict(list)
for emp in self.employees:
dept_salaries[emp["department"]].append(emp["salary"])
avg_salaries = []
for dept in self.departments_fo | end_index = start_index + self.items_per_page |
n filtered
if search_lower in emp["first_name"].lower()
or search_lower in emp["last_name"].lower()
or search_lower in emp["email"].lower()
or (search_lower in emp["department"].lower())
or (search_lower in str(emp["salary"]))
or (search_lower in str(emp["projects_closed"]))
or (search_lower in str(emp["pending_projects"]))
]
return filtered
@rx.var
def total_pages(self) -> int:
"""Calculate the total number of pages based on filtered employees."""
return math.ceil(len(self.filtered_employees) / self.items_per_page)
@rx.var
def paginated_employees(self) -> List[Employee]:
"""Get the employees for the current page."""
start_index = (self.current_page - 1) * self.items_per_page
end_index = start_index + self.items_per_page
return self.filtered_employees[start_index:end_index]
@rx.var
|
@rx.var
def average_salary_by_department(
self,
) -> list[AverageSalaryData]:
"""Calculate the average salary for each department, considering filters."""
if not self.employees:
return []
dept_salaries = defaultdict(list)
for emp in self.employees:
dept_salaries[emp["department"]].append(emp["salary"])
avg_salaries = []
for dept in self.departments_for_filter:
salaries = dept_salaries.get(dept, [])
if salaries:
avg_salary = statistics.mean(salaries)
avg_salaries.append(
AverageSalaryData(
department=dept,
average_salary=round(avg_salary, 2),
)
)
else:
pass
if self.selected_department != "All":
avg_salaries = [
item
for item in avg_salaries
if | def department_distribution(
self,
) -> List[DepartmentData]:
"""Calculate the distribution of employees by department based on filters."""
target_employees = self.filtered_employees
if not target_employees:
return []
dept_counts = Counter((emp["department"] for emp in target_employees))
return [
DepartmentData(name=dept, value=count)
for dept, count in dept_counts.items()
] |
mp["email"].lower()
or (search_lower in emp["department"].lower())
or (search_lower in str(emp["salary"]))
or (search_lower in str(emp["projects_closed"]))
or (search_lower in str(emp["pending_projects"]))
]
return filtered
@rx.var
def total_pages(self) -> int:
"""Calculate the total number of pages based on filtered employees."""
return math.ceil(len(self.filtered_employees) / self.items_per_page)
@rx.var
def paginated_employees(self) -> List[Employee]:
"""Get the employees for the current page."""
start_index = (self.current_page - 1) * self.items_per_page
end_index = start_index + self.items_per_page
return self.filtered_employees[start_index:end_index]
@rx.var
def department_distribution(
self,
) -> List[DepartmentData]:
"""Calculate the distribution of employees by department based on filters."""
|
if not target_employees:
return []
dept_counts = Counter((emp["department"] for emp in target_employees))
return [
DepartmentData(name=dept, value=count)
for dept, count in dept_counts.items()
]
@rx.var
def average_salary_by_department(
self,
) -> list[AverageSalaryData]:
"""Calculate the average salary for each department, considering filters."""
if not self.employees:
return []
dept_salaries = defaultdict(list)
for emp in self.employees:
dept_salaries[emp["department"]].append(emp["salary"])
avg_salaries = []
for dept in self.departments_for_filter:
salaries = dept_salaries.get(dept, [])
if salaries:
avg_salary = statistics.mean(salaries)
avg_salaries.append(
AverageSalaryData(
department=dept,
average_ | target_employees = self.filtered_employees |
r in emp["department"].lower())
or (search_lower in str(emp["salary"]))
or (search_lower in str(emp["projects_closed"]))
or (search_lower in str(emp["pending_projects"]))
]
return filtered
@rx.var
def total_pages(self) -> int:
"""Calculate the total number of pages based on filtered employees."""
return math.ceil(len(self.filtered_employees) / self.items_per_page)
@rx.var
def paginated_employees(self) -> List[Employee]:
"""Get the employees for the current page."""
start_index = (self.current_page - 1) * self.items_per_page
end_index = start_index + self.items_per_page
return self.filtered_employees[start_index:end_index]
@rx.var
def department_distribution(
self,
) -> List[DepartmentData]:
"""Calculate the distribution of employees by department based on filters."""
target_employees = self.filtered_employees
|
dept_counts = Counter((emp["department"] for emp in target_employees))
return [
DepartmentData(name=dept, value=count)
for dept, count in dept_counts.items()
]
@rx.var
def average_salary_by_department(
self,
) -> list[AverageSalaryData]:
"""Calculate the average salary for each department, considering filters."""
if not self.employees:
return []
dept_salaries = defaultdict(list)
for emp in self.employees:
dept_salaries[emp["department"]].append(emp["salary"])
avg_salaries = []
for dept in self.departments_for_filter:
salaries = dept_salaries.get(dept, [])
if salaries:
avg_salary = statistics.mean(salaries)
avg_salaries.append(
AverageSalaryData(
department=dept,
average_salary=round(avg_salary, 2),
)
| if not target_employees:
return [] |
rch_lower in str(emp["salary"]))
or (search_lower in str(emp["projects_closed"]))
or (search_lower in str(emp["pending_projects"]))
]
return filtered
@rx.var
def total_pages(self) -> int:
"""Calculate the total number of pages based on filtered employees."""
return math.ceil(len(self.filtered_employees) / self.items_per_page)
@rx.var
def paginated_employees(self) -> List[Employee]:
"""Get the employees for the current page."""
start_index = (self.current_page - 1) * self.items_per_page
end_index = start_index + self.items_per_page
return self.filtered_employees[start_index:end_index]
@rx.var
def department_distribution(
self,
) -> List[DepartmentData]:
"""Calculate the distribution of employees by department based on filters."""
target_employees = self.filtered_employees
if not target_employees:
return []
|
return [
DepartmentData(name=dept, value=count)
for dept, count in dept_counts.items()
]
@rx.var
def average_salary_by_department(
self,
) -> list[AverageSalaryData]:
"""Calculate the average salary for each department, considering filters."""
if not self.employees:
return []
dept_salaries = defaultdict(list)
for emp in self.employees:
dept_salaries[emp["department"]].append(emp["salary"])
avg_salaries = []
for dept in self.departments_for_filter:
salaries = dept_salaries.get(dept, [])
if salaries:
avg_salary = statistics.mean(salaries)
avg_salaries.append(
AverageSalaryData(
department=dept,
average_salary=round(avg_salary, 2),
)
)
else:
pass
if self.selected_d | dept_counts = Counter((emp["department"] for emp in target_employees)) |
ms_per_page)
@rx.var
def paginated_employees(self) -> List[Employee]:
"""Get the employees for the current page."""
start_index = (self.current_page - 1) * self.items_per_page
end_index = start_index + self.items_per_page
return self.filtered_employees[start_index:end_index]
@rx.var
def department_distribution(
self,
) -> List[DepartmentData]:
"""Calculate the distribution of employees by department based on filters."""
target_employees = self.filtered_employees
if not target_employees:
return []
dept_counts = Counter((emp["department"] for emp in target_employees))
return [
DepartmentData(name=dept, value=count)
for dept, count in dept_counts.items()
]
@rx.var
def average_salary_by_department(
self,
) -> list[AverageSalaryData]:
"""Calculate the average salary for each department, considering filters."""
|
dept_salaries = defaultdict(list)
for emp in self.employees:
dept_salaries[emp["department"]].append(emp["salary"])
avg_salaries = []
for dept in self.departments_for_filter:
salaries = dept_salaries.get(dept, [])
if salaries:
avg_salary = statistics.mean(salaries)
avg_salaries.append(
AverageSalaryData(
department=dept,
average_salary=round(avg_salary, 2),
)
)
else:
pass
if self.selected_department != "All":
avg_salaries = [
item
for item in avg_salaries
if item["department"] == self.selected_department
]
return avg_salaries
@rx.event
def set_search_query(self, value: str):
"""Set the search query and reset to page 1."""
self.search_query = valu | if not self.employees:
return [] |
(self) -> List[Employee]:
"""Get the employees for the current page."""
start_index = (self.current_page - 1) * self.items_per_page
end_index = start_index + self.items_per_page
return self.filtered_employees[start_index:end_index]
@rx.var
def department_distribution(
self,
) -> List[DepartmentData]:
"""Calculate the distribution of employees by department based on filters."""
target_employees = self.filtered_employees
if not target_employees:
return []
dept_counts = Counter((emp["department"] for emp in target_employees))
return [
DepartmentData(name=dept, value=count)
for dept, count in dept_counts.items()
]
@rx.var
def average_salary_by_department(
self,
) -> list[AverageSalaryData]:
"""Calculate the average salary for each department, considering filters."""
if not self.employees:
return []
|
for emp in self.employees:
dept_salaries[emp["department"]].append(emp["salary"])
avg_salaries = []
for dept in self.departments_for_filter:
salaries = dept_salaries.get(dept, [])
if salaries:
avg_salary = statistics.mean(salaries)
avg_salaries.append(
AverageSalaryData(
department=dept,
average_salary=round(avg_salary, 2),
)
)
else:
pass
if self.selected_department != "All":
avg_salaries = [
item
for item in avg_salaries
if item["department"] == self.selected_department
]
return avg_salaries
@rx.event
def set_search_query(self, value: str):
"""Set the search query and reset to page 1."""
self.search_query = value
self.current_page = 1
@rx.e | dept_salaries = defaultdict(list) |
he employees for the current page."""
start_index = (self.current_page - 1) * self.items_per_page
end_index = start_index + self.items_per_page
return self.filtered_employees[start_index:end_index]
@rx.var
def department_distribution(
self,
) -> List[DepartmentData]:
"""Calculate the distribution of employees by department based on filters."""
target_employees = self.filtered_employees
if not target_employees:
return []
dept_counts = Counter((emp["department"] for emp in target_employees))
return [
DepartmentData(name=dept, value=count)
for dept, count in dept_counts.items()
]
@rx.var
def average_salary_by_department(
self,
) -> list[AverageSalaryData]:
"""Calculate the average salary for each department, considering filters."""
if not self.employees:
return []
dept_salaries = defaultdict(list)
|
avg_salaries = []
for dept in self.departments_for_filter:
salaries = dept_salaries.get(dept, [])
if salaries:
avg_salary = statistics.mean(salaries)
avg_salaries.append(
AverageSalaryData(
department=dept,
average_salary=round(avg_salary, 2),
)
)
else:
pass
if self.selected_department != "All":
avg_salaries = [
item
for item in avg_salaries
if item["department"] == self.selected_department
]
return avg_salaries
@rx.event
def set_search_query(self, value: str):
"""Set the search query and reset to page 1."""
self.search_query = value
self.current_page = 1
@rx.event
def set_selected_department(self, department: str):
"""Set the selected department an | for emp in self.employees:
dept_salaries[emp["department"]].append(emp["salary"]) |
age
end_index = start_index + self.items_per_page
return self.filtered_employees[start_index:end_index]
@rx.var
def department_distribution(
self,
) -> List[DepartmentData]:
"""Calculate the distribution of employees by department based on filters."""
target_employees = self.filtered_employees
if not target_employees:
return []
dept_counts = Counter((emp["department"] for emp in target_employees))
return [
DepartmentData(name=dept, value=count)
for dept, count in dept_counts.items()
]
@rx.var
def average_salary_by_department(
self,
) -> list[AverageSalaryData]:
"""Calculate the average salary for each department, considering filters."""
if not self.employees:
return []
dept_salaries = defaultdict(list)
for emp in self.employees:
dept_salaries[emp["department"]].append(emp["salary"])
|
for dept in self.departments_for_filter:
salaries = dept_salaries.get(dept, [])
if salaries:
avg_salary = statistics.mean(salaries)
avg_salaries.append(
AverageSalaryData(
department=dept,
average_salary=round(avg_salary, 2),
)
)
else:
pass
if self.selected_department != "All":
avg_salaries = [
item
for item in avg_salaries
if item["department"] == self.selected_department
]
return avg_salaries
@rx.event
def set_search_query(self, value: str):
"""Set the search query and reset to page 1."""
self.search_query = value
self.current_page = 1
@rx.event
def set_selected_department(self, department: str):
"""Set the selected department and reset to page 1."""
| avg_salaries = [] |
art_index + self.items_per_page
return self.filtered_employees[start_index:end_index]
@rx.var
def department_distribution(
self,
) -> List[DepartmentData]:
"""Calculate the distribution of employees by department based on filters."""
target_employees = self.filtered_employees
if not target_employees:
return []
dept_counts = Counter((emp["department"] for emp in target_employees))
return [
DepartmentData(name=dept, value=count)
for dept, count in dept_counts.items()
]
@rx.var
def average_salary_by_department(
self,
) -> list[AverageSalaryData]:
"""Calculate the average salary for each department, considering filters."""
if not self.employees:
return []
dept_salaries = defaultdict(list)
for emp in self.employees:
dept_salaries[emp["department"]].append(emp["salary"])
avg_salaries = []
|
if self.selected_department != "All":
avg_salaries = [
item
for item in avg_salaries
if item["department"] == self.selected_department
]
return avg_salaries
@rx.event
def set_search_query(self, value: str):
"""Set the search query and reset to page 1."""
self.search_query = value
self.current_page = 1
@rx.event
def set_selected_department(self, department: str):
"""Set the selected department and reset to page 1."""
self.selected_department = department
self.current_page = 1
@rx.event
def previous_page(self):
"""Go to the previous page."""
if self.current_page > 1:
self.current_page -= 1
@rx.event
def next_page(self):
"""Go to the next page."""
if self.current_page < self.total_pages:
self.current_page += 1
@rx.event
def go_to_page(self, page_num: int) | for dept in self.departments_for_filter:
salaries = dept_salaries.get(dept, [])
if salaries:
avg_salary = statistics.mean(salaries)
avg_salaries.append(
AverageSalaryData(
department=dept,
average_salary=round(avg_salary, 2),
)
)
else:
pass |
iltered_employees[start_index:end_index]
@rx.var
def department_distribution(
self,
) -> List[DepartmentData]:
"""Calculate the distribution of employees by department based on filters."""
target_employees = self.filtered_employees
if not target_employees:
return []
dept_counts = Counter((emp["department"] for emp in target_employees))
return [
DepartmentData(name=dept, value=count)
for dept, count in dept_counts.items()
]
@rx.var
def average_salary_by_department(
self,
) -> list[AverageSalaryData]:
"""Calculate the average salary for each department, considering filters."""
if not self.employees:
return []
dept_salaries = defaultdict(list)
for emp in self.employees:
dept_salaries[emp["department"]].append(emp["salary"])
avg_salaries = []
for dept in self.departments_for_filter:
|
if salaries:
avg_salary = statistics.mean(salaries)
avg_salaries.append(
AverageSalaryData(
department=dept,
average_salary=round(avg_salary, 2),
)
)
else:
pass
if self.selected_department != "All":
avg_salaries = [
item
for item in avg_salaries
if item["department"] == self.selected_department
]
return avg_salaries
@rx.event
def set_search_query(self, value: str):
"""Set the search query and reset to page 1."""
self.search_query = value
self.current_page = 1
@rx.event
def set_selected_department(self, department: str):
"""Set the selected department and reset to page 1."""
self.selected_department = department
self.current_page = 1
@rx.event
def previ | salaries = dept_salaries.get(dept, []) |
ar
def department_distribution(
self,
) -> List[DepartmentData]:
"""Calculate the distribution of employees by department based on filters."""
target_employees = self.filtered_employees
if not target_employees:
return []
dept_counts = Counter((emp["department"] for emp in target_employees))
return [
DepartmentData(name=dept, value=count)
for dept, count in dept_counts.items()
]
@rx.var
def average_salary_by_department(
self,
) -> list[AverageSalaryData]:
"""Calculate the average salary for each department, considering filters."""
if not self.employees:
return []
dept_salaries = defaultdict(list)
for emp in self.employees:
dept_salaries[emp["department"]].append(emp["salary"])
avg_salaries = []
for dept in self.departments_for_filter:
salaries = dept_salaries.get(dept, [])
|
if self.selected_department != "All":
avg_salaries = [
item
for item in avg_salaries
if item["department"] == self.selected_department
]
return avg_salaries
@rx.event
def set_search_query(self, value: str):
"""Set the search query and reset to page 1."""
self.search_query = value
self.current_page = 1
@rx.event
def set_selected_department(self, department: str):
"""Set the selected department and reset to page 1."""
self.selected_department = department
self.current_page = 1
@rx.event
def previous_page(self):
"""Go to the previous page."""
if self.current_page > 1:
self.current_page -= 1
@rx.event
def next_page(self):
"""Go to the next page."""
if self.current_page < self.total_pages:
self.current_page += 1
@rx.event
def go_to_page(self, page_num: int) | if salaries:
avg_salary = statistics.mean(salaries)
avg_salaries.append(
AverageSalaryData(
department=dept,
average_salary=round(avg_salary, 2),
)
)
else:
pass |
ution(
self,
) -> List[DepartmentData]:
"""Calculate the distribution of employees by department based on filters."""
target_employees = self.filtered_employees
if not target_employees:
return []
dept_counts = Counter((emp["department"] for emp in target_employees))
return [
DepartmentData(name=dept, value=count)
for dept, count in dept_counts.items()
]
@rx.var
def average_salary_by_department(
self,
) -> list[AverageSalaryData]:
"""Calculate the average salary for each department, considering filters."""
if not self.employees:
return []
dept_salaries = defaultdict(list)
for emp in self.employees:
dept_salaries[emp["department"]].append(emp["salary"])
avg_salaries = []
for dept in self.departments_for_filter:
salaries = dept_salaries.get(dept, [])
if salaries:
|
avg_salaries.append(
AverageSalaryData(
department=dept,
average_salary=round(avg_salary, 2),
)
)
else:
pass
if self.selected_department != "All":
avg_salaries = [
item
for item in avg_salaries
if item["department"] == self.selected_department
]
return avg_salaries
@rx.event
def set_search_query(self, value: str):
"""Set the search query and reset to page 1."""
self.search_query = value
self.current_page = 1
@rx.event
def set_selected_department(self, department: str):
"""Set the selected department and reset to page 1."""
self.selected_department = department
self.current_page = 1
@rx.event
def previous_page(self):
"""Go to the previous page."""
if self.current_p | avg_salary = statistics.mean(salaries) |
target_employees))
return [
DepartmentData(name=dept, value=count)
for dept, count in dept_counts.items()
]
@rx.var
def average_salary_by_department(
self,
) -> list[AverageSalaryData]:
"""Calculate the average salary for each department, considering filters."""
if not self.employees:
return []
dept_salaries = defaultdict(list)
for emp in self.employees:
dept_salaries[emp["department"]].append(emp["salary"])
avg_salaries = []
for dept in self.departments_for_filter:
salaries = dept_salaries.get(dept, [])
if salaries:
avg_salary = statistics.mean(salaries)
avg_salaries.append(
AverageSalaryData(
department=dept,
average_salary=round(avg_salary, 2),
)
)
else:
pass
|
return avg_salaries
@rx.event
def set_search_query(self, value: str):
"""Set the search query and reset to page 1."""
self.search_query = value
self.current_page = 1
@rx.event
def set_selected_department(self, department: str):
"""Set the selected department and reset to page 1."""
self.selected_department = department
self.current_page = 1
@rx.event
def previous_page(self):
"""Go to the previous page."""
if self.current_page > 1:
self.current_page -= 1
@rx.event
def next_page(self):
"""Go to the next page."""
if self.current_page < self.total_pages:
self.current_page += 1
@rx.event
def go_to_page(self, page_num: int):
"""Go to a specific page number."""
if 1 <= page_num <= self.total_pages:
self.current_page = page_num
| if self.selected_department != "All":
avg_salaries = [
item
for item in avg_salaries
if item["department"] == self.selected_department
] |
partmentData(name=dept, value=count)
for dept, count in dept_counts.items()
]
@rx.var
def average_salary_by_department(
self,
) -> list[AverageSalaryData]:
"""Calculate the average salary for each department, considering filters."""
if not self.employees:
return []
dept_salaries = defaultdict(list)
for emp in self.employees:
dept_salaries[emp["department"]].append(emp["salary"])
avg_salaries = []
for dept in self.departments_for_filter:
salaries = dept_salaries.get(dept, [])
if salaries:
avg_salary = statistics.mean(salaries)
avg_salaries.append(
AverageSalaryData(
department=dept,
average_salary=round(avg_salary, 2),
)
)
else:
pass
if self.selected_department != "All":
|
return avg_salaries
@rx.event
def set_search_query(self, value: str):
"""Set the search query and reset to page 1."""
self.search_query = value
self.current_page = 1
@rx.event
def set_selected_department(self, department: str):
"""Set the selected department and reset to page 1."""
self.selected_department = department
self.current_page = 1
@rx.event
def previous_page(self):
"""Go to the previous page."""
if self.current_page > 1:
self.current_page -= 1
@rx.event
def next_page(self):
"""Go to the next page."""
if self.current_page < self.total_pages:
self.current_page += 1
@rx.event
def go_to_page(self, page_num: int):
"""Go to a specific page number."""
if 1 <= page_num <= self.total_pages:
self.current_page = page_num
| avg_salaries = [
item
for item in avg_salaries
if item["department"] == self.selected_department
] |
""Calculate the average salary for each department, considering filters."""
if not self.employees:
return []
dept_salaries = defaultdict(list)
for emp in self.employees:
dept_salaries[emp["department"]].append(emp["salary"])
avg_salaries = []
for dept in self.departments_for_filter:
salaries = dept_salaries.get(dept, [])
if salaries:
avg_salary = statistics.mean(salaries)
avg_salaries.append(
AverageSalaryData(
department=dept,
average_salary=round(avg_salary, 2),
)
)
else:
pass
if self.selected_department != "All":
avg_salaries = [
item
for item in avg_salaries
if item["department"] == self.selected_department
]
return avg_salaries
@rx.event
|
@rx.event
def set_selected_department(self, department: str):
"""Set the selected department and reset to page 1."""
self.selected_department = department
self.current_page = 1
@rx.event
def previous_page(self):
"""Go to the previous page."""
if self.current_page > 1:
self.current_page -= 1
@rx.event
def next_page(self):
"""Go to the next page."""
if self.current_page < self.total_pages:
self.current_page += 1
@rx.event
def go_to_page(self, page_num: int):
"""Go to a specific page number."""
if 1 <= page_num <= self.total_pages:
self.current_page = page_num
| def set_search_query(self, value: str):
"""Set the search query and reset to page 1."""
self.search_query = value
self.current_page = 1 |
s:
return []
dept_salaries = defaultdict(list)
for emp in self.employees:
dept_salaries[emp["department"]].append(emp["salary"])
avg_salaries = []
for dept in self.departments_for_filter:
salaries = dept_salaries.get(dept, [])
if salaries:
avg_salary = statistics.mean(salaries)
avg_salaries.append(
AverageSalaryData(
department=dept,
average_salary=round(avg_salary, 2),
)
)
else:
pass
if self.selected_department != "All":
avg_salaries = [
item
for item in avg_salaries
if item["department"] == self.selected_department
]
return avg_salaries
@rx.event
def set_search_query(self, value: str):
"""Set the search query and reset to page 1."""
|
self.current_page = 1
@rx.event
def set_selected_department(self, department: str):
"""Set the selected department and reset to page 1."""
self.selected_department = department
self.current_page = 1
@rx.event
def previous_page(self):
"""Go to the previous page."""
if self.current_page > 1:
self.current_page -= 1
@rx.event
def next_page(self):
"""Go to the next page."""
if self.current_page < self.total_pages:
self.current_page += 1
@rx.event
def go_to_page(self, page_num: int):
"""Go to a specific page number."""
if 1 <= page_num <= self.total_pages:
self.current_page = page_num
| self.search_query = value |
ept_salaries = defaultdict(list)
for emp in self.employees:
dept_salaries[emp["department"]].append(emp["salary"])
avg_salaries = []
for dept in self.departments_for_filter:
salaries = dept_salaries.get(dept, [])
if salaries:
avg_salary = statistics.mean(salaries)
avg_salaries.append(
AverageSalaryData(
department=dept,
average_salary=round(avg_salary, 2),
)
)
else:
pass
if self.selected_department != "All":
avg_salaries = [
item
for item in avg_salaries
if item["department"] == self.selected_department
]
return avg_salaries
@rx.event
def set_search_query(self, value: str):
"""Set the search query and reset to page 1."""
self.search_query = value
|
@rx.event
def set_selected_department(self, department: str):
"""Set the selected department and reset to page 1."""
self.selected_department = department
self.current_page = 1
@rx.event
def previous_page(self):
"""Go to the previous page."""
if self.current_page > 1:
self.current_page -= 1
@rx.event
def next_page(self):
"""Go to the next page."""
if self.current_page < self.total_pages:
self.current_page += 1
@rx.event
def go_to_page(self, page_num: int):
"""Go to a specific page number."""
if 1 <= page_num <= self.total_pages:
self.current_page = page_num
| self.current_page = 1 |
for emp in self.employees:
dept_salaries[emp["department"]].append(emp["salary"])
avg_salaries = []
for dept in self.departments_for_filter:
salaries = dept_salaries.get(dept, [])
if salaries:
avg_salary = statistics.mean(salaries)
avg_salaries.append(
AverageSalaryData(
department=dept,
average_salary=round(avg_salary, 2),
)
)
else:
pass
if self.selected_department != "All":
avg_salaries = [
item
for item in avg_salaries
if item["department"] == self.selected_department
]
return avg_salaries
@rx.event
def set_search_query(self, value: str):
"""Set the search query and reset to page 1."""
self.search_query = value
self.current_page = 1
@rx.event
|
@rx.event
def previous_page(self):
"""Go to the previous page."""
if self.current_page > 1:
self.current_page -= 1
@rx.event
def next_page(self):
"""Go to the next page."""
if self.current_page < self.total_pages:
self.current_page += 1
@rx.event
def go_to_page(self, page_num: int):
"""Go to a specific page number."""
if 1 <= page_num <= self.total_pages:
self.current_page = page_num
| def set_selected_department(self, department: str):
"""Set the selected department and reset to page 1."""
self.selected_department = department
self.current_page = 1 |
for dept in self.departments_for_filter:
salaries = dept_salaries.get(dept, [])
if salaries:
avg_salary = statistics.mean(salaries)
avg_salaries.append(
AverageSalaryData(
department=dept,
average_salary=round(avg_salary, 2),
)
)
else:
pass
if self.selected_department != "All":
avg_salaries = [
item
for item in avg_salaries
if item["department"] == self.selected_department
]
return avg_salaries
@rx.event
def set_search_query(self, value: str):
"""Set the search query and reset to page 1."""
self.search_query = value
self.current_page = 1
@rx.event
def set_selected_department(self, department: str):
"""Set the selected department and reset to page 1."""
|
self.current_page = 1
@rx.event
def previous_page(self):
"""Go to the previous page."""
if self.current_page > 1:
self.current_page -= 1
@rx.event
def next_page(self):
"""Go to the next page."""
if self.current_page < self.total_pages:
self.current_page += 1
@rx.event
def go_to_page(self, page_num: int):
"""Go to a specific page number."""
if 1 <= page_num <= self.total_pages:
self.current_page = page_num
| self.selected_department = department |
salaries = dept_salaries.get(dept, [])
if salaries:
avg_salary = statistics.mean(salaries)
avg_salaries.append(
AverageSalaryData(
department=dept,
average_salary=round(avg_salary, 2),
)
)
else:
pass
if self.selected_department != "All":
avg_salaries = [
item
for item in avg_salaries
if item["department"] == self.selected_department
]
return avg_salaries
@rx.event
def set_search_query(self, value: str):
"""Set the search query and reset to page 1."""
self.search_query = value
self.current_page = 1
@rx.event
def set_selected_department(self, department: str):
"""Set the selected department and reset to page 1."""
self.selected_department = department
|
@rx.event
def previous_page(self):
"""Go to the previous page."""
if self.current_page > 1:
self.current_page -= 1
@rx.event
def next_page(self):
"""Go to the next page."""
if self.current_page < self.total_pages:
self.current_page += 1
@rx.event
def go_to_page(self, page_num: int):
"""Go to a specific page number."""
if 1 <= page_num <= self.total_pages:
self.current_page = page_num
| self.current_page = 1 |
dept, [])
if salaries:
avg_salary = statistics.mean(salaries)
avg_salaries.append(
AverageSalaryData(
department=dept,
average_salary=round(avg_salary, 2),
)
)
else:
pass
if self.selected_department != "All":
avg_salaries = [
item
for item in avg_salaries
if item["department"] == self.selected_department
]
return avg_salaries
@rx.event
def set_search_query(self, value: str):
"""Set the search query and reset to page 1."""
self.search_query = value
self.current_page = 1
@rx.event
def set_selected_department(self, department: str):
"""Set the selected department and reset to page 1."""
self.selected_department = department
self.current_page = 1
@rx.event
|
@rx.event
def next_page(self):
"""Go to the next page."""
if self.current_page < self.total_pages:
self.current_page += 1
@rx.event
def go_to_page(self, page_num: int):
"""Go to a specific page number."""
if 1 <= page_num <= self.total_pages:
self.current_page = page_num
| def previous_page(self):
"""Go to the previous page."""
if self.current_page > 1:
self.current_page -= 1 |
cs.mean(salaries)
avg_salaries.append(
AverageSalaryData(
department=dept,
average_salary=round(avg_salary, 2),
)
)
else:
pass
if self.selected_department != "All":
avg_salaries = [
item
for item in avg_salaries
if item["department"] == self.selected_department
]
return avg_salaries
@rx.event
def set_search_query(self, value: str):
"""Set the search query and reset to page 1."""
self.search_query = value
self.current_page = 1
@rx.event
def set_selected_department(self, department: str):
"""Set the selected department and reset to page 1."""
self.selected_department = department
self.current_page = 1
@rx.event
def previous_page(self):
"""Go to the previous page."""
|
@rx.event
def next_page(self):
"""Go to the next page."""
if self.current_page < self.total_pages:
self.current_page += 1
@rx.event
def go_to_page(self, page_num: int):
"""Go to a specific page number."""
if 1 <= page_num <= self.total_pages:
self.current_page = page_num
| if self.current_page > 1:
self.current_page -= 1 |
geSalaryData(
department=dept,
average_salary=round(avg_salary, 2),
)
)
else:
pass
if self.selected_department != "All":
avg_salaries = [
item
for item in avg_salaries
if item["department"] == self.selected_department
]
return avg_salaries
@rx.event
def set_search_query(self, value: str):
"""Set the search query and reset to page 1."""
self.search_query = value
self.current_page = 1
@rx.event
def set_selected_department(self, department: str):
"""Set the selected department and reset to page 1."""
self.selected_department = department
self.current_page = 1
@rx.event
def previous_page(self):
"""Go to the previous page."""
if self.current_page > 1:
self.current_page -= 1
@rx.event
|
@rx.event
def go_to_page(self, page_num: int):
"""Go to a specific page number."""
if 1 <= page_num <= self.total_pages:
self.current_page = page_num
| def next_page(self):
"""Go to the next page."""
if self.current_page < self.total_pages:
self.current_page += 1 |
average_salary=round(avg_salary, 2),
)
)
else:
pass
if self.selected_department != "All":
avg_salaries = [
item
for item in avg_salaries
if item["department"] == self.selected_department
]
return avg_salaries
@rx.event
def set_search_query(self, value: str):
"""Set the search query and reset to page 1."""
self.search_query = value
self.current_page = 1
@rx.event
def set_selected_department(self, department: str):
"""Set the selected department and reset to page 1."""
self.selected_department = department
self.current_page = 1
@rx.event
def previous_page(self):
"""Go to the previous page."""
if self.current_page > 1:
self.current_page -= 1
@rx.event
def next_page(self):
"""Go to the next page."""
|
@rx.event
def go_to_page(self, page_num: int):
"""Go to a specific page number."""
if 1 <= page_num <= self.total_pages:
self.current_page = page_num
| if self.current_page < self.total_pages:
self.current_page += 1 |
else:
pass
if self.selected_department != "All":
avg_salaries = [
item
for item in avg_salaries
if item["department"] == self.selected_department
]
return avg_salaries
@rx.event
def set_search_query(self, value: str):
"""Set the search query and reset to page 1."""
self.search_query = value
self.current_page = 1
@rx.event
def set_selected_department(self, department: str):
"""Set the selected department and reset to page 1."""
self.selected_department = department
self.current_page = 1
@rx.event
def previous_page(self):
"""Go to the previous page."""
if self.current_page > 1:
self.current_page -= 1
@rx.event
def next_page(self):
"""Go to the next page."""
if self.current_page < self.total_pages:
self.current_page += 1
@rx.event
| def go_to_page(self, page_num: int):
"""Go to a specific page number."""
if 1 <= page_num <= self.total_pages:
self.current_page = page_num | |
avg_salaries = [
item
for item in avg_salaries
if item["department"] == self.selected_department
]
return avg_salaries
@rx.event
def set_search_query(self, value: str):
"""Set the search query and reset to page 1."""
self.search_query = value
self.current_page = 1
@rx.event
def set_selected_department(self, department: str):
"""Set the selected department and reset to page 1."""
self.selected_department = department
self.current_page = 1
@rx.event
def previous_page(self):
"""Go to the previous page."""
if self.current_page > 1:
self.current_page -= 1
@rx.event
def next_page(self):
"""Go to the next page."""
if self.current_page < self.total_pages:
self.current_page += 1
@rx.event
def go_to_page(self, page_num: int):
"""Go to a specific page number."""
| if 1 <= page_num <= self.total_pages:
self.current_page = page_num | |
for item in avg_salaries
if item["department"] == self.selected_department
]
return avg_salaries
@rx.event
def set_search_query(self, value: str):
"""Set the search query and reset to page 1."""
self.search_query = value
self.current_page = 1
@rx.event
def set_selected_department(self, department: str):
"""Set the selected department and reset to page 1."""
self.selected_department = department
self.current_page = 1
@rx.event
def previous_page(self):
"""Go to the previous page."""
if self.current_page > 1:
self.current_page -= 1
@rx.event
def next_page(self):
"""Go to the next page."""
if self.current_page < self.total_pages:
self.current_page += 1
@rx.event
def go_to_page(self, page_num: int):
"""Go to a specific page number."""
if 1 <= page_num <= self.total_pages:
| self.current_page = page_num | |
from chat_app.components.chat_interface import chat_interface
def index() -> rx.Component:
"""The main page of the chat application."""
return chat_interface()
app = rx.App(theme=rx.theme(appearance="light"))
app.add_page(index)
| import reflex as rx | |
from chat_app.components.input_area import input_area
from chat_app.components.message_bubble import message_bubble
from chat_app.components.preset_cards import preset_cards
from chat_app.states.chat_state import ChatState
def chat_interface() -> rx.Component:
"""The main chat interface component."""
return rx.el.div(
rx.cond(
ChatState.messages,
rx.auto_scroll(
rx.foreach(
ChatState.messages,
lambda m, i: message_bubble(
m["text"],
m["is_ai"],
i == ChatState.messages.length() - 1,
),
),
class_name="flex flex-col gap-4 pb-24 pt-6",
),
preset_cards(),
),
input_area(),
class_name="h-screen flex flex-col bg-gray-50 w-full",
)
| import reflex as rx | |
import reflex as rx
|
from chat_app.components.message_bubble import message_bubble
from chat_app.components.preset_cards import preset_cards
from chat_app.states.chat_state import ChatState
def chat_interface() -> rx.Component:
"""The main chat interface component."""
return rx.el.div(
rx.cond(
ChatState.messages,
rx.auto_scroll(
rx.foreach(
ChatState.messages,
lambda m, i: message_bubble(
m["text"],
m["is_ai"],
i == ChatState.messages.length() - 1,
),
),
class_name="flex flex-col gap-4 pb-24 pt-6",
),
preset_cards(),
),
input_area(),
class_name="h-screen flex flex-col bg-gray-50 w-full",
)
| from chat_app.components.input_area import input_area |
import reflex as rx
from chat_app.components.input_area import input_area
|
from chat_app.components.preset_cards import preset_cards
from chat_app.states.chat_state import ChatState
def chat_interface() -> rx.Component:
"""The main chat interface component."""
return rx.el.div(
rx.cond(
ChatState.messages,
rx.auto_scroll(
rx.foreach(
ChatState.messages,
lambda m, i: message_bubble(
m["text"],
m["is_ai"],
i == ChatState.messages.length() - 1,
),
),
class_name="flex flex-col gap-4 pb-24 pt-6",
),
preset_cards(),
),
input_area(),
class_name="h-screen flex flex-col bg-gray-50 w-full",
)
| from chat_app.components.message_bubble import message_bubble |
import reflex as rx
from chat_app.components.input_area import input_area
from chat_app.components.message_bubble import message_bubble
|
from chat_app.states.chat_state import ChatState
def chat_interface() -> rx.Component:
"""The main chat interface component."""
return rx.el.div(
rx.cond(
ChatState.messages,
rx.auto_scroll(
rx.foreach(
ChatState.messages,
lambda m, i: message_bubble(
m["text"],
m["is_ai"],
i == ChatState.messages.length() - 1,
),
),
class_name="flex flex-col gap-4 pb-24 pt-6",
),
preset_cards(),
),
input_area(),
class_name="h-screen flex flex-col bg-gray-50 w-full",
)
| from chat_app.components.preset_cards import preset_cards |
import reflex as rx
from chat_app.components.input_area import input_area
from chat_app.components.message_bubble import message_bubble
from chat_app.components.preset_cards import preset_cards
|
def chat_interface() -> rx.Component:
"""The main chat interface component."""
return rx.el.div(
rx.cond(
ChatState.messages,
rx.auto_scroll(
rx.foreach(
ChatState.messages,
lambda m, i: message_bubble(
m["text"],
m["is_ai"],
i == ChatState.messages.length() - 1,
),
),
class_name="flex flex-col gap-4 pb-24 pt-6",
),
preset_cards(),
),
input_area(),
class_name="h-screen flex flex-col bg-gray-50 w-full",
)
| from chat_app.states.chat_state import ChatState |
from chat_app.states.chat_state import ChatState
def input_area() -> rx.Component:
return rx.el.div(
rx.el.div(
rx.el.form(
rx.el.textarea(
name="message",
placeholder="Ask me anything",
enter_key_submit=True,
class_name="bg-transparent resize-none outline-none text-base py-2 px-3 min-h-10 text-black max-h-36 peer !overflow-y-auto",
auto_height=True,
required=True,
),
rx.box(
rx.cond(
ChatState.messages,
rx.el.button(
rx.icon("square-pen", size=16),
title="New chat",
class_name="rounded-full bg-white text-gray-500 p-2 shadow-sm size-9 inline-flex items-center justify-center hover:bg-gray-100 border transition-colors",
| import reflex as rx | |
import reflex as rx
|
def input_area() -> rx.Component:
return rx.el.div(
rx.el.div(
rx.el.form(
rx.el.textarea(
name="message",
placeholder="Ask me anything",
enter_key_submit=True,
class_name="bg-transparent resize-none outline-none text-base py-2 px-3 min-h-10 text-black max-h-36 peer !overflow-y-auto",
auto_height=True,
required=True,
),
rx.box(
rx.cond(
ChatState.messages,
rx.el.button(
rx.icon("square-pen", size=16),
title="New chat",
class_name="rounded-full bg-white text-gray-500 p-2 shadow-sm size-9 inline-flex items-center justify-center hover:bg-gray-100 border transition-colors",
type="button",
on_cl | from chat_app.states.chat_state import ChatState |
from chat_app.components.typing_indicator import typing_indicator
def ai_bubble(message: str, is_last: bool = False) -> rx.Component:
return rx.el.div(
rx.el.div(
rx.icon("bot", size=16),
class_name="rounded-full bg-white text-black p-2 size-8 inline-flex items-center justify-center border",
),
rx.cond(
message,
rx.el.p(message, class_name="text-sm sm:text-base"),
rx.cond(
is_last,
typing_indicator(),
),
),
class_name="text-black text-base max-w-4xl flex flex-row gap-4",
)
def user_bubble(message: str) -> rx.Component:
return rx.el.div(
rx.el.p(message, class_name="text-sm sm:text-base"),
class_name="text-white px-3 py-2 bg-blue-500 rounded-xl w-fit self-end max-w-[90%]",
)
def message_bubble(
message: str, is_ai: bool = False, is_last: bool = False
) -> rx.Component:
return rx.el.div(
rx. | import reflex as rx | |
import reflex as rx
|
def ai_bubble(message: str, is_last: bool = False) -> rx.Component:
return rx.el.div(
rx.el.div(
rx.icon("bot", size=16),
class_name="rounded-full bg-white text-black p-2 size-8 inline-flex items-center justify-center border",
),
rx.cond(
message,
rx.el.p(message, class_name="text-sm sm:text-base"),
rx.cond(
is_last,
typing_indicator(),
),
),
class_name="text-black text-base max-w-4xl flex flex-row gap-4",
)
def user_bubble(message: str) -> rx.Component:
return rx.el.div(
rx.el.p(message, class_name="text-sm sm:text-base"),
class_name="text-white px-3 py-2 bg-blue-500 rounded-xl w-fit self-end max-w-[90%]",
)
def message_bubble(
message: str, is_ai: bool = False, is_last: bool = False
) -> rx.Component:
return rx.el.div(
rx.cond(
is_ai,
ai_bubble(message, is_last),
| from chat_app.components.typing_indicator import typing_indicator |
from chat_app.states.chat_state import ChatState
def card(icon: str, title: str, description: str, color: str) -> rx.Component:
return rx.el.button(
rx.el.div(
rx.icon(tag=icon, size=16, class_name=f"stroke-{color}-500"),
rx.el.p(title, class_name="font-medium text-black text-base"),
class_name="flex flex-row gap-2 items-center",
),
rx.el.p(description, class_name="text-gray-500 text-sm font-medium"),
on_click=ChatState.send_message({"message": description}),
type="button",
class_name="flex flex-col gap-1 border bg-white hover:bg-gray-100 shadow-sm px-4 py-3.5 rounded-xl text-start transition-colors flex-1",
)
def preset_cards() -> rx.Component:
return rx.el.div(
rx.el.div(
rx.el.div(
rx.icon("bot", size=24),
class_name="rounded-full bg-whit p-2 size-10 inline-flex items-center justify-center border",
),
rx.el. | import reflex as rx | |
import reflex as rx
|
def card(icon: str, title: str, description: str, color: str) -> rx.Component:
return rx.el.button(
rx.el.div(
rx.icon(tag=icon, size=16, class_name=f"stroke-{color}-500"),
rx.el.p(title, class_name="font-medium text-black text-base"),
class_name="flex flex-row gap-2 items-center",
),
rx.el.p(description, class_name="text-gray-500 text-sm font-medium"),
on_click=ChatState.send_message({"message": description}),
type="button",
class_name="flex flex-col gap-1 border bg-white hover:bg-gray-100 shadow-sm px-4 py-3.5 rounded-xl text-start transition-colors flex-1",
)
def preset_cards() -> rx.Component:
return rx.el.div(
rx.el.div(
rx.el.div(
rx.icon("bot", size=24),
class_name="rounded-full bg-whit p-2 size-10 inline-flex items-center justify-center border",
),
rx.el.p(
"How can I help you today?",
| from chat_app.states.chat_state import ChatState |
def typing_indicator() -> rx.Component:
return rx.el.div(
rx.el.div(class_name="size-1.5 bg-gray-500 rounded-full animate-bounce"),
rx.el.div(
class_name="size-1.5 bg-gray-400 rounded-full animate-bounce [animation-delay:0.2s]"
),
rx.el.div(
class_name="size-1.5 bg-gray-500 rounded-full animate-bounce [animation-delay:0.4s]"
),
class_name="flex gap-1 justify-center items-center",
)
| import reflex as rx | |
import os
from typing import List, TypedDict
import reflex as rx
class Message(TypedDict):
text: str
is_ai: bool
class ChatState(rx.State):
messages: List[Message] = []
typing: bool = False
has_openai_key: bool = "OPENAI_API_KEY" in os.environ
@rx.event
def clear_messages(self):
"""Clears all chat messages and resets typing status."""
self.typing = False
self.messages = []
@rx.event
def send_message(self, form_data: dict):
"""Adds a user message and triggers AI response generation."""
if self.typing:
return
message = form_data["message"].strip()
if message:
self.messages.append({"text": message, "is_ai": False})
self.messages.append({"text": "", "is_ai": True})
self.typing = True
yield ChatState.generate_response
@rx.event(background=True)
async def generate_response(self):
"""Generates a response (mock or OpenA | import asyncio | |
import asyncio
import os
|
import reflex as rx
class Message(TypedDict):
text: str
is_ai: bool
class ChatState(rx.State):
messages: List[Message] = []
typing: bool = False
has_openai_key: bool = "OPENAI_API_KEY" in os.environ
@rx.event
def clear_messages(self):
"""Clears all chat messages and resets typing status."""
self.typing = False
self.messages = []
@rx.event
def send_message(self, form_data: dict):
"""Adds a user message and triggers AI response generation."""
if self.typing:
return
message = form_data["message"].strip()
if message:
self.messages.append({"text": message, "is_ai": False})
self.messages.append({"text": "", "is_ai": True})
self.typing = True
yield ChatState.generate_response
@rx.event(background=True)
async def generate_response(self):
"""Generates a response (mock or OpenAI)."""
if not self.has_openai_key:
| from typing import List, TypedDict |
import asyncio
import os
from typing import List, TypedDict
|
class Message(TypedDict):
text: str
is_ai: bool
class ChatState(rx.State):
messages: List[Message] = []
typing: bool = False
has_openai_key: bool = "OPENAI_API_KEY" in os.environ
@rx.event
def clear_messages(self):
"""Clears all chat messages and resets typing status."""
self.typing = False
self.messages = []
@rx.event
def send_message(self, form_data: dict):
"""Adds a user message and triggers AI response generation."""
if self.typing:
return
message = form_data["message"].strip()
if message:
self.messages.append({"text": message, "is_ai": False})
self.messages.append({"text": "", "is_ai": True})
self.typing = True
yield ChatState.generate_response
@rx.event(background=True)
async def generate_response(self):
"""Generates a response (mock or OpenAI)."""
if not self.has_openai_key:
await async | import reflex as rx |
import asyncio
import os
from typing import List, TypedDict
import reflex as rx
|
class ChatState(rx.State):
messages: List[Message] = []
typing: bool = False
has_openai_key: bool = "OPENAI_API_KEY" in os.environ
@rx.event
def clear_messages(self):
"""Clears all chat messages and resets typing status."""
self.typing = False
self.messages = []
@rx.event
def send_message(self, form_data: dict):
"""Adds a user message and triggers AI response generation."""
if self.typing:
return
message = form_data["message"].strip()
if message:
self.messages.append({"text": message, "is_ai": False})
self.messages.append({"text": "", "is_ai": True})
self.typing = True
yield ChatState.generate_response
@rx.event(background=True)
async def generate_response(self):
"""Generates a response (mock or OpenAI)."""
if not self.has_openai_key:
await asyncio.sleep(1)
response = "This is a mock respons | class Message(TypedDict):
text: str
is_ai: bool |
import asyncio
import os
from typing import List, TypedDict
import reflex as rx
class Message(TypedDict):
text: str
is_ai: bool
class ChatState(rx.State):
messages: List[Message] = []
typing: bool = False
has_openai_key: bool = "OPENAI_API_KEY" in os.environ
@rx.event
|
@rx.event
def send_message(self, form_data: dict):
"""Adds a user message and triggers AI response generation."""
if self.typing:
return
message = form_data["message"].strip()
if message:
self.messages.append({"text": message, "is_ai": False})
self.messages.append({"text": "", "is_ai": True})
self.typing = True
yield ChatState.generate_response
@rx.event(background=True)
async def generate_response(self):
"""Generates a response (mock or OpenAI)."""
if not self.has_openai_key:
await asyncio.sleep(1)
response = "This is a mock response as the OPENAI_API_KEY is not set. Please set the environment variable to use the actual LLM."
current_text = ""
async with self:
if not self.messages:
self.typing = False
return
for char in response:
| def clear_messages(self):
"""Clears all chat messages and resets typing status."""
self.typing = False
self.messages = [] |
import asyncio
import os
from typing import List, TypedDict
import reflex as rx
class Message(TypedDict):
text: str
is_ai: bool
class ChatState(rx.State):
messages: List[Message] = []
typing: bool = False
has_openai_key: bool = "OPENAI_API_KEY" in os.environ
@rx.event
def clear_messages(self):
"""Clears all chat messages and resets typing status."""
|
self.messages = []
@rx.event
def send_message(self, form_data: dict):
"""Adds a user message and triggers AI response generation."""
if self.typing:
return
message = form_data["message"].strip()
if message:
self.messages.append({"text": message, "is_ai": False})
self.messages.append({"text": "", "is_ai": True})
self.typing = True
yield ChatState.generate_response
@rx.event(background=True)
async def generate_response(self):
"""Generates a response (mock or OpenAI)."""
if not self.has_openai_key:
await asyncio.sleep(1)
response = "This is a mock response as the OPENAI_API_KEY is not set. Please set the environment variable to use the actual LLM."
current_text = ""
async with self:
if not self.messages:
self.typing = False
return
for char in | self.typing = False |
import asyncio
import os
from typing import List, TypedDict
import reflex as rx
class Message(TypedDict):
text: str
is_ai: bool
class ChatState(rx.State):
messages: List[Message] = []
typing: bool = False
has_openai_key: bool = "OPENAI_API_KEY" in os.environ
@rx.event
def clear_messages(self):
"""Clears all chat messages and resets typing status."""
self.typing = False
self.messages = []
@rx.event
def send_message(self, form_data: dict):
"""Adds a user message and triggers AI response generation."""
|
message = form_data["message"].strip()
if message:
self.messages.append({"text": message, "is_ai": False})
self.messages.append({"text": "", "is_ai": True})
self.typing = True
yield ChatState.generate_response
@rx.event(background=True)
async def generate_response(self):
"""Generates a response (mock or OpenAI)."""
if not self.has_openai_key:
await asyncio.sleep(1)
response = "This is a mock response as the OPENAI_API_KEY is not set. Please set the environment variable to use the actual LLM."
current_text = ""
async with self:
if not self.messages:
self.typing = False
return
for char in response:
if not self.typing:
break
current_text += char
async with self:
if self.messages:
| if self.typing:
return |
import asyncio
import os
from typing import List, TypedDict
import reflex as rx
class Message(TypedDict):
text: str
is_ai: bool
class ChatState(rx.State):
messages: List[Message] = []
typing: bool = False
has_openai_key: bool = "OPENAI_API_KEY" in os.environ
@rx.event
def clear_messages(self):
"""Clears all chat messages and resets typing status."""
self.typing = False
self.messages = []
@rx.event
def send_message(self, form_data: dict):
"""Adds a user message and triggers AI response generation."""
if self.typing:
return
|
if message:
self.messages.append({"text": message, "is_ai": False})
self.messages.append({"text": "", "is_ai": True})
self.typing = True
yield ChatState.generate_response
@rx.event(background=True)
async def generate_response(self):
"""Generates a response (mock or OpenAI)."""
if not self.has_openai_key:
await asyncio.sleep(1)
response = "This is a mock response as the OPENAI_API_KEY is not set. Please set the environment variable to use the actual LLM."
current_text = ""
async with self:
if not self.messages:
self.typing = False
return
for char in response:
if not self.typing:
break
current_text += char
async with self:
if self.messages:
self.messages[-1]["text"] = current_text
| message = form_data["message"].strip() |
import asyncio
import os
from typing import List, TypedDict
import reflex as rx
class Message(TypedDict):
text: str
is_ai: bool
class ChatState(rx.State):
messages: List[Message] = []
typing: bool = False
has_openai_key: bool = "OPENAI_API_KEY" in os.environ
@rx.event
def clear_messages(self):
"""Clears all chat messages and resets typing status."""
self.typing = False
self.messages = []
@rx.event
def send_message(self, form_data: dict):
"""Adds a user message and triggers AI response generation."""
if self.typing:
return
message = form_data["message"].strip()
|
@rx.event(background=True)
async def generate_response(self):
"""Generates a response (mock or OpenAI)."""
if not self.has_openai_key:
await asyncio.sleep(1)
response = "This is a mock response as the OPENAI_API_KEY is not set. Please set the environment variable to use the actual LLM."
current_text = ""
async with self:
if not self.messages:
self.typing = False
return
for char in response:
if not self.typing:
break
current_text += char
async with self:
if self.messages:
self.messages[-1]["text"] = current_text
await asyncio.sleep(0.02)
async with self:
self.typing = False
else:
from openai import OpenAI
client = OpenAI()
api_messages = [
| if message:
self.messages.append({"text": message, "is_ai": False})
self.messages.append({"text": "", "is_ai": True})
self.typing = True
yield ChatState.generate_response |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.