instruction stringlengths 0 1k | input stringlengths 1 1k | output stringlengths 10 6.51k |
|---|---|---|
time_to_completion: float = 0.0
is_running: bool = False
ucl: float = 0.432
lcl: float = 0.407
target_mean: float = 0.42
usl: float = 0.424
lsl: float = 0.415
process_metrics: List[MetricData] = initial_process_metrics
spc_chart_data: List[SpcDataPoint] = initial_spc_data
pie_data: List[PieChartData] = initial_pie_data
distribution_data: List[DistributionPoint] = initial_distribution_data
def _reset_to_initial(self):
"""Resets data to a new initial state."""
self.process_metrics = _generate_process_metrics()
self.spc_chart_data = _generate_spc_data(base_min=self.lsl, base_max=self.usl)
self.pie_data = _generate_pie_data(self.process_metrics)
self.distribution_data = _generate_distribution_data(self.spc_chart_data)
@rx.event(background=True)
async def start_process(self):
"""Simulates starting a process and updating data over time using Faker."""
async with self:
|
self.is_running = True
self.time_to_completion = 0.0
update_interval = 0.1
data_gen_interval = 10
metrics_update_interval = 30
for i in range(101):
async with self:
self.time_to_completion = float(i)
if i > 0 and i % data_gen_interval == 0:
last_name = (
self.spc_chart_data[-1]["name"] if self.spc_chart_data else -1
)
new_name = last_name + 1
new_value_base = fake.pyfloat(
left_digits=0,
right_digits=4,
positive=True,
min_value=self.lsl - 0.002,
max_value=self.usl + 0.002,
)
if self.spc_chart_data:
drift = random.uniform(-0.001, 0.001)
new_value_base = self.spc_chart_data[-1]["val | if self.is_running:
return |
lcl: float = 0.407
target_mean: float = 0.42
usl: float = 0.424
lsl: float = 0.415
process_metrics: List[MetricData] = initial_process_metrics
spc_chart_data: List[SpcDataPoint] = initial_spc_data
pie_data: List[PieChartData] = initial_pie_data
distribution_data: List[DistributionPoint] = initial_distribution_data
def _reset_to_initial(self):
"""Resets data to a new initial state."""
self.process_metrics = _generate_process_metrics()
self.spc_chart_data = _generate_spc_data(base_min=self.lsl, base_max=self.usl)
self.pie_data = _generate_pie_data(self.process_metrics)
self.distribution_data = _generate_distribution_data(self.spc_chart_data)
@rx.event(background=True)
async def start_process(self):
"""Simulates starting a process and updating data over time using Faker."""
async with self:
if self.is_running:
return
self.is_running = True
|
update_interval = 0.1
data_gen_interval = 10
metrics_update_interval = 30
for i in range(101):
async with self:
self.time_to_completion = float(i)
if i > 0 and i % data_gen_interval == 0:
last_name = (
self.spc_chart_data[-1]["name"] if self.spc_chart_data else -1
)
new_name = last_name + 1
new_value_base = fake.pyfloat(
left_digits=0,
right_digits=4,
positive=True,
min_value=self.lsl - 0.002,
max_value=self.usl + 0.002,
)
if self.spc_chart_data:
drift = random.uniform(-0.001, 0.001)
new_value_base = self.spc_chart_data[-1]["value"] + drift
if random.random() < 0.08:
| self.time_to_completion = 0.0 |
loat = 0.42
usl: float = 0.424
lsl: float = 0.415
process_metrics: List[MetricData] = initial_process_metrics
spc_chart_data: List[SpcDataPoint] = initial_spc_data
pie_data: List[PieChartData] = initial_pie_data
distribution_data: List[DistributionPoint] = initial_distribution_data
def _reset_to_initial(self):
"""Resets data to a new initial state."""
self.process_metrics = _generate_process_metrics()
self.spc_chart_data = _generate_spc_data(base_min=self.lsl, base_max=self.usl)
self.pie_data = _generate_pie_data(self.process_metrics)
self.distribution_data = _generate_distribution_data(self.spc_chart_data)
@rx.event(background=True)
async def start_process(self):
"""Simulates starting a process and updating data over time using Faker."""
async with self:
if self.is_running:
return
self.is_running = True
self.time_to_completion = 0.0
|
data_gen_interval = 10
metrics_update_interval = 30
for i in range(101):
async with self:
self.time_to_completion = float(i)
if i > 0 and i % data_gen_interval == 0:
last_name = (
self.spc_chart_data[-1]["name"] if self.spc_chart_data else -1
)
new_name = last_name + 1
new_value_base = fake.pyfloat(
left_digits=0,
right_digits=4,
positive=True,
min_value=self.lsl - 0.002,
max_value=self.usl + 0.002,
)
if self.spc_chart_data:
drift = random.uniform(-0.001, 0.001)
new_value_base = self.spc_chart_data[-1]["value"] + drift
if random.random() < 0.08:
new_value_base += rando | update_interval = 0.1 |
.424
lsl: float = 0.415
process_metrics: List[MetricData] = initial_process_metrics
spc_chart_data: List[SpcDataPoint] = initial_spc_data
pie_data: List[PieChartData] = initial_pie_data
distribution_data: List[DistributionPoint] = initial_distribution_data
def _reset_to_initial(self):
"""Resets data to a new initial state."""
self.process_metrics = _generate_process_metrics()
self.spc_chart_data = _generate_spc_data(base_min=self.lsl, base_max=self.usl)
self.pie_data = _generate_pie_data(self.process_metrics)
self.distribution_data = _generate_distribution_data(self.spc_chart_data)
@rx.event(background=True)
async def start_process(self):
"""Simulates starting a process and updating data over time using Faker."""
async with self:
if self.is_running:
return
self.is_running = True
self.time_to_completion = 0.0
update_interval = 0.1
|
metrics_update_interval = 30
for i in range(101):
async with self:
self.time_to_completion = float(i)
if i > 0 and i % data_gen_interval == 0:
last_name = (
self.spc_chart_data[-1]["name"] if self.spc_chart_data else -1
)
new_name = last_name + 1
new_value_base = fake.pyfloat(
left_digits=0,
right_digits=4,
positive=True,
min_value=self.lsl - 0.002,
max_value=self.usl + 0.002,
)
if self.spc_chart_data:
drift = random.uniform(-0.001, 0.001)
new_value_base = self.spc_chart_data[-1]["value"] + drift
if random.random() < 0.08:
new_value_base += random.uniform(0.003, 0.008)
| data_gen_interval = 10 |
process_metrics: List[MetricData] = initial_process_metrics
spc_chart_data: List[SpcDataPoint] = initial_spc_data
pie_data: List[PieChartData] = initial_pie_data
distribution_data: List[DistributionPoint] = initial_distribution_data
def _reset_to_initial(self):
"""Resets data to a new initial state."""
self.process_metrics = _generate_process_metrics()
self.spc_chart_data = _generate_spc_data(base_min=self.lsl, base_max=self.usl)
self.pie_data = _generate_pie_data(self.process_metrics)
self.distribution_data = _generate_distribution_data(self.spc_chart_data)
@rx.event(background=True)
async def start_process(self):
"""Simulates starting a process and updating data over time using Faker."""
async with self:
if self.is_running:
return
self.is_running = True
self.time_to_completion = 0.0
update_interval = 0.1
data_gen_interval = 10
|
for i in range(101):
async with self:
self.time_to_completion = float(i)
if i > 0 and i % data_gen_interval == 0:
last_name = (
self.spc_chart_data[-1]["name"] if self.spc_chart_data else -1
)
new_name = last_name + 1
new_value_base = fake.pyfloat(
left_digits=0,
right_digits=4,
positive=True,
min_value=self.lsl - 0.002,
max_value=self.usl + 0.002,
)
if self.spc_chart_data:
drift = random.uniform(-0.001, 0.001)
new_value_base = self.spc_chart_data[-1]["value"] + drift
if random.random() < 0.08:
new_value_base += random.uniform(0.003, 0.008)
elif random.random() < 0 | metrics_update_interval = 30 |
nitial_spc_data
pie_data: List[PieChartData] = initial_pie_data
distribution_data: List[DistributionPoint] = initial_distribution_data
def _reset_to_initial(self):
"""Resets data to a new initial state."""
self.process_metrics = _generate_process_metrics()
self.spc_chart_data = _generate_spc_data(base_min=self.lsl, base_max=self.usl)
self.pie_data = _generate_pie_data(self.process_metrics)
self.distribution_data = _generate_distribution_data(self.spc_chart_data)
@rx.event(background=True)
async def start_process(self):
"""Simulates starting a process and updating data over time using Faker."""
async with self:
if self.is_running:
return
self.is_running = True
self.time_to_completion = 0.0
update_interval = 0.1
data_gen_interval = 10
metrics_update_interval = 30
for i in range(101):
async with self:
|
if i > 0 and i % data_gen_interval == 0:
last_name = (
self.spc_chart_data[-1]["name"] if self.spc_chart_data else -1
)
new_name = last_name + 1
new_value_base = fake.pyfloat(
left_digits=0,
right_digits=4,
positive=True,
min_value=self.lsl - 0.002,
max_value=self.usl + 0.002,
)
if self.spc_chart_data:
drift = random.uniform(-0.001, 0.001)
new_value_base = self.spc_chart_data[-1]["value"] + drift
if random.random() < 0.08:
new_value_base += random.uniform(0.003, 0.008)
elif random.random() < 0.08:
new_value_base -= random.uniform(0.003, 0.008)
new_value = r | self.time_to_completion = float(i) |
t] = initial_distribution_data
def _reset_to_initial(self):
"""Resets data to a new initial state."""
self.process_metrics = _generate_process_metrics()
self.spc_chart_data = _generate_spc_data(base_min=self.lsl, base_max=self.usl)
self.pie_data = _generate_pie_data(self.process_metrics)
self.distribution_data = _generate_distribution_data(self.spc_chart_data)
@rx.event(background=True)
async def start_process(self):
"""Simulates starting a process and updating data over time using Faker."""
async with self:
if self.is_running:
return
self.is_running = True
self.time_to_completion = 0.0
update_interval = 0.1
data_gen_interval = 10
metrics_update_interval = 30
for i in range(101):
async with self:
self.time_to_completion = float(i)
if i > 0 and i % data_gen_interval == 0:
|
new_name = last_name + 1
new_value_base = fake.pyfloat(
left_digits=0,
right_digits=4,
positive=True,
min_value=self.lsl - 0.002,
max_value=self.usl + 0.002,
)
if self.spc_chart_data:
drift = random.uniform(-0.001, 0.001)
new_value_base = self.spc_chart_data[-1]["value"] + drift
if random.random() < 0.08:
new_value_base += random.uniform(0.003, 0.008)
elif random.random() < 0.08:
new_value_base -= random.uniform(0.003, 0.008)
new_value = round(
max(
self.lcl - 0.01,
min(
self.ucl + 0.01,
new_va | last_name = (
self.spc_chart_data[-1]["name"] if self.spc_chart_data else -1
) |
pc_chart_data = _generate_spc_data(base_min=self.lsl, base_max=self.usl)
self.pie_data = _generate_pie_data(self.process_metrics)
self.distribution_data = _generate_distribution_data(self.spc_chart_data)
@rx.event(background=True)
async def start_process(self):
"""Simulates starting a process and updating data over time using Faker."""
async with self:
if self.is_running:
return
self.is_running = True
self.time_to_completion = 0.0
update_interval = 0.1
data_gen_interval = 10
metrics_update_interval = 30
for i in range(101):
async with self:
self.time_to_completion = float(i)
if i > 0 and i % data_gen_interval == 0:
last_name = (
self.spc_chart_data[-1]["name"] if self.spc_chart_data else -1
)
new_name = last_name + 1
|
if self.spc_chart_data:
drift = random.uniform(-0.001, 0.001)
new_value_base = self.spc_chart_data[-1]["value"] + drift
if random.random() < 0.08:
new_value_base += random.uniform(0.003, 0.008)
elif random.random() < 0.08:
new_value_base -= random.uniform(0.003, 0.008)
new_value = round(
max(
self.lcl - 0.01,
min(
self.ucl + 0.01,
new_value_base,
),
),
4,
)
new_point: SpcDataPoint = {
"name": new_name,
"value": new_value,
}
self.spc_chart_data = ([*self.spc_chart_data, n | new_value_base = fake.pyfloat(
left_digits=0,
right_digits=4,
positive=True,
min_value=self.lsl - 0.002,
max_value=self.usl + 0.002,
) |
"""Simulates starting a process and updating data over time using Faker."""
async with self:
if self.is_running:
return
self.is_running = True
self.time_to_completion = 0.0
update_interval = 0.1
data_gen_interval = 10
metrics_update_interval = 30
for i in range(101):
async with self:
self.time_to_completion = float(i)
if i > 0 and i % data_gen_interval == 0:
last_name = (
self.spc_chart_data[-1]["name"] if self.spc_chart_data else -1
)
new_name = last_name + 1
new_value_base = fake.pyfloat(
left_digits=0,
right_digits=4,
positive=True,
min_value=self.lsl - 0.002,
max_value=self.usl + 0.002,
)
|
if random.random() < 0.08:
new_value_base += random.uniform(0.003, 0.008)
elif random.random() < 0.08:
new_value_base -= random.uniform(0.003, 0.008)
new_value = round(
max(
self.lcl - 0.01,
min(
self.ucl + 0.01,
new_value_base,
),
),
4,
)
new_point: SpcDataPoint = {
"name": new_name,
"value": new_value,
}
self.spc_chart_data = ([*self.spc_chart_data, new_point])[-50:]
self.distribution_data = _generate_distribution_data(
self.spc_chart_data
)
if i > 0 and i | if self.spc_chart_data:
drift = random.uniform(-0.001, 0.001)
new_value_base = self.spc_chart_data[-1]["value"] + drift |
a over time using Faker."""
async with self:
if self.is_running:
return
self.is_running = True
self.time_to_completion = 0.0
update_interval = 0.1
data_gen_interval = 10
metrics_update_interval = 30
for i in range(101):
async with self:
self.time_to_completion = float(i)
if i > 0 and i % data_gen_interval == 0:
last_name = (
self.spc_chart_data[-1]["name"] if self.spc_chart_data else -1
)
new_name = last_name + 1
new_value_base = fake.pyfloat(
left_digits=0,
right_digits=4,
positive=True,
min_value=self.lsl - 0.002,
max_value=self.usl + 0.002,
)
if self.spc_chart_data:
|
new_value_base = self.spc_chart_data[-1]["value"] + drift
if random.random() < 0.08:
new_value_base += random.uniform(0.003, 0.008)
elif random.random() < 0.08:
new_value_base -= random.uniform(0.003, 0.008)
new_value = round(
max(
self.lcl - 0.01,
min(
self.ucl + 0.01,
new_value_base,
),
),
4,
)
new_point: SpcDataPoint = {
"name": new_name,
"value": new_value,
}
self.spc_chart_data = ([*self.spc_chart_data, new_point])[-50:]
self.distribution_data = _generate_distribution_data(
| drift = random.uniform(-0.001, 0.001) |
if self.is_running:
return
self.is_running = True
self.time_to_completion = 0.0
update_interval = 0.1
data_gen_interval = 10
metrics_update_interval = 30
for i in range(101):
async with self:
self.time_to_completion = float(i)
if i > 0 and i % data_gen_interval == 0:
last_name = (
self.spc_chart_data[-1]["name"] if self.spc_chart_data else -1
)
new_name = last_name + 1
new_value_base = fake.pyfloat(
left_digits=0,
right_digits=4,
positive=True,
min_value=self.lsl - 0.002,
max_value=self.usl + 0.002,
)
if self.spc_chart_data:
drift = random.uniform(-0.001, 0.001)
|
if random.random() < 0.08:
new_value_base += random.uniform(0.003, 0.008)
elif random.random() < 0.08:
new_value_base -= random.uniform(0.003, 0.008)
new_value = round(
max(
self.lcl - 0.01,
min(
self.ucl + 0.01,
new_value_base,
),
),
4,
)
new_point: SpcDataPoint = {
"name": new_name,
"value": new_value,
}
self.spc_chart_data = ([*self.spc_chart_data, new_point])[-50:]
self.distribution_data = _generate_distribution_data(
self.spc_chart_data
)
if i > 0 and i | new_value_base = self.spc_chart_data[-1]["value"] + drift |
ue
self.time_to_completion = 0.0
update_interval = 0.1
data_gen_interval = 10
metrics_update_interval = 30
for i in range(101):
async with self:
self.time_to_completion = float(i)
if i > 0 and i % data_gen_interval == 0:
last_name = (
self.spc_chart_data[-1]["name"] if self.spc_chart_data else -1
)
new_name = last_name + 1
new_value_base = fake.pyfloat(
left_digits=0,
right_digits=4,
positive=True,
min_value=self.lsl - 0.002,
max_value=self.usl + 0.002,
)
if self.spc_chart_data:
drift = random.uniform(-0.001, 0.001)
new_value_base = self.spc_chart_data[-1]["value"] + drift
|
new_value = round(
max(
self.lcl - 0.01,
min(
self.ucl + 0.01,
new_value_base,
),
),
4,
)
new_point: SpcDataPoint = {
"name": new_name,
"value": new_value,
}
self.spc_chart_data = ([*self.spc_chart_data, new_point])[-50:]
self.distribution_data = _generate_distribution_data(
self.spc_chart_data
)
if i > 0 and i % metrics_update_interval == 0:
self.process_metrics = _generate_process_metrics()
self.pie_data = _generate_pie_data(self.process_metrics)
await asyncio.sleep(update_interval)
| if random.random() < 0.08:
new_value_base += random.uniform(0.003, 0.008)
elif random.random() < 0.08:
new_value_base -= random.uniform(0.003, 0.008) |
ics_update_interval = 30
for i in range(101):
async with self:
self.time_to_completion = float(i)
if i > 0 and i % data_gen_interval == 0:
last_name = (
self.spc_chart_data[-1]["name"] if self.spc_chart_data else -1
)
new_name = last_name + 1
new_value_base = fake.pyfloat(
left_digits=0,
right_digits=4,
positive=True,
min_value=self.lsl - 0.002,
max_value=self.usl + 0.002,
)
if self.spc_chart_data:
drift = random.uniform(-0.001, 0.001)
new_value_base = self.spc_chart_data[-1]["value"] + drift
if random.random() < 0.08:
new_value_base += random.uniform(0.003, 0.008)
|
new_value = round(
max(
self.lcl - 0.01,
min(
self.ucl + 0.01,
new_value_base,
),
),
4,
)
new_point: SpcDataPoint = {
"name": new_name,
"value": new_value,
}
self.spc_chart_data = ([*self.spc_chart_data, new_point])[-50:]
self.distribution_data = _generate_distribution_data(
self.spc_chart_data
)
if i > 0 and i % metrics_update_interval == 0:
self.process_metrics = _generate_process_metrics()
self.pie_data = _generate_pie_data(self.process_metrics)
await asyncio.sleep(update_interval)
| elif random.random() < 0.08:
new_value_base -= random.uniform(0.003, 0.008) |
on = float(i)
if i > 0 and i % data_gen_interval == 0:
last_name = (
self.spc_chart_data[-1]["name"] if self.spc_chart_data else -1
)
new_name = last_name + 1
new_value_base = fake.pyfloat(
left_digits=0,
right_digits=4,
positive=True,
min_value=self.lsl - 0.002,
max_value=self.usl + 0.002,
)
if self.spc_chart_data:
drift = random.uniform(-0.001, 0.001)
new_value_base = self.spc_chart_data[-1]["value"] + drift
if random.random() < 0.08:
new_value_base += random.uniform(0.003, 0.008)
elif random.random() < 0.08:
new_value_base -= random.uniform(0.003, 0.008)
|
new_point: SpcDataPoint = {
"name": new_name,
"value": new_value,
}
self.spc_chart_data = ([*self.spc_chart_data, new_point])[-50:]
self.distribution_data = _generate_distribution_data(
self.spc_chart_data
)
if i > 0 and i % metrics_update_interval == 0:
self.process_metrics = _generate_process_metrics()
self.pie_data = _generate_pie_data(self.process_metrics)
await asyncio.sleep(update_interval)
yield
async with self:
self.is_running = False
self._reset_to_initial()
@rx.var
def get_time_stroke_dasharray(self) -> str:
"""Calculates the stroke-dasharray for the time completion circle."""
percentage = self.time_to_completion
radius = 40
circumference = 2 * 3.14159 * r | new_value = round(
max(
self.lcl - 0.01,
min(
self.ucl + 0.01,
new_value_base,
),
),
4,
) |
x_value=self.usl + 0.002,
)
if self.spc_chart_data:
drift = random.uniform(-0.001, 0.001)
new_value_base = self.spc_chart_data[-1]["value"] + drift
if random.random() < 0.08:
new_value_base += random.uniform(0.003, 0.008)
elif random.random() < 0.08:
new_value_base -= random.uniform(0.003, 0.008)
new_value = round(
max(
self.lcl - 0.01,
min(
self.ucl + 0.01,
new_value_base,
),
),
4,
)
new_point: SpcDataPoint = {
"name": new_name,
"value": new_value,
}
|
self.distribution_data = _generate_distribution_data(
self.spc_chart_data
)
if i > 0 and i % metrics_update_interval == 0:
self.process_metrics = _generate_process_metrics()
self.pie_data = _generate_pie_data(self.process_metrics)
await asyncio.sleep(update_interval)
yield
async with self:
self.is_running = False
self._reset_to_initial()
@rx.var
def get_time_stroke_dasharray(self) -> str:
"""Calculates the stroke-dasharray for the time completion circle."""
percentage = self.time_to_completion
radius = 40
circumference = 2 * 3.14159 * radius
clamped_percentage = max(0, min(percentage, 100))
dash_length = clamped_percentage / 100 * circumference
dash_length = max(0, dash_length)
gap_length = max(0, circumference - dash_length)
return | self.spc_chart_data = ([*self.spc_chart_data, new_point])[-50:] |
t_data:
drift = random.uniform(-0.001, 0.001)
new_value_base = self.spc_chart_data[-1]["value"] + drift
if random.random() < 0.08:
new_value_base += random.uniform(0.003, 0.008)
elif random.random() < 0.08:
new_value_base -= random.uniform(0.003, 0.008)
new_value = round(
max(
self.lcl - 0.01,
min(
self.ucl + 0.01,
new_value_base,
),
),
4,
)
new_point: SpcDataPoint = {
"name": new_name,
"value": new_value,
}
self.spc_chart_data = ([*self.spc_chart_data, new_point])[-50:]
|
if i > 0 and i % metrics_update_interval == 0:
self.process_metrics = _generate_process_metrics()
self.pie_data = _generate_pie_data(self.process_metrics)
await asyncio.sleep(update_interval)
yield
async with self:
self.is_running = False
self._reset_to_initial()
@rx.var
def get_time_stroke_dasharray(self) -> str:
"""Calculates the stroke-dasharray for the time completion circle."""
percentage = self.time_to_completion
radius = 40
circumference = 2 * 3.14159 * radius
clamped_percentage = max(0, min(percentage, 100))
dash_length = clamped_percentage / 100 * circumference
dash_length = max(0, dash_length)
gap_length = max(0, circumference - dash_length)
return f"{dash_length:.2f} {gap_length:.2f}"
@rx.var
def ooc_points(self) -> List[SpcDataPoint]:
"""Filters SPC data to find poin | self.distribution_data = _generate_distribution_data(
self.spc_chart_data
) |
value"] + drift
if random.random() < 0.08:
new_value_base += random.uniform(0.003, 0.008)
elif random.random() < 0.08:
new_value_base -= random.uniform(0.003, 0.008)
new_value = round(
max(
self.lcl - 0.01,
min(
self.ucl + 0.01,
new_value_base,
),
),
4,
)
new_point: SpcDataPoint = {
"name": new_name,
"value": new_value,
}
self.spc_chart_data = ([*self.spc_chart_data, new_point])[-50:]
self.distribution_data = _generate_distribution_data(
self.spc_chart_data
)
|
await asyncio.sleep(update_interval)
yield
async with self:
self.is_running = False
self._reset_to_initial()
@rx.var
def get_time_stroke_dasharray(self) -> str:
"""Calculates the stroke-dasharray for the time completion circle."""
percentage = self.time_to_completion
radius = 40
circumference = 2 * 3.14159 * radius
clamped_percentage = max(0, min(percentage, 100))
dash_length = clamped_percentage / 100 * circumference
dash_length = max(0, dash_length)
gap_length = max(0, circumference - dash_length)
return f"{dash_length:.2f} {gap_length:.2f}"
@rx.var
def ooc_points(self) -> List[SpcDataPoint]:
"""Filters SPC data to find points outside control limits (OOC)."""
ooc = []
if not self.spc_chart_data:
return []
ooc = [
point
for point in self.spc_chart_data
if isinst | if i > 0 and i % metrics_update_interval == 0:
self.process_metrics = _generate_process_metrics()
self.pie_data = _generate_pie_data(self.process_metrics) |
new_value_base += random.uniform(0.003, 0.008)
elif random.random() < 0.08:
new_value_base -= random.uniform(0.003, 0.008)
new_value = round(
max(
self.lcl - 0.01,
min(
self.ucl + 0.01,
new_value_base,
),
),
4,
)
new_point: SpcDataPoint = {
"name": new_name,
"value": new_value,
}
self.spc_chart_data = ([*self.spc_chart_data, new_point])[-50:]
self.distribution_data = _generate_distribution_data(
self.spc_chart_data
)
if i > 0 and i % metrics_update_interval == 0:
|
self.pie_data = _generate_pie_data(self.process_metrics)
await asyncio.sleep(update_interval)
yield
async with self:
self.is_running = False
self._reset_to_initial()
@rx.var
def get_time_stroke_dasharray(self) -> str:
"""Calculates the stroke-dasharray for the time completion circle."""
percentage = self.time_to_completion
radius = 40
circumference = 2 * 3.14159 * radius
clamped_percentage = max(0, min(percentage, 100))
dash_length = clamped_percentage / 100 * circumference
dash_length = max(0, dash_length)
gap_length = max(0, circumference - dash_length)
return f"{dash_length:.2f} {gap_length:.2f}"
@rx.var
def ooc_points(self) -> List[SpcDataPoint]:
"""Filters SPC data to find points outside control limits (OOC)."""
ooc = []
if not self.spc_chart_data:
return []
ooc = [
| self.process_metrics = _generate_process_metrics() |
elif random.random() < 0.08:
new_value_base -= random.uniform(0.003, 0.008)
new_value = round(
max(
self.lcl - 0.01,
min(
self.ucl + 0.01,
new_value_base,
),
),
4,
)
new_point: SpcDataPoint = {
"name": new_name,
"value": new_value,
}
self.spc_chart_data = ([*self.spc_chart_data, new_point])[-50:]
self.distribution_data = _generate_distribution_data(
self.spc_chart_data
)
if i > 0 and i % metrics_update_interval == 0:
self.process_metrics = _generate_process_metrics()
|
await asyncio.sleep(update_interval)
yield
async with self:
self.is_running = False
self._reset_to_initial()
@rx.var
def get_time_stroke_dasharray(self) -> str:
"""Calculates the stroke-dasharray for the time completion circle."""
percentage = self.time_to_completion
radius = 40
circumference = 2 * 3.14159 * radius
clamped_percentage = max(0, min(percentage, 100))
dash_length = clamped_percentage / 100 * circumference
dash_length = max(0, dash_length)
gap_length = max(0, circumference - dash_length)
return f"{dash_length:.2f} {gap_length:.2f}"
@rx.var
def ooc_points(self) -> List[SpcDataPoint]:
"""Filters SPC data to find points outside control limits (OOC)."""
ooc = []
if not self.spc_chart_data:
return []
ooc = [
point
for point in self.spc_chart_data
if isinst | self.pie_data = _generate_pie_data(self.process_metrics) |
max(
self.lcl - 0.01,
min(
self.ucl + 0.01,
new_value_base,
),
),
4,
)
new_point: SpcDataPoint = {
"name": new_name,
"value": new_value,
}
self.spc_chart_data = ([*self.spc_chart_data, new_point])[-50:]
self.distribution_data = _generate_distribution_data(
self.spc_chart_data
)
if i > 0 and i % metrics_update_interval == 0:
self.process_metrics = _generate_process_metrics()
self.pie_data = _generate_pie_data(self.process_metrics)
await asyncio.sleep(update_interval)
yield
async with self:
|
self._reset_to_initial()
@rx.var
def get_time_stroke_dasharray(self) -> str:
"""Calculates the stroke-dasharray for the time completion circle."""
percentage = self.time_to_completion
radius = 40
circumference = 2 * 3.14159 * radius
clamped_percentage = max(0, min(percentage, 100))
dash_length = clamped_percentage / 100 * circumference
dash_length = max(0, dash_length)
gap_length = max(0, circumference - dash_length)
return f"{dash_length:.2f} {gap_length:.2f}"
@rx.var
def ooc_points(self) -> List[SpcDataPoint]:
"""Filters SPC data to find points outside control limits (OOC)."""
ooc = []
if not self.spc_chart_data:
return []
ooc = [
point
for point in self.spc_chart_data
if isinstance(point.get("value"), (int, float))
and (point["value"] < self.lcl or point["value"] > self.ucl)
]
| self.is_running = False |
min(
self.ucl + 0.01,
new_value_base,
),
),
4,
)
new_point: SpcDataPoint = {
"name": new_name,
"value": new_value,
}
self.spc_chart_data = ([*self.spc_chart_data, new_point])[-50:]
self.distribution_data = _generate_distribution_data(
self.spc_chart_data
)
if i > 0 and i % metrics_update_interval == 0:
self.process_metrics = _generate_process_metrics()
self.pie_data = _generate_pie_data(self.process_metrics)
await asyncio.sleep(update_interval)
yield
async with self:
self.is_running = False
self._reset_to_initial()
@rx.var
|
@rx.var
def ooc_points(self) -> List[SpcDataPoint]:
"""Filters SPC data to find points outside control limits (OOC)."""
ooc = []
if not self.spc_chart_data:
return []
ooc = [
point
for point in self.spc_chart_data
if isinstance(point.get("value"), (int, float))
and (point["value"] < self.lcl or point["value"] > self.ucl)
]
return ooc
| def get_time_stroke_dasharray(self) -> str:
"""Calculates the stroke-dasharray for the time completion circle."""
percentage = self.time_to_completion
radius = 40
circumference = 2 * 3.14159 * radius
clamped_percentage = max(0, min(percentage, 100))
dash_length = clamped_percentage / 100 * circumference
dash_length = max(0, dash_length)
gap_length = max(0, circumference - dash_length)
return f"{dash_length:.2f} {gap_length:.2f}" |
),
),
4,
)
new_point: SpcDataPoint = {
"name": new_name,
"value": new_value,
}
self.spc_chart_data = ([*self.spc_chart_data, new_point])[-50:]
self.distribution_data = _generate_distribution_data(
self.spc_chart_data
)
if i > 0 and i % metrics_update_interval == 0:
self.process_metrics = _generate_process_metrics()
self.pie_data = _generate_pie_data(self.process_metrics)
await asyncio.sleep(update_interval)
yield
async with self:
self.is_running = False
self._reset_to_initial()
@rx.var
def get_time_stroke_dasharray(self) -> str:
"""Calculates the stroke-dasharray for the time completion circle."""
|
radius = 40
circumference = 2 * 3.14159 * radius
clamped_percentage = max(0, min(percentage, 100))
dash_length = clamped_percentage / 100 * circumference
dash_length = max(0, dash_length)
gap_length = max(0, circumference - dash_length)
return f"{dash_length:.2f} {gap_length:.2f}"
@rx.var
def ooc_points(self) -> List[SpcDataPoint]:
"""Filters SPC data to find points outside control limits (OOC)."""
ooc = []
if not self.spc_chart_data:
return []
ooc = [
point
for point in self.spc_chart_data
if isinstance(point.get("value"), (int, float))
and (point["value"] < self.lcl or point["value"] > self.ucl)
]
return ooc
| percentage = self.time_to_completion |
),
4,
)
new_point: SpcDataPoint = {
"name": new_name,
"value": new_value,
}
self.spc_chart_data = ([*self.spc_chart_data, new_point])[-50:]
self.distribution_data = _generate_distribution_data(
self.spc_chart_data
)
if i > 0 and i % metrics_update_interval == 0:
self.process_metrics = _generate_process_metrics()
self.pie_data = _generate_pie_data(self.process_metrics)
await asyncio.sleep(update_interval)
yield
async with self:
self.is_running = False
self._reset_to_initial()
@rx.var
def get_time_stroke_dasharray(self) -> str:
"""Calculates the stroke-dasharray for the time completion circle."""
percentage = self.time_to_completion
|
circumference = 2 * 3.14159 * radius
clamped_percentage = max(0, min(percentage, 100))
dash_length = clamped_percentage / 100 * circumference
dash_length = max(0, dash_length)
gap_length = max(0, circumference - dash_length)
return f"{dash_length:.2f} {gap_length:.2f}"
@rx.var
def ooc_points(self) -> List[SpcDataPoint]:
"""Filters SPC data to find points outside control limits (OOC)."""
ooc = []
if not self.spc_chart_data:
return []
ooc = [
point
for point in self.spc_chart_data
if isinstance(point.get("value"), (int, float))
and (point["value"] < self.lcl or point["value"] > self.ucl)
]
return ooc
| radius = 40 |
new_point: SpcDataPoint = {
"name": new_name,
"value": new_value,
}
self.spc_chart_data = ([*self.spc_chart_data, new_point])[-50:]
self.distribution_data = _generate_distribution_data(
self.spc_chart_data
)
if i > 0 and i % metrics_update_interval == 0:
self.process_metrics = _generate_process_metrics()
self.pie_data = _generate_pie_data(self.process_metrics)
await asyncio.sleep(update_interval)
yield
async with self:
self.is_running = False
self._reset_to_initial()
@rx.var
def get_time_stroke_dasharray(self) -> str:
"""Calculates the stroke-dasharray for the time completion circle."""
percentage = self.time_to_completion
radius = 40
circumference = 2 * 3.14159 * radius
|
dash_length = clamped_percentage / 100 * circumference
dash_length = max(0, dash_length)
gap_length = max(0, circumference - dash_length)
return f"{dash_length:.2f} {gap_length:.2f}"
@rx.var
def ooc_points(self) -> List[SpcDataPoint]:
"""Filters SPC data to find points outside control limits (OOC)."""
ooc = []
if not self.spc_chart_data:
return []
ooc = [
point
for point in self.spc_chart_data
if isinstance(point.get("value"), (int, float))
and (point["value"] < self.lcl or point["value"] > self.ucl)
]
return ooc
| clamped_percentage = max(0, min(percentage, 100)) |
"name": new_name,
"value": new_value,
}
self.spc_chart_data = ([*self.spc_chart_data, new_point])[-50:]
self.distribution_data = _generate_distribution_data(
self.spc_chart_data
)
if i > 0 and i % metrics_update_interval == 0:
self.process_metrics = _generate_process_metrics()
self.pie_data = _generate_pie_data(self.process_metrics)
await asyncio.sleep(update_interval)
yield
async with self:
self.is_running = False
self._reset_to_initial()
@rx.var
def get_time_stroke_dasharray(self) -> str:
"""Calculates the stroke-dasharray for the time completion circle."""
percentage = self.time_to_completion
radius = 40
circumference = 2 * 3.14159 * radius
clamped_percentage = max(0, min(percentage, 100))
|
dash_length = max(0, dash_length)
gap_length = max(0, circumference - dash_length)
return f"{dash_length:.2f} {gap_length:.2f}"
@rx.var
def ooc_points(self) -> List[SpcDataPoint]:
"""Filters SPC data to find points outside control limits (OOC)."""
ooc = []
if not self.spc_chart_data:
return []
ooc = [
point
for point in self.spc_chart_data
if isinstance(point.get("value"), (int, float))
and (point["value"] < self.lcl or point["value"] > self.ucl)
]
return ooc
| dash_length = clamped_percentage / 100 * circumference |
}
self.spc_chart_data = ([*self.spc_chart_data, new_point])[-50:]
self.distribution_data = _generate_distribution_data(
self.spc_chart_data
)
if i > 0 and i % metrics_update_interval == 0:
self.process_metrics = _generate_process_metrics()
self.pie_data = _generate_pie_data(self.process_metrics)
await asyncio.sleep(update_interval)
yield
async with self:
self.is_running = False
self._reset_to_initial()
@rx.var
def get_time_stroke_dasharray(self) -> str:
"""Calculates the stroke-dasharray for the time completion circle."""
percentage = self.time_to_completion
radius = 40
circumference = 2 * 3.14159 * radius
clamped_percentage = max(0, min(percentage, 100))
dash_length = clamped_percentage / 100 * circumference
|
gap_length = max(0, circumference - dash_length)
return f"{dash_length:.2f} {gap_length:.2f}"
@rx.var
def ooc_points(self) -> List[SpcDataPoint]:
"""Filters SPC data to find points outside control limits (OOC)."""
ooc = []
if not self.spc_chart_data:
return []
ooc = [
point
for point in self.spc_chart_data
if isinstance(point.get("value"), (int, float))
and (point["value"] < self.lcl or point["value"] > self.ucl)
]
return ooc
| dash_length = max(0, dash_length) |
self.spc_chart_data = ([*self.spc_chart_data, new_point])[-50:]
self.distribution_data = _generate_distribution_data(
self.spc_chart_data
)
if i > 0 and i % metrics_update_interval == 0:
self.process_metrics = _generate_process_metrics()
self.pie_data = _generate_pie_data(self.process_metrics)
await asyncio.sleep(update_interval)
yield
async with self:
self.is_running = False
self._reset_to_initial()
@rx.var
def get_time_stroke_dasharray(self) -> str:
"""Calculates the stroke-dasharray for the time completion circle."""
percentage = self.time_to_completion
radius = 40
circumference = 2 * 3.14159 * radius
clamped_percentage = max(0, min(percentage, 100))
dash_length = clamped_percentage / 100 * circumference
dash_length = max(0, dash_length)
|
return f"{dash_length:.2f} {gap_length:.2f}"
@rx.var
def ooc_points(self) -> List[SpcDataPoint]:
"""Filters SPC data to find points outside control limits (OOC)."""
ooc = []
if not self.spc_chart_data:
return []
ooc = [
point
for point in self.spc_chart_data
if isinstance(point.get("value"), (int, float))
and (point["value"] < self.lcl or point["value"] > self.ucl)
]
return ooc
| gap_length = max(0, circumference - dash_length) |
distribution_data(
self.spc_chart_data
)
if i > 0 and i % metrics_update_interval == 0:
self.process_metrics = _generate_process_metrics()
self.pie_data = _generate_pie_data(self.process_metrics)
await asyncio.sleep(update_interval)
yield
async with self:
self.is_running = False
self._reset_to_initial()
@rx.var
def get_time_stroke_dasharray(self) -> str:
"""Calculates the stroke-dasharray for the time completion circle."""
percentage = self.time_to_completion
radius = 40
circumference = 2 * 3.14159 * radius
clamped_percentage = max(0, min(percentage, 100))
dash_length = clamped_percentage / 100 * circumference
dash_length = max(0, dash_length)
gap_length = max(0, circumference - dash_length)
return f"{dash_length:.2f} {gap_length:.2f}"
@rx.var
| def ooc_points(self) -> List[SpcDataPoint]:
"""Filters SPC data to find points outside control limits (OOC)."""
ooc = []
if not self.spc_chart_data:
return []
ooc = [
point
for point in self.spc_chart_data
if isinstance(point.get("value"), (int, float))
and (point["value"] < self.lcl or point["value"] > self.ucl)
]
return ooc | |
0:
self.process_metrics = _generate_process_metrics()
self.pie_data = _generate_pie_data(self.process_metrics)
await asyncio.sleep(update_interval)
yield
async with self:
self.is_running = False
self._reset_to_initial()
@rx.var
def get_time_stroke_dasharray(self) -> str:
"""Calculates the stroke-dasharray for the time completion circle."""
percentage = self.time_to_completion
radius = 40
circumference = 2 * 3.14159 * radius
clamped_percentage = max(0, min(percentage, 100))
dash_length = clamped_percentage / 100 * circumference
dash_length = max(0, dash_length)
gap_length = max(0, circumference - dash_length)
return f"{dash_length:.2f} {gap_length:.2f}"
@rx.var
def ooc_points(self) -> List[SpcDataPoint]:
"""Filters SPC data to find points outside control limits (OOC)."""
ooc = []
|
ooc = [
point
for point in self.spc_chart_data
if isinstance(point.get("value"), (int, float))
and (point["value"] < self.lcl or point["value"] > self.ucl)
]
return ooc
| if not self.spc_chart_data:
return [] |
ocess_metrics()
self.pie_data = _generate_pie_data(self.process_metrics)
await asyncio.sleep(update_interval)
yield
async with self:
self.is_running = False
self._reset_to_initial()
@rx.var
def get_time_stroke_dasharray(self) -> str:
"""Calculates the stroke-dasharray for the time completion circle."""
percentage = self.time_to_completion
radius = 40
circumference = 2 * 3.14159 * radius
clamped_percentage = max(0, min(percentage, 100))
dash_length = clamped_percentage / 100 * circumference
dash_length = max(0, dash_length)
gap_length = max(0, circumference - dash_length)
return f"{dash_length:.2f} {gap_length:.2f}"
@rx.var
def ooc_points(self) -> List[SpcDataPoint]:
"""Filters SPC data to find points outside control limits (OOC)."""
ooc = []
if not self.spc_chart_data:
return []
|
return ooc
| ooc = [
point
for point in self.spc_chart_data
if isinstance(point.get("value"), (int, float))
and (point["value"] < self.lcl or point["value"] > self.ucl)
] |
from .backend.backend import State
from .views.navbar import navbar
from .views.stats import stats_ui
from .views.table import main_table
def _tabs_trigger(text: str, icon: str, value: str):
return rx.tabs.trigger(
rx.hstack(
rx.icon(icon, size=24),
rx.heading(text, size="5"),
spacing="2",
align="center",
width="100%",
),
value=value,
)
def index() -> rx.Component:
return rx.vstack(
navbar(),
rx.tabs.root(
rx.tabs.list(
_tabs_trigger("Table", "table-2", value="table"),
_tabs_trigger("Stats", "bar-chart-3", value="stats"),
),
rx.tabs.content(
main_table(),
margin_top="1em",
value="table",
),
rx.tabs.content(
stats_ui(),
margin_top="1em",
value="stats",
),
default | import reflex as rx | |
import reflex as rx
|
from .views.navbar import navbar
from .views.stats import stats_ui
from .views.table import main_table
def _tabs_trigger(text: str, icon: str, value: str):
return rx.tabs.trigger(
rx.hstack(
rx.icon(icon, size=24),
rx.heading(text, size="5"),
spacing="2",
align="center",
width="100%",
),
value=value,
)
def index() -> rx.Component:
return rx.vstack(
navbar(),
rx.tabs.root(
rx.tabs.list(
_tabs_trigger("Table", "table-2", value="table"),
_tabs_trigger("Stats", "bar-chart-3", value="stats"),
),
rx.tabs.content(
main_table(),
margin_top="1em",
value="table",
),
rx.tabs.content(
stats_ui(),
margin_top="1em",
value="stats",
),
default_value="table",
width="1 | from .backend.backend import State |
import reflex as rx
from .backend.backend import State
|
from .views.stats import stats_ui
from .views.table import main_table
def _tabs_trigger(text: str, icon: str, value: str):
return rx.tabs.trigger(
rx.hstack(
rx.icon(icon, size=24),
rx.heading(text, size="5"),
spacing="2",
align="center",
width="100%",
),
value=value,
)
def index() -> rx.Component:
return rx.vstack(
navbar(),
rx.tabs.root(
rx.tabs.list(
_tabs_trigger("Table", "table-2", value="table"),
_tabs_trigger("Stats", "bar-chart-3", value="stats"),
),
rx.tabs.content(
main_table(),
margin_top="1em",
value="table",
),
rx.tabs.content(
stats_ui(),
margin_top="1em",
value="stats",
),
default_value="table",
width="100%",
),
width="1 | from .views.navbar import navbar |
import reflex as rx
from .backend.backend import State
from .views.navbar import navbar
|
from .views.table import main_table
def _tabs_trigger(text: str, icon: str, value: str):
return rx.tabs.trigger(
rx.hstack(
rx.icon(icon, size=24),
rx.heading(text, size="5"),
spacing="2",
align="center",
width="100%",
),
value=value,
)
def index() -> rx.Component:
return rx.vstack(
navbar(),
rx.tabs.root(
rx.tabs.list(
_tabs_trigger("Table", "table-2", value="table"),
_tabs_trigger("Stats", "bar-chart-3", value="stats"),
),
rx.tabs.content(
main_table(),
margin_top="1em",
value="table",
),
rx.tabs.content(
stats_ui(),
margin_top="1em",
value="stats",
),
default_value="table",
width="100%",
),
width="100%",
spacing="6",
| from .views.stats import stats_ui |
import reflex as rx
from .backend.backend import State
from .views.navbar import navbar
from .views.stats import stats_ui
|
def _tabs_trigger(text: str, icon: str, value: str):
return rx.tabs.trigger(
rx.hstack(
rx.icon(icon, size=24),
rx.heading(text, size="5"),
spacing="2",
align="center",
width="100%",
),
value=value,
)
def index() -> rx.Component:
return rx.vstack(
navbar(),
rx.tabs.root(
rx.tabs.list(
_tabs_trigger("Table", "table-2", value="table"),
_tabs_trigger("Stats", "bar-chart-3", value="stats"),
),
rx.tabs.content(
main_table(),
margin_top="1em",
value="table",
),
rx.tabs.content(
stats_ui(),
margin_top="1em",
value="stats",
),
default_value="table",
width="100%",
),
width="100%",
spacing="6",
padding_x=["1.5em", "1.5em", "3em", | from .views.table import main_table |
rn rx.tabs.trigger(
rx.hstack(
rx.icon(icon, size=24),
rx.heading(text, size="5"),
spacing="2",
align="center",
width="100%",
),
value=value,
)
def index() -> rx.Component:
return rx.vstack(
navbar(),
rx.tabs.root(
rx.tabs.list(
_tabs_trigger("Table", "table-2", value="table"),
_tabs_trigger("Stats", "bar-chart-3", value="stats"),
),
rx.tabs.content(
main_table(),
margin_top="1em",
value="table",
),
rx.tabs.content(
stats_ui(),
margin_top="1em",
value="stats",
),
default_value="table",
width="100%",
),
width="100%",
spacing="6",
padding_x=["1.5em", "1.5em", "3em", "5em"],
padding_y=["1.25em", "1.25em", "2em"],
)
|
base_style = {
"font_family": "Inter",
}
app = rx.App(
style=base_style,
stylesheets=base_stylesheets,
theme=rx.theme(
appearance="light", has_background=True, radius="large", accent_color="orange"
),
)
app.add_page(
index,
on_load=State.load_entries,
title="NBA Data",
description="NBA Data for the 2015-2016 season.",
)
| base_stylesheets = [
"https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700;800&display=swap",
"grid.css",
] |
ng="2",
align="center",
width="100%",
),
value=value,
)
def index() -> rx.Component:
return rx.vstack(
navbar(),
rx.tabs.root(
rx.tabs.list(
_tabs_trigger("Table", "table-2", value="table"),
_tabs_trigger("Stats", "bar-chart-3", value="stats"),
),
rx.tabs.content(
main_table(),
margin_top="1em",
value="table",
),
rx.tabs.content(
stats_ui(),
margin_top="1em",
value="stats",
),
default_value="table",
width="100%",
),
width="100%",
spacing="6",
padding_x=["1.5em", "1.5em", "3em", "5em"],
padding_y=["1.25em", "1.25em", "2em"],
)
base_stylesheets = [
"https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700;800&display=swap",
"grid.css",
]
|
app = rx.App(
style=base_style,
stylesheets=base_stylesheets,
theme=rx.theme(
appearance="light", has_background=True, radius="large", accent_color="orange"
),
)
app.add_page(
index,
on_load=State.load_entries,
title="NBA Data",
description="NBA Data for the 2015-2016 season.",
)
| base_style = {
"font_family": "Inter",
} |
import numpy as np
import pandas as pd
import reflex as rx
from .data_items import all_items
from .player import Player
nba_csv = "nbastats.csv"
class State(rx.State):
"""The app state."""
players: list[Player] = []
search_value: str = ""
sort_value: str = ""
sort_reverse: bool = False
total_items: int = 0
offset: int = 0
limit: int = 12 # Number of rows per page
selected_items: Dict[str, List] = (
all_items # We add all items to the selected items by default
)
age: tuple[int, int] = (19, 40)
salary: tuple[int, int] = (0, 25000000)
@rx.event
def set_age(self, value: list[int | float]):
self.age = (int(value[0]), int(value[1]))
@rx.event
def set_salary(self, value: list[int | float]):
self.salary = (int(value[0]), int(value[1]))
@rx.event
def set_sort_value(self, value: str):
self.sort_value = value
@rx.event
def set_search_value(self, value: str):
self | from typing import Dict, List | |
from typing import Dict, List
|
import pandas as pd
import reflex as rx
from .data_items import all_items
from .player import Player
nba_csv = "nbastats.csv"
class State(rx.State):
"""The app state."""
players: list[Player] = []
search_value: str = ""
sort_value: str = ""
sort_reverse: bool = False
total_items: int = 0
offset: int = 0
limit: int = 12 # Number of rows per page
selected_items: Dict[str, List] = (
all_items # We add all items to the selected items by default
)
age: tuple[int, int] = (19, 40)
salary: tuple[int, int] = (0, 25000000)
@rx.event
def set_age(self, value: list[int | float]):
self.age = (int(value[0]), int(value[1]))
@rx.event
def set_salary(self, value: list[int | float]):
self.salary = (int(value[0]), int(value[1]))
@rx.event
def set_sort_value(self, value: str):
self.sort_value = value
@rx.event
def set_search_value(self, value: str):
self.search_value = valu | import numpy as np |
from typing import Dict, List
import numpy as np
|
import reflex as rx
from .data_items import all_items
from .player import Player
nba_csv = "nbastats.csv"
class State(rx.State):
"""The app state."""
players: list[Player] = []
search_value: str = ""
sort_value: str = ""
sort_reverse: bool = False
total_items: int = 0
offset: int = 0
limit: int = 12 # Number of rows per page
selected_items: Dict[str, List] = (
all_items # We add all items to the selected items by default
)
age: tuple[int, int] = (19, 40)
salary: tuple[int, int] = (0, 25000000)
@rx.event
def set_age(self, value: list[int | float]):
self.age = (int(value[0]), int(value[1]))
@rx.event
def set_salary(self, value: list[int | float]):
self.salary = (int(value[0]), int(value[1]))
@rx.event
def set_sort_value(self, value: str):
self.sort_value = value
@rx.event
def set_search_value(self, value: str):
self.search_value = value
@rx.var(cache | import pandas as pd |
from typing import Dict, List
import numpy as np
import pandas as pd
|
from .data_items import all_items
from .player import Player
nba_csv = "nbastats.csv"
class State(rx.State):
"""The app state."""
players: list[Player] = []
search_value: str = ""
sort_value: str = ""
sort_reverse: bool = False
total_items: int = 0
offset: int = 0
limit: int = 12 # Number of rows per page
selected_items: Dict[str, List] = (
all_items # We add all items to the selected items by default
)
age: tuple[int, int] = (19, 40)
salary: tuple[int, int] = (0, 25000000)
@rx.event
def set_age(self, value: list[int | float]):
self.age = (int(value[0]), int(value[1]))
@rx.event
def set_salary(self, value: list[int | float]):
self.salary = (int(value[0]), int(value[1]))
@rx.event
def set_sort_value(self, value: str):
self.sort_value = value
@rx.event
def set_search_value(self, value: str):
self.search_value = value
@rx.var(cache=True)
def filte | import reflex as rx |
from typing import Dict, List
import numpy as np
import pandas as pd
import reflex as rx
|
from .player import Player
nba_csv = "nbastats.csv"
class State(rx.State):
"""The app state."""
players: list[Player] = []
search_value: str = ""
sort_value: str = ""
sort_reverse: bool = False
total_items: int = 0
offset: int = 0
limit: int = 12 # Number of rows per page
selected_items: Dict[str, List] = (
all_items # We add all items to the selected items by default
)
age: tuple[int, int] = (19, 40)
salary: tuple[int, int] = (0, 25000000)
@rx.event
def set_age(self, value: list[int | float]):
self.age = (int(value[0]), int(value[1]))
@rx.event
def set_salary(self, value: list[int | float]):
self.salary = (int(value[0]), int(value[1]))
@rx.event
def set_sort_value(self, value: str):
self.sort_value = value
@rx.event
def set_search_value(self, value: str):
self.search_value = value
@rx.var(cache=True)
def filtered_sorted_players(self) -> list[Pl | from .data_items import all_items |
from typing import Dict, List
import numpy as np
import pandas as pd
import reflex as rx
from .data_items import all_items
from .player import Player
|
class State(rx.State):
"""The app state."""
players: list[Player] = []
search_value: str = ""
sort_value: str = ""
sort_reverse: bool = False
total_items: int = 0
offset: int = 0
limit: int = 12 # Number of rows per page
selected_items: Dict[str, List] = (
all_items # We add all items to the selected items by default
)
age: tuple[int, int] = (19, 40)
salary: tuple[int, int] = (0, 25000000)
@rx.event
def set_age(self, value: list[int | float]):
self.age = (int(value[0]), int(value[1]))
@rx.event
def set_salary(self, value: list[int | float]):
self.salary = (int(value[0]), int(value[1]))
@rx.event
def set_sort_value(self, value: str):
self.sort_value = value
@rx.event
def set_search_value(self, value: str):
self.search_value = value
@rx.var(cache=True)
def filtered_sorted_players(self) -> list[Player]:
players = self.players
# Filt | nba_csv = "nbastats.csv" |
from typing import Dict, List
import numpy as np
import pandas as pd
import reflex as rx
from .data_items import all_items
from .player import Player
nba_csv = "nbastats.csv"
class State(rx.State):
"""The app state."""
players: list[Player] = []
search_value: str = ""
sort_value: str = ""
sort_reverse: bool = False
total_items: int = 0
offset: int = 0
limit: int = 12 # Number of rows per page
selected_items: Dict[str, List] = (
all_items # We add all items to the selected items by default
)
age: tuple[int, int] = (19, 40)
salary: tuple[int, int] = (0, 25000000)
@rx.event
|
@rx.event
def set_salary(self, value: list[int | float]):
self.salary = (int(value[0]), int(value[1]))
@rx.event
def set_sort_value(self, value: str):
self.sort_value = value
@rx.event
def set_search_value(self, value: str):
self.search_value = value
@rx.var(cache=True)
def filtered_sorted_players(self) -> list[Player]:
players = self.players
# Filter players based on selected item
if self.sort_value:
if self.sort_value in ["salary", "number"]:
players = sorted(
players,
key=lambda player: float(getattr(player, self.sort_value)),
reverse=self.sort_reverse,
)
else:
players = sorted(
players,
key=lambda player: str(getattr(player, self.sort_value)).lower(),
reverse=self.sort_reverse,
)
# Fi | def set_age(self, value: list[int | float]):
self.age = (int(value[0]), int(value[1])) |
from typing import Dict, List
import numpy as np
import pandas as pd
import reflex as rx
from .data_items import all_items
from .player import Player
nba_csv = "nbastats.csv"
class State(rx.State):
"""The app state."""
players: list[Player] = []
search_value: str = ""
sort_value: str = ""
sort_reverse: bool = False
total_items: int = 0
offset: int = 0
limit: int = 12 # Number of rows per page
selected_items: Dict[str, List] = (
all_items # We add all items to the selected items by default
)
age: tuple[int, int] = (19, 40)
salary: tuple[int, int] = (0, 25000000)
@rx.event
def set_age(self, value: list[int | float]):
|
@rx.event
def set_salary(self, value: list[int | float]):
self.salary = (int(value[0]), int(value[1]))
@rx.event
def set_sort_value(self, value: str):
self.sort_value = value
@rx.event
def set_search_value(self, value: str):
self.search_value = value
@rx.var(cache=True)
def filtered_sorted_players(self) -> list[Player]:
players = self.players
# Filter players based on selected item
if self.sort_value:
if self.sort_value in ["salary", "number"]:
players = sorted(
players,
key=lambda player: float(getattr(player, self.sort_value)),
reverse=self.sort_reverse,
)
else:
players = sorted(
players,
key=lambda player: str(getattr(player, self.sort_value)).lower(),
reverse=self.sort_reverse,
)
# Fi | self.age = (int(value[0]), int(value[1])) |
from typing import Dict, List
import numpy as np
import pandas as pd
import reflex as rx
from .data_items import all_items
from .player import Player
nba_csv = "nbastats.csv"
class State(rx.State):
"""The app state."""
players: list[Player] = []
search_value: str = ""
sort_value: str = ""
sort_reverse: bool = False
total_items: int = 0
offset: int = 0
limit: int = 12 # Number of rows per page
selected_items: Dict[str, List] = (
all_items # We add all items to the selected items by default
)
age: tuple[int, int] = (19, 40)
salary: tuple[int, int] = (0, 25000000)
@rx.event
def set_age(self, value: list[int | float]):
self.age = (int(value[0]), int(value[1]))
@rx.event
|
@rx.event
def set_sort_value(self, value: str):
self.sort_value = value
@rx.event
def set_search_value(self, value: str):
self.search_value = value
@rx.var(cache=True)
def filtered_sorted_players(self) -> list[Player]:
players = self.players
# Filter players based on selected item
if self.sort_value:
if self.sort_value in ["salary", "number"]:
players = sorted(
players,
key=lambda player: float(getattr(player, self.sort_value)),
reverse=self.sort_reverse,
)
else:
players = sorted(
players,
key=lambda player: str(getattr(player, self.sort_value)).lower(),
reverse=self.sort_reverse,
)
# Filter players based on search value
if self.search_value:
search_value = self.search_value.lower()
| def set_salary(self, value: list[int | float]):
self.salary = (int(value[0]), int(value[1])) |
from typing import Dict, List
import numpy as np
import pandas as pd
import reflex as rx
from .data_items import all_items
from .player import Player
nba_csv = "nbastats.csv"
class State(rx.State):
"""The app state."""
players: list[Player] = []
search_value: str = ""
sort_value: str = ""
sort_reverse: bool = False
total_items: int = 0
offset: int = 0
limit: int = 12 # Number of rows per page
selected_items: Dict[str, List] = (
all_items # We add all items to the selected items by default
)
age: tuple[int, int] = (19, 40)
salary: tuple[int, int] = (0, 25000000)
@rx.event
def set_age(self, value: list[int | float]):
self.age = (int(value[0]), int(value[1]))
@rx.event
def set_salary(self, value: list[int | float]):
|
@rx.event
def set_sort_value(self, value: str):
self.sort_value = value
@rx.event
def set_search_value(self, value: str):
self.search_value = value
@rx.var(cache=True)
def filtered_sorted_players(self) -> list[Player]:
players = self.players
# Filter players based on selected item
if self.sort_value:
if self.sort_value in ["salary", "number"]:
players = sorted(
players,
key=lambda player: float(getattr(player, self.sort_value)),
reverse=self.sort_reverse,
)
else:
players = sorted(
players,
key=lambda player: str(getattr(player, self.sort_value)).lower(),
reverse=self.sort_reverse,
)
# Filter players based on search value
if self.search_value:
search_value = self.search_value.lower()
| self.salary = (int(value[0]), int(value[1])) |
from typing import Dict, List
import numpy as np
import pandas as pd
import reflex as rx
from .data_items import all_items
from .player import Player
nba_csv = "nbastats.csv"
class State(rx.State):
"""The app state."""
players: list[Player] = []
search_value: str = ""
sort_value: str = ""
sort_reverse: bool = False
total_items: int = 0
offset: int = 0
limit: int = 12 # Number of rows per page
selected_items: Dict[str, List] = (
all_items # We add all items to the selected items by default
)
age: tuple[int, int] = (19, 40)
salary: tuple[int, int] = (0, 25000000)
@rx.event
def set_age(self, value: list[int | float]):
self.age = (int(value[0]), int(value[1]))
@rx.event
def set_salary(self, value: list[int | float]):
self.salary = (int(value[0]), int(value[1]))
@rx.event
|
@rx.event
def set_search_value(self, value: str):
self.search_value = value
@rx.var(cache=True)
def filtered_sorted_players(self) -> list[Player]:
players = self.players
# Filter players based on selected item
if self.sort_value:
if self.sort_value in ["salary", "number"]:
players = sorted(
players,
key=lambda player: float(getattr(player, self.sort_value)),
reverse=self.sort_reverse,
)
else:
players = sorted(
players,
key=lambda player: str(getattr(player, self.sort_value)).lower(),
reverse=self.sort_reverse,
)
# Filter players based on search value
if self.search_value:
search_value = self.search_value.lower()
players = [
player
for player in players
| def set_sort_value(self, value: str):
self.sort_value = value |
from typing import Dict, List
import numpy as np
import pandas as pd
import reflex as rx
from .data_items import all_items
from .player import Player
nba_csv = "nbastats.csv"
class State(rx.State):
"""The app state."""
players: list[Player] = []
search_value: str = ""
sort_value: str = ""
sort_reverse: bool = False
total_items: int = 0
offset: int = 0
limit: int = 12 # Number of rows per page
selected_items: Dict[str, List] = (
all_items # We add all items to the selected items by default
)
age: tuple[int, int] = (19, 40)
salary: tuple[int, int] = (0, 25000000)
@rx.event
def set_age(self, value: list[int | float]):
self.age = (int(value[0]), int(value[1]))
@rx.event
def set_salary(self, value: list[int | float]):
self.salary = (int(value[0]), int(value[1]))
@rx.event
def set_sort_value(self, value: str):
|
@rx.event
def set_search_value(self, value: str):
self.search_value = value
@rx.var(cache=True)
def filtered_sorted_players(self) -> list[Player]:
players = self.players
# Filter players based on selected item
if self.sort_value:
if self.sort_value in ["salary", "number"]:
players = sorted(
players,
key=lambda player: float(getattr(player, self.sort_value)),
reverse=self.sort_reverse,
)
else:
players = sorted(
players,
key=lambda player: str(getattr(player, self.sort_value)).lower(),
reverse=self.sort_reverse,
)
# Filter players based on search value
if self.search_value:
search_value = self.search_value.lower()
players = [
player
for player in players
| self.sort_value = value |
from typing import Dict, List
import numpy as np
import pandas as pd
import reflex as rx
from .data_items import all_items
from .player import Player
nba_csv = "nbastats.csv"
class State(rx.State):
"""The app state."""
players: list[Player] = []
search_value: str = ""
sort_value: str = ""
sort_reverse: bool = False
total_items: int = 0
offset: int = 0
limit: int = 12 # Number of rows per page
selected_items: Dict[str, List] = (
all_items # We add all items to the selected items by default
)
age: tuple[int, int] = (19, 40)
salary: tuple[int, int] = (0, 25000000)
@rx.event
def set_age(self, value: list[int | float]):
self.age = (int(value[0]), int(value[1]))
@rx.event
def set_salary(self, value: list[int | float]):
self.salary = (int(value[0]), int(value[1]))
@rx.event
def set_sort_value(self, value: str):
self.sort_value = value
@rx.event
|
@rx.var(cache=True)
def filtered_sorted_players(self) -> list[Player]:
players = self.players
# Filter players based on selected item
if self.sort_value:
if self.sort_value in ["salary", "number"]:
players = sorted(
players,
key=lambda player: float(getattr(player, self.sort_value)),
reverse=self.sort_reverse,
)
else:
players = sorted(
players,
key=lambda player: str(getattr(player, self.sort_value)).lower(),
reverse=self.sort_reverse,
)
# Filter players based on search value
if self.search_value:
search_value = self.search_value.lower()
players = [
player
for player in players
if any(
search_value in str(getattr(player, attr)).lower()
| def set_search_value(self, value: str):
self.search_value = value |
List
import numpy as np
import pandas as pd
import reflex as rx
from .data_items import all_items
from .player import Player
nba_csv = "nbastats.csv"
class State(rx.State):
"""The app state."""
players: list[Player] = []
search_value: str = ""
sort_value: str = ""
sort_reverse: bool = False
total_items: int = 0
offset: int = 0
limit: int = 12 # Number of rows per page
selected_items: Dict[str, List] = (
all_items # We add all items to the selected items by default
)
age: tuple[int, int] = (19, 40)
salary: tuple[int, int] = (0, 25000000)
@rx.event
def set_age(self, value: list[int | float]):
self.age = (int(value[0]), int(value[1]))
@rx.event
def set_salary(self, value: list[int | float]):
self.salary = (int(value[0]), int(value[1]))
@rx.event
def set_sort_value(self, value: str):
self.sort_value = value
@rx.event
def set_search_value(self, value: str):
|
@rx.var(cache=True)
def filtered_sorted_players(self) -> list[Player]:
players = self.players
# Filter players based on selected item
if self.sort_value:
if self.sort_value in ["salary", "number"]:
players = sorted(
players,
key=lambda player: float(getattr(player, self.sort_value)),
reverse=self.sort_reverse,
)
else:
players = sorted(
players,
key=lambda player: str(getattr(player, self.sort_value)).lower(),
reverse=self.sort_reverse,
)
# Filter players based on search value
if self.search_value:
search_value = self.search_value.lower()
players = [
player
for player in players
if any(
search_value in str(getattr(player, attr)).lower()
| self.search_value = value |
mport Player
nba_csv = "nbastats.csv"
class State(rx.State):
"""The app state."""
players: list[Player] = []
search_value: str = ""
sort_value: str = ""
sort_reverse: bool = False
total_items: int = 0
offset: int = 0
limit: int = 12 # Number of rows per page
selected_items: Dict[str, List] = (
all_items # We add all items to the selected items by default
)
age: tuple[int, int] = (19, 40)
salary: tuple[int, int] = (0, 25000000)
@rx.event
def set_age(self, value: list[int | float]):
self.age = (int(value[0]), int(value[1]))
@rx.event
def set_salary(self, value: list[int | float]):
self.salary = (int(value[0]), int(value[1]))
@rx.event
def set_sort_value(self, value: str):
self.sort_value = value
@rx.event
def set_search_value(self, value: str):
self.search_value = value
@rx.var(cache=True)
def filtered_sorted_players(self) -> list[Player]:
|
# Filter players based on selected item
if self.sort_value:
if self.sort_value in ["salary", "number"]:
players = sorted(
players,
key=lambda player: float(getattr(player, self.sort_value)),
reverse=self.sort_reverse,
)
else:
players = sorted(
players,
key=lambda player: str(getattr(player, self.sort_value)).lower(),
reverse=self.sort_reverse,
)
# Filter players based on search value
if self.search_value:
search_value = self.search_value.lower()
players = [
player
for player in players
if any(
search_value in str(getattr(player, attr)).lower()
for attr in [
"name",
"team",
| players = self.players |
tate."""
players: list[Player] = []
search_value: str = ""
sort_value: str = ""
sort_reverse: bool = False
total_items: int = 0
offset: int = 0
limit: int = 12 # Number of rows per page
selected_items: Dict[str, List] = (
all_items # We add all items to the selected items by default
)
age: tuple[int, int] = (19, 40)
salary: tuple[int, int] = (0, 25000000)
@rx.event
def set_age(self, value: list[int | float]):
self.age = (int(value[0]), int(value[1]))
@rx.event
def set_salary(self, value: list[int | float]):
self.salary = (int(value[0]), int(value[1]))
@rx.event
def set_sort_value(self, value: str):
self.sort_value = value
@rx.event
def set_search_value(self, value: str):
self.search_value = value
@rx.var(cache=True)
def filtered_sorted_players(self) -> list[Player]:
players = self.players
# Filter players based on selected item
|
# Filter players based on search value
if self.search_value:
search_value = self.search_value.lower()
players = [
player
for player in players
if any(
search_value in str(getattr(player, attr)).lower()
for attr in [
"name",
"team",
"number",
"position",
"age",
"height",
"weight",
"college",
"salary",
]
)
]
return players
@rx.var(cache=True)
def page_number(self) -> int:
return (self.offset // self.limit) + 1
@rx.var(cache=True)
def total_pages(self) -> int:
return (self.total_items // self.limit) + (
1 if self.total_items % self.limit else 0
| if self.sort_value:
if self.sort_value in ["salary", "number"]:
players = sorted(
players,
key=lambda player: float(getattr(player, self.sort_value)),
reverse=self.sort_reverse,
)
else:
players = sorted(
players,
key=lambda player: str(getattr(player, self.sort_value)).lower(),
reverse=self.sort_reverse,
) |
er] = []
search_value: str = ""
sort_value: str = ""
sort_reverse: bool = False
total_items: int = 0
offset: int = 0
limit: int = 12 # Number of rows per page
selected_items: Dict[str, List] = (
all_items # We add all items to the selected items by default
)
age: tuple[int, int] = (19, 40)
salary: tuple[int, int] = (0, 25000000)
@rx.event
def set_age(self, value: list[int | float]):
self.age = (int(value[0]), int(value[1]))
@rx.event
def set_salary(self, value: list[int | float]):
self.salary = (int(value[0]), int(value[1]))
@rx.event
def set_sort_value(self, value: str):
self.sort_value = value
@rx.event
def set_search_value(self, value: str):
self.search_value = value
@rx.var(cache=True)
def filtered_sorted_players(self) -> list[Player]:
players = self.players
# Filter players based on selected item
if self.sort_value:
|
# Filter players based on search value
if self.search_value:
search_value = self.search_value.lower()
players = [
player
for player in players
if any(
search_value in str(getattr(player, attr)).lower()
for attr in [
"name",
"team",
"number",
"position",
"age",
"height",
"weight",
"college",
"salary",
]
)
]
return players
@rx.var(cache=True)
def page_number(self) -> int:
return (self.offset // self.limit) + 1
@rx.var(cache=True)
def total_pages(self) -> int:
return (self.total_items // self.limit) + (
1 if self.total_items % self.limit else 0
| if self.sort_value in ["salary", "number"]:
players = sorted(
players,
key=lambda player: float(getattr(player, self.sort_value)),
reverse=self.sort_reverse,
)
else:
players = sorted(
players,
key=lambda player: str(getattr(player, self.sort_value)).lower(),
reverse=self.sort_reverse,
) |
"
sort_reverse: bool = False
total_items: int = 0
offset: int = 0
limit: int = 12 # Number of rows per page
selected_items: Dict[str, List] = (
all_items # We add all items to the selected items by default
)
age: tuple[int, int] = (19, 40)
salary: tuple[int, int] = (0, 25000000)
@rx.event
def set_age(self, value: list[int | float]):
self.age = (int(value[0]), int(value[1]))
@rx.event
def set_salary(self, value: list[int | float]):
self.salary = (int(value[0]), int(value[1]))
@rx.event
def set_sort_value(self, value: str):
self.sort_value = value
@rx.event
def set_search_value(self, value: str):
self.search_value = value
@rx.var(cache=True)
def filtered_sorted_players(self) -> list[Player]:
players = self.players
# Filter players based on selected item
if self.sort_value:
if self.sort_value in ["salary", "number"]:
|
else:
players = sorted(
players,
key=lambda player: str(getattr(player, self.sort_value)).lower(),
reverse=self.sort_reverse,
)
# Filter players based on search value
if self.search_value:
search_value = self.search_value.lower()
players = [
player
for player in players
if any(
search_value in str(getattr(player, attr)).lower()
for attr in [
"name",
"team",
"number",
"position",
"age",
"height",
"weight",
"college",
"salary",
]
)
]
return players
@rx.var(cache=True)
def page_numb | players = sorted(
players,
key=lambda player: float(getattr(player, self.sort_value)),
reverse=self.sort_reverse,
) |
by default
)
age: tuple[int, int] = (19, 40)
salary: tuple[int, int] = (0, 25000000)
@rx.event
def set_age(self, value: list[int | float]):
self.age = (int(value[0]), int(value[1]))
@rx.event
def set_salary(self, value: list[int | float]):
self.salary = (int(value[0]), int(value[1]))
@rx.event
def set_sort_value(self, value: str):
self.sort_value = value
@rx.event
def set_search_value(self, value: str):
self.search_value = value
@rx.var(cache=True)
def filtered_sorted_players(self) -> list[Player]:
players = self.players
# Filter players based on selected item
if self.sort_value:
if self.sort_value in ["salary", "number"]:
players = sorted(
players,
key=lambda player: float(getattr(player, self.sort_value)),
reverse=self.sort_reverse,
)
else:
|
# Filter players based on search value
if self.search_value:
search_value = self.search_value.lower()
players = [
player
for player in players
if any(
search_value in str(getattr(player, attr)).lower()
for attr in [
"name",
"team",
"number",
"position",
"age",
"height",
"weight",
"college",
"salary",
]
)
]
return players
@rx.var(cache=True)
def page_number(self) -> int:
return (self.offset // self.limit) + 1
@rx.var(cache=True)
def total_pages(self) -> int:
return (self.total_items // self.limit) + (
1 if self.total_items % self.limit else 0
| players = sorted(
players,
key=lambda player: str(getattr(player, self.sort_value)).lower(),
reverse=self.sort_reverse,
) |
lue: list[int | float]):
self.salary = (int(value[0]), int(value[1]))
@rx.event
def set_sort_value(self, value: str):
self.sort_value = value
@rx.event
def set_search_value(self, value: str):
self.search_value = value
@rx.var(cache=True)
def filtered_sorted_players(self) -> list[Player]:
players = self.players
# Filter players based on selected item
if self.sort_value:
if self.sort_value in ["salary", "number"]:
players = sorted(
players,
key=lambda player: float(getattr(player, self.sort_value)),
reverse=self.sort_reverse,
)
else:
players = sorted(
players,
key=lambda player: str(getattr(player, self.sort_value)).lower(),
reverse=self.sort_reverse,
)
# Filter players based on search value
|
return players
@rx.var(cache=True)
def page_number(self) -> int:
return (self.offset // self.limit) + 1
@rx.var(cache=True)
def total_pages(self) -> int:
return (self.total_items // self.limit) + (
1 if self.total_items % self.limit else 0
)
@rx.var(cache=True, initial_value=[])
def get_current_page(self) -> list[Player]:
start_index = self.offset
end_index = start_index + self.limit
return self.filtered_sorted_players[start_index:end_index]
def prev_page(self):
if self.page_number > 1:
self.offset -= self.limit
def next_page(self):
if self.page_number < self.total_pages:
self.offset += self.limit
def first_page(self):
self.offset = 0
def last_page(self):
self.offset = (self.total_pages - 1) * self.limit
def load_entries(self):
df = pd.read_csv(nba_csv)
df = df.replace("", np.nan) # Replace emp | if self.search_value:
search_value = self.search_value.lower()
players = [
player
for player in players
if any(
search_value in str(getattr(player, attr)).lower()
for attr in [
"name",
"team",
"number",
"position",
"age",
"height",
"weight",
"college",
"salary",
]
)
] |
elf.salary = (int(value[0]), int(value[1]))
@rx.event
def set_sort_value(self, value: str):
self.sort_value = value
@rx.event
def set_search_value(self, value: str):
self.search_value = value
@rx.var(cache=True)
def filtered_sorted_players(self) -> list[Player]:
players = self.players
# Filter players based on selected item
if self.sort_value:
if self.sort_value in ["salary", "number"]:
players = sorted(
players,
key=lambda player: float(getattr(player, self.sort_value)),
reverse=self.sort_reverse,
)
else:
players = sorted(
players,
key=lambda player: str(getattr(player, self.sort_value)).lower(),
reverse=self.sort_reverse,
)
# Filter players based on search value
if self.search_value:
|
players = [
player
for player in players
if any(
search_value in str(getattr(player, attr)).lower()
for attr in [
"name",
"team",
"number",
"position",
"age",
"height",
"weight",
"college",
"salary",
]
)
]
return players
@rx.var(cache=True)
def page_number(self) -> int:
return (self.offset // self.limit) + 1
@rx.var(cache=True)
def total_pages(self) -> int:
return (self.total_items // self.limit) + (
1 if self.total_items % self.limit else 0
)
@rx.var(cache=True, initial_value=[])
def get_current_page(self) -> list[Player]:
start_index = self.offset | search_value = self.search_value.lower() |
event
def set_sort_value(self, value: str):
self.sort_value = value
@rx.event
def set_search_value(self, value: str):
self.search_value = value
@rx.var(cache=True)
def filtered_sorted_players(self) -> list[Player]:
players = self.players
# Filter players based on selected item
if self.sort_value:
if self.sort_value in ["salary", "number"]:
players = sorted(
players,
key=lambda player: float(getattr(player, self.sort_value)),
reverse=self.sort_reverse,
)
else:
players = sorted(
players,
key=lambda player: str(getattr(player, self.sort_value)).lower(),
reverse=self.sort_reverse,
)
# Filter players based on search value
if self.search_value:
search_value = self.search_value.lower()
|
return players
@rx.var(cache=True)
def page_number(self) -> int:
return (self.offset // self.limit) + 1
@rx.var(cache=True)
def total_pages(self) -> int:
return (self.total_items // self.limit) + (
1 if self.total_items % self.limit else 0
)
@rx.var(cache=True, initial_value=[])
def get_current_page(self) -> list[Player]:
start_index = self.offset
end_index = start_index + self.limit
return self.filtered_sorted_players[start_index:end_index]
def prev_page(self):
if self.page_number > 1:
self.offset -= self.limit
def next_page(self):
if self.page_number < self.total_pages:
self.offset += self.limit
def first_page(self):
self.offset = 0
def last_page(self):
self.offset = (self.total_pages - 1) * self.limit
def load_entries(self):
df = pd.read_csv(nba_csv)
df = df.replace("", np.nan) # Replace emp | players = [
player
for player in players
if any(
search_value in str(getattr(player, attr)).lower()
for attr in [
"name",
"team",
"number",
"position",
"age",
"height",
"weight",
"college",
"salary",
]
)
] |
)
else:
players = sorted(
players,
key=lambda player: str(getattr(player, self.sort_value)).lower(),
reverse=self.sort_reverse,
)
# Filter players based on search value
if self.search_value:
search_value = self.search_value.lower()
players = [
player
for player in players
if any(
search_value in str(getattr(player, attr)).lower()
for attr in [
"name",
"team",
"number",
"position",
"age",
"height",
"weight",
"college",
"salary",
]
)
]
return players
@rx.var(cache=True)
|
@rx.var(cache=True)
def total_pages(self) -> int:
return (self.total_items // self.limit) + (
1 if self.total_items % self.limit else 0
)
@rx.var(cache=True, initial_value=[])
def get_current_page(self) -> list[Player]:
start_index = self.offset
end_index = start_index + self.limit
return self.filtered_sorted_players[start_index:end_index]
def prev_page(self):
if self.page_number > 1:
self.offset -= self.limit
def next_page(self):
if self.page_number < self.total_pages:
self.offset += self.limit
def first_page(self):
self.offset = 0
def last_page(self):
self.offset = (self.total_pages - 1) * self.limit
def load_entries(self):
df = pd.read_csv(nba_csv)
df = df.replace("", np.nan) # Replace empty strings with NaN
self.players = [Player(**row) for _, row in df.iterrows()]
self.total_items = len(self.players | def page_number(self) -> int:
return (self.offset // self.limit) + 1 |
key=lambda player: str(getattr(player, self.sort_value)).lower(),
reverse=self.sort_reverse,
)
# Filter players based on search value
if self.search_value:
search_value = self.search_value.lower()
players = [
player
for player in players
if any(
search_value in str(getattr(player, attr)).lower()
for attr in [
"name",
"team",
"number",
"position",
"age",
"height",
"weight",
"college",
"salary",
]
)
]
return players
@rx.var(cache=True)
def page_number(self) -> int:
return (self.offset // self.limit) + 1
@rx.var(cache=True)
|
@rx.var(cache=True, initial_value=[])
def get_current_page(self) -> list[Player]:
start_index = self.offset
end_index = start_index + self.limit
return self.filtered_sorted_players[start_index:end_index]
def prev_page(self):
if self.page_number > 1:
self.offset -= self.limit
def next_page(self):
if self.page_number < self.total_pages:
self.offset += self.limit
def first_page(self):
self.offset = 0
def last_page(self):
self.offset = (self.total_pages - 1) * self.limit
def load_entries(self):
df = pd.read_csv(nba_csv)
df = df.replace("", np.nan) # Replace empty strings with NaN
self.players = [Player(**row) for _, row in df.iterrows()]
self.total_items = len(self.players)
def toggle_sort(self):
self.sort_reverse = not self.sort_reverse
self.load_entries()
@rx.var(cache=True)
def get_age_salary_chart_data(self) -> | def total_pages(self) -> int:
return (self.total_items // self.limit) + (
1 if self.total_items % self.limit else 0
) |
if self.search_value:
search_value = self.search_value.lower()
players = [
player
for player in players
if any(
search_value in str(getattr(player, attr)).lower()
for attr in [
"name",
"team",
"number",
"position",
"age",
"height",
"weight",
"college",
"salary",
]
)
]
return players
@rx.var(cache=True)
def page_number(self) -> int:
return (self.offset // self.limit) + 1
@rx.var(cache=True)
def total_pages(self) -> int:
return (self.total_items // self.limit) + (
1 if self.total_items % self.limit else 0
)
@rx.var(cache=True, initial_value=[])
|
def prev_page(self):
if self.page_number > 1:
self.offset -= self.limit
def next_page(self):
if self.page_number < self.total_pages:
self.offset += self.limit
def first_page(self):
self.offset = 0
def last_page(self):
self.offset = (self.total_pages - 1) * self.limit
def load_entries(self):
df = pd.read_csv(nba_csv)
df = df.replace("", np.nan) # Replace empty strings with NaN
self.players = [Player(**row) for _, row in df.iterrows()]
self.total_items = len(self.players)
def toggle_sort(self):
self.sort_reverse = not self.sort_reverse
self.load_entries()
@rx.var(cache=True)
def get_age_salary_chart_data(self) -> list[dict]:
age_salary_data = {}
age_count = {}
for player in self.players:
if (
not pd.isna(player.age)
and not pd.isna(player.salary)
and player.team | def get_current_page(self) -> list[Player]:
start_index = self.offset
end_index = start_index + self.limit
return self.filtered_sorted_players[start_index:end_index] |
self.search_value.lower()
players = [
player
for player in players
if any(
search_value in str(getattr(player, attr)).lower()
for attr in [
"name",
"team",
"number",
"position",
"age",
"height",
"weight",
"college",
"salary",
]
)
]
return players
@rx.var(cache=True)
def page_number(self) -> int:
return (self.offset // self.limit) + 1
@rx.var(cache=True)
def total_pages(self) -> int:
return (self.total_items // self.limit) + (
1 if self.total_items % self.limit else 0
)
@rx.var(cache=True, initial_value=[])
def get_current_page(self) -> list[Player]:
|
end_index = start_index + self.limit
return self.filtered_sorted_players[start_index:end_index]
def prev_page(self):
if self.page_number > 1:
self.offset -= self.limit
def next_page(self):
if self.page_number < self.total_pages:
self.offset += self.limit
def first_page(self):
self.offset = 0
def last_page(self):
self.offset = (self.total_pages - 1) * self.limit
def load_entries(self):
df = pd.read_csv(nba_csv)
df = df.replace("", np.nan) # Replace empty strings with NaN
self.players = [Player(**row) for _, row in df.iterrows()]
self.total_items = len(self.players)
def toggle_sort(self):
self.sort_reverse = not self.sort_reverse
self.load_entries()
@rx.var(cache=True)
def get_age_salary_chart_data(self) -> list[dict]:
age_salary_data = {}
age_count = {}
for player in self.players:
if (
| start_index = self.offset |
players = [
player
for player in players
if any(
search_value in str(getattr(player, attr)).lower()
for attr in [
"name",
"team",
"number",
"position",
"age",
"height",
"weight",
"college",
"salary",
]
)
]
return players
@rx.var(cache=True)
def page_number(self) -> int:
return (self.offset // self.limit) + 1
@rx.var(cache=True)
def total_pages(self) -> int:
return (self.total_items // self.limit) + (
1 if self.total_items % self.limit else 0
)
@rx.var(cache=True, initial_value=[])
def get_current_page(self) -> list[Player]:
start_index = self.offset
|
return self.filtered_sorted_players[start_index:end_index]
def prev_page(self):
if self.page_number > 1:
self.offset -= self.limit
def next_page(self):
if self.page_number < self.total_pages:
self.offset += self.limit
def first_page(self):
self.offset = 0
def last_page(self):
self.offset = (self.total_pages - 1) * self.limit
def load_entries(self):
df = pd.read_csv(nba_csv)
df = df.replace("", np.nan) # Replace empty strings with NaN
self.players = [Player(**row) for _, row in df.iterrows()]
self.total_items = len(self.players)
def toggle_sort(self):
self.sort_reverse = not self.sort_reverse
self.load_entries()
@rx.var(cache=True)
def get_age_salary_chart_data(self) -> list[dict]:
age_salary_data = {}
age_count = {}
for player in self.players:
if (
not pd.isna(player.age)
| end_index = start_index + self.limit |
search_value in str(getattr(player, attr)).lower()
for attr in [
"name",
"team",
"number",
"position",
"age",
"height",
"weight",
"college",
"salary",
]
)
]
return players
@rx.var(cache=True)
def page_number(self) -> int:
return (self.offset // self.limit) + 1
@rx.var(cache=True)
def total_pages(self) -> int:
return (self.total_items // self.limit) + (
1 if self.total_items % self.limit else 0
)
@rx.var(cache=True, initial_value=[])
def get_current_page(self) -> list[Player]:
start_index = self.offset
end_index = start_index + self.limit
return self.filtered_sorted_players[start_index:end_index]
|
def next_page(self):
if self.page_number < self.total_pages:
self.offset += self.limit
def first_page(self):
self.offset = 0
def last_page(self):
self.offset = (self.total_pages - 1) * self.limit
def load_entries(self):
df = pd.read_csv(nba_csv)
df = df.replace("", np.nan) # Replace empty strings with NaN
self.players = [Player(**row) for _, row in df.iterrows()]
self.total_items = len(self.players)
def toggle_sort(self):
self.sort_reverse = not self.sort_reverse
self.load_entries()
@rx.var(cache=True)
def get_age_salary_chart_data(self) -> list[dict]:
age_salary_data = {}
age_count = {}
for player in self.players:
if (
not pd.isna(player.age)
and not pd.isna(player.salary)
and player.team in self.selected_items["teams"]
and player.college in self.selected_items["colle | def prev_page(self):
if self.page_number > 1:
self.offset -= self.limit |
tr(getattr(player, attr)).lower()
for attr in [
"name",
"team",
"number",
"position",
"age",
"height",
"weight",
"college",
"salary",
]
)
]
return players
@rx.var(cache=True)
def page_number(self) -> int:
return (self.offset // self.limit) + 1
@rx.var(cache=True)
def total_pages(self) -> int:
return (self.total_items // self.limit) + (
1 if self.total_items % self.limit else 0
)
@rx.var(cache=True, initial_value=[])
def get_current_page(self) -> list[Player]:
start_index = self.offset
end_index = start_index + self.limit
return self.filtered_sorted_players[start_index:end_index]
def prev_page(self):
|
def next_page(self):
if self.page_number < self.total_pages:
self.offset += self.limit
def first_page(self):
self.offset = 0
def last_page(self):
self.offset = (self.total_pages - 1) * self.limit
def load_entries(self):
df = pd.read_csv(nba_csv)
df = df.replace("", np.nan) # Replace empty strings with NaN
self.players = [Player(**row) for _, row in df.iterrows()]
self.total_items = len(self.players)
def toggle_sort(self):
self.sort_reverse = not self.sort_reverse
self.load_entries()
@rx.var(cache=True)
def get_age_salary_chart_data(self) -> list[dict]:
age_salary_data = {}
age_count = {}
for player in self.players:
if (
not pd.isna(player.age)
and not pd.isna(player.salary)
and player.team in self.selected_items["teams"]
and player.college in self.selected_items["colle | if self.page_number > 1:
self.offset -= self.limit |
"name",
"team",
"number",
"position",
"age",
"height",
"weight",
"college",
"salary",
]
)
]
return players
@rx.var(cache=True)
def page_number(self) -> int:
return (self.offset // self.limit) + 1
@rx.var(cache=True)
def total_pages(self) -> int:
return (self.total_items // self.limit) + (
1 if self.total_items % self.limit else 0
)
@rx.var(cache=True, initial_value=[])
def get_current_page(self) -> list[Player]:
start_index = self.offset
end_index = start_index + self.limit
return self.filtered_sorted_players[start_index:end_index]
def prev_page(self):
if self.page_number > 1:
self.offset -= self.limit
|
def first_page(self):
self.offset = 0
def last_page(self):
self.offset = (self.total_pages - 1) * self.limit
def load_entries(self):
df = pd.read_csv(nba_csv)
df = df.replace("", np.nan) # Replace empty strings with NaN
self.players = [Player(**row) for _, row in df.iterrows()]
self.total_items = len(self.players)
def toggle_sort(self):
self.sort_reverse = not self.sort_reverse
self.load_entries()
@rx.var(cache=True)
def get_age_salary_chart_data(self) -> list[dict]:
age_salary_data = {}
age_count = {}
for player in self.players:
if (
not pd.isna(player.age)
and not pd.isna(player.salary)
and player.team in self.selected_items["teams"]
and player.college in self.selected_items["colleges"]
and player.position in self.selected_items["positions"]
and self.age[0] <= | def next_page(self):
if self.page_number < self.total_pages:
self.offset += self.limit |
",
"team",
"number",
"position",
"age",
"height",
"weight",
"college",
"salary",
]
)
]
return players
@rx.var(cache=True)
def page_number(self) -> int:
return (self.offset // self.limit) + 1
@rx.var(cache=True)
def total_pages(self) -> int:
return (self.total_items // self.limit) + (
1 if self.total_items % self.limit else 0
)
@rx.var(cache=True, initial_value=[])
def get_current_page(self) -> list[Player]:
start_index = self.offset
end_index = start_index + self.limit
return self.filtered_sorted_players[start_index:end_index]
def prev_page(self):
if self.page_number > 1:
self.offset -= self.limit
def next_page(self):
|
def first_page(self):
self.offset = 0
def last_page(self):
self.offset = (self.total_pages - 1) * self.limit
def load_entries(self):
df = pd.read_csv(nba_csv)
df = df.replace("", np.nan) # Replace empty strings with NaN
self.players = [Player(**row) for _, row in df.iterrows()]
self.total_items = len(self.players)
def toggle_sort(self):
self.sort_reverse = not self.sort_reverse
self.load_entries()
@rx.var(cache=True)
def get_age_salary_chart_data(self) -> list[dict]:
age_salary_data = {}
age_count = {}
for player in self.players:
if (
not pd.isna(player.age)
and not pd.isna(player.salary)
and player.team in self.selected_items["teams"]
and player.college in self.selected_items["colleges"]
and player.position in self.selected_items["positions"]
and self.age[0] <= | if self.page_number < self.total_pages:
self.offset += self.limit |
"position",
"age",
"height",
"weight",
"college",
"salary",
]
)
]
return players
@rx.var(cache=True)
def page_number(self) -> int:
return (self.offset // self.limit) + 1
@rx.var(cache=True)
def total_pages(self) -> int:
return (self.total_items // self.limit) + (
1 if self.total_items % self.limit else 0
)
@rx.var(cache=True, initial_value=[])
def get_current_page(self) -> list[Player]:
start_index = self.offset
end_index = start_index + self.limit
return self.filtered_sorted_players[start_index:end_index]
def prev_page(self):
if self.page_number > 1:
self.offset -= self.limit
def next_page(self):
if self.page_number < self.total_pages:
self.offset += self.limit
|
def last_page(self):
self.offset = (self.total_pages - 1) * self.limit
def load_entries(self):
df = pd.read_csv(nba_csv)
df = df.replace("", np.nan) # Replace empty strings with NaN
self.players = [Player(**row) for _, row in df.iterrows()]
self.total_items = len(self.players)
def toggle_sort(self):
self.sort_reverse = not self.sort_reverse
self.load_entries()
@rx.var(cache=True)
def get_age_salary_chart_data(self) -> list[dict]:
age_salary_data = {}
age_count = {}
for player in self.players:
if (
not pd.isna(player.age)
and not pd.isna(player.salary)
and player.team in self.selected_items["teams"]
and player.college in self.selected_items["colleges"]
and player.position in self.selected_items["positions"]
and self.age[0] <= player.age <= self.age[1]
and self | def first_page(self):
self.offset = 0 |
"age",
"height",
"weight",
"college",
"salary",
]
)
]
return players
@rx.var(cache=True)
def page_number(self) -> int:
return (self.offset // self.limit) + 1
@rx.var(cache=True)
def total_pages(self) -> int:
return (self.total_items // self.limit) + (
1 if self.total_items % self.limit else 0
)
@rx.var(cache=True, initial_value=[])
def get_current_page(self) -> list[Player]:
start_index = self.offset
end_index = start_index + self.limit
return self.filtered_sorted_players[start_index:end_index]
def prev_page(self):
if self.page_number > 1:
self.offset -= self.limit
def next_page(self):
if self.page_number < self.total_pages:
self.offset += self.limit
def first_page(self):
|
def last_page(self):
self.offset = (self.total_pages - 1) * self.limit
def load_entries(self):
df = pd.read_csv(nba_csv)
df = df.replace("", np.nan) # Replace empty strings with NaN
self.players = [Player(**row) for _, row in df.iterrows()]
self.total_items = len(self.players)
def toggle_sort(self):
self.sort_reverse = not self.sort_reverse
self.load_entries()
@rx.var(cache=True)
def get_age_salary_chart_data(self) -> list[dict]:
age_salary_data = {}
age_count = {}
for player in self.players:
if (
not pd.isna(player.age)
and not pd.isna(player.salary)
and player.team in self.selected_items["teams"]
and player.college in self.selected_items["colleges"]
and player.position in self.selected_items["positions"]
and self.age[0] <= player.age <= self.age[1]
and self | self.offset = 0 |
,
"height",
"weight",
"college",
"salary",
]
)
]
return players
@rx.var(cache=True)
def page_number(self) -> int:
return (self.offset // self.limit) + 1
@rx.var(cache=True)
def total_pages(self) -> int:
return (self.total_items // self.limit) + (
1 if self.total_items % self.limit else 0
)
@rx.var(cache=True, initial_value=[])
def get_current_page(self) -> list[Player]:
start_index = self.offset
end_index = start_index + self.limit
return self.filtered_sorted_players[start_index:end_index]
def prev_page(self):
if self.page_number > 1:
self.offset -= self.limit
def next_page(self):
if self.page_number < self.total_pages:
self.offset += self.limit
def first_page(self):
self.offset = 0
|
def load_entries(self):
df = pd.read_csv(nba_csv)
df = df.replace("", np.nan) # Replace empty strings with NaN
self.players = [Player(**row) for _, row in df.iterrows()]
self.total_items = len(self.players)
def toggle_sort(self):
self.sort_reverse = not self.sort_reverse
self.load_entries()
@rx.var(cache=True)
def get_age_salary_chart_data(self) -> list[dict]:
age_salary_data = {}
age_count = {}
for player in self.players:
if (
not pd.isna(player.age)
and not pd.isna(player.salary)
and player.team in self.selected_items["teams"]
and player.college in self.selected_items["colleges"]
and player.position in self.selected_items["positions"]
and self.age[0] <= player.age <= self.age[1]
and self.salary[0] <= float(player.salary) <= self.salary[1]
):
| def last_page(self):
self.offset = (self.total_pages - 1) * self.limit |
ight",
"weight",
"college",
"salary",
]
)
]
return players
@rx.var(cache=True)
def page_number(self) -> int:
return (self.offset // self.limit) + 1
@rx.var(cache=True)
def total_pages(self) -> int:
return (self.total_items // self.limit) + (
1 if self.total_items % self.limit else 0
)
@rx.var(cache=True, initial_value=[])
def get_current_page(self) -> list[Player]:
start_index = self.offset
end_index = start_index + self.limit
return self.filtered_sorted_players[start_index:end_index]
def prev_page(self):
if self.page_number > 1:
self.offset -= self.limit
def next_page(self):
if self.page_number < self.total_pages:
self.offset += self.limit
def first_page(self):
self.offset = 0
def last_page(self):
|
def load_entries(self):
df = pd.read_csv(nba_csv)
df = df.replace("", np.nan) # Replace empty strings with NaN
self.players = [Player(**row) for _, row in df.iterrows()]
self.total_items = len(self.players)
def toggle_sort(self):
self.sort_reverse = not self.sort_reverse
self.load_entries()
@rx.var(cache=True)
def get_age_salary_chart_data(self) -> list[dict]:
age_salary_data = {}
age_count = {}
for player in self.players:
if (
not pd.isna(player.age)
and not pd.isna(player.salary)
and player.team in self.selected_items["teams"]
and player.college in self.selected_items["colleges"]
and player.position in self.selected_items["positions"]
and self.age[0] <= player.age <= self.age[1]
and self.salary[0] <= float(player.salary) <= self.salary[1]
):
| self.offset = (self.total_pages - 1) * self.limit |
"college",
"salary",
]
)
]
return players
@rx.var(cache=True)
def page_number(self) -> int:
return (self.offset // self.limit) + 1
@rx.var(cache=True)
def total_pages(self) -> int:
return (self.total_items // self.limit) + (
1 if self.total_items % self.limit else 0
)
@rx.var(cache=True, initial_value=[])
def get_current_page(self) -> list[Player]:
start_index = self.offset
end_index = start_index + self.limit
return self.filtered_sorted_players[start_index:end_index]
def prev_page(self):
if self.page_number > 1:
self.offset -= self.limit
def next_page(self):
if self.page_number < self.total_pages:
self.offset += self.limit
def first_page(self):
self.offset = 0
def last_page(self):
self.offset = (self.total_pages - 1) * self.limit
|
def toggle_sort(self):
self.sort_reverse = not self.sort_reverse
self.load_entries()
@rx.var(cache=True)
def get_age_salary_chart_data(self) -> list[dict]:
age_salary_data = {}
age_count = {}
for player in self.players:
if (
not pd.isna(player.age)
and not pd.isna(player.salary)
and player.team in self.selected_items["teams"]
and player.college in self.selected_items["colleges"]
and player.position in self.selected_items["positions"]
and self.age[0] <= player.age <= self.age[1]
and self.salary[0] <= float(player.salary) <= self.salary[1]
):
age = player.age
if age not in age_salary_data:
age_salary_data[age] = 0
age_count[age] = 0
age_salary_data[age] += float(player.salary)
age_count[age] += 1 | def load_entries(self):
df = pd.read_csv(nba_csv)
df = df.replace("", np.nan) # Replace empty strings with NaN
self.players = [Player(**row) for _, row in df.iterrows()]
self.total_items = len(self.players) |
"salary",
]
)
]
return players
@rx.var(cache=True)
def page_number(self) -> int:
return (self.offset // self.limit) + 1
@rx.var(cache=True)
def total_pages(self) -> int:
return (self.total_items // self.limit) + (
1 if self.total_items % self.limit else 0
)
@rx.var(cache=True, initial_value=[])
def get_current_page(self) -> list[Player]:
start_index = self.offset
end_index = start_index + self.limit
return self.filtered_sorted_players[start_index:end_index]
def prev_page(self):
if self.page_number > 1:
self.offset -= self.limit
def next_page(self):
if self.page_number < self.total_pages:
self.offset += self.limit
def first_page(self):
self.offset = 0
def last_page(self):
self.offset = (self.total_pages - 1) * self.limit
def load_entries(self):
|
df = df.replace("", np.nan) # Replace empty strings with NaN
self.players = [Player(**row) for _, row in df.iterrows()]
self.total_items = len(self.players)
def toggle_sort(self):
self.sort_reverse = not self.sort_reverse
self.load_entries()
@rx.var(cache=True)
def get_age_salary_chart_data(self) -> list[dict]:
age_salary_data = {}
age_count = {}
for player in self.players:
if (
not pd.isna(player.age)
and not pd.isna(player.salary)
and player.team in self.selected_items["teams"]
and player.college in self.selected_items["colleges"]
and player.position in self.selected_items["positions"]
and self.age[0] <= player.age <= self.age[1]
and self.salary[0] <= float(player.salary) <= self.salary[1]
):
age = player.age
if age not in age_salary_data: | df = pd.read_csv(nba_csv) |
]
)
]
return players
@rx.var(cache=True)
def page_number(self) -> int:
return (self.offset // self.limit) + 1
@rx.var(cache=True)
def total_pages(self) -> int:
return (self.total_items // self.limit) + (
1 if self.total_items % self.limit else 0
)
@rx.var(cache=True, initial_value=[])
def get_current_page(self) -> list[Player]:
start_index = self.offset
end_index = start_index + self.limit
return self.filtered_sorted_players[start_index:end_index]
def prev_page(self):
if self.page_number > 1:
self.offset -= self.limit
def next_page(self):
if self.page_number < self.total_pages:
self.offset += self.limit
def first_page(self):
self.offset = 0
def last_page(self):
self.offset = (self.total_pages - 1) * self.limit
def load_entries(self):
df = pd.read_csv(nba_csv)
| # Replace empty strings with NaN
self.players = [Player(**row) for _, row in df.iterrows()]
self.total_items = len(self.players)
def toggle_sort(self):
self.sort_reverse = not self.sort_reverse
self.load_entries()
@rx.var(cache=True)
def get_age_salary_chart_data(self) -> list[dict]:
age_salary_data = {}
age_count = {}
for player in self.players:
if (
not pd.isna(player.age)
and not pd.isna(player.salary)
and player.team in self.selected_items["teams"]
and player.college in self.selected_items["colleges"]
and player.position in self.selected_items["positions"]
and self.age[0] <= player.age <= self.age[1]
and self.salary[0] <= float(player.salary) <= self.salary[1]
):
age = player.age
if age not in age_salary_data:
age_salary_data | df = df.replace("", np.nan) |
@rx.var(cache=True)
def page_number(self) -> int:
return (self.offset // self.limit) + 1
@rx.var(cache=True)
def total_pages(self) -> int:
return (self.total_items // self.limit) + (
1 if self.total_items % self.limit else 0
)
@rx.var(cache=True, initial_value=[])
def get_current_page(self) -> list[Player]:
start_index = self.offset
end_index = start_index + self.limit
return self.filtered_sorted_players[start_index:end_index]
def prev_page(self):
if self.page_number > 1:
self.offset -= self.limit
def next_page(self):
if self.page_number < self.total_pages:
self.offset += self.limit
def first_page(self):
self.offset = 0
def last_page(self):
self.offset = (self.total_pages - 1) * self.limit
def load_entries(self):
df = pd.read_csv(nba_csv)
df = df.replace("", np.nan) # Replace empty strings with NaN
|
self.total_items = len(self.players)
def toggle_sort(self):
self.sort_reverse = not self.sort_reverse
self.load_entries()
@rx.var(cache=True)
def get_age_salary_chart_data(self) -> list[dict]:
age_salary_data = {}
age_count = {}
for player in self.players:
if (
not pd.isna(player.age)
and not pd.isna(player.salary)
and player.team in self.selected_items["teams"]
and player.college in self.selected_items["colleges"]
and player.position in self.selected_items["positions"]
and self.age[0] <= player.age <= self.age[1]
and self.salary[0] <= float(player.salary) <= self.salary[1]
):
age = player.age
if age not in age_salary_data:
age_salary_data[age] = 0
age_count[age] = 0
age_salary_data[age] += float(playe | self.players = [Player(**row) for _, row in df.iterrows()] |
urn (self.offset // self.limit) + 1
@rx.var(cache=True)
def total_pages(self) -> int:
return (self.total_items // self.limit) + (
1 if self.total_items % self.limit else 0
)
@rx.var(cache=True, initial_value=[])
def get_current_page(self) -> list[Player]:
start_index = self.offset
end_index = start_index + self.limit
return self.filtered_sorted_players[start_index:end_index]
def prev_page(self):
if self.page_number > 1:
self.offset -= self.limit
def next_page(self):
if self.page_number < self.total_pages:
self.offset += self.limit
def first_page(self):
self.offset = 0
def last_page(self):
self.offset = (self.total_pages - 1) * self.limit
def load_entries(self):
df = pd.read_csv(nba_csv)
df = df.replace("", np.nan) # Replace empty strings with NaN
self.players = [Player(**row) for _, row in df.iterrows()]
|
def toggle_sort(self):
self.sort_reverse = not self.sort_reverse
self.load_entries()
@rx.var(cache=True)
def get_age_salary_chart_data(self) -> list[dict]:
age_salary_data = {}
age_count = {}
for player in self.players:
if (
not pd.isna(player.age)
and not pd.isna(player.salary)
and player.team in self.selected_items["teams"]
and player.college in self.selected_items["colleges"]
and player.position in self.selected_items["positions"]
and self.age[0] <= player.age <= self.age[1]
and self.salary[0] <= float(player.salary) <= self.salary[1]
):
age = player.age
if age not in age_salary_data:
age_salary_data[age] = 0
age_count[age] = 0
age_salary_data[age] += float(player.salary)
age_count[age] += 1 | self.total_items = len(self.players) |
rx.var(cache=True)
def total_pages(self) -> int:
return (self.total_items // self.limit) + (
1 if self.total_items % self.limit else 0
)
@rx.var(cache=True, initial_value=[])
def get_current_page(self) -> list[Player]:
start_index = self.offset
end_index = start_index + self.limit
return self.filtered_sorted_players[start_index:end_index]
def prev_page(self):
if self.page_number > 1:
self.offset -= self.limit
def next_page(self):
if self.page_number < self.total_pages:
self.offset += self.limit
def first_page(self):
self.offset = 0
def last_page(self):
self.offset = (self.total_pages - 1) * self.limit
def load_entries(self):
df = pd.read_csv(nba_csv)
df = df.replace("", np.nan) # Replace empty strings with NaN
self.players = [Player(**row) for _, row in df.iterrows()]
self.total_items = len(self.players)
|
@rx.var(cache=True)
def get_age_salary_chart_data(self) -> list[dict]:
age_salary_data = {}
age_count = {}
for player in self.players:
if (
not pd.isna(player.age)
and not pd.isna(player.salary)
and player.team in self.selected_items["teams"]
and player.college in self.selected_items["colleges"]
and player.position in self.selected_items["positions"]
and self.age[0] <= player.age <= self.age[1]
and self.salary[0] <= float(player.salary) <= self.salary[1]
):
age = player.age
if age not in age_salary_data:
age_salary_data[age] = 0
age_count[age] = 0
age_salary_data[age] += float(player.salary)
age_count[age] += 1
return [
{
"age": age,
"average salary": round(
| def toggle_sort(self):
self.sort_reverse = not self.sort_reverse
self.load_entries() |
l_pages(self) -> int:
return (self.total_items // self.limit) + (
1 if self.total_items % self.limit else 0
)
@rx.var(cache=True, initial_value=[])
def get_current_page(self) -> list[Player]:
start_index = self.offset
end_index = start_index + self.limit
return self.filtered_sorted_players[start_index:end_index]
def prev_page(self):
if self.page_number > 1:
self.offset -= self.limit
def next_page(self):
if self.page_number < self.total_pages:
self.offset += self.limit
def first_page(self):
self.offset = 0
def last_page(self):
self.offset = (self.total_pages - 1) * self.limit
def load_entries(self):
df = pd.read_csv(nba_csv)
df = df.replace("", np.nan) # Replace empty strings with NaN
self.players = [Player(**row) for _, row in df.iterrows()]
self.total_items = len(self.players)
def toggle_sort(self):
|
self.load_entries()
@rx.var(cache=True)
def get_age_salary_chart_data(self) -> list[dict]:
age_salary_data = {}
age_count = {}
for player in self.players:
if (
not pd.isna(player.age)
and not pd.isna(player.salary)
and player.team in self.selected_items["teams"]
and player.college in self.selected_items["colleges"]
and player.position in self.selected_items["positions"]
and self.age[0] <= player.age <= self.age[1]
and self.salary[0] <= float(player.salary) <= self.salary[1]
):
age = player.age
if age not in age_salary_data:
age_salary_data[age] = 0
age_count[age] = 0
age_salary_data[age] += float(player.salary)
age_count[age] += 1
return [
{
"age": age,
" | self.sort_reverse = not self.sort_reverse |
rue, initial_value=[])
def get_current_page(self) -> list[Player]:
start_index = self.offset
end_index = start_index + self.limit
return self.filtered_sorted_players[start_index:end_index]
def prev_page(self):
if self.page_number > 1:
self.offset -= self.limit
def next_page(self):
if self.page_number < self.total_pages:
self.offset += self.limit
def first_page(self):
self.offset = 0
def last_page(self):
self.offset = (self.total_pages - 1) * self.limit
def load_entries(self):
df = pd.read_csv(nba_csv)
df = df.replace("", np.nan) # Replace empty strings with NaN
self.players = [Player(**row) for _, row in df.iterrows()]
self.total_items = len(self.players)
def toggle_sort(self):
self.sort_reverse = not self.sort_reverse
self.load_entries()
@rx.var(cache=True)
def get_age_salary_chart_data(self) -> list[dict]:
|
age_count = {}
for player in self.players:
if (
not pd.isna(player.age)
and not pd.isna(player.salary)
and player.team in self.selected_items["teams"]
and player.college in self.selected_items["colleges"]
and player.position in self.selected_items["positions"]
and self.age[0] <= player.age <= self.age[1]
and self.salary[0] <= float(player.salary) <= self.salary[1]
):
age = player.age
if age not in age_salary_data:
age_salary_data[age] = 0
age_count[age] = 0
age_salary_data[age] += float(player.salary)
age_count[age] += 1
return [
{
"age": age,
"average salary": round(
age_salary_data.get(age, 0) / age_count.get(age, 1), 2
),
}
| age_salary_data = {} |
f get_current_page(self) -> list[Player]:
start_index = self.offset
end_index = start_index + self.limit
return self.filtered_sorted_players[start_index:end_index]
def prev_page(self):
if self.page_number > 1:
self.offset -= self.limit
def next_page(self):
if self.page_number < self.total_pages:
self.offset += self.limit
def first_page(self):
self.offset = 0
def last_page(self):
self.offset = (self.total_pages - 1) * self.limit
def load_entries(self):
df = pd.read_csv(nba_csv)
df = df.replace("", np.nan) # Replace empty strings with NaN
self.players = [Player(**row) for _, row in df.iterrows()]
self.total_items = len(self.players)
def toggle_sort(self):
self.sort_reverse = not self.sort_reverse
self.load_entries()
@rx.var(cache=True)
def get_age_salary_chart_data(self) -> list[dict]:
age_salary_data = {}
|
for player in self.players:
if (
not pd.isna(player.age)
and not pd.isna(player.salary)
and player.team in self.selected_items["teams"]
and player.college in self.selected_items["colleges"]
and player.position in self.selected_items["positions"]
and self.age[0] <= player.age <= self.age[1]
and self.salary[0] <= float(player.salary) <= self.salary[1]
):
age = player.age
if age not in age_salary_data:
age_salary_data[age] = 0
age_count[age] = 0
age_salary_data[age] += float(player.salary)
age_count[age] += 1
return [
{
"age": age,
"average salary": round(
age_salary_data.get(age, 0) / age_count.get(age, 1), 2
),
}
for age in range | age_count = {} |
-> list[Player]:
start_index = self.offset
end_index = start_index + self.limit
return self.filtered_sorted_players[start_index:end_index]
def prev_page(self):
if self.page_number > 1:
self.offset -= self.limit
def next_page(self):
if self.page_number < self.total_pages:
self.offset += self.limit
def first_page(self):
self.offset = 0
def last_page(self):
self.offset = (self.total_pages - 1) * self.limit
def load_entries(self):
df = pd.read_csv(nba_csv)
df = df.replace("", np.nan) # Replace empty strings with NaN
self.players = [Player(**row) for _, row in df.iterrows()]
self.total_items = len(self.players)
def toggle_sort(self):
self.sort_reverse = not self.sort_reverse
self.load_entries()
@rx.var(cache=True)
def get_age_salary_chart_data(self) -> list[dict]:
age_salary_data = {}
age_count = {}
|
return [
{
"age": age,
"average salary": round(
age_salary_data.get(age, 0) / age_count.get(age, 1), 2
),
}
for age in range(self.age[0], self.age[1] + 1) # Ensure we include all ages
]
@rx.var(cache=True)
def get_position_salary_chart_data(self) -> list[dict]:
position_salary_data = {}
position_count = {}
for player in self.players:
if (
not pd.isna(player.position)
and not pd.isna(player.salary)
and player.team in self.selected_items["teams"]
and player.college in self.selected_items["colleges"]
and player.position in self.selected_items["positions"]
and self.age[0] <= player.age <= self.age[1]
and self.salary[0] <= float(player.salary) <= self.salary[1]
):
position = player.posit | for player in self.players:
if (
not pd.isna(player.age)
and not pd.isna(player.salary)
and player.team in self.selected_items["teams"]
and player.college in self.selected_items["colleges"]
and player.position in self.selected_items["positions"]
and self.age[0] <= player.age <= self.age[1]
and self.salary[0] <= float(player.salary) <= self.salary[1]
):
age = player.age
if age not in age_salary_data:
age_salary_data[age] = 0
age_count[age] = 0
age_salary_data[age] += float(player.salary)
age_count[age] += 1 |
self.offset
end_index = start_index + self.limit
return self.filtered_sorted_players[start_index:end_index]
def prev_page(self):
if self.page_number > 1:
self.offset -= self.limit
def next_page(self):
if self.page_number < self.total_pages:
self.offset += self.limit
def first_page(self):
self.offset = 0
def last_page(self):
self.offset = (self.total_pages - 1) * self.limit
def load_entries(self):
df = pd.read_csv(nba_csv)
df = df.replace("", np.nan) # Replace empty strings with NaN
self.players = [Player(**row) for _, row in df.iterrows()]
self.total_items = len(self.players)
def toggle_sort(self):
self.sort_reverse = not self.sort_reverse
self.load_entries()
@rx.var(cache=True)
def get_age_salary_chart_data(self) -> list[dict]:
age_salary_data = {}
age_count = {}
for player in self.players:
|
return [
{
"age": age,
"average salary": round(
age_salary_data.get(age, 0) / age_count.get(age, 1), 2
),
}
for age in range(self.age[0], self.age[1] + 1) # Ensure we include all ages
]
@rx.var(cache=True)
def get_position_salary_chart_data(self) -> list[dict]:
position_salary_data = {}
position_count = {}
for player in self.players:
if (
not pd.isna(player.position)
and not pd.isna(player.salary)
and player.team in self.selected_items["teams"]
and player.college in self.selected_items["colleges"]
and player.position in self.selected_items["positions"]
and self.age[0] <= player.age <= self.age[1]
and self.salary[0] <= float(player.salary) <= self.salary[1]
):
position = player.posit | if (
not pd.isna(player.age)
and not pd.isna(player.salary)
and player.team in self.selected_items["teams"]
and player.college in self.selected_items["colleges"]
and player.position in self.selected_items["positions"]
and self.age[0] <= player.age <= self.age[1]
and self.salary[0] <= float(player.salary) <= self.salary[1]
):
age = player.age
if age not in age_salary_data:
age_salary_data[age] = 0
age_count[age] = 0
age_salary_data[age] += float(player.salary)
age_count[age] += 1 |
def load_entries(self):
df = pd.read_csv(nba_csv)
df = df.replace("", np.nan) # Replace empty strings with NaN
self.players = [Player(**row) for _, row in df.iterrows()]
self.total_items = len(self.players)
def toggle_sort(self):
self.sort_reverse = not self.sort_reverse
self.load_entries()
@rx.var(cache=True)
def get_age_salary_chart_data(self) -> list[dict]:
age_salary_data = {}
age_count = {}
for player in self.players:
if (
not pd.isna(player.age)
and not pd.isna(player.salary)
and player.team in self.selected_items["teams"]
and player.college in self.selected_items["colleges"]
and player.position in self.selected_items["positions"]
and self.age[0] <= player.age <= self.age[1]
and self.salary[0] <= float(player.salary) <= self.salary[1]
):
|
if age not in age_salary_data:
age_salary_data[age] = 0
age_count[age] = 0
age_salary_data[age] += float(player.salary)
age_count[age] += 1
return [
{
"age": age,
"average salary": round(
age_salary_data.get(age, 0) / age_count.get(age, 1), 2
),
}
for age in range(self.age[0], self.age[1] + 1) # Ensure we include all ages
]
@rx.var(cache=True)
def get_position_salary_chart_data(self) -> list[dict]:
position_salary_data = {}
position_count = {}
for player in self.players:
if (
not pd.isna(player.position)
and not pd.isna(player.salary)
and player.team in self.selected_items["teams"]
and player.college in self.selected_items["colleges"]
and player.position | age = player.age |
df = pd.read_csv(nba_csv)
df = df.replace("", np.nan) # Replace empty strings with NaN
self.players = [Player(**row) for _, row in df.iterrows()]
self.total_items = len(self.players)
def toggle_sort(self):
self.sort_reverse = not self.sort_reverse
self.load_entries()
@rx.var(cache=True)
def get_age_salary_chart_data(self) -> list[dict]:
age_salary_data = {}
age_count = {}
for player in self.players:
if (
not pd.isna(player.age)
and not pd.isna(player.salary)
and player.team in self.selected_items["teams"]
and player.college in self.selected_items["colleges"]
and player.position in self.selected_items["positions"]
and self.age[0] <= player.age <= self.age[1]
and self.salary[0] <= float(player.salary) <= self.salary[1]
):
age = player.age
|
age_salary_data[age] += float(player.salary)
age_count[age] += 1
return [
{
"age": age,
"average salary": round(
age_salary_data.get(age, 0) / age_count.get(age, 1), 2
),
}
for age in range(self.age[0], self.age[1] + 1) # Ensure we include all ages
]
@rx.var(cache=True)
def get_position_salary_chart_data(self) -> list[dict]:
position_salary_data = {}
position_count = {}
for player in self.players:
if (
not pd.isna(player.position)
and not pd.isna(player.salary)
and player.team in self.selected_items["teams"]
and player.college in self.selected_items["colleges"]
and player.position in self.selected_items["positions"]
and self.age[0] <= player.age <= self.age[1]
and self.salary[0 | if age not in age_salary_data:
age_salary_data[age] = 0
age_count[age] = 0 |
ace("", np.nan) # Replace empty strings with NaN
self.players = [Player(**row) for _, row in df.iterrows()]
self.total_items = len(self.players)
def toggle_sort(self):
self.sort_reverse = not self.sort_reverse
self.load_entries()
@rx.var(cache=True)
def get_age_salary_chart_data(self) -> list[dict]:
age_salary_data = {}
age_count = {}
for player in self.players:
if (
not pd.isna(player.age)
and not pd.isna(player.salary)
and player.team in self.selected_items["teams"]
and player.college in self.selected_items["colleges"]
and player.position in self.selected_items["positions"]
and self.age[0] <= player.age <= self.age[1]
and self.salary[0] <= float(player.salary) <= self.salary[1]
):
age = player.age
if age not in age_salary_data:
|
age_count[age] = 0
age_salary_data[age] += float(player.salary)
age_count[age] += 1
return [
{
"age": age,
"average salary": round(
age_salary_data.get(age, 0) / age_count.get(age, 1), 2
),
}
for age in range(self.age[0], self.age[1] + 1) # Ensure we include all ages
]
@rx.var(cache=True)
def get_position_salary_chart_data(self) -> list[dict]:
position_salary_data = {}
position_count = {}
for player in self.players:
if (
not pd.isna(player.position)
and not pd.isna(player.salary)
and player.team in self.selected_items["teams"]
and player.college in self.selected_items["colleges"]
and player.position in self.selected_items["positions"]
and self.age[0] <= player.age <= self.a | age_salary_data[age] = 0 |
NaN
self.players = [Player(**row) for _, row in df.iterrows()]
self.total_items = len(self.players)
def toggle_sort(self):
self.sort_reverse = not self.sort_reverse
self.load_entries()
@rx.var(cache=True)
def get_age_salary_chart_data(self) -> list[dict]:
age_salary_data = {}
age_count = {}
for player in self.players:
if (
not pd.isna(player.age)
and not pd.isna(player.salary)
and player.team in self.selected_items["teams"]
and player.college in self.selected_items["colleges"]
and player.position in self.selected_items["positions"]
and self.age[0] <= player.age <= self.age[1]
and self.salary[0] <= float(player.salary) <= self.salary[1]
):
age = player.age
if age not in age_salary_data:
age_salary_data[age] = 0
|
age_salary_data[age] += float(player.salary)
age_count[age] += 1
return [
{
"age": age,
"average salary": round(
age_salary_data.get(age, 0) / age_count.get(age, 1), 2
),
}
for age in range(self.age[0], self.age[1] + 1) # Ensure we include all ages
]
@rx.var(cache=True)
def get_position_salary_chart_data(self) -> list[dict]:
position_salary_data = {}
position_count = {}
for player in self.players:
if (
not pd.isna(player.position)
and not pd.isna(player.salary)
and player.team in self.selected_items["teams"]
and player.college in self.selected_items["colleges"]
and player.position in self.selected_items["positions"]
and self.age[0] <= player.age <= self.age[1]
and self.salary[0 | age_count[age] = 0 |
ayer.team in self.selected_items["teams"]
and player.college in self.selected_items["colleges"]
and player.position in self.selected_items["positions"]
and self.age[0] <= player.age <= self.age[1]
and self.salary[0] <= float(player.salary) <= self.salary[1]
):
age = player.age
if age not in age_salary_data:
age_salary_data[age] = 0
age_count[age] = 0
age_salary_data[age] += float(player.salary)
age_count[age] += 1
return [
{
"age": age,
"average salary": round(
age_salary_data.get(age, 0) / age_count.get(age, 1), 2
),
}
for age in range(self.age[0], self.age[1] + 1) # Ensure we include all ages
]
@rx.var(cache=True)
def get_position_salary_chart_data(self) -> list[dict]:
|
position_count = {}
for player in self.players:
if (
not pd.isna(player.position)
and not pd.isna(player.salary)
and player.team in self.selected_items["teams"]
and player.college in self.selected_items["colleges"]
and player.position in self.selected_items["positions"]
and self.age[0] <= player.age <= self.age[1]
and self.salary[0] <= float(player.salary) <= self.salary[1]
):
position = player.position
if position not in position_salary_data:
position_salary_data[position] = 0
position_count[position] = 0
position_salary_data[position] += float(player.salary)
position_count[position] += 1
return [
{
"position": position,
"average salary": round(
position_sala | position_salary_data = {} |
teams"]
and player.college in self.selected_items["colleges"]
and player.position in self.selected_items["positions"]
and self.age[0] <= player.age <= self.age[1]
and self.salary[0] <= float(player.salary) <= self.salary[1]
):
age = player.age
if age not in age_salary_data:
age_salary_data[age] = 0
age_count[age] = 0
age_salary_data[age] += float(player.salary)
age_count[age] += 1
return [
{
"age": age,
"average salary": round(
age_salary_data.get(age, 0) / age_count.get(age, 1), 2
),
}
for age in range(self.age[0], self.age[1] + 1) # Ensure we include all ages
]
@rx.var(cache=True)
def get_position_salary_chart_data(self) -> list[dict]:
position_salary_data = {}
|
for player in self.players:
if (
not pd.isna(player.position)
and not pd.isna(player.salary)
and player.team in self.selected_items["teams"]
and player.college in self.selected_items["colleges"]
and player.position in self.selected_items["positions"]
and self.age[0] <= player.age <= self.age[1]
and self.salary[0] <= float(player.salary) <= self.salary[1]
):
position = player.position
if position not in position_salary_data:
position_salary_data[position] = 0
position_count[position] = 0
position_salary_data[position] += float(player.salary)
position_count[position] += 1
return [
{
"position": position,
"average salary": round(
position_salary_data[position] / position | position_count = {} |
layer.college in self.selected_items["colleges"]
and player.position in self.selected_items["positions"]
and self.age[0] <= player.age <= self.age[1]
and self.salary[0] <= float(player.salary) <= self.salary[1]
):
age = player.age
if age not in age_salary_data:
age_salary_data[age] = 0
age_count[age] = 0
age_salary_data[age] += float(player.salary)
age_count[age] += 1
return [
{
"age": age,
"average salary": round(
age_salary_data.get(age, 0) / age_count.get(age, 1), 2
),
}
for age in range(self.age[0], self.age[1] + 1) # Ensure we include all ages
]
@rx.var(cache=True)
def get_position_salary_chart_data(self) -> list[dict]:
position_salary_data = {}
position_count = {}
|
return [
{
"position": position,
"average salary": round(
position_salary_data[position] / position_count[position], 2
),
}
for position in position_salary_data
]
@rx.var(cache=True)
def get_team_salary_chart_data(self) -> list[dict]:
team_salary_data = {}
team_count = {}
for player in self.players:
if (
not pd.isna(player.team)
and not pd.isna(player.salary)
and player.team in self.selected_items["teams"]
and player.college in self.selected_items["colleges"]
and player.position in self.selected_items["positions"]
and self.age[0] <= player.age <= self.age[1]
and self.salary[0] <= float(player.salary) <= self.salary[1]
):
team = player.team
if team not in team_salary_d | for player in self.players:
if (
not pd.isna(player.position)
and not pd.isna(player.salary)
and player.team in self.selected_items["teams"]
and player.college in self.selected_items["colleges"]
and player.position in self.selected_items["positions"]
and self.age[0] <= player.age <= self.age[1]
and self.salary[0] <= float(player.salary) <= self.salary[1]
):
position = player.position
if position not in position_salary_data:
position_salary_data[position] = 0
position_count[position] = 0
position_salary_data[position] += float(player.salary)
position_count[position] += 1 |
age_count[age] += 1
return [
{
"age": age,
"average salary": round(
age_salary_data.get(age, 0) / age_count.get(age, 1), 2
),
}
for age in range(self.age[0], self.age[1] + 1) # Ensure we include all ages
]
@rx.var(cache=True)
def get_position_salary_chart_data(self) -> list[dict]:
position_salary_data = {}
position_count = {}
for player in self.players:
if (
not pd.isna(player.position)
and not pd.isna(player.salary)
and player.team in self.selected_items["teams"]
and player.college in self.selected_items["colleges"]
and player.position in self.selected_items["positions"]
and self.age[0] <= player.age <= self.age[1]
and self.salary[0] <= float(player.salary) <= self.salary[1]
):
|
if position not in position_salary_data:
position_salary_data[position] = 0
position_count[position] = 0
position_salary_data[position] += float(player.salary)
position_count[position] += 1
return [
{
"position": position,
"average salary": round(
position_salary_data[position] / position_count[position], 2
),
}
for position in position_salary_data
]
@rx.var(cache=True)
def get_team_salary_chart_data(self) -> list[dict]:
team_salary_data = {}
team_count = {}
for player in self.players:
if (
not pd.isna(player.team)
and not pd.isna(player.salary)
and player.team in self.selected_items["teams"]
and player.college in self.selected_items["colleges"]
and playe | position = player.position |
{
"age": age,
"average salary": round(
age_salary_data.get(age, 0) / age_count.get(age, 1), 2
),
}
for age in range(self.age[0], self.age[1] + 1) # Ensure we include all ages
]
@rx.var(cache=True)
def get_position_salary_chart_data(self) -> list[dict]:
position_salary_data = {}
position_count = {}
for player in self.players:
if (
not pd.isna(player.position)
and not pd.isna(player.salary)
and player.team in self.selected_items["teams"]
and player.college in self.selected_items["colleges"]
and player.position in self.selected_items["positions"]
and self.age[0] <= player.age <= self.age[1]
and self.salary[0] <= float(player.salary) <= self.salary[1]
):
position = player.position
|
position_salary_data[position] += float(player.salary)
position_count[position] += 1
return [
{
"position": position,
"average salary": round(
position_salary_data[position] / position_count[position], 2
),
}
for position in position_salary_data
]
@rx.var(cache=True)
def get_team_salary_chart_data(self) -> list[dict]:
team_salary_data = {}
team_count = {}
for player in self.players:
if (
not pd.isna(player.team)
and not pd.isna(player.salary)
and player.team in self.selected_items["teams"]
and player.college in self.selected_items["colleges"]
and player.position in self.selected_items["positions"]
and self.age[0] <= player.age <= self.age[1]
and self.salary[0] <= float(player.sa | if position not in position_salary_data:
position_salary_data[position] = 0
position_count[position] = 0 |
rage salary": round(
age_salary_data.get(age, 0) / age_count.get(age, 1), 2
),
}
for age in range(self.age[0], self.age[1] + 1) # Ensure we include all ages
]
@rx.var(cache=True)
def get_position_salary_chart_data(self) -> list[dict]:
position_salary_data = {}
position_count = {}
for player in self.players:
if (
not pd.isna(player.position)
and not pd.isna(player.salary)
and player.team in self.selected_items["teams"]
and player.college in self.selected_items["colleges"]
and player.position in self.selected_items["positions"]
and self.age[0] <= player.age <= self.age[1]
and self.salary[0] <= float(player.salary) <= self.salary[1]
):
position = player.position
if position not in position_salary_data:
|
position_count[position] = 0
position_salary_data[position] += float(player.salary)
position_count[position] += 1
return [
{
"position": position,
"average salary": round(
position_salary_data[position] / position_count[position], 2
),
}
for position in position_salary_data
]
@rx.var(cache=True)
def get_team_salary_chart_data(self) -> list[dict]:
team_salary_data = {}
team_count = {}
for player in self.players:
if (
not pd.isna(player.team)
and not pd.isna(player.salary)
and player.team in self.selected_items["teams"]
and player.college in self.selected_items["colleges"]
and player.position in self.selected_items["positions"]
and self.age[0] <= player.age <= self.age[1]
| position_salary_data[position] = 0 |
a.get(age, 0) / age_count.get(age, 1), 2
),
}
for age in range(self.age[0], self.age[1] + 1) # Ensure we include all ages
]
@rx.var(cache=True)
def get_position_salary_chart_data(self) -> list[dict]:
position_salary_data = {}
position_count = {}
for player in self.players:
if (
not pd.isna(player.position)
and not pd.isna(player.salary)
and player.team in self.selected_items["teams"]
and player.college in self.selected_items["colleges"]
and player.position in self.selected_items["positions"]
and self.age[0] <= player.age <= self.age[1]
and self.salary[0] <= float(player.salary) <= self.salary[1]
):
position = player.position
if position not in position_salary_data:
position_salary_data[position] = 0
|
position_salary_data[position] += float(player.salary)
position_count[position] += 1
return [
{
"position": position,
"average salary": round(
position_salary_data[position] / position_count[position], 2
),
}
for position in position_salary_data
]
@rx.var(cache=True)
def get_team_salary_chart_data(self) -> list[dict]:
team_salary_data = {}
team_count = {}
for player in self.players:
if (
not pd.isna(player.team)
and not pd.isna(player.salary)
and player.team in self.selected_items["teams"]
and player.college in self.selected_items["colleges"]
and player.position in self.selected_items["positions"]
and self.age[0] <= player.age <= self.age[1]
and self.salary[0] <= float(player.sa | position_count[position] = 0 |
lary)
and player.team in self.selected_items["teams"]
and player.college in self.selected_items["colleges"]
and player.position in self.selected_items["positions"]
and self.age[0] <= player.age <= self.age[1]
and self.salary[0] <= float(player.salary) <= self.salary[1]
):
position = player.position
if position not in position_salary_data:
position_salary_data[position] = 0
position_count[position] = 0
position_salary_data[position] += float(player.salary)
position_count[position] += 1
return [
{
"position": position,
"average salary": round(
position_salary_data[position] / position_count[position], 2
),
}
for position in position_salary_data
]
@rx.var(cache=True)
|
@rx.var(cache=True)
def get_college_salary_chart_data(self) -> list[dict]:
college_salary_data = {}
college_count = {}
for player in self.players:
if (
not pd.isna(player.college)
and not pd.isna(player.salary)
and player.team in self.selected_items["teams"]
and player.college in self.selected_items["colleges"]
and player.position in self.selected_items["positions"]
and self.age[0] <= player.age <= self.age[1]
and self.salary[0] <= float(player.salary) <= self.salary[1]
):
college = player.college
if college not in college_salary_data:
college_salary_data[college] = 0
college_count[college] = 0
college_salary_data[college] += float(player.salary)
college_count[college] += 1
return [
{
| def get_team_salary_chart_data(self) -> list[dict]:
team_salary_data = {}
team_count = {}
for player in self.players:
if (
not pd.isna(player.team)
and not pd.isna(player.salary)
and player.team in self.selected_items["teams"]
and player.college in self.selected_items["colleges"]
and player.position in self.selected_items["positions"]
and self.age[0] <= player.age <= self.age[1]
and self.salary[0] <= float(player.salary) <= self.salary[1]
):
team = player.team
if team not in team_salary_data:
team_salary_data[team] = 0
team_count[team] = 0
team_salary_data[team] += float(player.salary)
team_count[team] += 1
return [
{
"team": team,
"average salary": round(team_salary_data[team] / team_count[team], 2),
}
for team in team_salary_data
] |
["teams"]
and player.college in self.selected_items["colleges"]
and player.position in self.selected_items["positions"]
and self.age[0] <= player.age <= self.age[1]
and self.salary[0] <= float(player.salary) <= self.salary[1]
):
position = player.position
if position not in position_salary_data:
position_salary_data[position] = 0
position_count[position] = 0
position_salary_data[position] += float(player.salary)
position_count[position] += 1
return [
{
"position": position,
"average salary": round(
position_salary_data[position] / position_count[position], 2
),
}
for position in position_salary_data
]
@rx.var(cache=True)
def get_team_salary_chart_data(self) -> list[dict]:
|
team_count = {}
for player in self.players:
if (
not pd.isna(player.team)
and not pd.isna(player.salary)
and player.team in self.selected_items["teams"]
and player.college in self.selected_items["colleges"]
and player.position in self.selected_items["positions"]
and self.age[0] <= player.age <= self.age[1]
and self.salary[0] <= float(player.salary) <= self.salary[1]
):
team = player.team
if team not in team_salary_data:
team_salary_data[team] = 0
team_count[team] = 0
team_salary_data[team] += float(player.salary)
team_count[team] += 1
return [
{
"team": team,
"average salary": round(team_salary_data[team] / team_count[team], 2),
}
for team in team_salary_d | team_salary_data = {} |
player.college in self.selected_items["colleges"]
and player.position in self.selected_items["positions"]
and self.age[0] <= player.age <= self.age[1]
and self.salary[0] <= float(player.salary) <= self.salary[1]
):
position = player.position
if position not in position_salary_data:
position_salary_data[position] = 0
position_count[position] = 0
position_salary_data[position] += float(player.salary)
position_count[position] += 1
return [
{
"position": position,
"average salary": round(
position_salary_data[position] / position_count[position], 2
),
}
for position in position_salary_data
]
@rx.var(cache=True)
def get_team_salary_chart_data(self) -> list[dict]:
team_salary_data = {}
|
for player in self.players:
if (
not pd.isna(player.team)
and not pd.isna(player.salary)
and player.team in self.selected_items["teams"]
and player.college in self.selected_items["colleges"]
and player.position in self.selected_items["positions"]
and self.age[0] <= player.age <= self.age[1]
and self.salary[0] <= float(player.salary) <= self.salary[1]
):
team = player.team
if team not in team_salary_data:
team_salary_data[team] = 0
team_count[team] = 0
team_salary_data[team] += float(player.salary)
team_count[team] += 1
return [
{
"team": team,
"average salary": round(team_salary_data[team] / team_count[team], 2),
}
for team in team_salary_data
]
@rx.v | team_count = {} |
lected_items["colleges"]
and player.position in self.selected_items["positions"]
and self.age[0] <= player.age <= self.age[1]
and self.salary[0] <= float(player.salary) <= self.salary[1]
):
position = player.position
if position not in position_salary_data:
position_salary_data[position] = 0
position_count[position] = 0
position_salary_data[position] += float(player.salary)
position_count[position] += 1
return [
{
"position": position,
"average salary": round(
position_salary_data[position] / position_count[position], 2
),
}
for position in position_salary_data
]
@rx.var(cache=True)
def get_team_salary_chart_data(self) -> list[dict]:
team_salary_data = {}
team_count = {}
|
return [
{
"team": team,
"average salary": round(team_salary_data[team] / team_count[team], 2),
}
for team in team_salary_data
]
@rx.var(cache=True)
def get_college_salary_chart_data(self) -> list[dict]:
college_salary_data = {}
college_count = {}
for player in self.players:
if (
not pd.isna(player.college)
and not pd.isna(player.salary)
and player.team in self.selected_items["teams"]
and player.college in self.selected_items["colleges"]
and player.position in self.selected_items["positions"]
and self.age[0] <= player.age <= self.age[1]
and self.salary[0] <= float(player.salary) <= self.salary[1]
):
college = player.college
if college not in college_salary_data:
college_salary_data[c | for player in self.players:
if (
not pd.isna(player.team)
and not pd.isna(player.salary)
and player.team in self.selected_items["teams"]
and player.college in self.selected_items["colleges"]
and player.position in self.selected_items["positions"]
and self.age[0] <= player.age <= self.age[1]
and self.salary[0] <= float(player.salary) <= self.salary[1]
):
team = player.team
if team not in team_salary_data:
team_salary_data[team] = 0
team_count[team] = 0
team_salary_data[team] += float(player.salary)
team_count[team] += 1 |
and player.position in self.selected_items["positions"]
and self.age[0] <= player.age <= self.age[1]
and self.salary[0] <= float(player.salary) <= self.salary[1]
):
position = player.position
if position not in position_salary_data:
position_salary_data[position] = 0
position_count[position] = 0
position_salary_data[position] += float(player.salary)
position_count[position] += 1
return [
{
"position": position,
"average salary": round(
position_salary_data[position] / position_count[position], 2
),
}
for position in position_salary_data
]
@rx.var(cache=True)
def get_team_salary_chart_data(self) -> list[dict]:
team_salary_data = {}
team_count = {}
for player in self.players:
|
return [
{
"team": team,
"average salary": round(team_salary_data[team] / team_count[team], 2),
}
for team in team_salary_data
]
@rx.var(cache=True)
def get_college_salary_chart_data(self) -> list[dict]:
college_salary_data = {}
college_count = {}
for player in self.players:
if (
not pd.isna(player.college)
and not pd.isna(player.salary)
and player.team in self.selected_items["teams"]
and player.college in self.selected_items["colleges"]
and player.position in self.selected_items["positions"]
and self.age[0] <= player.age <= self.age[1]
and self.salary[0] <= float(player.salary) <= self.salary[1]
):
college = player.college
if college not in college_salary_data:
college_salary_data[c | if (
not pd.isna(player.team)
and not pd.isna(player.salary)
and player.team in self.selected_items["teams"]
and player.college in self.selected_items["colleges"]
and player.position in self.selected_items["positions"]
and self.age[0] <= player.age <= self.age[1]
and self.salary[0] <= float(player.salary) <= self.salary[1]
):
team = player.team
if team not in team_salary_data:
team_salary_data[team] = 0
team_count[team] = 0
team_salary_data[team] += float(player.salary)
team_count[team] += 1 |
at(player.salary)
position_count[position] += 1
return [
{
"position": position,
"average salary": round(
position_salary_data[position] / position_count[position], 2
),
}
for position in position_salary_data
]
@rx.var(cache=True)
def get_team_salary_chart_data(self) -> list[dict]:
team_salary_data = {}
team_count = {}
for player in self.players:
if (
not pd.isna(player.team)
and not pd.isna(player.salary)
and player.team in self.selected_items["teams"]
and player.college in self.selected_items["colleges"]
and player.position in self.selected_items["positions"]
and self.age[0] <= player.age <= self.age[1]
and self.salary[0] <= float(player.salary) <= self.salary[1]
):
|
if team not in team_salary_data:
team_salary_data[team] = 0
team_count[team] = 0
team_salary_data[team] += float(player.salary)
team_count[team] += 1
return [
{
"team": team,
"average salary": round(team_salary_data[team] / team_count[team], 2),
}
for team in team_salary_data
]
@rx.var(cache=True)
def get_college_salary_chart_data(self) -> list[dict]:
college_salary_data = {}
college_count = {}
for player in self.players:
if (
not pd.isna(player.college)
and not pd.isna(player.salary)
and player.team in self.selected_items["teams"]
and player.college in self.selected_items["colleges"]
and player.position in self.selected_items["positions"]
and self.age[0] <= player.age <= se | team = player.team |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.