instruction stringlengths 0 1k | input stringlengths 1 1k | output stringlengths 10 6.51k |
|---|---|---|
t the original items in sorted order
sorted_data = [item for _, item in items_with_sort_keys]
return sorted_data[:5]
def _get_sort_key_for_recent_activities(
self, item: DetailEntry
) -> datetime.datetime:
"""Helper to get sort key for recent activities, handling potential ValueError."""
try:
return datetime.datetime.strptime(item["last_edited"], "%d/%m/%Y %H:%M")
except ValueError:
return datetime.datetime.min
@rx.var
def unique_statuses(self) -> List[str]:
"""Get unique statuses from the data."""
return sorted({item["status"] for item in self._data})
@rx.var
def unique_countries(self) -> List[str]:
"""Get unique countries from the data."""
return sorted({item["country"] for item in self._data})
@rx.var
def filtered_data(self) -> List[DetailEntry]:
"""Filter the data based on current filter selections."""
data = self._data
|
if self.selected_statuses:
data = [item for item in data if item["status"] in self.selected_statuses]
if self.selected_countries:
data = [item for item in data if item["country"] in self.selected_countries]
if self.min_cost is not None:
data = [item for item in data if item["costs"] >= self.min_cost]
if self.max_cost is not None:
data = [item for item in data if item["costs"] <= self.max_cost]
return data
def _get_sort_key_for_filtered_data(
self, item: DetailEntry, internal_key: str, is_date_col: bool
) -> datetime.datetime | str | int | float:
"""Helper to get sort key for filtered_and_sorted_data."""
try:
if is_date_col:
return datetime.datetime.strptime(item[internal_key], "%d/%m/%Y %H:%M")
val = item[internal_key]
if isinstance(val, (int, float)):
return val
return str(val).lower()
| if self.search_owner:
data = [
item
for item in data
if self.search_owner.lower() in item["owner"].lower()
] |
er
sorted_data = [item for _, item in items_with_sort_keys]
return sorted_data[:5]
def _get_sort_key_for_recent_activities(
self, item: DetailEntry
) -> datetime.datetime:
"""Helper to get sort key for recent activities, handling potential ValueError."""
try:
return datetime.datetime.strptime(item["last_edited"], "%d/%m/%Y %H:%M")
except ValueError:
return datetime.datetime.min
@rx.var
def unique_statuses(self) -> List[str]:
"""Get unique statuses from the data."""
return sorted({item["status"] for item in self._data})
@rx.var
def unique_countries(self) -> List[str]:
"""Get unique countries from the data."""
return sorted({item["country"] for item in self._data})
@rx.var
def filtered_data(self) -> List[DetailEntry]:
"""Filter the data based on current filter selections."""
data = self._data
if self.search_owner:
|
if self.selected_statuses:
data = [item for item in data if item["status"] in self.selected_statuses]
if self.selected_countries:
data = [item for item in data if item["country"] in self.selected_countries]
if self.min_cost is not None:
data = [item for item in data if item["costs"] >= self.min_cost]
if self.max_cost is not None:
data = [item for item in data if item["costs"] <= self.max_cost]
return data
def _get_sort_key_for_filtered_data(
self, item: DetailEntry, internal_key: str, is_date_col: bool
) -> datetime.datetime | str | int | float:
"""Helper to get sort key for filtered_and_sorted_data."""
try:
if is_date_col:
return datetime.datetime.strptime(item[internal_key], "%d/%m/%Y %H:%M")
val = item[internal_key]
if isinstance(val, (int, float)):
return val
return str(val).lower()
| data = [
item
for item in data
if self.search_owner.lower() in item["owner"].lower()
] |
lf, item: DetailEntry
) -> datetime.datetime:
"""Helper to get sort key for recent activities, handling potential ValueError."""
try:
return datetime.datetime.strptime(item["last_edited"], "%d/%m/%Y %H:%M")
except ValueError:
return datetime.datetime.min
@rx.var
def unique_statuses(self) -> List[str]:
"""Get unique statuses from the data."""
return sorted({item["status"] for item in self._data})
@rx.var
def unique_countries(self) -> List[str]:
"""Get unique countries from the data."""
return sorted({item["country"] for item in self._data})
@rx.var
def filtered_data(self) -> List[DetailEntry]:
"""Filter the data based on current filter selections."""
data = self._data
if self.search_owner:
data = [
item
for item in data
if self.search_owner.lower() in item["owner"].lower()
]
|
if self.selected_countries:
data = [item for item in data if item["country"] in self.selected_countries]
if self.min_cost is not None:
data = [item for item in data if item["costs"] >= self.min_cost]
if self.max_cost is not None:
data = [item for item in data if item["costs"] <= self.max_cost]
return data
def _get_sort_key_for_filtered_data(
self, item: DetailEntry, internal_key: str, is_date_col: bool
) -> datetime.datetime | str | int | float:
"""Helper to get sort key for filtered_and_sorted_data."""
try:
if is_date_col:
return datetime.datetime.strptime(item[internal_key], "%d/%m/%Y %H:%M")
val = item[internal_key]
if isinstance(val, (int, float)):
return val
return str(val).lower()
except (KeyError, ValueError):
# Return a value that will sort consistently for error cases
| if self.selected_statuses:
data = [item for item in data if item["status"] in self.selected_statuses] |
.datetime:
"""Helper to get sort key for recent activities, handling potential ValueError."""
try:
return datetime.datetime.strptime(item["last_edited"], "%d/%m/%Y %H:%M")
except ValueError:
return datetime.datetime.min
@rx.var
def unique_statuses(self) -> List[str]:
"""Get unique statuses from the data."""
return sorted({item["status"] for item in self._data})
@rx.var
def unique_countries(self) -> List[str]:
"""Get unique countries from the data."""
return sorted({item["country"] for item in self._data})
@rx.var
def filtered_data(self) -> List[DetailEntry]:
"""Filter the data based on current filter selections."""
data = self._data
if self.search_owner:
data = [
item
for item in data
if self.search_owner.lower() in item["owner"].lower()
]
if self.selected_statuses:
|
if self.selected_countries:
data = [item for item in data if item["country"] in self.selected_countries]
if self.min_cost is not None:
data = [item for item in data if item["costs"] >= self.min_cost]
if self.max_cost is not None:
data = [item for item in data if item["costs"] <= self.max_cost]
return data
def _get_sort_key_for_filtered_data(
self, item: DetailEntry, internal_key: str, is_date_col: bool
) -> datetime.datetime | str | int | float:
"""Helper to get sort key for filtered_and_sorted_data."""
try:
if is_date_col:
return datetime.datetime.strptime(item[internal_key], "%d/%m/%Y %H:%M")
val = item[internal_key]
if isinstance(val, (int, float)):
return val
return str(val).lower()
except (KeyError, ValueError):
# Return a value that will sort consistently for error cases
| data = [item for item in data if item["status"] in self.selected_statuses] |
ial ValueError."""
try:
return datetime.datetime.strptime(item["last_edited"], "%d/%m/%Y %H:%M")
except ValueError:
return datetime.datetime.min
@rx.var
def unique_statuses(self) -> List[str]:
"""Get unique statuses from the data."""
return sorted({item["status"] for item in self._data})
@rx.var
def unique_countries(self) -> List[str]:
"""Get unique countries from the data."""
return sorted({item["country"] for item in self._data})
@rx.var
def filtered_data(self) -> List[DetailEntry]:
"""Filter the data based on current filter selections."""
data = self._data
if self.search_owner:
data = [
item
for item in data
if self.search_owner.lower() in item["owner"].lower()
]
if self.selected_statuses:
data = [item for item in data if item["status"] in self.selected_statuses]
|
if self.min_cost is not None:
data = [item for item in data if item["costs"] >= self.min_cost]
if self.max_cost is not None:
data = [item for item in data if item["costs"] <= self.max_cost]
return data
def _get_sort_key_for_filtered_data(
self, item: DetailEntry, internal_key: str, is_date_col: bool
) -> datetime.datetime | str | int | float:
"""Helper to get sort key for filtered_and_sorted_data."""
try:
if is_date_col:
return datetime.datetime.strptime(item[internal_key], "%d/%m/%Y %H:%M")
val = item[internal_key]
if isinstance(val, (int, float)):
return val
return str(val).lower()
except (KeyError, ValueError):
# Return a value that will sort consistently for error cases
if is_date_col:
return datetime.datetime.min
return ""
@rx.var
def filtered_and_sorted | if self.selected_countries:
data = [item for item in data if item["country"] in self.selected_countries] |
return datetime.datetime.strptime(item["last_edited"], "%d/%m/%Y %H:%M")
except ValueError:
return datetime.datetime.min
@rx.var
def unique_statuses(self) -> List[str]:
"""Get unique statuses from the data."""
return sorted({item["status"] for item in self._data})
@rx.var
def unique_countries(self) -> List[str]:
"""Get unique countries from the data."""
return sorted({item["country"] for item in self._data})
@rx.var
def filtered_data(self) -> List[DetailEntry]:
"""Filter the data based on current filter selections."""
data = self._data
if self.search_owner:
data = [
item
for item in data
if self.search_owner.lower() in item["owner"].lower()
]
if self.selected_statuses:
data = [item for item in data if item["status"] in self.selected_statuses]
if self.selected_countries:
|
if self.min_cost is not None:
data = [item for item in data if item["costs"] >= self.min_cost]
if self.max_cost is not None:
data = [item for item in data if item["costs"] <= self.max_cost]
return data
def _get_sort_key_for_filtered_data(
self, item: DetailEntry, internal_key: str, is_date_col: bool
) -> datetime.datetime | str | int | float:
"""Helper to get sort key for filtered_and_sorted_data."""
try:
if is_date_col:
return datetime.datetime.strptime(item[internal_key], "%d/%m/%Y %H:%M")
val = item[internal_key]
if isinstance(val, (int, float)):
return val
return str(val).lower()
except (KeyError, ValueError):
# Return a value that will sort consistently for error cases
if is_date_col:
return datetime.datetime.min
return ""
@rx.var
def filtered_and_sorted | data = [item for item in data if item["country"] in self.selected_countries] |
except ValueError:
return datetime.datetime.min
@rx.var
def unique_statuses(self) -> List[str]:
"""Get unique statuses from the data."""
return sorted({item["status"] for item in self._data})
@rx.var
def unique_countries(self) -> List[str]:
"""Get unique countries from the data."""
return sorted({item["country"] for item in self._data})
@rx.var
def filtered_data(self) -> List[DetailEntry]:
"""Filter the data based on current filter selections."""
data = self._data
if self.search_owner:
data = [
item
for item in data
if self.search_owner.lower() in item["owner"].lower()
]
if self.selected_statuses:
data = [item for item in data if item["status"] in self.selected_statuses]
if self.selected_countries:
data = [item for item in data if item["country"] in self.selected_countries]
|
if self.max_cost is not None:
data = [item for item in data if item["costs"] <= self.max_cost]
return data
def _get_sort_key_for_filtered_data(
self, item: DetailEntry, internal_key: str, is_date_col: bool
) -> datetime.datetime | str | int | float:
"""Helper to get sort key for filtered_and_sorted_data."""
try:
if is_date_col:
return datetime.datetime.strptime(item[internal_key], "%d/%m/%Y %H:%M")
val = item[internal_key]
if isinstance(val, (int, float)):
return val
return str(val).lower()
except (KeyError, ValueError):
# Return a value that will sort consistently for error cases
if is_date_col:
return datetime.datetime.min
return ""
@rx.var
def filtered_and_sorted_data(self) -> List[DetailEntry]:
"""Sort the filtered data."""
data_to_sort = self.filtered_data
| if self.min_cost is not None:
data = [item for item in data if item["costs"] >= self.min_cost] |
time.datetime.min
@rx.var
def unique_statuses(self) -> List[str]:
"""Get unique statuses from the data."""
return sorted({item["status"] for item in self._data})
@rx.var
def unique_countries(self) -> List[str]:
"""Get unique countries from the data."""
return sorted({item["country"] for item in self._data})
@rx.var
def filtered_data(self) -> List[DetailEntry]:
"""Filter the data based on current filter selections."""
data = self._data
if self.search_owner:
data = [
item
for item in data
if self.search_owner.lower() in item["owner"].lower()
]
if self.selected_statuses:
data = [item for item in data if item["status"] in self.selected_statuses]
if self.selected_countries:
data = [item for item in data if item["country"] in self.selected_countries]
if self.min_cost is not None:
|
if self.max_cost is not None:
data = [item for item in data if item["costs"] <= self.max_cost]
return data
def _get_sort_key_for_filtered_data(
self, item: DetailEntry, internal_key: str, is_date_col: bool
) -> datetime.datetime | str | int | float:
"""Helper to get sort key for filtered_and_sorted_data."""
try:
if is_date_col:
return datetime.datetime.strptime(item[internal_key], "%d/%m/%Y %H:%M")
val = item[internal_key]
if isinstance(val, (int, float)):
return val
return str(val).lower()
except (KeyError, ValueError):
# Return a value that will sort consistently for error cases
if is_date_col:
return datetime.datetime.min
return ""
@rx.var
def filtered_and_sorted_data(self) -> List[DetailEntry]:
"""Sort the filtered data."""
data_to_sort = self.filtered_data
| data = [item for item in data if item["costs"] >= self.min_cost] |
:
"""Get unique statuses from the data."""
return sorted({item["status"] for item in self._data})
@rx.var
def unique_countries(self) -> List[str]:
"""Get unique countries from the data."""
return sorted({item["country"] for item in self._data})
@rx.var
def filtered_data(self) -> List[DetailEntry]:
"""Filter the data based on current filter selections."""
data = self._data
if self.search_owner:
data = [
item
for item in data
if self.search_owner.lower() in item["owner"].lower()
]
if self.selected_statuses:
data = [item for item in data if item["status"] in self.selected_statuses]
if self.selected_countries:
data = [item for item in data if item["country"] in self.selected_countries]
if self.min_cost is not None:
data = [item for item in data if item["costs"] >= self.min_cost]
|
return data
def _get_sort_key_for_filtered_data(
self, item: DetailEntry, internal_key: str, is_date_col: bool
) -> datetime.datetime | str | int | float:
"""Helper to get sort key for filtered_and_sorted_data."""
try:
if is_date_col:
return datetime.datetime.strptime(item[internal_key], "%d/%m/%Y %H:%M")
val = item[internal_key]
if isinstance(val, (int, float)):
return val
return str(val).lower()
except (KeyError, ValueError):
# Return a value that will sort consistently for error cases
if is_date_col:
return datetime.datetime.min
return ""
@rx.var
def filtered_and_sorted_data(self) -> List[DetailEntry]:
"""Sort the filtered data."""
data_to_sort = self.filtered_data
if self.sort_column:
sort_key_map = {
"Owner": "owner",
"Status" | if self.max_cost is not None:
data = [item for item in data if item["costs"] <= self.max_cost] |
data."""
return sorted({item["status"] for item in self._data})
@rx.var
def unique_countries(self) -> List[str]:
"""Get unique countries from the data."""
return sorted({item["country"] for item in self._data})
@rx.var
def filtered_data(self) -> List[DetailEntry]:
"""Filter the data based on current filter selections."""
data = self._data
if self.search_owner:
data = [
item
for item in data
if self.search_owner.lower() in item["owner"].lower()
]
if self.selected_statuses:
data = [item for item in data if item["status"] in self.selected_statuses]
if self.selected_countries:
data = [item for item in data if item["country"] in self.selected_countries]
if self.min_cost is not None:
data = [item for item in data if item["costs"] >= self.min_cost]
if self.max_cost is not None:
|
return data
def _get_sort_key_for_filtered_data(
self, item: DetailEntry, internal_key: str, is_date_col: bool
) -> datetime.datetime | str | int | float:
"""Helper to get sort key for filtered_and_sorted_data."""
try:
if is_date_col:
return datetime.datetime.strptime(item[internal_key], "%d/%m/%Y %H:%M")
val = item[internal_key]
if isinstance(val, (int, float)):
return val
return str(val).lower()
except (KeyError, ValueError):
# Return a value that will sort consistently for error cases
if is_date_col:
return datetime.datetime.min
return ""
@rx.var
def filtered_and_sorted_data(self) -> List[DetailEntry]:
"""Sort the filtered data."""
data_to_sort = self.filtered_data
if self.sort_column:
sort_key_map = {
"Owner": "owner",
"Status" | data = [item for item in data if item["costs"] <= self.max_cost] |
ef unique_countries(self) -> List[str]:
"""Get unique countries from the data."""
return sorted({item["country"] for item in self._data})
@rx.var
def filtered_data(self) -> List[DetailEntry]:
"""Filter the data based on current filter selections."""
data = self._data
if self.search_owner:
data = [
item
for item in data
if self.search_owner.lower() in item["owner"].lower()
]
if self.selected_statuses:
data = [item for item in data if item["status"] in self.selected_statuses]
if self.selected_countries:
data = [item for item in data if item["country"] in self.selected_countries]
if self.min_cost is not None:
data = [item for item in data if item["costs"] >= self.min_cost]
if self.max_cost is not None:
data = [item for item in data if item["costs"] <= self.max_cost]
return data
|
@rx.var
def filtered_and_sorted_data(self) -> List[DetailEntry]:
"""Sort the filtered data."""
data_to_sort = self.filtered_data
if self.sort_column:
sort_key_map = {
"Owner": "owner",
"Status": "status",
"Country": "country",
"Stability": "stability",
"Costs": "costs",
"Last edited": "last_edited",
}
internal_key = sort_key_map.get(self.sort_column)
if internal_key:
is_date_col = self.sort_column == "Last edited"
# Precompute sort keys
items_with_sort_keys = [
(
self._get_sort_key_for_filtered_data(
item, internal_key, is_date_col
),
item,
)
for item in data_to_sort
]
# So | def _get_sort_key_for_filtered_data(
self, item: DetailEntry, internal_key: str, is_date_col: bool
) -> datetime.datetime | str | int | float:
"""Helper to get sort key for filtered_and_sorted_data."""
try:
if is_date_col:
return datetime.datetime.strptime(item[internal_key], "%d/%m/%Y %H:%M")
val = item[internal_key]
if isinstance(val, (int, float)):
return val
return str(val).lower()
except (KeyError, ValueError):
# Return a value that will sort consistently for error cases
if is_date_col:
return datetime.datetime.min
return "" |
ed on current filter selections."""
data = self._data
if self.search_owner:
data = [
item
for item in data
if self.search_owner.lower() in item["owner"].lower()
]
if self.selected_statuses:
data = [item for item in data if item["status"] in self.selected_statuses]
if self.selected_countries:
data = [item for item in data if item["country"] in self.selected_countries]
if self.min_cost is not None:
data = [item for item in data if item["costs"] >= self.min_cost]
if self.max_cost is not None:
data = [item for item in data if item["costs"] <= self.max_cost]
return data
def _get_sort_key_for_filtered_data(
self, item: DetailEntry, internal_key: str, is_date_col: bool
) -> datetime.datetime | str | int | float:
"""Helper to get sort key for filtered_and_sorted_data."""
try:
|
val = item[internal_key]
if isinstance(val, (int, float)):
return val
return str(val).lower()
except (KeyError, ValueError):
# Return a value that will sort consistently for error cases
if is_date_col:
return datetime.datetime.min
return ""
@rx.var
def filtered_and_sorted_data(self) -> List[DetailEntry]:
"""Sort the filtered data."""
data_to_sort = self.filtered_data
if self.sort_column:
sort_key_map = {
"Owner": "owner",
"Status": "status",
"Country": "country",
"Stability": "stability",
"Costs": "costs",
"Last edited": "last_edited",
}
internal_key = sort_key_map.get(self.sort_column)
if internal_key:
is_date_col = self.sort_column == "Last edited"
# Precompute sort | if is_date_col:
return datetime.datetime.strptime(item[internal_key], "%d/%m/%Y %H:%M") |
item
for item in data
if self.search_owner.lower() in item["owner"].lower()
]
if self.selected_statuses:
data = [item for item in data if item["status"] in self.selected_statuses]
if self.selected_countries:
data = [item for item in data if item["country"] in self.selected_countries]
if self.min_cost is not None:
data = [item for item in data if item["costs"] >= self.min_cost]
if self.max_cost is not None:
data = [item for item in data if item["costs"] <= self.max_cost]
return data
def _get_sort_key_for_filtered_data(
self, item: DetailEntry, internal_key: str, is_date_col: bool
) -> datetime.datetime | str | int | float:
"""Helper to get sort key for filtered_and_sorted_data."""
try:
if is_date_col:
return datetime.datetime.strptime(item[internal_key], "%d/%m/%Y %H:%M")
|
if isinstance(val, (int, float)):
return val
return str(val).lower()
except (KeyError, ValueError):
# Return a value that will sort consistently for error cases
if is_date_col:
return datetime.datetime.min
return ""
@rx.var
def filtered_and_sorted_data(self) -> List[DetailEntry]:
"""Sort the filtered data."""
data_to_sort = self.filtered_data
if self.sort_column:
sort_key_map = {
"Owner": "owner",
"Status": "status",
"Country": "country",
"Stability": "stability",
"Costs": "costs",
"Last edited": "last_edited",
}
internal_key = sort_key_map.get(self.sort_column)
if internal_key:
is_date_col = self.sort_column == "Last edited"
# Precompute sort keys
items_with_sort_ | val = item[internal_key] |
item in data
if self.search_owner.lower() in item["owner"].lower()
]
if self.selected_statuses:
data = [item for item in data if item["status"] in self.selected_statuses]
if self.selected_countries:
data = [item for item in data if item["country"] in self.selected_countries]
if self.min_cost is not None:
data = [item for item in data if item["costs"] >= self.min_cost]
if self.max_cost is not None:
data = [item for item in data if item["costs"] <= self.max_cost]
return data
def _get_sort_key_for_filtered_data(
self, item: DetailEntry, internal_key: str, is_date_col: bool
) -> datetime.datetime | str | int | float:
"""Helper to get sort key for filtered_and_sorted_data."""
try:
if is_date_col:
return datetime.datetime.strptime(item[internal_key], "%d/%m/%Y %H:%M")
val = item[internal_key]
|
return str(val).lower()
except (KeyError, ValueError):
# Return a value that will sort consistently for error cases
if is_date_col:
return datetime.datetime.min
return ""
@rx.var
def filtered_and_sorted_data(self) -> List[DetailEntry]:
"""Sort the filtered data."""
data_to_sort = self.filtered_data
if self.sort_column:
sort_key_map = {
"Owner": "owner",
"Status": "status",
"Country": "country",
"Stability": "stability",
"Costs": "costs",
"Last edited": "last_edited",
}
internal_key = sort_key_map.get(self.sort_column)
if internal_key:
is_date_col = self.sort_column == "Last edited"
# Precompute sort keys
items_with_sort_keys = [
(
self._get_sort_key | if isinstance(val, (int, float)):
return val |
if self.selected_countries:
data = [item for item in data if item["country"] in self.selected_countries]
if self.min_cost is not None:
data = [item for item in data if item["costs"] >= self.min_cost]
if self.max_cost is not None:
data = [item for item in data if item["costs"] <= self.max_cost]
return data
def _get_sort_key_for_filtered_data(
self, item: DetailEntry, internal_key: str, is_date_col: bool
) -> datetime.datetime | str | int | float:
"""Helper to get sort key for filtered_and_sorted_data."""
try:
if is_date_col:
return datetime.datetime.strptime(item[internal_key], "%d/%m/%Y %H:%M")
val = item[internal_key]
if isinstance(val, (int, float)):
return val
return str(val).lower()
except (KeyError, ValueError):
# Return a value that will sort consistently for error cases
|
return ""
@rx.var
def filtered_and_sorted_data(self) -> List[DetailEntry]:
"""Sort the filtered data."""
data_to_sort = self.filtered_data
if self.sort_column:
sort_key_map = {
"Owner": "owner",
"Status": "status",
"Country": "country",
"Stability": "stability",
"Costs": "costs",
"Last edited": "last_edited",
}
internal_key = sort_key_map.get(self.sort_column)
if internal_key:
is_date_col = self.sort_column == "Last edited"
# Precompute sort keys
items_with_sort_keys = [
(
self._get_sort_key_for_filtered_data(
item, internal_key, is_date_col
),
item,
)
for item in data_to_sort
] | if is_date_col:
return datetime.datetime.min |
elf.selected_countries]
if self.min_cost is not None:
data = [item for item in data if item["costs"] >= self.min_cost]
if self.max_cost is not None:
data = [item for item in data if item["costs"] <= self.max_cost]
return data
def _get_sort_key_for_filtered_data(
self, item: DetailEntry, internal_key: str, is_date_col: bool
) -> datetime.datetime | str | int | float:
"""Helper to get sort key for filtered_and_sorted_data."""
try:
if is_date_col:
return datetime.datetime.strptime(item[internal_key], "%d/%m/%Y %H:%M")
val = item[internal_key]
if isinstance(val, (int, float)):
return val
return str(val).lower()
except (KeyError, ValueError):
# Return a value that will sort consistently for error cases
if is_date_col:
return datetime.datetime.min
return ""
@rx.var
|
@rx.var
def total_rows(self) -> int:
"""Total number of rows after filtering."""
return len(self.filtered_and_sorted_data)
@rx.var
def total_pages(self) -> int:
"""Total number of pages."""
if self.rows_per_page <= 0:
return 1
return (
(self.total_rows + self.rows_per_page - 1) // self.rows_per_page
if self.rows_per_page > 0
else 1
)
@rx.var
def paginated_data(self) -> List[DetailEntry]:
"""Get the data for the current page."""
start_index = (self.current_page - 1) * self.rows_per_page
end_index = start_index + self.rows_per_page
return self.filtered_and_sorted_data[start_index:end_index]
@rx.var
def current_rows_display(self) -> str:
"""Display string for current rows."""
if self.total_rows == 0:
return "0"
start = (self.current_page - 1) * self.rows_per_page + 1
end = min(
| def filtered_and_sorted_data(self) -> List[DetailEntry]:
"""Sort the filtered data."""
data_to_sort = self.filtered_data
if self.sort_column:
sort_key_map = {
"Owner": "owner",
"Status": "status",
"Country": "country",
"Stability": "stability",
"Costs": "costs",
"Last edited": "last_edited",
}
internal_key = sort_key_map.get(self.sort_column)
if internal_key:
is_date_col = self.sort_column == "Last edited"
# Precompute sort keys
items_with_sort_keys = [
(
self._get_sort_key_for_filtered_data(
item, internal_key, is_date_col
),
item,
)
for item in data_to_sort
]
# Sort based on precomputed keys
items_with_sort_keys.sort(
key=lambda x: x[0], reverse=not self.sort_ascending
)
data_to_sort = [item for _, item in items_with_sort_keys]
return data_to_sort |
if item["costs"] >= self.min_cost]
if self.max_cost is not None:
data = [item for item in data if item["costs"] <= self.max_cost]
return data
def _get_sort_key_for_filtered_data(
self, item: DetailEntry, internal_key: str, is_date_col: bool
) -> datetime.datetime | str | int | float:
"""Helper to get sort key for filtered_and_sorted_data."""
try:
if is_date_col:
return datetime.datetime.strptime(item[internal_key], "%d/%m/%Y %H:%M")
val = item[internal_key]
if isinstance(val, (int, float)):
return val
return str(val).lower()
except (KeyError, ValueError):
# Return a value that will sort consistently for error cases
if is_date_col:
return datetime.datetime.min
return ""
@rx.var
def filtered_and_sorted_data(self) -> List[DetailEntry]:
"""Sort the filtered data."""
|
if self.sort_column:
sort_key_map = {
"Owner": "owner",
"Status": "status",
"Country": "country",
"Stability": "stability",
"Costs": "costs",
"Last edited": "last_edited",
}
internal_key = sort_key_map.get(self.sort_column)
if internal_key:
is_date_col = self.sort_column == "Last edited"
# Precompute sort keys
items_with_sort_keys = [
(
self._get_sort_key_for_filtered_data(
item, internal_key, is_date_col
),
item,
)
for item in data_to_sort
]
# Sort based on precomputed keys
items_with_sort_keys.sort(
key=lambda x: x[0], reverse=not self.sort_ascending
| data_to_sort = self.filtered_data |
if self.max_cost is not None:
data = [item for item in data if item["costs"] <= self.max_cost]
return data
def _get_sort_key_for_filtered_data(
self, item: DetailEntry, internal_key: str, is_date_col: bool
) -> datetime.datetime | str | int | float:
"""Helper to get sort key for filtered_and_sorted_data."""
try:
if is_date_col:
return datetime.datetime.strptime(item[internal_key], "%d/%m/%Y %H:%M")
val = item[internal_key]
if isinstance(val, (int, float)):
return val
return str(val).lower()
except (KeyError, ValueError):
# Return a value that will sort consistently for error cases
if is_date_col:
return datetime.datetime.min
return ""
@rx.var
def filtered_and_sorted_data(self) -> List[DetailEntry]:
"""Sort the filtered data."""
data_to_sort = self.filtered_data
|
return data_to_sort
@rx.var
def total_rows(self) -> int:
"""Total number of rows after filtering."""
return len(self.filtered_and_sorted_data)
@rx.var
def total_pages(self) -> int:
"""Total number of pages."""
if self.rows_per_page <= 0:
return 1
return (
(self.total_rows + self.rows_per_page - 1) // self.rows_per_page
if self.rows_per_page > 0
else 1
)
@rx.var
def paginated_data(self) -> List[DetailEntry]:
"""Get the data for the current page."""
start_index = (self.current_page - 1) * self.rows_per_page
end_index = start_index + self.rows_per_page
return self.filtered_and_sorted_data[start_index:end_index]
@rx.var
def current_rows_display(self) -> str:
"""Display string for current rows."""
if self.total_rows == 0:
return "0"
start = (self.current_page - 1) * self.rows_per_page | if self.sort_column:
sort_key_map = {
"Owner": "owner",
"Status": "status",
"Country": "country",
"Stability": "stability",
"Costs": "costs",
"Last edited": "last_edited",
}
internal_key = sort_key_map.get(self.sort_column)
if internal_key:
is_date_col = self.sort_column == "Last edited"
# Precompute sort keys
items_with_sort_keys = [
(
self._get_sort_key_for_filtered_data(
item, internal_key, is_date_col
),
item,
)
for item in data_to_sort
]
# Sort based on precomputed keys
items_with_sort_keys.sort(
key=lambda x: x[0], reverse=not self.sort_ascending
)
data_to_sort = [item for _, item in items_with_sort_keys] |
data = [item for item in data if item["costs"] <= self.max_cost]
return data
def _get_sort_key_for_filtered_data(
self, item: DetailEntry, internal_key: str, is_date_col: bool
) -> datetime.datetime | str | int | float:
"""Helper to get sort key for filtered_and_sorted_data."""
try:
if is_date_col:
return datetime.datetime.strptime(item[internal_key], "%d/%m/%Y %H:%M")
val = item[internal_key]
if isinstance(val, (int, float)):
return val
return str(val).lower()
except (KeyError, ValueError):
# Return a value that will sort consistently for error cases
if is_date_col:
return datetime.datetime.min
return ""
@rx.var
def filtered_and_sorted_data(self) -> List[DetailEntry]:
"""Sort the filtered data."""
data_to_sort = self.filtered_data
if self.sort_column:
|
internal_key = sort_key_map.get(self.sort_column)
if internal_key:
is_date_col = self.sort_column == "Last edited"
# Precompute sort keys
items_with_sort_keys = [
(
self._get_sort_key_for_filtered_data(
item, internal_key, is_date_col
),
item,
)
for item in data_to_sort
]
# Sort based on precomputed keys
items_with_sort_keys.sort(
key=lambda x: x[0], reverse=not self.sort_ascending
)
data_to_sort = [item for _, item in items_with_sort_keys]
return data_to_sort
@rx.var
def total_rows(self) -> int:
"""Total number of rows after filtering."""
return len(self.filtered_and_sorted_data)
@rx.var
def total_pages(self) -> i | sort_key_map = {
"Owner": "owner",
"Status": "status",
"Country": "country",
"Stability": "stability",
"Costs": "costs",
"Last edited": "last_edited",
} |
to get sort key for filtered_and_sorted_data."""
try:
if is_date_col:
return datetime.datetime.strptime(item[internal_key], "%d/%m/%Y %H:%M")
val = item[internal_key]
if isinstance(val, (int, float)):
return val
return str(val).lower()
except (KeyError, ValueError):
# Return a value that will sort consistently for error cases
if is_date_col:
return datetime.datetime.min
return ""
@rx.var
def filtered_and_sorted_data(self) -> List[DetailEntry]:
"""Sort the filtered data."""
data_to_sort = self.filtered_data
if self.sort_column:
sort_key_map = {
"Owner": "owner",
"Status": "status",
"Country": "country",
"Stability": "stability",
"Costs": "costs",
"Last edited": "last_edited",
}
|
if internal_key:
is_date_col = self.sort_column == "Last edited"
# Precompute sort keys
items_with_sort_keys = [
(
self._get_sort_key_for_filtered_data(
item, internal_key, is_date_col
),
item,
)
for item in data_to_sort
]
# Sort based on precomputed keys
items_with_sort_keys.sort(
key=lambda x: x[0], reverse=not self.sort_ascending
)
data_to_sort = [item for _, item in items_with_sort_keys]
return data_to_sort
@rx.var
def total_rows(self) -> int:
"""Total number of rows after filtering."""
return len(self.filtered_and_sorted_data)
@rx.var
def total_pages(self) -> int:
"""Total number of pages."""
if self.rows_ | internal_key = sort_key_map.get(self.sort_column) |
if is_date_col:
return datetime.datetime.strptime(item[internal_key], "%d/%m/%Y %H:%M")
val = item[internal_key]
if isinstance(val, (int, float)):
return val
return str(val).lower()
except (KeyError, ValueError):
# Return a value that will sort consistently for error cases
if is_date_col:
return datetime.datetime.min
return ""
@rx.var
def filtered_and_sorted_data(self) -> List[DetailEntry]:
"""Sort the filtered data."""
data_to_sort = self.filtered_data
if self.sort_column:
sort_key_map = {
"Owner": "owner",
"Status": "status",
"Country": "country",
"Stability": "stability",
"Costs": "costs",
"Last edited": "last_edited",
}
internal_key = sort_key_map.get(self.sort_column)
|
return data_to_sort
@rx.var
def total_rows(self) -> int:
"""Total number of rows after filtering."""
return len(self.filtered_and_sorted_data)
@rx.var
def total_pages(self) -> int:
"""Total number of pages."""
if self.rows_per_page <= 0:
return 1
return (
(self.total_rows + self.rows_per_page - 1) // self.rows_per_page
if self.rows_per_page > 0
else 1
)
@rx.var
def paginated_data(self) -> List[DetailEntry]:
"""Get the data for the current page."""
start_index = (self.current_page - 1) * self.rows_per_page
end_index = start_index + self.rows_per_page
return self.filtered_and_sorted_data[start_index:end_index]
@rx.var
def current_rows_display(self) -> str:
"""Display string for current rows."""
if self.total_rows == 0:
return "0"
start = (self.current_page - 1) * self.rows_per_page | if internal_key:
is_date_col = self.sort_column == "Last edited"
# Precompute sort keys
items_with_sort_keys = [
(
self._get_sort_key_for_filtered_data(
item, internal_key, is_date_col
),
item,
)
for item in data_to_sort
]
# Sort based on precomputed keys
items_with_sort_keys.sort(
key=lambda x: x[0], reverse=not self.sort_ascending
)
data_to_sort = [item for _, item in items_with_sort_keys] |
return datetime.datetime.strptime(item[internal_key], "%d/%m/%Y %H:%M")
val = item[internal_key]
if isinstance(val, (int, float)):
return val
return str(val).lower()
except (KeyError, ValueError):
# Return a value that will sort consistently for error cases
if is_date_col:
return datetime.datetime.min
return ""
@rx.var
def filtered_and_sorted_data(self) -> List[DetailEntry]:
"""Sort the filtered data."""
data_to_sort = self.filtered_data
if self.sort_column:
sort_key_map = {
"Owner": "owner",
"Status": "status",
"Country": "country",
"Stability": "stability",
"Costs": "costs",
"Last edited": "last_edited",
}
internal_key = sort_key_map.get(self.sort_column)
if internal_key:
|
# Precompute sort keys
items_with_sort_keys = [
(
self._get_sort_key_for_filtered_data(
item, internal_key, is_date_col
),
item,
)
for item in data_to_sort
]
# Sort based on precomputed keys
items_with_sort_keys.sort(
key=lambda x: x[0], reverse=not self.sort_ascending
)
data_to_sort = [item for _, item in items_with_sort_keys]
return data_to_sort
@rx.var
def total_rows(self) -> int:
"""Total number of rows after filtering."""
return len(self.filtered_and_sorted_data)
@rx.var
def total_pages(self) -> int:
"""Total number of pages."""
if self.rows_per_page <= 0:
return 1
return (
(self.total_rows + self.rows | is_date_col = self.sort_column == "Last edited" |
em[internal_key]
if isinstance(val, (int, float)):
return val
return str(val).lower()
except (KeyError, ValueError):
# Return a value that will sort consistently for error cases
if is_date_col:
return datetime.datetime.min
return ""
@rx.var
def filtered_and_sorted_data(self) -> List[DetailEntry]:
"""Sort the filtered data."""
data_to_sort = self.filtered_data
if self.sort_column:
sort_key_map = {
"Owner": "owner",
"Status": "status",
"Country": "country",
"Stability": "stability",
"Costs": "costs",
"Last edited": "last_edited",
}
internal_key = sort_key_map.get(self.sort_column)
if internal_key:
is_date_col = self.sort_column == "Last edited"
# Precompute sort keys
|
# Sort based on precomputed keys
items_with_sort_keys.sort(
key=lambda x: x[0], reverse=not self.sort_ascending
)
data_to_sort = [item for _, item in items_with_sort_keys]
return data_to_sort
@rx.var
def total_rows(self) -> int:
"""Total number of rows after filtering."""
return len(self.filtered_and_sorted_data)
@rx.var
def total_pages(self) -> int:
"""Total number of pages."""
if self.rows_per_page <= 0:
return 1
return (
(self.total_rows + self.rows_per_page - 1) // self.rows_per_page
if self.rows_per_page > 0
else 1
)
@rx.var
def paginated_data(self) -> List[DetailEntry]:
"""Get the data for the current page."""
start_index = (self.current_page - 1) * self.rows_per_page
end_index = start_index + self.rows_per_page
return self.filtered_a | items_with_sort_keys = [
(
self._get_sort_key_for_filtered_data(
item, internal_key, is_date_col
),
item,
)
for item in data_to_sort
] |
umn:
sort_key_map = {
"Owner": "owner",
"Status": "status",
"Country": "country",
"Stability": "stability",
"Costs": "costs",
"Last edited": "last_edited",
}
internal_key = sort_key_map.get(self.sort_column)
if internal_key:
is_date_col = self.sort_column == "Last edited"
# Precompute sort keys
items_with_sort_keys = [
(
self._get_sort_key_for_filtered_data(
item, internal_key, is_date_col
),
item,
)
for item in data_to_sort
]
# Sort based on precomputed keys
items_with_sort_keys.sort(
key=lambda x: x[0], reverse=not self.sort_ascending
)
|
return data_to_sort
@rx.var
def total_rows(self) -> int:
"""Total number of rows after filtering."""
return len(self.filtered_and_sorted_data)
@rx.var
def total_pages(self) -> int:
"""Total number of pages."""
if self.rows_per_page <= 0:
return 1
return (
(self.total_rows + self.rows_per_page - 1) // self.rows_per_page
if self.rows_per_page > 0
else 1
)
@rx.var
def paginated_data(self) -> List[DetailEntry]:
"""Get the data for the current page."""
start_index = (self.current_page - 1) * self.rows_per_page
end_index = start_index + self.rows_per_page
return self.filtered_and_sorted_data[start_index:end_index]
@rx.var
def current_rows_display(self) -> str:
"""Display string for current rows."""
if self.total_rows == 0:
return "0"
start = (self.current_page - 1) * self.rows_per_page | data_to_sort = [item for _, item in items_with_sort_keys] |
"Country": "country",
"Stability": "stability",
"Costs": "costs",
"Last edited": "last_edited",
}
internal_key = sort_key_map.get(self.sort_column)
if internal_key:
is_date_col = self.sort_column == "Last edited"
# Precompute sort keys
items_with_sort_keys = [
(
self._get_sort_key_for_filtered_data(
item, internal_key, is_date_col
),
item,
)
for item in data_to_sort
]
# Sort based on precomputed keys
items_with_sort_keys.sort(
key=lambda x: x[0], reverse=not self.sort_ascending
)
data_to_sort = [item for _, item in items_with_sort_keys]
return data_to_sort
@rx.var
|
@rx.var
def total_pages(self) -> int:
"""Total number of pages."""
if self.rows_per_page <= 0:
return 1
return (
(self.total_rows + self.rows_per_page - 1) // self.rows_per_page
if self.rows_per_page > 0
else 1
)
@rx.var
def paginated_data(self) -> List[DetailEntry]:
"""Get the data for the current page."""
start_index = (self.current_page - 1) * self.rows_per_page
end_index = start_index + self.rows_per_page
return self.filtered_and_sorted_data[start_index:end_index]
@rx.var
def current_rows_display(self) -> str:
"""Display string for current rows."""
if self.total_rows == 0:
return "0"
start = (self.current_page - 1) * self.rows_per_page + 1
end = min(
self.current_page * self.rows_per_page,
self.total_rows,
)
return f"{start} - {end}"
@rx.var
def page_it | def total_rows(self) -> int:
"""Total number of rows after filtering."""
return len(self.filtered_and_sorted_data) |
ast_edited",
}
internal_key = sort_key_map.get(self.sort_column)
if internal_key:
is_date_col = self.sort_column == "Last edited"
# Precompute sort keys
items_with_sort_keys = [
(
self._get_sort_key_for_filtered_data(
item, internal_key, is_date_col
),
item,
)
for item in data_to_sort
]
# Sort based on precomputed keys
items_with_sort_keys.sort(
key=lambda x: x[0], reverse=not self.sort_ascending
)
data_to_sort = [item for _, item in items_with_sort_keys]
return data_to_sort
@rx.var
def total_rows(self) -> int:
"""Total number of rows after filtering."""
return len(self.filtered_and_sorted_data)
@rx.var
|
@rx.var
def paginated_data(self) -> List[DetailEntry]:
"""Get the data for the current page."""
start_index = (self.current_page - 1) * self.rows_per_page
end_index = start_index + self.rows_per_page
return self.filtered_and_sorted_data[start_index:end_index]
@rx.var
def current_rows_display(self) -> str:
"""Display string for current rows."""
if self.total_rows == 0:
return "0"
start = (self.current_page - 1) * self.rows_per_page + 1
end = min(
self.current_page * self.rows_per_page,
self.total_rows,
)
return f"{start} - {end}"
@rx.var
def page_item_ids(self) -> Set[int]:
"""Get the set of IDs for items on the current page."""
return {item["id"] for item in self.paginated_data}
@rx.var
def all_rows_on_page_selected(self) -> bool:
"""Check if all rows on the current page are selected."""
if not self.pagi | def total_pages(self) -> int:
"""Total number of pages."""
if self.rows_per_page <= 0:
return 1
return (
(self.total_rows + self.rows_per_page - 1) // self.rows_per_page
if self.rows_per_page > 0
else 1
) |
.sort_column)
if internal_key:
is_date_col = self.sort_column == "Last edited"
# Precompute sort keys
items_with_sort_keys = [
(
self._get_sort_key_for_filtered_data(
item, internal_key, is_date_col
),
item,
)
for item in data_to_sort
]
# Sort based on precomputed keys
items_with_sort_keys.sort(
key=lambda x: x[0], reverse=not self.sort_ascending
)
data_to_sort = [item for _, item in items_with_sort_keys]
return data_to_sort
@rx.var
def total_rows(self) -> int:
"""Total number of rows after filtering."""
return len(self.filtered_and_sorted_data)
@rx.var
def total_pages(self) -> int:
"""Total number of pages."""
|
return (
(self.total_rows + self.rows_per_page - 1) // self.rows_per_page
if self.rows_per_page > 0
else 1
)
@rx.var
def paginated_data(self) -> List[DetailEntry]:
"""Get the data for the current page."""
start_index = (self.current_page - 1) * self.rows_per_page
end_index = start_index + self.rows_per_page
return self.filtered_and_sorted_data[start_index:end_index]
@rx.var
def current_rows_display(self) -> str:
"""Display string for current rows."""
if self.total_rows == 0:
return "0"
start = (self.current_page - 1) * self.rows_per_page + 1
end = min(
self.current_page * self.rows_per_page,
self.total_rows,
)
return f"{start} - {end}"
@rx.var
def page_item_ids(self) -> Set[int]:
"""Get the set of IDs for items on the current page."""
return {item["id"] for item in self.paginat | if self.rows_per_page <= 0:
return 1 |
self._get_sort_key_for_filtered_data(
item, internal_key, is_date_col
),
item,
)
for item in data_to_sort
]
# Sort based on precomputed keys
items_with_sort_keys.sort(
key=lambda x: x[0], reverse=not self.sort_ascending
)
data_to_sort = [item for _, item in items_with_sort_keys]
return data_to_sort
@rx.var
def total_rows(self) -> int:
"""Total number of rows after filtering."""
return len(self.filtered_and_sorted_data)
@rx.var
def total_pages(self) -> int:
"""Total number of pages."""
if self.rows_per_page <= 0:
return 1
return (
(self.total_rows + self.rows_per_page - 1) // self.rows_per_page
if self.rows_per_page > 0
else 1
)
@rx.var
|
@rx.var
def current_rows_display(self) -> str:
"""Display string for current rows."""
if self.total_rows == 0:
return "0"
start = (self.current_page - 1) * self.rows_per_page + 1
end = min(
self.current_page * self.rows_per_page,
self.total_rows,
)
return f"{start} - {end}"
@rx.var
def page_item_ids(self) -> Set[int]:
"""Get the set of IDs for items on the current page."""
return {item["id"] for item in self.paginated_data}
@rx.var
def all_rows_on_page_selected(self) -> bool:
"""Check if all rows on the current page are selected."""
if not self.paginated_data:
return False
return self.page_item_ids.issubset(self.selected_rows)
@rx.event
def set_search_owner(self, value: str):
"""Update the search owner filter."""
self.search_owner = value
self.current_page = 1
@rx.event
def toggle_so | def paginated_data(self) -> List[DetailEntry]:
"""Get the data for the current page."""
start_index = (self.current_page - 1) * self.rows_per_page
end_index = start_index + self.rows_per_page
return self.filtered_and_sorted_data[start_index:end_index] |
),
item,
)
for item in data_to_sort
]
# Sort based on precomputed keys
items_with_sort_keys.sort(
key=lambda x: x[0], reverse=not self.sort_ascending
)
data_to_sort = [item for _, item in items_with_sort_keys]
return data_to_sort
@rx.var
def total_rows(self) -> int:
"""Total number of rows after filtering."""
return len(self.filtered_and_sorted_data)
@rx.var
def total_pages(self) -> int:
"""Total number of pages."""
if self.rows_per_page <= 0:
return 1
return (
(self.total_rows + self.rows_per_page - 1) // self.rows_per_page
if self.rows_per_page > 0
else 1
)
@rx.var
def paginated_data(self) -> List[DetailEntry]:
"""Get the data for the current page."""
|
end_index = start_index + self.rows_per_page
return self.filtered_and_sorted_data[start_index:end_index]
@rx.var
def current_rows_display(self) -> str:
"""Display string for current rows."""
if self.total_rows == 0:
return "0"
start = (self.current_page - 1) * self.rows_per_page + 1
end = min(
self.current_page * self.rows_per_page,
self.total_rows,
)
return f"{start} - {end}"
@rx.var
def page_item_ids(self) -> Set[int]:
"""Get the set of IDs for items on the current page."""
return {item["id"] for item in self.paginated_data}
@rx.var
def all_rows_on_page_selected(self) -> bool:
"""Check if all rows on the current page are selected."""
if not self.paginated_data:
return False
return self.page_item_ids.issubset(self.selected_rows)
@rx.event
def set_search_owner(self, value: str):
"""Update the | start_index = (self.current_page - 1) * self.rows_per_page |
)
for item in data_to_sort
]
# Sort based on precomputed keys
items_with_sort_keys.sort(
key=lambda x: x[0], reverse=not self.sort_ascending
)
data_to_sort = [item for _, item in items_with_sort_keys]
return data_to_sort
@rx.var
def total_rows(self) -> int:
"""Total number of rows after filtering."""
return len(self.filtered_and_sorted_data)
@rx.var
def total_pages(self) -> int:
"""Total number of pages."""
if self.rows_per_page <= 0:
return 1
return (
(self.total_rows + self.rows_per_page - 1) // self.rows_per_page
if self.rows_per_page > 0
else 1
)
@rx.var
def paginated_data(self) -> List[DetailEntry]:
"""Get the data for the current page."""
start_index = (self.current_page - 1) * self.rows_per_page
|
return self.filtered_and_sorted_data[start_index:end_index]
@rx.var
def current_rows_display(self) -> str:
"""Display string for current rows."""
if self.total_rows == 0:
return "0"
start = (self.current_page - 1) * self.rows_per_page + 1
end = min(
self.current_page * self.rows_per_page,
self.total_rows,
)
return f"{start} - {end}"
@rx.var
def page_item_ids(self) -> Set[int]:
"""Get the set of IDs for items on the current page."""
return {item["id"] for item in self.paginated_data}
@rx.var
def all_rows_on_page_selected(self) -> bool:
"""Check if all rows on the current page are selected."""
if not self.paginated_data:
return False
return self.page_item_ids.issubset(self.selected_rows)
@rx.event
def set_search_owner(self, value: str):
"""Update the search owner filter."""
self.search_owner = | end_index = start_index + self.rows_per_page |
items_with_sort_keys.sort(
key=lambda x: x[0], reverse=not self.sort_ascending
)
data_to_sort = [item for _, item in items_with_sort_keys]
return data_to_sort
@rx.var
def total_rows(self) -> int:
"""Total number of rows after filtering."""
return len(self.filtered_and_sorted_data)
@rx.var
def total_pages(self) -> int:
"""Total number of pages."""
if self.rows_per_page <= 0:
return 1
return (
(self.total_rows + self.rows_per_page - 1) // self.rows_per_page
if self.rows_per_page > 0
else 1
)
@rx.var
def paginated_data(self) -> List[DetailEntry]:
"""Get the data for the current page."""
start_index = (self.current_page - 1) * self.rows_per_page
end_index = start_index + self.rows_per_page
return self.filtered_and_sorted_data[start_index:end_index]
@rx.var
|
@rx.var
def page_item_ids(self) -> Set[int]:
"""Get the set of IDs for items on the current page."""
return {item["id"] for item in self.paginated_data}
@rx.var
def all_rows_on_page_selected(self) -> bool:
"""Check if all rows on the current page are selected."""
if not self.paginated_data:
return False
return self.page_item_ids.issubset(self.selected_rows)
@rx.event
def set_search_owner(self, value: str):
"""Update the search owner filter."""
self.search_owner = value
self.current_page = 1
@rx.event
def toggle_sort(self, column_name: str):
"""Toggle sorting for a column."""
if self.sort_column == column_name:
self.sort_ascending = not self.sort_ascending
else:
self.sort_column = column_name
self.sort_ascending = True
self.current_page = 1
@rx.event
def go_to_page(self, page_number: int):
"" | def current_rows_display(self) -> str:
"""Display string for current rows."""
if self.total_rows == 0:
return "0"
start = (self.current_page - 1) * self.rows_per_page + 1
end = min(
self.current_page * self.rows_per_page,
self.total_rows,
)
return f"{start} - {end}" |
f.sort_ascending
)
data_to_sort = [item for _, item in items_with_sort_keys]
return data_to_sort
@rx.var
def total_rows(self) -> int:
"""Total number of rows after filtering."""
return len(self.filtered_and_sorted_data)
@rx.var
def total_pages(self) -> int:
"""Total number of pages."""
if self.rows_per_page <= 0:
return 1
return (
(self.total_rows + self.rows_per_page - 1) // self.rows_per_page
if self.rows_per_page > 0
else 1
)
@rx.var
def paginated_data(self) -> List[DetailEntry]:
"""Get the data for the current page."""
start_index = (self.current_page - 1) * self.rows_per_page
end_index = start_index + self.rows_per_page
return self.filtered_and_sorted_data[start_index:end_index]
@rx.var
def current_rows_display(self) -> str:
"""Display string for current rows."""
|
start = (self.current_page - 1) * self.rows_per_page + 1
end = min(
self.current_page * self.rows_per_page,
self.total_rows,
)
return f"{start} - {end}"
@rx.var
def page_item_ids(self) -> Set[int]:
"""Get the set of IDs for items on the current page."""
return {item["id"] for item in self.paginated_data}
@rx.var
def all_rows_on_page_selected(self) -> bool:
"""Check if all rows on the current page are selected."""
if not self.paginated_data:
return False
return self.page_item_ids.issubset(self.selected_rows)
@rx.event
def set_search_owner(self, value: str):
"""Update the search owner filter."""
self.search_owner = value
self.current_page = 1
@rx.event
def toggle_sort(self, column_name: str):
"""Toggle sorting for a column."""
if self.sort_column == column_name:
self.sort_ascending = not self.s | if self.total_rows == 0:
return "0" |
_to_sort = [item for _, item in items_with_sort_keys]
return data_to_sort
@rx.var
def total_rows(self) -> int:
"""Total number of rows after filtering."""
return len(self.filtered_and_sorted_data)
@rx.var
def total_pages(self) -> int:
"""Total number of pages."""
if self.rows_per_page <= 0:
return 1
return (
(self.total_rows + self.rows_per_page - 1) // self.rows_per_page
if self.rows_per_page > 0
else 1
)
@rx.var
def paginated_data(self) -> List[DetailEntry]:
"""Get the data for the current page."""
start_index = (self.current_page - 1) * self.rows_per_page
end_index = start_index + self.rows_per_page
return self.filtered_and_sorted_data[start_index:end_index]
@rx.var
def current_rows_display(self) -> str:
"""Display string for current rows."""
if self.total_rows == 0:
return "0"
|
end = min(
self.current_page * self.rows_per_page,
self.total_rows,
)
return f"{start} - {end}"
@rx.var
def page_item_ids(self) -> Set[int]:
"""Get the set of IDs for items on the current page."""
return {item["id"] for item in self.paginated_data}
@rx.var
def all_rows_on_page_selected(self) -> bool:
"""Check if all rows on the current page are selected."""
if not self.paginated_data:
return False
return self.page_item_ids.issubset(self.selected_rows)
@rx.event
def set_search_owner(self, value: str):
"""Update the search owner filter."""
self.search_owner = value
self.current_page = 1
@rx.event
def toggle_sort(self, column_name: str):
"""Toggle sorting for a column."""
if self.sort_column == column_name:
self.sort_ascending = not self.sort_ascending
else:
self.sort_column = column | start = (self.current_page - 1) * self.rows_per_page + 1 |
urn data_to_sort
@rx.var
def total_rows(self) -> int:
"""Total number of rows after filtering."""
return len(self.filtered_and_sorted_data)
@rx.var
def total_pages(self) -> int:
"""Total number of pages."""
if self.rows_per_page <= 0:
return 1
return (
(self.total_rows + self.rows_per_page - 1) // self.rows_per_page
if self.rows_per_page > 0
else 1
)
@rx.var
def paginated_data(self) -> List[DetailEntry]:
"""Get the data for the current page."""
start_index = (self.current_page - 1) * self.rows_per_page
end_index = start_index + self.rows_per_page
return self.filtered_and_sorted_data[start_index:end_index]
@rx.var
def current_rows_display(self) -> str:
"""Display string for current rows."""
if self.total_rows == 0:
return "0"
start = (self.current_page - 1) * self.rows_per_page + 1
|
return f"{start} - {end}"
@rx.var
def page_item_ids(self) -> Set[int]:
"""Get the set of IDs for items on the current page."""
return {item["id"] for item in self.paginated_data}
@rx.var
def all_rows_on_page_selected(self) -> bool:
"""Check if all rows on the current page are selected."""
if not self.paginated_data:
return False
return self.page_item_ids.issubset(self.selected_rows)
@rx.event
def set_search_owner(self, value: str):
"""Update the search owner filter."""
self.search_owner = value
self.current_page = 1
@rx.event
def toggle_sort(self, column_name: str):
"""Toggle sorting for a column."""
if self.sort_column == column_name:
self.sort_ascending = not self.sort_ascending
else:
self.sort_column = column_name
self.sort_ascending = True
self.current_page = 1
@rx.event
def go_to_page(s | end = min(
self.current_page * self.rows_per_page,
self.total_rows,
) |
orted_data)
@rx.var
def total_pages(self) -> int:
"""Total number of pages."""
if self.rows_per_page <= 0:
return 1
return (
(self.total_rows + self.rows_per_page - 1) // self.rows_per_page
if self.rows_per_page > 0
else 1
)
@rx.var
def paginated_data(self) -> List[DetailEntry]:
"""Get the data for the current page."""
start_index = (self.current_page - 1) * self.rows_per_page
end_index = start_index + self.rows_per_page
return self.filtered_and_sorted_data[start_index:end_index]
@rx.var
def current_rows_display(self) -> str:
"""Display string for current rows."""
if self.total_rows == 0:
return "0"
start = (self.current_page - 1) * self.rows_per_page + 1
end = min(
self.current_page * self.rows_per_page,
self.total_rows,
)
return f"{start} - {end}"
@rx.var
|
@rx.var
def all_rows_on_page_selected(self) -> bool:
"""Check if all rows on the current page are selected."""
if not self.paginated_data:
return False
return self.page_item_ids.issubset(self.selected_rows)
@rx.event
def set_search_owner(self, value: str):
"""Update the search owner filter."""
self.search_owner = value
self.current_page = 1
@rx.event
def toggle_sort(self, column_name: str):
"""Toggle sorting for a column."""
if self.sort_column == column_name:
self.sort_ascending = not self.sort_ascending
else:
self.sort_column = column_name
self.sort_ascending = True
self.current_page = 1
@rx.event
def go_to_page(self, page_number: int):
"""Navigate to a specific page."""
if 1 <= page_number <= self.total_pages:
self.current_page = page_number
@rx.event
def next_page(self):
"""G | def page_item_ids(self) -> Set[int]:
"""Get the set of IDs for items on the current page."""
return {item["id"] for item in self.paginated_data} |
(self.total_rows + self.rows_per_page - 1) // self.rows_per_page
if self.rows_per_page > 0
else 1
)
@rx.var
def paginated_data(self) -> List[DetailEntry]:
"""Get the data for the current page."""
start_index = (self.current_page - 1) * self.rows_per_page
end_index = start_index + self.rows_per_page
return self.filtered_and_sorted_data[start_index:end_index]
@rx.var
def current_rows_display(self) -> str:
"""Display string for current rows."""
if self.total_rows == 0:
return "0"
start = (self.current_page - 1) * self.rows_per_page + 1
end = min(
self.current_page * self.rows_per_page,
self.total_rows,
)
return f"{start} - {end}"
@rx.var
def page_item_ids(self) -> Set[int]:
"""Get the set of IDs for items on the current page."""
return {item["id"] for item in self.paginated_data}
@rx.var
|
@rx.event
def set_search_owner(self, value: str):
"""Update the search owner filter."""
self.search_owner = value
self.current_page = 1
@rx.event
def toggle_sort(self, column_name: str):
"""Toggle sorting for a column."""
if self.sort_column == column_name:
self.sort_ascending = not self.sort_ascending
else:
self.sort_column = column_name
self.sort_ascending = True
self.current_page = 1
@rx.event
def go_to_page(self, page_number: int):
"""Navigate to a specific page."""
if 1 <= page_number <= self.total_pages:
self.current_page = page_number
@rx.event
def next_page(self):
"""Go to the next page."""
if self.current_page < self.total_pages:
self.current_page += 1
@rx.event
def previous_page(self):
"""Go to the previous page."""
if self.current_page > 1:
self.current_pag | def all_rows_on_page_selected(self) -> bool:
"""Check if all rows on the current page are selected."""
if not self.paginated_data:
return False
return self.page_item_ids.issubset(self.selected_rows) |
else 1
)
@rx.var
def paginated_data(self) -> List[DetailEntry]:
"""Get the data for the current page."""
start_index = (self.current_page - 1) * self.rows_per_page
end_index = start_index + self.rows_per_page
return self.filtered_and_sorted_data[start_index:end_index]
@rx.var
def current_rows_display(self) -> str:
"""Display string for current rows."""
if self.total_rows == 0:
return "0"
start = (self.current_page - 1) * self.rows_per_page + 1
end = min(
self.current_page * self.rows_per_page,
self.total_rows,
)
return f"{start} - {end}"
@rx.var
def page_item_ids(self) -> Set[int]:
"""Get the set of IDs for items on the current page."""
return {item["id"] for item in self.paginated_data}
@rx.var
def all_rows_on_page_selected(self) -> bool:
"""Check if all rows on the current page are selected."""
|
return self.page_item_ids.issubset(self.selected_rows)
@rx.event
def set_search_owner(self, value: str):
"""Update the search owner filter."""
self.search_owner = value
self.current_page = 1
@rx.event
def toggle_sort(self, column_name: str):
"""Toggle sorting for a column."""
if self.sort_column == column_name:
self.sort_ascending = not self.sort_ascending
else:
self.sort_column = column_name
self.sort_ascending = True
self.current_page = 1
@rx.event
def go_to_page(self, page_number: int):
"""Navigate to a specific page."""
if 1 <= page_number <= self.total_pages:
self.current_page = page_number
@rx.event
def next_page(self):
"""Go to the next page."""
if self.current_page < self.total_pages:
self.current_page += 1
@rx.event
def previous_page(self):
"""Go to the previous page.""" | if not self.paginated_data:
return False |
start_index = (self.current_page - 1) * self.rows_per_page
end_index = start_index + self.rows_per_page
return self.filtered_and_sorted_data[start_index:end_index]
@rx.var
def current_rows_display(self) -> str:
"""Display string for current rows."""
if self.total_rows == 0:
return "0"
start = (self.current_page - 1) * self.rows_per_page + 1
end = min(
self.current_page * self.rows_per_page,
self.total_rows,
)
return f"{start} - {end}"
@rx.var
def page_item_ids(self) -> Set[int]:
"""Get the set of IDs for items on the current page."""
return {item["id"] for item in self.paginated_data}
@rx.var
def all_rows_on_page_selected(self) -> bool:
"""Check if all rows on the current page are selected."""
if not self.paginated_data:
return False
return self.page_item_ids.issubset(self.selected_rows)
@rx.event
|
@rx.event
def toggle_sort(self, column_name: str):
"""Toggle sorting for a column."""
if self.sort_column == column_name:
self.sort_ascending = not self.sort_ascending
else:
self.sort_column = column_name
self.sort_ascending = True
self.current_page = 1
@rx.event
def go_to_page(self, page_number: int):
"""Navigate to a specific page."""
if 1 <= page_number <= self.total_pages:
self.current_page = page_number
@rx.event
def next_page(self):
"""Go to the next page."""
if self.current_page < self.total_pages:
self.current_page += 1
@rx.event
def previous_page(self):
"""Go to the previous page."""
if self.current_page > 1:
self.current_page -= 1
@rx.event
def toggle_row_selection(self, row_id: int):
"""Toggle selection state for a single row using its ID."""
if row_id in self.sele | def set_search_owner(self, value: str):
"""Update the search owner filter."""
self.search_owner = value
self.current_page = 1 |
+ self.rows_per_page
return self.filtered_and_sorted_data[start_index:end_index]
@rx.var
def current_rows_display(self) -> str:
"""Display string for current rows."""
if self.total_rows == 0:
return "0"
start = (self.current_page - 1) * self.rows_per_page + 1
end = min(
self.current_page * self.rows_per_page,
self.total_rows,
)
return f"{start} - {end}"
@rx.var
def page_item_ids(self) -> Set[int]:
"""Get the set of IDs for items on the current page."""
return {item["id"] for item in self.paginated_data}
@rx.var
def all_rows_on_page_selected(self) -> bool:
"""Check if all rows on the current page are selected."""
if not self.paginated_data:
return False
return self.page_item_ids.issubset(self.selected_rows)
@rx.event
def set_search_owner(self, value: str):
"""Update the search owner filter."""
|
self.current_page = 1
@rx.event
def toggle_sort(self, column_name: str):
"""Toggle sorting for a column."""
if self.sort_column == column_name:
self.sort_ascending = not self.sort_ascending
else:
self.sort_column = column_name
self.sort_ascending = True
self.current_page = 1
@rx.event
def go_to_page(self, page_number: int):
"""Navigate to a specific page."""
if 1 <= page_number <= self.total_pages:
self.current_page = page_number
@rx.event
def next_page(self):
"""Go to the next page."""
if self.current_page < self.total_pages:
self.current_page += 1
@rx.event
def previous_page(self):
"""Go to the previous page."""
if self.current_page > 1:
self.current_page -= 1
@rx.event
def toggle_row_selection(self, row_id: int):
"""Toggle selection state for a single row using its ID."""
| self.search_owner = value |
n self.filtered_and_sorted_data[start_index:end_index]
@rx.var
def current_rows_display(self) -> str:
"""Display string for current rows."""
if self.total_rows == 0:
return "0"
start = (self.current_page - 1) * self.rows_per_page + 1
end = min(
self.current_page * self.rows_per_page,
self.total_rows,
)
return f"{start} - {end}"
@rx.var
def page_item_ids(self) -> Set[int]:
"""Get the set of IDs for items on the current page."""
return {item["id"] for item in self.paginated_data}
@rx.var
def all_rows_on_page_selected(self) -> bool:
"""Check if all rows on the current page are selected."""
if not self.paginated_data:
return False
return self.page_item_ids.issubset(self.selected_rows)
@rx.event
def set_search_owner(self, value: str):
"""Update the search owner filter."""
self.search_owner = value
|
@rx.event
def toggle_sort(self, column_name: str):
"""Toggle sorting for a column."""
if self.sort_column == column_name:
self.sort_ascending = not self.sort_ascending
else:
self.sort_column = column_name
self.sort_ascending = True
self.current_page = 1
@rx.event
def go_to_page(self, page_number: int):
"""Navigate to a specific page."""
if 1 <= page_number <= self.total_pages:
self.current_page = page_number
@rx.event
def next_page(self):
"""Go to the next page."""
if self.current_page < self.total_pages:
self.current_page += 1
@rx.event
def previous_page(self):
"""Go to the previous page."""
if self.current_page > 1:
self.current_page -= 1
@rx.event
def toggle_row_selection(self, row_id: int):
"""Toggle selection state for a single row using its ID."""
if row_id in self.sele | self.current_page = 1 |
ex:end_index]
@rx.var
def current_rows_display(self) -> str:
"""Display string for current rows."""
if self.total_rows == 0:
return "0"
start = (self.current_page - 1) * self.rows_per_page + 1
end = min(
self.current_page * self.rows_per_page,
self.total_rows,
)
return f"{start} - {end}"
@rx.var
def page_item_ids(self) -> Set[int]:
"""Get the set of IDs for items on the current page."""
return {item["id"] for item in self.paginated_data}
@rx.var
def all_rows_on_page_selected(self) -> bool:
"""Check if all rows on the current page are selected."""
if not self.paginated_data:
return False
return self.page_item_ids.issubset(self.selected_rows)
@rx.event
def set_search_owner(self, value: str):
"""Update the search owner filter."""
self.search_owner = value
self.current_page = 1
@rx.event
|
@rx.event
def go_to_page(self, page_number: int):
"""Navigate to a specific page."""
if 1 <= page_number <= self.total_pages:
self.current_page = page_number
@rx.event
def next_page(self):
"""Go to the next page."""
if self.current_page < self.total_pages:
self.current_page += 1
@rx.event
def previous_page(self):
"""Go to the previous page."""
if self.current_page > 1:
self.current_page -= 1
@rx.event
def toggle_row_selection(self, row_id: int):
"""Toggle selection state for a single row using its ID."""
if row_id in self.selected_rows:
self.selected_rows.remove(row_id)
else:
self.selected_rows.add(row_id)
@rx.event
def toggle_select_all_on_page(self):
"""Select or deselect all rows on the current page."""
page_ids = self.page_item_ids
if self.all_rows_on_page_selected:
self. | def toggle_sort(self, column_name: str):
"""Toggle sorting for a column."""
if self.sort_column == column_name:
self.sort_ascending = not self.sort_ascending
else:
self.sort_column = column_name
self.sort_ascending = True
self.current_page = 1 |
ing for current rows."""
if self.total_rows == 0:
return "0"
start = (self.current_page - 1) * self.rows_per_page + 1
end = min(
self.current_page * self.rows_per_page,
self.total_rows,
)
return f"{start} - {end}"
@rx.var
def page_item_ids(self) -> Set[int]:
"""Get the set of IDs for items on the current page."""
return {item["id"] for item in self.paginated_data}
@rx.var
def all_rows_on_page_selected(self) -> bool:
"""Check if all rows on the current page are selected."""
if not self.paginated_data:
return False
return self.page_item_ids.issubset(self.selected_rows)
@rx.event
def set_search_owner(self, value: str):
"""Update the search owner filter."""
self.search_owner = value
self.current_page = 1
@rx.event
def toggle_sort(self, column_name: str):
"""Toggle sorting for a column."""
|
self.current_page = 1
@rx.event
def go_to_page(self, page_number: int):
"""Navigate to a specific page."""
if 1 <= page_number <= self.total_pages:
self.current_page = page_number
@rx.event
def next_page(self):
"""Go to the next page."""
if self.current_page < self.total_pages:
self.current_page += 1
@rx.event
def previous_page(self):
"""Go to the previous page."""
if self.current_page > 1:
self.current_page -= 1
@rx.event
def toggle_row_selection(self, row_id: int):
"""Toggle selection state for a single row using its ID."""
if row_id in self.selected_rows:
self.selected_rows.remove(row_id)
else:
self.selected_rows.add(row_id)
@rx.event
def toggle_select_all_on_page(self):
"""Select or deselect all rows on the current page."""
page_ids = self.page_item_ids
if self.all_rows_on_pa | if self.sort_column == column_name:
self.sort_ascending = not self.sort_ascending
else:
self.sort_column = column_name
self.sort_ascending = True |
ows == 0:
return "0"
start = (self.current_page - 1) * self.rows_per_page + 1
end = min(
self.current_page * self.rows_per_page,
self.total_rows,
)
return f"{start} - {end}"
@rx.var
def page_item_ids(self) -> Set[int]:
"""Get the set of IDs for items on the current page."""
return {item["id"] for item in self.paginated_data}
@rx.var
def all_rows_on_page_selected(self) -> bool:
"""Check if all rows on the current page are selected."""
if not self.paginated_data:
return False
return self.page_item_ids.issubset(self.selected_rows)
@rx.event
def set_search_owner(self, value: str):
"""Update the search owner filter."""
self.search_owner = value
self.current_page = 1
@rx.event
def toggle_sort(self, column_name: str):
"""Toggle sorting for a column."""
if self.sort_column == column_name:
|
else:
self.sort_column = column_name
self.sort_ascending = True
self.current_page = 1
@rx.event
def go_to_page(self, page_number: int):
"""Navigate to a specific page."""
if 1 <= page_number <= self.total_pages:
self.current_page = page_number
@rx.event
def next_page(self):
"""Go to the next page."""
if self.current_page < self.total_pages:
self.current_page += 1
@rx.event
def previous_page(self):
"""Go to the previous page."""
if self.current_page > 1:
self.current_page -= 1
@rx.event
def toggle_row_selection(self, row_id: int):
"""Toggle selection state for a single row using its ID."""
if row_id in self.selected_rows:
self.selected_rows.remove(row_id)
else:
self.selected_rows.add(row_id)
@rx.event
def toggle_select_all_on_page(self):
"""Select or deselect all r | self.sort_ascending = not self.sort_ascending |
* self.rows_per_page + 1
end = min(
self.current_page * self.rows_per_page,
self.total_rows,
)
return f"{start} - {end}"
@rx.var
def page_item_ids(self) -> Set[int]:
"""Get the set of IDs for items on the current page."""
return {item["id"] for item in self.paginated_data}
@rx.var
def all_rows_on_page_selected(self) -> bool:
"""Check if all rows on the current page are selected."""
if not self.paginated_data:
return False
return self.page_item_ids.issubset(self.selected_rows)
@rx.event
def set_search_owner(self, value: str):
"""Update the search owner filter."""
self.search_owner = value
self.current_page = 1
@rx.event
def toggle_sort(self, column_name: str):
"""Toggle sorting for a column."""
if self.sort_column == column_name:
self.sort_ascending = not self.sort_ascending
else:
|
self.sort_ascending = True
self.current_page = 1
@rx.event
def go_to_page(self, page_number: int):
"""Navigate to a specific page."""
if 1 <= page_number <= self.total_pages:
self.current_page = page_number
@rx.event
def next_page(self):
"""Go to the next page."""
if self.current_page < self.total_pages:
self.current_page += 1
@rx.event
def previous_page(self):
"""Go to the previous page."""
if self.current_page > 1:
self.current_page -= 1
@rx.event
def toggle_row_selection(self, row_id: int):
"""Toggle selection state for a single row using its ID."""
if row_id in self.selected_rows:
self.selected_rows.remove(row_id)
else:
self.selected_rows.add(row_id)
@rx.event
def toggle_select_all_on_page(self):
"""Select or deselect all rows on the current page."""
page_ids = self.page_ | self.sort_column = column_name |
(
self.current_page * self.rows_per_page,
self.total_rows,
)
return f"{start} - {end}"
@rx.var
def page_item_ids(self) -> Set[int]:
"""Get the set of IDs for items on the current page."""
return {item["id"] for item in self.paginated_data}
@rx.var
def all_rows_on_page_selected(self) -> bool:
"""Check if all rows on the current page are selected."""
if not self.paginated_data:
return False
return self.page_item_ids.issubset(self.selected_rows)
@rx.event
def set_search_owner(self, value: str):
"""Update the search owner filter."""
self.search_owner = value
self.current_page = 1
@rx.event
def toggle_sort(self, column_name: str):
"""Toggle sorting for a column."""
if self.sort_column == column_name:
self.sort_ascending = not self.sort_ascending
else:
self.sort_column = column_name
|
self.current_page = 1
@rx.event
def go_to_page(self, page_number: int):
"""Navigate to a specific page."""
if 1 <= page_number <= self.total_pages:
self.current_page = page_number
@rx.event
def next_page(self):
"""Go to the next page."""
if self.current_page < self.total_pages:
self.current_page += 1
@rx.event
def previous_page(self):
"""Go to the previous page."""
if self.current_page > 1:
self.current_page -= 1
@rx.event
def toggle_row_selection(self, row_id: int):
"""Toggle selection state for a single row using its ID."""
if row_id in self.selected_rows:
self.selected_rows.remove(row_id)
else:
self.selected_rows.add(row_id)
@rx.event
def toggle_select_all_on_page(self):
"""Select or deselect all rows on the current page."""
page_ids = self.page_item_ids
if self.all_rows_on_pa | self.sort_ascending = True |
elf.rows_per_page,
self.total_rows,
)
return f"{start} - {end}"
@rx.var
def page_item_ids(self) -> Set[int]:
"""Get the set of IDs for items on the current page."""
return {item["id"] for item in self.paginated_data}
@rx.var
def all_rows_on_page_selected(self) -> bool:
"""Check if all rows on the current page are selected."""
if not self.paginated_data:
return False
return self.page_item_ids.issubset(self.selected_rows)
@rx.event
def set_search_owner(self, value: str):
"""Update the search owner filter."""
self.search_owner = value
self.current_page = 1
@rx.event
def toggle_sort(self, column_name: str):
"""Toggle sorting for a column."""
if self.sort_column == column_name:
self.sort_ascending = not self.sort_ascending
else:
self.sort_column = column_name
self.sort_ascending = True
|
@rx.event
def go_to_page(self, page_number: int):
"""Navigate to a specific page."""
if 1 <= page_number <= self.total_pages:
self.current_page = page_number
@rx.event
def next_page(self):
"""Go to the next page."""
if self.current_page < self.total_pages:
self.current_page += 1
@rx.event
def previous_page(self):
"""Go to the previous page."""
if self.current_page > 1:
self.current_page -= 1
@rx.event
def toggle_row_selection(self, row_id: int):
"""Toggle selection state for a single row using its ID."""
if row_id in self.selected_rows:
self.selected_rows.remove(row_id)
else:
self.selected_rows.add(row_id)
@rx.event
def toggle_select_all_on_page(self):
"""Select or deselect all rows on the current page."""
page_ids = self.page_item_ids
if self.all_rows_on_page_selected:
self. | self.current_page = 1 |
_rows,
)
return f"{start} - {end}"
@rx.var
def page_item_ids(self) -> Set[int]:
"""Get the set of IDs for items on the current page."""
return {item["id"] for item in self.paginated_data}
@rx.var
def all_rows_on_page_selected(self) -> bool:
"""Check if all rows on the current page are selected."""
if not self.paginated_data:
return False
return self.page_item_ids.issubset(self.selected_rows)
@rx.event
def set_search_owner(self, value: str):
"""Update the search owner filter."""
self.search_owner = value
self.current_page = 1
@rx.event
def toggle_sort(self, column_name: str):
"""Toggle sorting for a column."""
if self.sort_column == column_name:
self.sort_ascending = not self.sort_ascending
else:
self.sort_column = column_name
self.sort_ascending = True
self.current_page = 1
@rx.event
|
@rx.event
def next_page(self):
"""Go to the next page."""
if self.current_page < self.total_pages:
self.current_page += 1
@rx.event
def previous_page(self):
"""Go to the previous page."""
if self.current_page > 1:
self.current_page -= 1
@rx.event
def toggle_row_selection(self, row_id: int):
"""Toggle selection state for a single row using its ID."""
if row_id in self.selected_rows:
self.selected_rows.remove(row_id)
else:
self.selected_rows.add(row_id)
@rx.event
def toggle_select_all_on_page(self):
"""Select or deselect all rows on the current page."""
page_ids = self.page_item_ids
if self.all_rows_on_page_selected:
self.selected_rows -= page_ids
else:
self.selected_rows.update(page_ids)
@rx.event
def toggle_status_filter(self):
"""Toggle the visibility of the status filter dr | def go_to_page(self, page_number: int):
"""Navigate to a specific page."""
if 1 <= page_number <= self.total_pages:
self.current_page = page_number |
-> Set[int]:
"""Get the set of IDs for items on the current page."""
return {item["id"] for item in self.paginated_data}
@rx.var
def all_rows_on_page_selected(self) -> bool:
"""Check if all rows on the current page are selected."""
if not self.paginated_data:
return False
return self.page_item_ids.issubset(self.selected_rows)
@rx.event
def set_search_owner(self, value: str):
"""Update the search owner filter."""
self.search_owner = value
self.current_page = 1
@rx.event
def toggle_sort(self, column_name: str):
"""Toggle sorting for a column."""
if self.sort_column == column_name:
self.sort_ascending = not self.sort_ascending
else:
self.sort_column = column_name
self.sort_ascending = True
self.current_page = 1
@rx.event
def go_to_page(self, page_number: int):
"""Navigate to a specific page."""
|
@rx.event
def next_page(self):
"""Go to the next page."""
if self.current_page < self.total_pages:
self.current_page += 1
@rx.event
def previous_page(self):
"""Go to the previous page."""
if self.current_page > 1:
self.current_page -= 1
@rx.event
def toggle_row_selection(self, row_id: int):
"""Toggle selection state for a single row using its ID."""
if row_id in self.selected_rows:
self.selected_rows.remove(row_id)
else:
self.selected_rows.add(row_id)
@rx.event
def toggle_select_all_on_page(self):
"""Select or deselect all rows on the current page."""
page_ids = self.page_item_ids
if self.all_rows_on_page_selected:
self.selected_rows -= page_ids
else:
self.selected_rows.update(page_ids)
@rx.event
def toggle_status_filter(self):
"""Toggle the visibility of the status filter dr | if 1 <= page_number <= self.total_pages:
self.current_page = page_number |
on the current page."""
return {item["id"] for item in self.paginated_data}
@rx.var
def all_rows_on_page_selected(self) -> bool:
"""Check if all rows on the current page are selected."""
if not self.paginated_data:
return False
return self.page_item_ids.issubset(self.selected_rows)
@rx.event
def set_search_owner(self, value: str):
"""Update the search owner filter."""
self.search_owner = value
self.current_page = 1
@rx.event
def toggle_sort(self, column_name: str):
"""Toggle sorting for a column."""
if self.sort_column == column_name:
self.sort_ascending = not self.sort_ascending
else:
self.sort_column = column_name
self.sort_ascending = True
self.current_page = 1
@rx.event
def go_to_page(self, page_number: int):
"""Navigate to a specific page."""
if 1 <= page_number <= self.total_pages:
|
@rx.event
def next_page(self):
"""Go to the next page."""
if self.current_page < self.total_pages:
self.current_page += 1
@rx.event
def previous_page(self):
"""Go to the previous page."""
if self.current_page > 1:
self.current_page -= 1
@rx.event
def toggle_row_selection(self, row_id: int):
"""Toggle selection state for a single row using its ID."""
if row_id in self.selected_rows:
self.selected_rows.remove(row_id)
else:
self.selected_rows.add(row_id)
@rx.event
def toggle_select_all_on_page(self):
"""Select or deselect all rows on the current page."""
page_ids = self.page_item_ids
if self.all_rows_on_page_selected:
self.selected_rows -= page_ids
else:
self.selected_rows.update(page_ids)
@rx.event
def toggle_status_filter(self):
"""Toggle the visibility of the status filter dr | self.current_page = page_number |
for item in self.paginated_data}
@rx.var
def all_rows_on_page_selected(self) -> bool:
"""Check if all rows on the current page are selected."""
if not self.paginated_data:
return False
return self.page_item_ids.issubset(self.selected_rows)
@rx.event
def set_search_owner(self, value: str):
"""Update the search owner filter."""
self.search_owner = value
self.current_page = 1
@rx.event
def toggle_sort(self, column_name: str):
"""Toggle sorting for a column."""
if self.sort_column == column_name:
self.sort_ascending = not self.sort_ascending
else:
self.sort_column = column_name
self.sort_ascending = True
self.current_page = 1
@rx.event
def go_to_page(self, page_number: int):
"""Navigate to a specific page."""
if 1 <= page_number <= self.total_pages:
self.current_page = page_number
@rx.event
|
@rx.event
def previous_page(self):
"""Go to the previous page."""
if self.current_page > 1:
self.current_page -= 1
@rx.event
def toggle_row_selection(self, row_id: int):
"""Toggle selection state for a single row using its ID."""
if row_id in self.selected_rows:
self.selected_rows.remove(row_id)
else:
self.selected_rows.add(row_id)
@rx.event
def toggle_select_all_on_page(self):
"""Select or deselect all rows on the current page."""
page_ids = self.page_item_ids
if self.all_rows_on_page_selected:
self.selected_rows -= page_ids
else:
self.selected_rows.update(page_ids)
@rx.event
def toggle_status_filter(self):
"""Toggle the visibility of the status filter dropdown."""
self.show_status_filter = not self.show_status_filter
if self.show_status_filter:
self.temp_selected_statuses = self.sel | def next_page(self):
"""Go to the next page."""
if self.current_page < self.total_pages:
self.current_page += 1 |
on_page_selected(self) -> bool:
"""Check if all rows on the current page are selected."""
if not self.paginated_data:
return False
return self.page_item_ids.issubset(self.selected_rows)
@rx.event
def set_search_owner(self, value: str):
"""Update the search owner filter."""
self.search_owner = value
self.current_page = 1
@rx.event
def toggle_sort(self, column_name: str):
"""Toggle sorting for a column."""
if self.sort_column == column_name:
self.sort_ascending = not self.sort_ascending
else:
self.sort_column = column_name
self.sort_ascending = True
self.current_page = 1
@rx.event
def go_to_page(self, page_number: int):
"""Navigate to a specific page."""
if 1 <= page_number <= self.total_pages:
self.current_page = page_number
@rx.event
def next_page(self):
"""Go to the next page."""
|
@rx.event
def previous_page(self):
"""Go to the previous page."""
if self.current_page > 1:
self.current_page -= 1
@rx.event
def toggle_row_selection(self, row_id: int):
"""Toggle selection state for a single row using its ID."""
if row_id in self.selected_rows:
self.selected_rows.remove(row_id)
else:
self.selected_rows.add(row_id)
@rx.event
def toggle_select_all_on_page(self):
"""Select or deselect all rows on the current page."""
page_ids = self.page_item_ids
if self.all_rows_on_page_selected:
self.selected_rows -= page_ids
else:
self.selected_rows.update(page_ids)
@rx.event
def toggle_status_filter(self):
"""Toggle the visibility of the status filter dropdown."""
self.show_status_filter = not self.show_status_filter
if self.show_status_filter:
self.temp_selected_statuses = self.sel | if self.current_page < self.total_pages:
self.current_page += 1 |
""
if not self.paginated_data:
return False
return self.page_item_ids.issubset(self.selected_rows)
@rx.event
def set_search_owner(self, value: str):
"""Update the search owner filter."""
self.search_owner = value
self.current_page = 1
@rx.event
def toggle_sort(self, column_name: str):
"""Toggle sorting for a column."""
if self.sort_column == column_name:
self.sort_ascending = not self.sort_ascending
else:
self.sort_column = column_name
self.sort_ascending = True
self.current_page = 1
@rx.event
def go_to_page(self, page_number: int):
"""Navigate to a specific page."""
if 1 <= page_number <= self.total_pages:
self.current_page = page_number
@rx.event
def next_page(self):
"""Go to the next page."""
if self.current_page < self.total_pages:
self.current_page += 1
@rx.event
|
@rx.event
def toggle_row_selection(self, row_id: int):
"""Toggle selection state for a single row using its ID."""
if row_id in self.selected_rows:
self.selected_rows.remove(row_id)
else:
self.selected_rows.add(row_id)
@rx.event
def toggle_select_all_on_page(self):
"""Select or deselect all rows on the current page."""
page_ids = self.page_item_ids
if self.all_rows_on_page_selected:
self.selected_rows -= page_ids
else:
self.selected_rows.update(page_ids)
@rx.event
def toggle_status_filter(self):
"""Toggle the visibility of the status filter dropdown."""
self.show_status_filter = not self.show_status_filter
if self.show_status_filter:
self.temp_selected_statuses = self.selected_statuses.copy()
self.show_country_filter = False
self.show_costs_filter = False
@rx.event
def toggle_country_filt | def previous_page(self):
"""Go to the previous page."""
if self.current_page > 1:
self.current_page -= 1 |
return self.page_item_ids.issubset(self.selected_rows)
@rx.event
def set_search_owner(self, value: str):
"""Update the search owner filter."""
self.search_owner = value
self.current_page = 1
@rx.event
def toggle_sort(self, column_name: str):
"""Toggle sorting for a column."""
if self.sort_column == column_name:
self.sort_ascending = not self.sort_ascending
else:
self.sort_column = column_name
self.sort_ascending = True
self.current_page = 1
@rx.event
def go_to_page(self, page_number: int):
"""Navigate to a specific page."""
if 1 <= page_number <= self.total_pages:
self.current_page = page_number
@rx.event
def next_page(self):
"""Go to the next page."""
if self.current_page < self.total_pages:
self.current_page += 1
@rx.event
def previous_page(self):
"""Go to the previous page."""
|
@rx.event
def toggle_row_selection(self, row_id: int):
"""Toggle selection state for a single row using its ID."""
if row_id in self.selected_rows:
self.selected_rows.remove(row_id)
else:
self.selected_rows.add(row_id)
@rx.event
def toggle_select_all_on_page(self):
"""Select or deselect all rows on the current page."""
page_ids = self.page_item_ids
if self.all_rows_on_page_selected:
self.selected_rows -= page_ids
else:
self.selected_rows.update(page_ids)
@rx.event
def toggle_status_filter(self):
"""Toggle the visibility of the status filter dropdown."""
self.show_status_filter = not self.show_status_filter
if self.show_status_filter:
self.temp_selected_statuses = self.selected_statuses.copy()
self.show_country_filter = False
self.show_costs_filter = False
@rx.event
def toggle_country_filt | if self.current_page > 1:
self.current_page -= 1 |
t_search_owner(self, value: str):
"""Update the search owner filter."""
self.search_owner = value
self.current_page = 1
@rx.event
def toggle_sort(self, column_name: str):
"""Toggle sorting for a column."""
if self.sort_column == column_name:
self.sort_ascending = not self.sort_ascending
else:
self.sort_column = column_name
self.sort_ascending = True
self.current_page = 1
@rx.event
def go_to_page(self, page_number: int):
"""Navigate to a specific page."""
if 1 <= page_number <= self.total_pages:
self.current_page = page_number
@rx.event
def next_page(self):
"""Go to the next page."""
if self.current_page < self.total_pages:
self.current_page += 1
@rx.event
def previous_page(self):
"""Go to the previous page."""
if self.current_page > 1:
self.current_page -= 1
@rx.event
|
@rx.event
def toggle_select_all_on_page(self):
"""Select or deselect all rows on the current page."""
page_ids = self.page_item_ids
if self.all_rows_on_page_selected:
self.selected_rows -= page_ids
else:
self.selected_rows.update(page_ids)
@rx.event
def toggle_status_filter(self):
"""Toggle the visibility of the status filter dropdown."""
self.show_status_filter = not self.show_status_filter
if self.show_status_filter:
self.temp_selected_statuses = self.selected_statuses.copy()
self.show_country_filter = False
self.show_costs_filter = False
@rx.event
def toggle_country_filter(self):
"""Toggle the visibility of the country filter dropdown."""
self.show_country_filter = not self.show_country_filter
if self.show_country_filter:
self.temp_selected_countries = self.selected_countries.copy()
self.show_s | def toggle_row_selection(self, row_id: int):
"""Toggle selection state for a single row using its ID."""
if row_id in self.selected_rows:
self.selected_rows.remove(row_id)
else:
self.selected_rows.add(row_id) |
self.current_page = 1
@rx.event
def toggle_sort(self, column_name: str):
"""Toggle sorting for a column."""
if self.sort_column == column_name:
self.sort_ascending = not self.sort_ascending
else:
self.sort_column = column_name
self.sort_ascending = True
self.current_page = 1
@rx.event
def go_to_page(self, page_number: int):
"""Navigate to a specific page."""
if 1 <= page_number <= self.total_pages:
self.current_page = page_number
@rx.event
def next_page(self):
"""Go to the next page."""
if self.current_page < self.total_pages:
self.current_page += 1
@rx.event
def previous_page(self):
"""Go to the previous page."""
if self.current_page > 1:
self.current_page -= 1
@rx.event
def toggle_row_selection(self, row_id: int):
"""Toggle selection state for a single row using its ID."""
|
@rx.event
def toggle_select_all_on_page(self):
"""Select or deselect all rows on the current page."""
page_ids = self.page_item_ids
if self.all_rows_on_page_selected:
self.selected_rows -= page_ids
else:
self.selected_rows.update(page_ids)
@rx.event
def toggle_status_filter(self):
"""Toggle the visibility of the status filter dropdown."""
self.show_status_filter = not self.show_status_filter
if self.show_status_filter:
self.temp_selected_statuses = self.selected_statuses.copy()
self.show_country_filter = False
self.show_costs_filter = False
@rx.event
def toggle_country_filter(self):
"""Toggle the visibility of the country filter dropdown."""
self.show_country_filter = not self.show_country_filter
if self.show_country_filter:
self.temp_selected_countries = self.selected_countries.copy()
self.show_s | if row_id in self.selected_rows:
self.selected_rows.remove(row_id)
else:
self.selected_rows.add(row_id) |
= column_name:
self.sort_ascending = not self.sort_ascending
else:
self.sort_column = column_name
self.sort_ascending = True
self.current_page = 1
@rx.event
def go_to_page(self, page_number: int):
"""Navigate to a specific page."""
if 1 <= page_number <= self.total_pages:
self.current_page = page_number
@rx.event
def next_page(self):
"""Go to the next page."""
if self.current_page < self.total_pages:
self.current_page += 1
@rx.event
def previous_page(self):
"""Go to the previous page."""
if self.current_page > 1:
self.current_page -= 1
@rx.event
def toggle_row_selection(self, row_id: int):
"""Toggle selection state for a single row using its ID."""
if row_id in self.selected_rows:
self.selected_rows.remove(row_id)
else:
self.selected_rows.add(row_id)
@rx.event
|
@rx.event
def toggle_status_filter(self):
"""Toggle the visibility of the status filter dropdown."""
self.show_status_filter = not self.show_status_filter
if self.show_status_filter:
self.temp_selected_statuses = self.selected_statuses.copy()
self.show_country_filter = False
self.show_costs_filter = False
@rx.event
def toggle_country_filter(self):
"""Toggle the visibility of the country filter dropdown."""
self.show_country_filter = not self.show_country_filter
if self.show_country_filter:
self.temp_selected_countries = self.selected_countries.copy()
self.show_status_filter = False
self.show_costs_filter = False
@rx.event
def toggle_costs_filter(self):
is_opening = not self.show_costs_filter
self.show_costs_filter = is_opening
self.show_status_filter = False
self.show_country_filter = False
if is_open | def toggle_select_all_on_page(self):
"""Select or deselect all rows on the current page."""
page_ids = self.page_item_ids
if self.all_rows_on_page_selected:
self.selected_rows -= page_ids
else:
self.selected_rows.update(page_ids) |
_column = column_name
self.sort_ascending = True
self.current_page = 1
@rx.event
def go_to_page(self, page_number: int):
"""Navigate to a specific page."""
if 1 <= page_number <= self.total_pages:
self.current_page = page_number
@rx.event
def next_page(self):
"""Go to the next page."""
if self.current_page < self.total_pages:
self.current_page += 1
@rx.event
def previous_page(self):
"""Go to the previous page."""
if self.current_page > 1:
self.current_page -= 1
@rx.event
def toggle_row_selection(self, row_id: int):
"""Toggle selection state for a single row using its ID."""
if row_id in self.selected_rows:
self.selected_rows.remove(row_id)
else:
self.selected_rows.add(row_id)
@rx.event
def toggle_select_all_on_page(self):
"""Select or deselect all rows on the current page."""
|
if self.all_rows_on_page_selected:
self.selected_rows -= page_ids
else:
self.selected_rows.update(page_ids)
@rx.event
def toggle_status_filter(self):
"""Toggle the visibility of the status filter dropdown."""
self.show_status_filter = not self.show_status_filter
if self.show_status_filter:
self.temp_selected_statuses = self.selected_statuses.copy()
self.show_country_filter = False
self.show_costs_filter = False
@rx.event
def toggle_country_filter(self):
"""Toggle the visibility of the country filter dropdown."""
self.show_country_filter = not self.show_country_filter
if self.show_country_filter:
self.temp_selected_countries = self.selected_countries.copy()
self.show_status_filter = False
self.show_costs_filter = False
@rx.event
def toggle_costs_filter(self):
is_opening = not self.show_costs_fi | page_ids = self.page_item_ids |
.sort_ascending = True
self.current_page = 1
@rx.event
def go_to_page(self, page_number: int):
"""Navigate to a specific page."""
if 1 <= page_number <= self.total_pages:
self.current_page = page_number
@rx.event
def next_page(self):
"""Go to the next page."""
if self.current_page < self.total_pages:
self.current_page += 1
@rx.event
def previous_page(self):
"""Go to the previous page."""
if self.current_page > 1:
self.current_page -= 1
@rx.event
def toggle_row_selection(self, row_id: int):
"""Toggle selection state for a single row using its ID."""
if row_id in self.selected_rows:
self.selected_rows.remove(row_id)
else:
self.selected_rows.add(row_id)
@rx.event
def toggle_select_all_on_page(self):
"""Select or deselect all rows on the current page."""
page_ids = self.page_item_ids
|
@rx.event
def toggle_status_filter(self):
"""Toggle the visibility of the status filter dropdown."""
self.show_status_filter = not self.show_status_filter
if self.show_status_filter:
self.temp_selected_statuses = self.selected_statuses.copy()
self.show_country_filter = False
self.show_costs_filter = False
@rx.event
def toggle_country_filter(self):
"""Toggle the visibility of the country filter dropdown."""
self.show_country_filter = not self.show_country_filter
if self.show_country_filter:
self.temp_selected_countries = self.selected_countries.copy()
self.show_status_filter = False
self.show_costs_filter = False
@rx.event
def toggle_costs_filter(self):
is_opening = not self.show_costs_filter
self.show_costs_filter = is_opening
self.show_status_filter = False
self.show_country_filter = False
if is_open | if self.all_rows_on_page_selected:
self.selected_rows -= page_ids
else:
self.selected_rows.update(page_ids) |
if 1 <= page_number <= self.total_pages:
self.current_page = page_number
@rx.event
def next_page(self):
"""Go to the next page."""
if self.current_page < self.total_pages:
self.current_page += 1
@rx.event
def previous_page(self):
"""Go to the previous page."""
if self.current_page > 1:
self.current_page -= 1
@rx.event
def toggle_row_selection(self, row_id: int):
"""Toggle selection state for a single row using its ID."""
if row_id in self.selected_rows:
self.selected_rows.remove(row_id)
else:
self.selected_rows.add(row_id)
@rx.event
def toggle_select_all_on_page(self):
"""Select or deselect all rows on the current page."""
page_ids = self.page_item_ids
if self.all_rows_on_page_selected:
self.selected_rows -= page_ids
else:
self.selected_rows.update(page_ids)
@rx.event
|
@rx.event
def toggle_country_filter(self):
"""Toggle the visibility of the country filter dropdown."""
self.show_country_filter = not self.show_country_filter
if self.show_country_filter:
self.temp_selected_countries = self.selected_countries.copy()
self.show_status_filter = False
self.show_costs_filter = False
@rx.event
def toggle_costs_filter(self):
is_opening = not self.show_costs_filter
self.show_costs_filter = is_opening
self.show_status_filter = False
self.show_country_filter = False
if is_opening:
self.temp_min_cost_str = (
str(self.min_cost) if self.min_cost is not None else ""
)
self.temp_max_cost_str = (
str(self.max_cost) if self.max_cost is not None else ""
)
@rx.event
def toggle_temp_status(self, status: str):
"""Toggle a status in the temporary set."""
| def toggle_status_filter(self):
"""Toggle the visibility of the status filter dropdown."""
self.show_status_filter = not self.show_status_filter
if self.show_status_filter:
self.temp_selected_statuses = self.selected_statuses.copy()
self.show_country_filter = False
self.show_costs_filter = False |
def next_page(self):
"""Go to the next page."""
if self.current_page < self.total_pages:
self.current_page += 1
@rx.event
def previous_page(self):
"""Go to the previous page."""
if self.current_page > 1:
self.current_page -= 1
@rx.event
def toggle_row_selection(self, row_id: int):
"""Toggle selection state for a single row using its ID."""
if row_id in self.selected_rows:
self.selected_rows.remove(row_id)
else:
self.selected_rows.add(row_id)
@rx.event
def toggle_select_all_on_page(self):
"""Select or deselect all rows on the current page."""
page_ids = self.page_item_ids
if self.all_rows_on_page_selected:
self.selected_rows -= page_ids
else:
self.selected_rows.update(page_ids)
@rx.event
def toggle_status_filter(self):
"""Toggle the visibility of the status filter dropdown."""
|
if self.show_status_filter:
self.temp_selected_statuses = self.selected_statuses.copy()
self.show_country_filter = False
self.show_costs_filter = False
@rx.event
def toggle_country_filter(self):
"""Toggle the visibility of the country filter dropdown."""
self.show_country_filter = not self.show_country_filter
if self.show_country_filter:
self.temp_selected_countries = self.selected_countries.copy()
self.show_status_filter = False
self.show_costs_filter = False
@rx.event
def toggle_costs_filter(self):
is_opening = not self.show_costs_filter
self.show_costs_filter = is_opening
self.show_status_filter = False
self.show_country_filter = False
if is_opening:
self.temp_min_cost_str = (
str(self.min_cost) if self.min_cost is not None else ""
)
self.temp_max_cost_str = (
| self.show_status_filter = not self.show_status_filter |
if self.current_page < self.total_pages:
self.current_page += 1
@rx.event
def previous_page(self):
"""Go to the previous page."""
if self.current_page > 1:
self.current_page -= 1
@rx.event
def toggle_row_selection(self, row_id: int):
"""Toggle selection state for a single row using its ID."""
if row_id in self.selected_rows:
self.selected_rows.remove(row_id)
else:
self.selected_rows.add(row_id)
@rx.event
def toggle_select_all_on_page(self):
"""Select or deselect all rows on the current page."""
page_ids = self.page_item_ids
if self.all_rows_on_page_selected:
self.selected_rows -= page_ids
else:
self.selected_rows.update(page_ids)
@rx.event
def toggle_status_filter(self):
"""Toggle the visibility of the status filter dropdown."""
self.show_status_filter = not self.show_status_filter
|
@rx.event
def toggle_country_filter(self):
"""Toggle the visibility of the country filter dropdown."""
self.show_country_filter = not self.show_country_filter
if self.show_country_filter:
self.temp_selected_countries = self.selected_countries.copy()
self.show_status_filter = False
self.show_costs_filter = False
@rx.event
def toggle_costs_filter(self):
is_opening = not self.show_costs_filter
self.show_costs_filter = is_opening
self.show_status_filter = False
self.show_country_filter = False
if is_opening:
self.temp_min_cost_str = (
str(self.min_cost) if self.min_cost is not None else ""
)
self.temp_max_cost_str = (
str(self.max_cost) if self.max_cost is not None else ""
)
@rx.event
def toggle_temp_status(self, status: str):
"""Toggle a status in the temporary set."""
| if self.show_status_filter:
self.temp_selected_statuses = self.selected_statuses.copy()
self.show_country_filter = False
self.show_costs_filter = False |
es:
self.current_page += 1
@rx.event
def previous_page(self):
"""Go to the previous page."""
if self.current_page > 1:
self.current_page -= 1
@rx.event
def toggle_row_selection(self, row_id: int):
"""Toggle selection state for a single row using its ID."""
if row_id in self.selected_rows:
self.selected_rows.remove(row_id)
else:
self.selected_rows.add(row_id)
@rx.event
def toggle_select_all_on_page(self):
"""Select or deselect all rows on the current page."""
page_ids = self.page_item_ids
if self.all_rows_on_page_selected:
self.selected_rows -= page_ids
else:
self.selected_rows.update(page_ids)
@rx.event
def toggle_status_filter(self):
"""Toggle the visibility of the status filter dropdown."""
self.show_status_filter = not self.show_status_filter
if self.show_status_filter:
|
self.show_country_filter = False
self.show_costs_filter = False
@rx.event
def toggle_country_filter(self):
"""Toggle the visibility of the country filter dropdown."""
self.show_country_filter = not self.show_country_filter
if self.show_country_filter:
self.temp_selected_countries = self.selected_countries.copy()
self.show_status_filter = False
self.show_costs_filter = False
@rx.event
def toggle_costs_filter(self):
is_opening = not self.show_costs_filter
self.show_costs_filter = is_opening
self.show_status_filter = False
self.show_country_filter = False
if is_opening:
self.temp_min_cost_str = (
str(self.min_cost) if self.min_cost is not None else ""
)
self.temp_max_cost_str = (
str(self.max_cost) if self.max_cost is not None else ""
)
@rx.event
def toggle_tem | self.temp_selected_statuses = self.selected_statuses.copy() |
age(self):
"""Go to the previous page."""
if self.current_page > 1:
self.current_page -= 1
@rx.event
def toggle_row_selection(self, row_id: int):
"""Toggle selection state for a single row using its ID."""
if row_id in self.selected_rows:
self.selected_rows.remove(row_id)
else:
self.selected_rows.add(row_id)
@rx.event
def toggle_select_all_on_page(self):
"""Select or deselect all rows on the current page."""
page_ids = self.page_item_ids
if self.all_rows_on_page_selected:
self.selected_rows -= page_ids
else:
self.selected_rows.update(page_ids)
@rx.event
def toggle_status_filter(self):
"""Toggle the visibility of the status filter dropdown."""
self.show_status_filter = not self.show_status_filter
if self.show_status_filter:
self.temp_selected_statuses = self.selected_statuses.copy()
|
self.show_costs_filter = False
@rx.event
def toggle_country_filter(self):
"""Toggle the visibility of the country filter dropdown."""
self.show_country_filter = not self.show_country_filter
if self.show_country_filter:
self.temp_selected_countries = self.selected_countries.copy()
self.show_status_filter = False
self.show_costs_filter = False
@rx.event
def toggle_costs_filter(self):
is_opening = not self.show_costs_filter
self.show_costs_filter = is_opening
self.show_status_filter = False
self.show_country_filter = False
if is_opening:
self.temp_min_cost_str = (
str(self.min_cost) if self.min_cost is not None else ""
)
self.temp_max_cost_str = (
str(self.max_cost) if self.max_cost is not None else ""
)
@rx.event
def toggle_temp_status(self, status: str):
"""Toggl | self.show_country_filter = False |
."""
if self.current_page > 1:
self.current_page -= 1
@rx.event
def toggle_row_selection(self, row_id: int):
"""Toggle selection state for a single row using its ID."""
if row_id in self.selected_rows:
self.selected_rows.remove(row_id)
else:
self.selected_rows.add(row_id)
@rx.event
def toggle_select_all_on_page(self):
"""Select or deselect all rows on the current page."""
page_ids = self.page_item_ids
if self.all_rows_on_page_selected:
self.selected_rows -= page_ids
else:
self.selected_rows.update(page_ids)
@rx.event
def toggle_status_filter(self):
"""Toggle the visibility of the status filter dropdown."""
self.show_status_filter = not self.show_status_filter
if self.show_status_filter:
self.temp_selected_statuses = self.selected_statuses.copy()
self.show_country_filter = False
|
@rx.event
def toggle_country_filter(self):
"""Toggle the visibility of the country filter dropdown."""
self.show_country_filter = not self.show_country_filter
if self.show_country_filter:
self.temp_selected_countries = self.selected_countries.copy()
self.show_status_filter = False
self.show_costs_filter = False
@rx.event
def toggle_costs_filter(self):
is_opening = not self.show_costs_filter
self.show_costs_filter = is_opening
self.show_status_filter = False
self.show_country_filter = False
if is_opening:
self.temp_min_cost_str = (
str(self.min_cost) if self.min_cost is not None else ""
)
self.temp_max_cost_str = (
str(self.max_cost) if self.max_cost is not None else ""
)
@rx.event
def toggle_temp_status(self, status: str):
"""Toggle a status in the temporary set."""
| self.show_costs_filter = False |
self.current_page -= 1
@rx.event
def toggle_row_selection(self, row_id: int):
"""Toggle selection state for a single row using its ID."""
if row_id in self.selected_rows:
self.selected_rows.remove(row_id)
else:
self.selected_rows.add(row_id)
@rx.event
def toggle_select_all_on_page(self):
"""Select or deselect all rows on the current page."""
page_ids = self.page_item_ids
if self.all_rows_on_page_selected:
self.selected_rows -= page_ids
else:
self.selected_rows.update(page_ids)
@rx.event
def toggle_status_filter(self):
"""Toggle the visibility of the status filter dropdown."""
self.show_status_filter = not self.show_status_filter
if self.show_status_filter:
self.temp_selected_statuses = self.selected_statuses.copy()
self.show_country_filter = False
self.show_costs_filter = False
@rx.event
|
@rx.event
def toggle_costs_filter(self):
is_opening = not self.show_costs_filter
self.show_costs_filter = is_opening
self.show_status_filter = False
self.show_country_filter = False
if is_opening:
self.temp_min_cost_str = (
str(self.min_cost) if self.min_cost is not None else ""
)
self.temp_max_cost_str = (
str(self.max_cost) if self.max_cost is not None else ""
)
@rx.event
def toggle_temp_status(self, status: str):
"""Toggle a status in the temporary set."""
self.temp_selected_statuses.symmetric_difference_update({status})
@rx.event
def toggle_temp_country(self, country: str):
"""Toggle a country in the temporary set."""
self.temp_selected_countries.symmetric_difference_update({country})
@rx.event
def set_temp_min_cost(self, value: float):
self.temp_min_cost_str = str(value) if value is not | def toggle_country_filter(self):
"""Toggle the visibility of the country filter dropdown."""
self.show_country_filter = not self.show_country_filter
if self.show_country_filter:
self.temp_selected_countries = self.selected_countries.copy()
self.show_status_filter = False
self.show_costs_filter = False |
ection state for a single row using its ID."""
if row_id in self.selected_rows:
self.selected_rows.remove(row_id)
else:
self.selected_rows.add(row_id)
@rx.event
def toggle_select_all_on_page(self):
"""Select or deselect all rows on the current page."""
page_ids = self.page_item_ids
if self.all_rows_on_page_selected:
self.selected_rows -= page_ids
else:
self.selected_rows.update(page_ids)
@rx.event
def toggle_status_filter(self):
"""Toggle the visibility of the status filter dropdown."""
self.show_status_filter = not self.show_status_filter
if self.show_status_filter:
self.temp_selected_statuses = self.selected_statuses.copy()
self.show_country_filter = False
self.show_costs_filter = False
@rx.event
def toggle_country_filter(self):
"""Toggle the visibility of the country filter dropdown."""
|
if self.show_country_filter:
self.temp_selected_countries = self.selected_countries.copy()
self.show_status_filter = False
self.show_costs_filter = False
@rx.event
def toggle_costs_filter(self):
is_opening = not self.show_costs_filter
self.show_costs_filter = is_opening
self.show_status_filter = False
self.show_country_filter = False
if is_opening:
self.temp_min_cost_str = (
str(self.min_cost) if self.min_cost is not None else ""
)
self.temp_max_cost_str = (
str(self.max_cost) if self.max_cost is not None else ""
)
@rx.event
def toggle_temp_status(self, status: str):
"""Toggle a status in the temporary set."""
self.temp_selected_statuses.symmetric_difference_update({status})
@rx.event
def toggle_temp_country(self, country: str):
"""Toggle a country in the temporary set."""
| self.show_country_filter = not self.show_country_filter |
in self.selected_rows:
self.selected_rows.remove(row_id)
else:
self.selected_rows.add(row_id)
@rx.event
def toggle_select_all_on_page(self):
"""Select or deselect all rows on the current page."""
page_ids = self.page_item_ids
if self.all_rows_on_page_selected:
self.selected_rows -= page_ids
else:
self.selected_rows.update(page_ids)
@rx.event
def toggle_status_filter(self):
"""Toggle the visibility of the status filter dropdown."""
self.show_status_filter = not self.show_status_filter
if self.show_status_filter:
self.temp_selected_statuses = self.selected_statuses.copy()
self.show_country_filter = False
self.show_costs_filter = False
@rx.event
def toggle_country_filter(self):
"""Toggle the visibility of the country filter dropdown."""
self.show_country_filter = not self.show_country_filter
|
@rx.event
def toggle_costs_filter(self):
is_opening = not self.show_costs_filter
self.show_costs_filter = is_opening
self.show_status_filter = False
self.show_country_filter = False
if is_opening:
self.temp_min_cost_str = (
str(self.min_cost) if self.min_cost is not None else ""
)
self.temp_max_cost_str = (
str(self.max_cost) if self.max_cost is not None else ""
)
@rx.event
def toggle_temp_status(self, status: str):
"""Toggle a status in the temporary set."""
self.temp_selected_statuses.symmetric_difference_update({status})
@rx.event
def toggle_temp_country(self, country: str):
"""Toggle a country in the temporary set."""
self.temp_selected_countries.symmetric_difference_update({country})
@rx.event
def set_temp_min_cost(self, value: float):
self.temp_min_cost_str = str(value) if value is not | if self.show_country_filter:
self.temp_selected_countries = self.selected_countries.copy()
self.show_status_filter = False
self.show_costs_filter = False |
selected_rows.remove(row_id)
else:
self.selected_rows.add(row_id)
@rx.event
def toggle_select_all_on_page(self):
"""Select or deselect all rows on the current page."""
page_ids = self.page_item_ids
if self.all_rows_on_page_selected:
self.selected_rows -= page_ids
else:
self.selected_rows.update(page_ids)
@rx.event
def toggle_status_filter(self):
"""Toggle the visibility of the status filter dropdown."""
self.show_status_filter = not self.show_status_filter
if self.show_status_filter:
self.temp_selected_statuses = self.selected_statuses.copy()
self.show_country_filter = False
self.show_costs_filter = False
@rx.event
def toggle_country_filter(self):
"""Toggle the visibility of the country filter dropdown."""
self.show_country_filter = not self.show_country_filter
if self.show_country_filter:
|
self.show_status_filter = False
self.show_costs_filter = False
@rx.event
def toggle_costs_filter(self):
is_opening = not self.show_costs_filter
self.show_costs_filter = is_opening
self.show_status_filter = False
self.show_country_filter = False
if is_opening:
self.temp_min_cost_str = (
str(self.min_cost) if self.min_cost is not None else ""
)
self.temp_max_cost_str = (
str(self.max_cost) if self.max_cost is not None else ""
)
@rx.event
def toggle_temp_status(self, status: str):
"""Toggle a status in the temporary set."""
self.temp_selected_statuses.symmetric_difference_update({status})
@rx.event
def toggle_temp_country(self, country: str):
"""Toggle a country in the temporary set."""
self.temp_selected_countries.symmetric_difference_update({country})
@rx.event
def set_temp_min | self.temp_selected_countries = self.selected_countries.copy() |
add(row_id)
@rx.event
def toggle_select_all_on_page(self):
"""Select or deselect all rows on the current page."""
page_ids = self.page_item_ids
if self.all_rows_on_page_selected:
self.selected_rows -= page_ids
else:
self.selected_rows.update(page_ids)
@rx.event
def toggle_status_filter(self):
"""Toggle the visibility of the status filter dropdown."""
self.show_status_filter = not self.show_status_filter
if self.show_status_filter:
self.temp_selected_statuses = self.selected_statuses.copy()
self.show_country_filter = False
self.show_costs_filter = False
@rx.event
def toggle_country_filter(self):
"""Toggle the visibility of the country filter dropdown."""
self.show_country_filter = not self.show_country_filter
if self.show_country_filter:
self.temp_selected_countries = self.selected_countries.copy()
|
self.show_costs_filter = False
@rx.event
def toggle_costs_filter(self):
is_opening = not self.show_costs_filter
self.show_costs_filter = is_opening
self.show_status_filter = False
self.show_country_filter = False
if is_opening:
self.temp_min_cost_str = (
str(self.min_cost) if self.min_cost is not None else ""
)
self.temp_max_cost_str = (
str(self.max_cost) if self.max_cost is not None else ""
)
@rx.event
def toggle_temp_status(self, status: str):
"""Toggle a status in the temporary set."""
self.temp_selected_statuses.symmetric_difference_update({status})
@rx.event
def toggle_temp_country(self, country: str):
"""Toggle a country in the temporary set."""
self.temp_selected_countries.symmetric_difference_update({country})
@rx.event
def set_temp_min_cost(self, value: float):
self.temp | self.show_status_filter = False |
lect_all_on_page(self):
"""Select or deselect all rows on the current page."""
page_ids = self.page_item_ids
if self.all_rows_on_page_selected:
self.selected_rows -= page_ids
else:
self.selected_rows.update(page_ids)
@rx.event
def toggle_status_filter(self):
"""Toggle the visibility of the status filter dropdown."""
self.show_status_filter = not self.show_status_filter
if self.show_status_filter:
self.temp_selected_statuses = self.selected_statuses.copy()
self.show_country_filter = False
self.show_costs_filter = False
@rx.event
def toggle_country_filter(self):
"""Toggle the visibility of the country filter dropdown."""
self.show_country_filter = not self.show_country_filter
if self.show_country_filter:
self.temp_selected_countries = self.selected_countries.copy()
self.show_status_filter = False
|
@rx.event
def toggle_costs_filter(self):
is_opening = not self.show_costs_filter
self.show_costs_filter = is_opening
self.show_status_filter = False
self.show_country_filter = False
if is_opening:
self.temp_min_cost_str = (
str(self.min_cost) if self.min_cost is not None else ""
)
self.temp_max_cost_str = (
str(self.max_cost) if self.max_cost is not None else ""
)
@rx.event
def toggle_temp_status(self, status: str):
"""Toggle a status in the temporary set."""
self.temp_selected_statuses.symmetric_difference_update({status})
@rx.event
def toggle_temp_country(self, country: str):
"""Toggle a country in the temporary set."""
self.temp_selected_countries.symmetric_difference_update({country})
@rx.event
def set_temp_min_cost(self, value: float):
self.temp_min_cost_str = str(value) if value is not | self.show_costs_filter = False |
ect all rows on the current page."""
page_ids = self.page_item_ids
if self.all_rows_on_page_selected:
self.selected_rows -= page_ids
else:
self.selected_rows.update(page_ids)
@rx.event
def toggle_status_filter(self):
"""Toggle the visibility of the status filter dropdown."""
self.show_status_filter = not self.show_status_filter
if self.show_status_filter:
self.temp_selected_statuses = self.selected_statuses.copy()
self.show_country_filter = False
self.show_costs_filter = False
@rx.event
def toggle_country_filter(self):
"""Toggle the visibility of the country filter dropdown."""
self.show_country_filter = not self.show_country_filter
if self.show_country_filter:
self.temp_selected_countries = self.selected_countries.copy()
self.show_status_filter = False
self.show_costs_filter = False
@rx.event
|
@rx.event
def toggle_temp_status(self, status: str):
"""Toggle a status in the temporary set."""
self.temp_selected_statuses.symmetric_difference_update({status})
@rx.event
def toggle_temp_country(self, country: str):
"""Toggle a country in the temporary set."""
self.temp_selected_countries.symmetric_difference_update({country})
@rx.event
def set_temp_min_cost(self, value: float):
self.temp_min_cost_str = str(value) if value is not None else ""
@rx.event
def set_temp_max_cost(self, value: float):
self.temp_max_cost_str = str(value) if value is not None else ""
@rx.event
def apply_status_filter(self):
"""Apply the temporary status filter to the main selection."""
self.selected_statuses = self.temp_selected_statuses.copy()
self.current_page = 1
self.close_filter_dropdowns()
@rx.event
def apply_country_filter(self):
"""Apply the temporary country f | def toggle_costs_filter(self):
is_opening = not self.show_costs_filter
self.show_costs_filter = is_opening
self.show_status_filter = False
self.show_country_filter = False
if is_opening:
self.temp_min_cost_str = (
str(self.min_cost) if self.min_cost is not None else ""
)
self.temp_max_cost_str = (
str(self.max_cost) if self.max_cost is not None else ""
) |
page_ids = self.page_item_ids
if self.all_rows_on_page_selected:
self.selected_rows -= page_ids
else:
self.selected_rows.update(page_ids)
@rx.event
def toggle_status_filter(self):
"""Toggle the visibility of the status filter dropdown."""
self.show_status_filter = not self.show_status_filter
if self.show_status_filter:
self.temp_selected_statuses = self.selected_statuses.copy()
self.show_country_filter = False
self.show_costs_filter = False
@rx.event
def toggle_country_filter(self):
"""Toggle the visibility of the country filter dropdown."""
self.show_country_filter = not self.show_country_filter
if self.show_country_filter:
self.temp_selected_countries = self.selected_countries.copy()
self.show_status_filter = False
self.show_costs_filter = False
@rx.event
def toggle_costs_filter(self):
|
self.show_costs_filter = is_opening
self.show_status_filter = False
self.show_country_filter = False
if is_opening:
self.temp_min_cost_str = (
str(self.min_cost) if self.min_cost is not None else ""
)
self.temp_max_cost_str = (
str(self.max_cost) if self.max_cost is not None else ""
)
@rx.event
def toggle_temp_status(self, status: str):
"""Toggle a status in the temporary set."""
self.temp_selected_statuses.symmetric_difference_update({status})
@rx.event
def toggle_temp_country(self, country: str):
"""Toggle a country in the temporary set."""
self.temp_selected_countries.symmetric_difference_update({country})
@rx.event
def set_temp_min_cost(self, value: float):
self.temp_min_cost_str = str(value) if value is not None else ""
@rx.event
def set_temp_max_cost(self, value: float):
self.temp_max_c | is_opening = not self.show_costs_filter |
elf.all_rows_on_page_selected:
self.selected_rows -= page_ids
else:
self.selected_rows.update(page_ids)
@rx.event
def toggle_status_filter(self):
"""Toggle the visibility of the status filter dropdown."""
self.show_status_filter = not self.show_status_filter
if self.show_status_filter:
self.temp_selected_statuses = self.selected_statuses.copy()
self.show_country_filter = False
self.show_costs_filter = False
@rx.event
def toggle_country_filter(self):
"""Toggle the visibility of the country filter dropdown."""
self.show_country_filter = not self.show_country_filter
if self.show_country_filter:
self.temp_selected_countries = self.selected_countries.copy()
self.show_status_filter = False
self.show_costs_filter = False
@rx.event
def toggle_costs_filter(self):
is_opening = not self.show_costs_filter
|
self.show_status_filter = False
self.show_country_filter = False
if is_opening:
self.temp_min_cost_str = (
str(self.min_cost) if self.min_cost is not None else ""
)
self.temp_max_cost_str = (
str(self.max_cost) if self.max_cost is not None else ""
)
@rx.event
def toggle_temp_status(self, status: str):
"""Toggle a status in the temporary set."""
self.temp_selected_statuses.symmetric_difference_update({status})
@rx.event
def toggle_temp_country(self, country: str):
"""Toggle a country in the temporary set."""
self.temp_selected_countries.symmetric_difference_update({country})
@rx.event
def set_temp_min_cost(self, value: float):
self.temp_min_cost_str = str(value) if value is not None else ""
@rx.event
def set_temp_max_cost(self, value: float):
self.temp_max_cost_str = str(value) if value is not None el | self.show_costs_filter = is_opening |
elf.selected_rows -= page_ids
else:
self.selected_rows.update(page_ids)
@rx.event
def toggle_status_filter(self):
"""Toggle the visibility of the status filter dropdown."""
self.show_status_filter = not self.show_status_filter
if self.show_status_filter:
self.temp_selected_statuses = self.selected_statuses.copy()
self.show_country_filter = False
self.show_costs_filter = False
@rx.event
def toggle_country_filter(self):
"""Toggle the visibility of the country filter dropdown."""
self.show_country_filter = not self.show_country_filter
if self.show_country_filter:
self.temp_selected_countries = self.selected_countries.copy()
self.show_status_filter = False
self.show_costs_filter = False
@rx.event
def toggle_costs_filter(self):
is_opening = not self.show_costs_filter
self.show_costs_filter = is_opening
|
self.show_country_filter = False
if is_opening:
self.temp_min_cost_str = (
str(self.min_cost) if self.min_cost is not None else ""
)
self.temp_max_cost_str = (
str(self.max_cost) if self.max_cost is not None else ""
)
@rx.event
def toggle_temp_status(self, status: str):
"""Toggle a status in the temporary set."""
self.temp_selected_statuses.symmetric_difference_update({status})
@rx.event
def toggle_temp_country(self, country: str):
"""Toggle a country in the temporary set."""
self.temp_selected_countries.symmetric_difference_update({country})
@rx.event
def set_temp_min_cost(self, value: float):
self.temp_min_cost_str = str(value) if value is not None else ""
@rx.event
def set_temp_max_cost(self, value: float):
self.temp_max_cost_str = str(value) if value is not None else ""
@rx.event
def apply_statu | self.show_status_filter = False |
se:
self.selected_rows.update(page_ids)
@rx.event
def toggle_status_filter(self):
"""Toggle the visibility of the status filter dropdown."""
self.show_status_filter = not self.show_status_filter
if self.show_status_filter:
self.temp_selected_statuses = self.selected_statuses.copy()
self.show_country_filter = False
self.show_costs_filter = False
@rx.event
def toggle_country_filter(self):
"""Toggle the visibility of the country filter dropdown."""
self.show_country_filter = not self.show_country_filter
if self.show_country_filter:
self.temp_selected_countries = self.selected_countries.copy()
self.show_status_filter = False
self.show_costs_filter = False
@rx.event
def toggle_costs_filter(self):
is_opening = not self.show_costs_filter
self.show_costs_filter = is_opening
self.show_status_filter = False
|
if is_opening:
self.temp_min_cost_str = (
str(self.min_cost) if self.min_cost is not None else ""
)
self.temp_max_cost_str = (
str(self.max_cost) if self.max_cost is not None else ""
)
@rx.event
def toggle_temp_status(self, status: str):
"""Toggle a status in the temporary set."""
self.temp_selected_statuses.symmetric_difference_update({status})
@rx.event
def toggle_temp_country(self, country: str):
"""Toggle a country in the temporary set."""
self.temp_selected_countries.symmetric_difference_update({country})
@rx.event
def set_temp_min_cost(self, value: float):
self.temp_min_cost_str = str(value) if value is not None else ""
@rx.event
def set_temp_max_cost(self, value: float):
self.temp_max_cost_str = str(value) if value is not None else ""
@rx.event
def apply_status_filter(self):
"""Apply the temp | self.show_country_filter = False |
(page_ids)
@rx.event
def toggle_status_filter(self):
"""Toggle the visibility of the status filter dropdown."""
self.show_status_filter = not self.show_status_filter
if self.show_status_filter:
self.temp_selected_statuses = self.selected_statuses.copy()
self.show_country_filter = False
self.show_costs_filter = False
@rx.event
def toggle_country_filter(self):
"""Toggle the visibility of the country filter dropdown."""
self.show_country_filter = not self.show_country_filter
if self.show_country_filter:
self.temp_selected_countries = self.selected_countries.copy()
self.show_status_filter = False
self.show_costs_filter = False
@rx.event
def toggle_costs_filter(self):
is_opening = not self.show_costs_filter
self.show_costs_filter = is_opening
self.show_status_filter = False
self.show_country_filter = False
|
@rx.event
def toggle_temp_status(self, status: str):
"""Toggle a status in the temporary set."""
self.temp_selected_statuses.symmetric_difference_update({status})
@rx.event
def toggle_temp_country(self, country: str):
"""Toggle a country in the temporary set."""
self.temp_selected_countries.symmetric_difference_update({country})
@rx.event
def set_temp_min_cost(self, value: float):
self.temp_min_cost_str = str(value) if value is not None else ""
@rx.event
def set_temp_max_cost(self, value: float):
self.temp_max_cost_str = str(value) if value is not None else ""
@rx.event
def apply_status_filter(self):
"""Apply the temporary status filter to the main selection."""
self.selected_statuses = self.temp_selected_statuses.copy()
self.current_page = 1
self.close_filter_dropdowns()
@rx.event
def apply_country_filter(self):
"""Apply the temporary country f | if is_opening:
self.temp_min_cost_str = (
str(self.min_cost) if self.min_cost is not None else ""
)
self.temp_max_cost_str = (
str(self.max_cost) if self.max_cost is not None else ""
) |
def toggle_status_filter(self):
"""Toggle the visibility of the status filter dropdown."""
self.show_status_filter = not self.show_status_filter
if self.show_status_filter:
self.temp_selected_statuses = self.selected_statuses.copy()
self.show_country_filter = False
self.show_costs_filter = False
@rx.event
def toggle_country_filter(self):
"""Toggle the visibility of the country filter dropdown."""
self.show_country_filter = not self.show_country_filter
if self.show_country_filter:
self.temp_selected_countries = self.selected_countries.copy()
self.show_status_filter = False
self.show_costs_filter = False
@rx.event
def toggle_costs_filter(self):
is_opening = not self.show_costs_filter
self.show_costs_filter = is_opening
self.show_status_filter = False
self.show_country_filter = False
if is_opening:
|
self.temp_max_cost_str = (
str(self.max_cost) if self.max_cost is not None else ""
)
@rx.event
def toggle_temp_status(self, status: str):
"""Toggle a status in the temporary set."""
self.temp_selected_statuses.symmetric_difference_update({status})
@rx.event
def toggle_temp_country(self, country: str):
"""Toggle a country in the temporary set."""
self.temp_selected_countries.symmetric_difference_update({country})
@rx.event
def set_temp_min_cost(self, value: float):
self.temp_min_cost_str = str(value) if value is not None else ""
@rx.event
def set_temp_max_cost(self, value: float):
self.temp_max_cost_str = str(value) if value is not None else ""
@rx.event
def apply_status_filter(self):
"""Apply the temporary status filter to the main selection."""
self.selected_statuses = self.temp_selected_statuses.copy()
self.current_page = 1
| self.temp_min_cost_str = (
str(self.min_cost) if self.min_cost is not None else ""
) |
s_filter = not self.show_status_filter
if self.show_status_filter:
self.temp_selected_statuses = self.selected_statuses.copy()
self.show_country_filter = False
self.show_costs_filter = False
@rx.event
def toggle_country_filter(self):
"""Toggle the visibility of the country filter dropdown."""
self.show_country_filter = not self.show_country_filter
if self.show_country_filter:
self.temp_selected_countries = self.selected_countries.copy()
self.show_status_filter = False
self.show_costs_filter = False
@rx.event
def toggle_costs_filter(self):
is_opening = not self.show_costs_filter
self.show_costs_filter = is_opening
self.show_status_filter = False
self.show_country_filter = False
if is_opening:
self.temp_min_cost_str = (
str(self.min_cost) if self.min_cost is not None else ""
)
|
@rx.event
def toggle_temp_status(self, status: str):
"""Toggle a status in the temporary set."""
self.temp_selected_statuses.symmetric_difference_update({status})
@rx.event
def toggle_temp_country(self, country: str):
"""Toggle a country in the temporary set."""
self.temp_selected_countries.symmetric_difference_update({country})
@rx.event
def set_temp_min_cost(self, value: float):
self.temp_min_cost_str = str(value) if value is not None else ""
@rx.event
def set_temp_max_cost(self, value: float):
self.temp_max_cost_str = str(value) if value is not None else ""
@rx.event
def apply_status_filter(self):
"""Apply the temporary status filter to the main selection."""
self.selected_statuses = self.temp_selected_statuses.copy()
self.current_page = 1
self.close_filter_dropdowns()
@rx.event
def apply_country_filter(self):
"""Apply the temporary country f | self.temp_max_cost_str = (
str(self.max_cost) if self.max_cost is not None else ""
) |
tatuses.copy()
self.show_country_filter = False
self.show_costs_filter = False
@rx.event
def toggle_country_filter(self):
"""Toggle the visibility of the country filter dropdown."""
self.show_country_filter = not self.show_country_filter
if self.show_country_filter:
self.temp_selected_countries = self.selected_countries.copy()
self.show_status_filter = False
self.show_costs_filter = False
@rx.event
def toggle_costs_filter(self):
is_opening = not self.show_costs_filter
self.show_costs_filter = is_opening
self.show_status_filter = False
self.show_country_filter = False
if is_opening:
self.temp_min_cost_str = (
str(self.min_cost) if self.min_cost is not None else ""
)
self.temp_max_cost_str = (
str(self.max_cost) if self.max_cost is not None else ""
)
@rx.event
|
@rx.event
def toggle_temp_country(self, country: str):
"""Toggle a country in the temporary set."""
self.temp_selected_countries.symmetric_difference_update({country})
@rx.event
def set_temp_min_cost(self, value: float):
self.temp_min_cost_str = str(value) if value is not None else ""
@rx.event
def set_temp_max_cost(self, value: float):
self.temp_max_cost_str = str(value) if value is not None else ""
@rx.event
def apply_status_filter(self):
"""Apply the temporary status filter to the main selection."""
self.selected_statuses = self.temp_selected_statuses.copy()
self.current_page = 1
self.close_filter_dropdowns()
@rx.event
def apply_country_filter(self):
"""Apply the temporary country filter to the main selection."""
self.selected_countries = self.temp_selected_countries.copy()
self.current_page = 1
self.close_filter_dropdowns()
@rx.event
| def toggle_temp_status(self, status: str):
"""Toggle a status in the temporary set."""
self.temp_selected_statuses.symmetric_difference_update({status}) |
of the country filter dropdown."""
self.show_country_filter = not self.show_country_filter
if self.show_country_filter:
self.temp_selected_countries = self.selected_countries.copy()
self.show_status_filter = False
self.show_costs_filter = False
@rx.event
def toggle_costs_filter(self):
is_opening = not self.show_costs_filter
self.show_costs_filter = is_opening
self.show_status_filter = False
self.show_country_filter = False
if is_opening:
self.temp_min_cost_str = (
str(self.min_cost) if self.min_cost is not None else ""
)
self.temp_max_cost_str = (
str(self.max_cost) if self.max_cost is not None else ""
)
@rx.event
def toggle_temp_status(self, status: str):
"""Toggle a status in the temporary set."""
self.temp_selected_statuses.symmetric_difference_update({status})
@rx.event
|
@rx.event
def set_temp_min_cost(self, value: float):
self.temp_min_cost_str = str(value) if value is not None else ""
@rx.event
def set_temp_max_cost(self, value: float):
self.temp_max_cost_str = str(value) if value is not None else ""
@rx.event
def apply_status_filter(self):
"""Apply the temporary status filter to the main selection."""
self.selected_statuses = self.temp_selected_statuses.copy()
self.current_page = 1
self.close_filter_dropdowns()
@rx.event
def apply_country_filter(self):
"""Apply the temporary country filter to the main selection."""
self.selected_countries = self.temp_selected_countries.copy()
self.current_page = 1
self.close_filter_dropdowns()
@rx.event
def apply_costs_filter(self):
new_min_cost = None
new_max_cost = None
try:
if self.temp_min_cost_str:
new_min_cost = float(self.temp_min_cos | def toggle_temp_country(self, country: str):
"""Toggle a country in the temporary set."""
self.temp_selected_countries.symmetric_difference_update({country}) |
countries.copy()
self.show_status_filter = False
self.show_costs_filter = False
@rx.event
def toggle_costs_filter(self):
is_opening = not self.show_costs_filter
self.show_costs_filter = is_opening
self.show_status_filter = False
self.show_country_filter = False
if is_opening:
self.temp_min_cost_str = (
str(self.min_cost) if self.min_cost is not None else ""
)
self.temp_max_cost_str = (
str(self.max_cost) if self.max_cost is not None else ""
)
@rx.event
def toggle_temp_status(self, status: str):
"""Toggle a status in the temporary set."""
self.temp_selected_statuses.symmetric_difference_update({status})
@rx.event
def toggle_temp_country(self, country: str):
"""Toggle a country in the temporary set."""
self.temp_selected_countries.symmetric_difference_update({country})
@rx.event
|
@rx.event
def set_temp_max_cost(self, value: float):
self.temp_max_cost_str = str(value) if value is not None else ""
@rx.event
def apply_status_filter(self):
"""Apply the temporary status filter to the main selection."""
self.selected_statuses = self.temp_selected_statuses.copy()
self.current_page = 1
self.close_filter_dropdowns()
@rx.event
def apply_country_filter(self):
"""Apply the temporary country filter to the main selection."""
self.selected_countries = self.temp_selected_countries.copy()
self.current_page = 1
self.close_filter_dropdowns()
@rx.event
def apply_costs_filter(self):
new_min_cost = None
new_max_cost = None
try:
if self.temp_min_cost_str:
new_min_cost = float(self.temp_min_cost_str)
except ValueError:
pass
try:
if self.temp_max_cost_str:
new_max_cost = f | def set_temp_min_cost(self, value: float):
self.temp_min_cost_str = str(value) if value is not None else "" |
r = False
self.show_costs_filter = False
@rx.event
def toggle_costs_filter(self):
is_opening = not self.show_costs_filter
self.show_costs_filter = is_opening
self.show_status_filter = False
self.show_country_filter = False
if is_opening:
self.temp_min_cost_str = (
str(self.min_cost) if self.min_cost is not None else ""
)
self.temp_max_cost_str = (
str(self.max_cost) if self.max_cost is not None else ""
)
@rx.event
def toggle_temp_status(self, status: str):
"""Toggle a status in the temporary set."""
self.temp_selected_statuses.symmetric_difference_update({status})
@rx.event
def toggle_temp_country(self, country: str):
"""Toggle a country in the temporary set."""
self.temp_selected_countries.symmetric_difference_update({country})
@rx.event
def set_temp_min_cost(self, value: float):
|
@rx.event
def set_temp_max_cost(self, value: float):
self.temp_max_cost_str = str(value) if value is not None else ""
@rx.event
def apply_status_filter(self):
"""Apply the temporary status filter to the main selection."""
self.selected_statuses = self.temp_selected_statuses.copy()
self.current_page = 1
self.close_filter_dropdowns()
@rx.event
def apply_country_filter(self):
"""Apply the temporary country filter to the main selection."""
self.selected_countries = self.temp_selected_countries.copy()
self.current_page = 1
self.close_filter_dropdowns()
@rx.event
def apply_costs_filter(self):
new_min_cost = None
new_max_cost = None
try:
if self.temp_min_cost_str:
new_min_cost = float(self.temp_min_cost_str)
except ValueError:
pass
try:
if self.temp_max_cost_str:
new_max_cost = f | self.temp_min_cost_str = str(value) if value is not None else "" |
osts_filter(self):
is_opening = not self.show_costs_filter
self.show_costs_filter = is_opening
self.show_status_filter = False
self.show_country_filter = False
if is_opening:
self.temp_min_cost_str = (
str(self.min_cost) if self.min_cost is not None else ""
)
self.temp_max_cost_str = (
str(self.max_cost) if self.max_cost is not None else ""
)
@rx.event
def toggle_temp_status(self, status: str):
"""Toggle a status in the temporary set."""
self.temp_selected_statuses.symmetric_difference_update({status})
@rx.event
def toggle_temp_country(self, country: str):
"""Toggle a country in the temporary set."""
self.temp_selected_countries.symmetric_difference_update({country})
@rx.event
def set_temp_min_cost(self, value: float):
self.temp_min_cost_str = str(value) if value is not None else ""
@rx.event
|
@rx.event
def apply_status_filter(self):
"""Apply the temporary status filter to the main selection."""
self.selected_statuses = self.temp_selected_statuses.copy()
self.current_page = 1
self.close_filter_dropdowns()
@rx.event
def apply_country_filter(self):
"""Apply the temporary country filter to the main selection."""
self.selected_countries = self.temp_selected_countries.copy()
self.current_page = 1
self.close_filter_dropdowns()
@rx.event
def apply_costs_filter(self):
new_min_cost = None
new_max_cost = None
try:
if self.temp_min_cost_str:
new_min_cost = float(self.temp_min_cost_str)
except ValueError:
pass
try:
if self.temp_max_cost_str:
new_max_cost = float(self.temp_max_cost_str)
except ValueError:
pass
if (
new_min_cost is not None
| def set_temp_max_cost(self, value: float):
self.temp_max_cost_str = str(value) if value is not None else "" |
ow_costs_filter
self.show_costs_filter = is_opening
self.show_status_filter = False
self.show_country_filter = False
if is_opening:
self.temp_min_cost_str = (
str(self.min_cost) if self.min_cost is not None else ""
)
self.temp_max_cost_str = (
str(self.max_cost) if self.max_cost is not None else ""
)
@rx.event
def toggle_temp_status(self, status: str):
"""Toggle a status in the temporary set."""
self.temp_selected_statuses.symmetric_difference_update({status})
@rx.event
def toggle_temp_country(self, country: str):
"""Toggle a country in the temporary set."""
self.temp_selected_countries.symmetric_difference_update({country})
@rx.event
def set_temp_min_cost(self, value: float):
self.temp_min_cost_str = str(value) if value is not None else ""
@rx.event
def set_temp_max_cost(self, value: float):
|
@rx.event
def apply_status_filter(self):
"""Apply the temporary status filter to the main selection."""
self.selected_statuses = self.temp_selected_statuses.copy()
self.current_page = 1
self.close_filter_dropdowns()
@rx.event
def apply_country_filter(self):
"""Apply the temporary country filter to the main selection."""
self.selected_countries = self.temp_selected_countries.copy()
self.current_page = 1
self.close_filter_dropdowns()
@rx.event
def apply_costs_filter(self):
new_min_cost = None
new_max_cost = None
try:
if self.temp_min_cost_str:
new_min_cost = float(self.temp_min_cost_str)
except ValueError:
pass
try:
if self.temp_max_cost_str:
new_max_cost = float(self.temp_max_cost_str)
except ValueError:
pass
if (
new_min_cost is not None
| self.temp_max_cost_str = str(value) if value is not None else "" |
_filter = False
self.show_country_filter = False
if is_opening:
self.temp_min_cost_str = (
str(self.min_cost) if self.min_cost is not None else ""
)
self.temp_max_cost_str = (
str(self.max_cost) if self.max_cost is not None else ""
)
@rx.event
def toggle_temp_status(self, status: str):
"""Toggle a status in the temporary set."""
self.temp_selected_statuses.symmetric_difference_update({status})
@rx.event
def toggle_temp_country(self, country: str):
"""Toggle a country in the temporary set."""
self.temp_selected_countries.symmetric_difference_update({country})
@rx.event
def set_temp_min_cost(self, value: float):
self.temp_min_cost_str = str(value) if value is not None else ""
@rx.event
def set_temp_max_cost(self, value: float):
self.temp_max_cost_str = str(value) if value is not None else ""
@rx.event
|
@rx.event
def apply_country_filter(self):
"""Apply the temporary country filter to the main selection."""
self.selected_countries = self.temp_selected_countries.copy()
self.current_page = 1
self.close_filter_dropdowns()
@rx.event
def apply_costs_filter(self):
new_min_cost = None
new_max_cost = None
try:
if self.temp_min_cost_str:
new_min_cost = float(self.temp_min_cost_str)
except ValueError:
pass
try:
if self.temp_max_cost_str:
new_max_cost = float(self.temp_max_cost_str)
except ValueError:
pass
if (
new_min_cost is not None
and new_max_cost is not None
and (new_min_cost > new_max_cost)
):
self.min_cost = new_max_cost
self.max_cost = new_min_cost
else:
self.min_cost = new_min_cost
self.max_cost = new_ma | def apply_status_filter(self):
"""Apply the temporary status filter to the main selection."""
self.selected_statuses = self.temp_selected_statuses.copy()
self.current_page = 1
self.close_filter_dropdowns() |
_str = (
str(self.min_cost) if self.min_cost is not None else ""
)
self.temp_max_cost_str = (
str(self.max_cost) if self.max_cost is not None else ""
)
@rx.event
def toggle_temp_status(self, status: str):
"""Toggle a status in the temporary set."""
self.temp_selected_statuses.symmetric_difference_update({status})
@rx.event
def toggle_temp_country(self, country: str):
"""Toggle a country in the temporary set."""
self.temp_selected_countries.symmetric_difference_update({country})
@rx.event
def set_temp_min_cost(self, value: float):
self.temp_min_cost_str = str(value) if value is not None else ""
@rx.event
def set_temp_max_cost(self, value: float):
self.temp_max_cost_str = str(value) if value is not None else ""
@rx.event
def apply_status_filter(self):
"""Apply the temporary status filter to the main selection."""
|
self.current_page = 1
self.close_filter_dropdowns()
@rx.event
def apply_country_filter(self):
"""Apply the temporary country filter to the main selection."""
self.selected_countries = self.temp_selected_countries.copy()
self.current_page = 1
self.close_filter_dropdowns()
@rx.event
def apply_costs_filter(self):
new_min_cost = None
new_max_cost = None
try:
if self.temp_min_cost_str:
new_min_cost = float(self.temp_min_cost_str)
except ValueError:
pass
try:
if self.temp_max_cost_str:
new_max_cost = float(self.temp_max_cost_str)
except ValueError:
pass
if (
new_min_cost is not None
and new_max_cost is not None
and (new_min_cost > new_max_cost)
):
self.min_cost = new_max_cost
self.max_cost = new_min_cost
else:
| self.selected_statuses = self.temp_selected_statuses.copy() |
None else ""
)
self.temp_max_cost_str = (
str(self.max_cost) if self.max_cost is not None else ""
)
@rx.event
def toggle_temp_status(self, status: str):
"""Toggle a status in the temporary set."""
self.temp_selected_statuses.symmetric_difference_update({status})
@rx.event
def toggle_temp_country(self, country: str):
"""Toggle a country in the temporary set."""
self.temp_selected_countries.symmetric_difference_update({country})
@rx.event
def set_temp_min_cost(self, value: float):
self.temp_min_cost_str = str(value) if value is not None else ""
@rx.event
def set_temp_max_cost(self, value: float):
self.temp_max_cost_str = str(value) if value is not None else ""
@rx.event
def apply_status_filter(self):
"""Apply the temporary status filter to the main selection."""
self.selected_statuses = self.temp_selected_statuses.copy()
|
self.close_filter_dropdowns()
@rx.event
def apply_country_filter(self):
"""Apply the temporary country filter to the main selection."""
self.selected_countries = self.temp_selected_countries.copy()
self.current_page = 1
self.close_filter_dropdowns()
@rx.event
def apply_costs_filter(self):
new_min_cost = None
new_max_cost = None
try:
if self.temp_min_cost_str:
new_min_cost = float(self.temp_min_cost_str)
except ValueError:
pass
try:
if self.temp_max_cost_str:
new_max_cost = float(self.temp_max_cost_str)
except ValueError:
pass
if (
new_min_cost is not None
and new_max_cost is not None
and (new_min_cost > new_max_cost)
):
self.min_cost = new_max_cost
self.max_cost = new_min_cost
else:
self.min_cost = new_min_c | self.current_page = 1 |
str(self.max_cost) if self.max_cost is not None else ""
)
@rx.event
def toggle_temp_status(self, status: str):
"""Toggle a status in the temporary set."""
self.temp_selected_statuses.symmetric_difference_update({status})
@rx.event
def toggle_temp_country(self, country: str):
"""Toggle a country in the temporary set."""
self.temp_selected_countries.symmetric_difference_update({country})
@rx.event
def set_temp_min_cost(self, value: float):
self.temp_min_cost_str = str(value) if value is not None else ""
@rx.event
def set_temp_max_cost(self, value: float):
self.temp_max_cost_str = str(value) if value is not None else ""
@rx.event
def apply_status_filter(self):
"""Apply the temporary status filter to the main selection."""
self.selected_statuses = self.temp_selected_statuses.copy()
self.current_page = 1
self.close_filter_dropdowns()
@rx.event
|
@rx.event
def apply_costs_filter(self):
new_min_cost = None
new_max_cost = None
try:
if self.temp_min_cost_str:
new_min_cost = float(self.temp_min_cost_str)
except ValueError:
pass
try:
if self.temp_max_cost_str:
new_max_cost = float(self.temp_max_cost_str)
except ValueError:
pass
if (
new_min_cost is not None
and new_max_cost is not None
and (new_min_cost > new_max_cost)
):
self.min_cost = new_max_cost
self.max_cost = new_min_cost
else:
self.min_cost = new_min_cost
self.max_cost = new_max_cost
self.show_costs_filter = False
self.current_page = 1
@rx.event
def reset_status_filter(self):
"""Reset the status filter."""
self.temp_selected_statuses = set()
@rx.event
def reset_country_filter(self):
| def apply_country_filter(self):
"""Apply the temporary country filter to the main selection."""
self.selected_countries = self.temp_selected_countries.copy()
self.current_page = 1
self.close_filter_dropdowns() |
us(self, status: str):
"""Toggle a status in the temporary set."""
self.temp_selected_statuses.symmetric_difference_update({status})
@rx.event
def toggle_temp_country(self, country: str):
"""Toggle a country in the temporary set."""
self.temp_selected_countries.symmetric_difference_update({country})
@rx.event
def set_temp_min_cost(self, value: float):
self.temp_min_cost_str = str(value) if value is not None else ""
@rx.event
def set_temp_max_cost(self, value: float):
self.temp_max_cost_str = str(value) if value is not None else ""
@rx.event
def apply_status_filter(self):
"""Apply the temporary status filter to the main selection."""
self.selected_statuses = self.temp_selected_statuses.copy()
self.current_page = 1
self.close_filter_dropdowns()
@rx.event
def apply_country_filter(self):
"""Apply the temporary country filter to the main selection."""
|
self.current_page = 1
self.close_filter_dropdowns()
@rx.event
def apply_costs_filter(self):
new_min_cost = None
new_max_cost = None
try:
if self.temp_min_cost_str:
new_min_cost = float(self.temp_min_cost_str)
except ValueError:
pass
try:
if self.temp_max_cost_str:
new_max_cost = float(self.temp_max_cost_str)
except ValueError:
pass
if (
new_min_cost is not None
and new_max_cost is not None
and (new_min_cost > new_max_cost)
):
self.min_cost = new_max_cost
self.max_cost = new_min_cost
else:
self.min_cost = new_min_cost
self.max_cost = new_max_cost
self.show_costs_filter = False
self.current_page = 1
@rx.event
def reset_status_filter(self):
"""Reset the status filter."""
self.temp_selected_s | self.selected_countries = self.temp_selected_countries.copy() |
."""
self.temp_selected_statuses.symmetric_difference_update({status})
@rx.event
def toggle_temp_country(self, country: str):
"""Toggle a country in the temporary set."""
self.temp_selected_countries.symmetric_difference_update({country})
@rx.event
def set_temp_min_cost(self, value: float):
self.temp_min_cost_str = str(value) if value is not None else ""
@rx.event
def set_temp_max_cost(self, value: float):
self.temp_max_cost_str = str(value) if value is not None else ""
@rx.event
def apply_status_filter(self):
"""Apply the temporary status filter to the main selection."""
self.selected_statuses = self.temp_selected_statuses.copy()
self.current_page = 1
self.close_filter_dropdowns()
@rx.event
def apply_country_filter(self):
"""Apply the temporary country filter to the main selection."""
self.selected_countries = self.temp_selected_countries.copy()
|
self.close_filter_dropdowns()
@rx.event
def apply_costs_filter(self):
new_min_cost = None
new_max_cost = None
try:
if self.temp_min_cost_str:
new_min_cost = float(self.temp_min_cost_str)
except ValueError:
pass
try:
if self.temp_max_cost_str:
new_max_cost = float(self.temp_max_cost_str)
except ValueError:
pass
if (
new_min_cost is not None
and new_max_cost is not None
and (new_min_cost > new_max_cost)
):
self.min_cost = new_max_cost
self.max_cost = new_min_cost
else:
self.min_cost = new_min_cost
self.max_cost = new_max_cost
self.show_costs_filter = False
self.current_page = 1
@rx.event
def reset_status_filter(self):
"""Reset the status filter."""
self.temp_selected_statuses = set()
@rx.event | self.current_page = 1 |
@rx.event
def toggle_temp_country(self, country: str):
"""Toggle a country in the temporary set."""
self.temp_selected_countries.symmetric_difference_update({country})
@rx.event
def set_temp_min_cost(self, value: float):
self.temp_min_cost_str = str(value) if value is not None else ""
@rx.event
def set_temp_max_cost(self, value: float):
self.temp_max_cost_str = str(value) if value is not None else ""
@rx.event
def apply_status_filter(self):
"""Apply the temporary status filter to the main selection."""
self.selected_statuses = self.temp_selected_statuses.copy()
self.current_page = 1
self.close_filter_dropdowns()
@rx.event
def apply_country_filter(self):
"""Apply the temporary country filter to the main selection."""
self.selected_countries = self.temp_selected_countries.copy()
self.current_page = 1
self.close_filter_dropdowns()
@rx.event
|
@rx.event
def reset_status_filter(self):
"""Reset the status filter."""
self.temp_selected_statuses = set()
@rx.event
def reset_country_filter(self):
"""Reset the country filter."""
self.temp_selected_countries = set()
@rx.event
def reset_costs_filter(self):
self.temp_min_cost_str = ""
self.temp_max_cost_str = ""
self.min_cost = None
self.max_cost = None
self.show_costs_filter = False
self.current_page = 1
@rx.event
def reset_all_filters(self):
"""Reset all active filters and search."""
self.search_owner = ""
self.selected_statuses = set()
self.selected_countries = set()
self.min_cost = None
self.max_cost = None
self.temp_selected_statuses = set()
self.temp_selected_countries = set()
self.temp_min_cost_str = ""
self.temp_max_cost_str = ""
self.sort_column = None
self.current_p | def apply_costs_filter(self):
new_min_cost = None
new_max_cost = None
try:
if self.temp_min_cost_str:
new_min_cost = float(self.temp_min_cost_str)
except ValueError:
pass
try:
if self.temp_max_cost_str:
new_max_cost = float(self.temp_max_cost_str)
except ValueError:
pass
if (
new_min_cost is not None
and new_max_cost is not None
and (new_min_cost > new_max_cost)
):
self.min_cost = new_max_cost
self.max_cost = new_min_cost
else:
self.min_cost = new_min_cost
self.max_cost = new_max_cost
self.show_costs_filter = False
self.current_page = 1 |
ntry(self, country: str):
"""Toggle a country in the temporary set."""
self.temp_selected_countries.symmetric_difference_update({country})
@rx.event
def set_temp_min_cost(self, value: float):
self.temp_min_cost_str = str(value) if value is not None else ""
@rx.event
def set_temp_max_cost(self, value: float):
self.temp_max_cost_str = str(value) if value is not None else ""
@rx.event
def apply_status_filter(self):
"""Apply the temporary status filter to the main selection."""
self.selected_statuses = self.temp_selected_statuses.copy()
self.current_page = 1
self.close_filter_dropdowns()
@rx.event
def apply_country_filter(self):
"""Apply the temporary country filter to the main selection."""
self.selected_countries = self.temp_selected_countries.copy()
self.current_page = 1
self.close_filter_dropdowns()
@rx.event
def apply_costs_filter(self):
|
new_max_cost = None
try:
if self.temp_min_cost_str:
new_min_cost = float(self.temp_min_cost_str)
except ValueError:
pass
try:
if self.temp_max_cost_str:
new_max_cost = float(self.temp_max_cost_str)
except ValueError:
pass
if (
new_min_cost is not None
and new_max_cost is not None
and (new_min_cost > new_max_cost)
):
self.min_cost = new_max_cost
self.max_cost = new_min_cost
else:
self.min_cost = new_min_cost
self.max_cost = new_max_cost
self.show_costs_filter = False
self.current_page = 1
@rx.event
def reset_status_filter(self):
"""Reset the status filter."""
self.temp_selected_statuses = set()
@rx.event
def reset_country_filter(self):
"""Reset the country filter."""
self.temp_selected_countries = | new_min_cost = None |
"""Toggle a country in the temporary set."""
self.temp_selected_countries.symmetric_difference_update({country})
@rx.event
def set_temp_min_cost(self, value: float):
self.temp_min_cost_str = str(value) if value is not None else ""
@rx.event
def set_temp_max_cost(self, value: float):
self.temp_max_cost_str = str(value) if value is not None else ""
@rx.event
def apply_status_filter(self):
"""Apply the temporary status filter to the main selection."""
self.selected_statuses = self.temp_selected_statuses.copy()
self.current_page = 1
self.close_filter_dropdowns()
@rx.event
def apply_country_filter(self):
"""Apply the temporary country filter to the main selection."""
self.selected_countries = self.temp_selected_countries.copy()
self.current_page = 1
self.close_filter_dropdowns()
@rx.event
def apply_costs_filter(self):
new_min_cost = None
|
try:
if self.temp_min_cost_str:
new_min_cost = float(self.temp_min_cost_str)
except ValueError:
pass
try:
if self.temp_max_cost_str:
new_max_cost = float(self.temp_max_cost_str)
except ValueError:
pass
if (
new_min_cost is not None
and new_max_cost is not None
and (new_min_cost > new_max_cost)
):
self.min_cost = new_max_cost
self.max_cost = new_min_cost
else:
self.min_cost = new_min_cost
self.max_cost = new_max_cost
self.show_costs_filter = False
self.current_page = 1
@rx.event
def reset_status_filter(self):
"""Reset the status filter."""
self.temp_selected_statuses = set()
@rx.event
def reset_country_filter(self):
"""Reset the country filter."""
self.temp_selected_countries = set()
@rx.event
de | new_max_cost = None |
t."""
self.temp_selected_countries.symmetric_difference_update({country})
@rx.event
def set_temp_min_cost(self, value: float):
self.temp_min_cost_str = str(value) if value is not None else ""
@rx.event
def set_temp_max_cost(self, value: float):
self.temp_max_cost_str = str(value) if value is not None else ""
@rx.event
def apply_status_filter(self):
"""Apply the temporary status filter to the main selection."""
self.selected_statuses = self.temp_selected_statuses.copy()
self.current_page = 1
self.close_filter_dropdowns()
@rx.event
def apply_country_filter(self):
"""Apply the temporary country filter to the main selection."""
self.selected_countries = self.temp_selected_countries.copy()
self.current_page = 1
self.close_filter_dropdowns()
@rx.event
def apply_costs_filter(self):
new_min_cost = None
new_max_cost = None
try:
|
except ValueError:
pass
try:
if self.temp_max_cost_str:
new_max_cost = float(self.temp_max_cost_str)
except ValueError:
pass
if (
new_min_cost is not None
and new_max_cost is not None
and (new_min_cost > new_max_cost)
):
self.min_cost = new_max_cost
self.max_cost = new_min_cost
else:
self.min_cost = new_min_cost
self.max_cost = new_max_cost
self.show_costs_filter = False
self.current_page = 1
@rx.event
def reset_status_filter(self):
"""Reset the status filter."""
self.temp_selected_statuses = set()
@rx.event
def reset_country_filter(self):
"""Reset the country filter."""
self.temp_selected_countries = set()
@rx.event
def reset_costs_filter(self):
self.temp_min_cost_str = ""
self.temp_max_cost_str = ""
self. | if self.temp_min_cost_str:
new_min_cost = float(self.temp_min_cost_str) |
symmetric_difference_update({country})
@rx.event
def set_temp_min_cost(self, value: float):
self.temp_min_cost_str = str(value) if value is not None else ""
@rx.event
def set_temp_max_cost(self, value: float):
self.temp_max_cost_str = str(value) if value is not None else ""
@rx.event
def apply_status_filter(self):
"""Apply the temporary status filter to the main selection."""
self.selected_statuses = self.temp_selected_statuses.copy()
self.current_page = 1
self.close_filter_dropdowns()
@rx.event
def apply_country_filter(self):
"""Apply the temporary country filter to the main selection."""
self.selected_countries = self.temp_selected_countries.copy()
self.current_page = 1
self.close_filter_dropdowns()
@rx.event
def apply_costs_filter(self):
new_min_cost = None
new_max_cost = None
try:
if self.temp_min_cost_str:
|
except ValueError:
pass
try:
if self.temp_max_cost_str:
new_max_cost = float(self.temp_max_cost_str)
except ValueError:
pass
if (
new_min_cost is not None
and new_max_cost is not None
and (new_min_cost > new_max_cost)
):
self.min_cost = new_max_cost
self.max_cost = new_min_cost
else:
self.min_cost = new_min_cost
self.max_cost = new_max_cost
self.show_costs_filter = False
self.current_page = 1
@rx.event
def reset_status_filter(self):
"""Reset the status filter."""
self.temp_selected_statuses = set()
@rx.event
def reset_country_filter(self):
"""Reset the country filter."""
self.temp_selected_countries = set()
@rx.event
def reset_costs_filter(self):
self.temp_min_cost_str = ""
self.temp_max_cost_str = ""
self. | new_min_cost = float(self.temp_min_cost_str) |
temp_min_cost_str = str(value) if value is not None else ""
@rx.event
def set_temp_max_cost(self, value: float):
self.temp_max_cost_str = str(value) if value is not None else ""
@rx.event
def apply_status_filter(self):
"""Apply the temporary status filter to the main selection."""
self.selected_statuses = self.temp_selected_statuses.copy()
self.current_page = 1
self.close_filter_dropdowns()
@rx.event
def apply_country_filter(self):
"""Apply the temporary country filter to the main selection."""
self.selected_countries = self.temp_selected_countries.copy()
self.current_page = 1
self.close_filter_dropdowns()
@rx.event
def apply_costs_filter(self):
new_min_cost = None
new_max_cost = None
try:
if self.temp_min_cost_str:
new_min_cost = float(self.temp_min_cost_str)
except ValueError:
pass
try:
|
except ValueError:
pass
if (
new_min_cost is not None
and new_max_cost is not None
and (new_min_cost > new_max_cost)
):
self.min_cost = new_max_cost
self.max_cost = new_min_cost
else:
self.min_cost = new_min_cost
self.max_cost = new_max_cost
self.show_costs_filter = False
self.current_page = 1
@rx.event
def reset_status_filter(self):
"""Reset the status filter."""
self.temp_selected_statuses = set()
@rx.event
def reset_country_filter(self):
"""Reset the country filter."""
self.temp_selected_countries = set()
@rx.event
def reset_costs_filter(self):
self.temp_min_cost_str = ""
self.temp_max_cost_str = ""
self.min_cost = None
self.max_cost = None
self.show_costs_filter = False
self.current_page = 1
@rx.event
def reset_all_filters(se | if self.temp_max_cost_str:
new_max_cost = float(self.temp_max_cost_str) |
not None else ""
@rx.event
def set_temp_max_cost(self, value: float):
self.temp_max_cost_str = str(value) if value is not None else ""
@rx.event
def apply_status_filter(self):
"""Apply the temporary status filter to the main selection."""
self.selected_statuses = self.temp_selected_statuses.copy()
self.current_page = 1
self.close_filter_dropdowns()
@rx.event
def apply_country_filter(self):
"""Apply the temporary country filter to the main selection."""
self.selected_countries = self.temp_selected_countries.copy()
self.current_page = 1
self.close_filter_dropdowns()
@rx.event
def apply_costs_filter(self):
new_min_cost = None
new_max_cost = None
try:
if self.temp_min_cost_str:
new_min_cost = float(self.temp_min_cost_str)
except ValueError:
pass
try:
if self.temp_max_cost_str:
|
except ValueError:
pass
if (
new_min_cost is not None
and new_max_cost is not None
and (new_min_cost > new_max_cost)
):
self.min_cost = new_max_cost
self.max_cost = new_min_cost
else:
self.min_cost = new_min_cost
self.max_cost = new_max_cost
self.show_costs_filter = False
self.current_page = 1
@rx.event
def reset_status_filter(self):
"""Reset the status filter."""
self.temp_selected_statuses = set()
@rx.event
def reset_country_filter(self):
"""Reset the country filter."""
self.temp_selected_countries = set()
@rx.event
def reset_costs_filter(self):
self.temp_min_cost_str = ""
self.temp_max_cost_str = ""
self.min_cost = None
self.max_cost = None
self.show_costs_filter = False
self.current_page = 1
@rx.event
def reset_all_filters(se | new_max_cost = float(self.temp_max_cost_str) |
max_cost_str = str(value) if value is not None else ""
@rx.event
def apply_status_filter(self):
"""Apply the temporary status filter to the main selection."""
self.selected_statuses = self.temp_selected_statuses.copy()
self.current_page = 1
self.close_filter_dropdowns()
@rx.event
def apply_country_filter(self):
"""Apply the temporary country filter to the main selection."""
self.selected_countries = self.temp_selected_countries.copy()
self.current_page = 1
self.close_filter_dropdowns()
@rx.event
def apply_costs_filter(self):
new_min_cost = None
new_max_cost = None
try:
if self.temp_min_cost_str:
new_min_cost = float(self.temp_min_cost_str)
except ValueError:
pass
try:
if self.temp_max_cost_str:
new_max_cost = float(self.temp_max_cost_str)
except ValueError:
pass
|
self.show_costs_filter = False
self.current_page = 1
@rx.event
def reset_status_filter(self):
"""Reset the status filter."""
self.temp_selected_statuses = set()
@rx.event
def reset_country_filter(self):
"""Reset the country filter."""
self.temp_selected_countries = set()
@rx.event
def reset_costs_filter(self):
self.temp_min_cost_str = ""
self.temp_max_cost_str = ""
self.min_cost = None
self.max_cost = None
self.show_costs_filter = False
self.current_page = 1
@rx.event
def reset_all_filters(self):
"""Reset all active filters and search."""
self.search_owner = ""
self.selected_statuses = set()
self.selected_countries = set()
self.min_cost = None
self.max_cost = None
self.temp_selected_statuses = set()
self.temp_selected_countries = set()
self.temp_min_cost_str = ""
self.temp_max | if (
new_min_cost is not None
and new_max_cost is not None
and (new_min_cost > new_max_cost)
):
self.min_cost = new_max_cost
self.max_cost = new_min_cost
else:
self.min_cost = new_min_cost
self.max_cost = new_max_cost |
the main selection."""
self.selected_statuses = self.temp_selected_statuses.copy()
self.current_page = 1
self.close_filter_dropdowns()
@rx.event
def apply_country_filter(self):
"""Apply the temporary country filter to the main selection."""
self.selected_countries = self.temp_selected_countries.copy()
self.current_page = 1
self.close_filter_dropdowns()
@rx.event
def apply_costs_filter(self):
new_min_cost = None
new_max_cost = None
try:
if self.temp_min_cost_str:
new_min_cost = float(self.temp_min_cost_str)
except ValueError:
pass
try:
if self.temp_max_cost_str:
new_max_cost = float(self.temp_max_cost_str)
except ValueError:
pass
if (
new_min_cost is not None
and new_max_cost is not None
and (new_min_cost > new_max_cost)
):
|
self.max_cost = new_min_cost
else:
self.min_cost = new_min_cost
self.max_cost = new_max_cost
self.show_costs_filter = False
self.current_page = 1
@rx.event
def reset_status_filter(self):
"""Reset the status filter."""
self.temp_selected_statuses = set()
@rx.event
def reset_country_filter(self):
"""Reset the country filter."""
self.temp_selected_countries = set()
@rx.event
def reset_costs_filter(self):
self.temp_min_cost_str = ""
self.temp_max_cost_str = ""
self.min_cost = None
self.max_cost = None
self.show_costs_filter = False
self.current_page = 1
@rx.event
def reset_all_filters(self):
"""Reset all active filters and search."""
self.search_owner = ""
self.selected_statuses = set()
self.selected_countries = set()
self.min_cost = None
self.max_cost = None
s | self.min_cost = new_max_cost |
cted_statuses = self.temp_selected_statuses.copy()
self.current_page = 1
self.close_filter_dropdowns()
@rx.event
def apply_country_filter(self):
"""Apply the temporary country filter to the main selection."""
self.selected_countries = self.temp_selected_countries.copy()
self.current_page = 1
self.close_filter_dropdowns()
@rx.event
def apply_costs_filter(self):
new_min_cost = None
new_max_cost = None
try:
if self.temp_min_cost_str:
new_min_cost = float(self.temp_min_cost_str)
except ValueError:
pass
try:
if self.temp_max_cost_str:
new_max_cost = float(self.temp_max_cost_str)
except ValueError:
pass
if (
new_min_cost is not None
and new_max_cost is not None
and (new_min_cost > new_max_cost)
):
self.min_cost = new_max_cost
|
else:
self.min_cost = new_min_cost
self.max_cost = new_max_cost
self.show_costs_filter = False
self.current_page = 1
@rx.event
def reset_status_filter(self):
"""Reset the status filter."""
self.temp_selected_statuses = set()
@rx.event
def reset_country_filter(self):
"""Reset the country filter."""
self.temp_selected_countries = set()
@rx.event
def reset_costs_filter(self):
self.temp_min_cost_str = ""
self.temp_max_cost_str = ""
self.min_cost = None
self.max_cost = None
self.show_costs_filter = False
self.current_page = 1
@rx.event
def reset_all_filters(self):
"""Reset all active filters and search."""
self.search_owner = ""
self.selected_statuses = set()
self.selected_countries = set()
self.min_cost = None
self.max_cost = None
self.temp_selected_statuses = set()
| self.max_cost = new_min_cost |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.