instruction stringlengths 0 1k | input stringlengths 1 1k | output stringlengths 10 6.51k |
|---|---|---|
import json
import re
from typing import (
List,
Optional,
Tuple,
TypedDict,
)
import reflex as rx
_COLOR_CYCLE: List[Tuple[str, str]] = [
("bg-blue-500", "text-white"),
("bg-green-600", "text-white"),
("bg-red-500", "text-white"),
("bg-orange-500", "text-white"),
("bg-purple-500", "text-white"),
("bg-pink-500", "text-white"),
("bg-yellow-400", "text-black"),
("bg-teal-500", "text-white"),
("bg-cyan-500", "text-white"),
("bg-gray-600", "text-white"),
("bg-fuchsia-600", "text-white"),
("bg-lime-400", "text-black"),
("bg-rose-600", "text-white"),
("bg-amber-500", "text-black"),
("bg-indigo-700", "text-white"),
("bg-emerald-700", "text-white"),
("bg-sky-500", "text-white"),
]
class EntityInfo(TypedDict):
name: str
color: str
text_color: str
keywords: List[str]
|
class NerState(rx.State):
"""State for the Named Entity Recognition display."""
_raw_text: str = 'Sia Kate Isobelle Furler (/\'siːə/ SEE-ə; born 18 December 1975) is an Australian singer, songwriter, record producer and music video director.[1] She started her career as a singer in the acid jazz band Crisp in the mid-1990s in Adelaide. In 1997, when Crisp disbanded, she released her debut studio album titled OnlySee in Australia. She moved to London, England, and provided lead vocals for the British duo Zero 7. In 2000, Sia released her second studio album, Healing Is Difficult, on the Columbia label the following year, and her third studio album, Colour the Small One, in 2004, but all of these struggled to connect with a mainstream audience. Sia relocated to New York City in 2005 and toured in the United States. Her fourth and fifth studio albums, Some People Have Real Problems and We Are Born, were released in 2008 and 2010, respectively. Each was certified gold by the Au | class Segment(TypedDict):
id: int
text: str
label_name: str
bg_color: Optional[str]
text_color: Optional[str] |
Kate Isobelle Furler",
"Sia",
"David Guetta",
"Rihanna",
"Flo Rida",
],
},
{
"name": "COUNTRY",
"color": "bg-green-600",
"text_color": "text-white",
"keywords": [
"Australian",
"Australia",
"England",
"United States",
],
},
{
"name": "CITY",
"color": "bg-red-500",
"text_color": "text-white",
"keywords": [
"Adelaide",
"London",
"New York City",
],
},
]
display_segments: List[Segment] = []
new_label_name: str = ""
new_label_keywords_str: str = ""
selected_label_name: Optional[str] = None
available_colors: List[Tuple[str, str]] = _COLOR_CYCLE
new_label_selected_color_index: int = 0
_segment_id_counter: int = 0
|
def _reset_segment_ids(self):
self._segment_id_counter = 0
@rx.event
def process_text_on_load(self):
"""Processes the raw text to identify and segment entities based on current labels."""
self._reset_segment_ids()
initial_parts = re.split("(\\s+|\\b)", self._raw_text)
initial_segments: List[Segment] = [
{
"id": self._get_next_segment_id(),
"text": part,
"label_name": None,
"bg_color": None,
"text_color": None,
}
for part in initial_parts
if part
]
for entity in self.entities:
for keyword in entity["keywords"]:
keyword_segments = re.split("(\\s+|\\b)", keyword)
keyword_words = [kw for kw in keyword_segments if kw and kw.strip()]
if not keyword_words:
continue
i = 0
while i <= len( | def _get_next_segment_id(self) -> int:
self._segment_id_counter += 1
return self._segment_id_counter |
Flo Rida",
],
},
{
"name": "COUNTRY",
"color": "bg-green-600",
"text_color": "text-white",
"keywords": [
"Australian",
"Australia",
"England",
"United States",
],
},
{
"name": "CITY",
"color": "bg-red-500",
"text_color": "text-white",
"keywords": [
"Adelaide",
"London",
"New York City",
],
},
]
display_segments: List[Segment] = []
new_label_name: str = ""
new_label_keywords_str: str = ""
selected_label_name: Optional[str] = None
available_colors: List[Tuple[str, str]] = _COLOR_CYCLE
new_label_selected_color_index: int = 0
_segment_id_counter: int = 0
def _get_next_segment_id(self) -> int:
self._segment_id_counter += 1
return self._segment_id_counter
|
@rx.event
def process_text_on_load(self):
"""Processes the raw text to identify and segment entities based on current labels."""
self._reset_segment_ids()
initial_parts = re.split("(\\s+|\\b)", self._raw_text)
initial_segments: List[Segment] = [
{
"id": self._get_next_segment_id(),
"text": part,
"label_name": None,
"bg_color": None,
"text_color": None,
}
for part in initial_parts
if part
]
for entity in self.entities:
for keyword in entity["keywords"]:
keyword_segments = re.split("(\\s+|\\b)", keyword)
keyword_words = [kw for kw in keyword_segments if kw and kw.strip()]
if not keyword_words:
continue
i = 0
while i <= len(initial_segments) - len(keyword_words):
match = True | def _reset_segment_ids(self):
self._segment_id_counter = 0 |
{
"name": "COUNTRY",
"color": "bg-green-600",
"text_color": "text-white",
"keywords": [
"Australian",
"Australia",
"England",
"United States",
],
},
{
"name": "CITY",
"color": "bg-red-500",
"text_color": "text-white",
"keywords": [
"Adelaide",
"London",
"New York City",
],
},
]
display_segments: List[Segment] = []
new_label_name: str = ""
new_label_keywords_str: str = ""
selected_label_name: Optional[str] = None
available_colors: List[Tuple[str, str]] = _COLOR_CYCLE
new_label_selected_color_index: int = 0
_segment_id_counter: int = 0
def _get_next_segment_id(self) -> int:
self._segment_id_counter += 1
return self._segment_id_counter
def _reset_segment_ids(self):
|
@rx.event
def process_text_on_load(self):
"""Processes the raw text to identify and segment entities based on current labels."""
self._reset_segment_ids()
initial_parts = re.split("(\\s+|\\b)", self._raw_text)
initial_segments: List[Segment] = [
{
"id": self._get_next_segment_id(),
"text": part,
"label_name": None,
"bg_color": None,
"text_color": None,
}
for part in initial_parts
if part
]
for entity in self.entities:
for keyword in entity["keywords"]:
keyword_segments = re.split("(\\s+|\\b)", keyword)
keyword_words = [kw for kw in keyword_segments if kw and kw.strip()]
if not keyword_words:
continue
i = 0
while i <= len(initial_segments) - len(keyword_words):
match = True | self._segment_id_counter = 0 |
"England",
"United States",
],
},
{
"name": "CITY",
"color": "bg-red-500",
"text_color": "text-white",
"keywords": [
"Adelaide",
"London",
"New York City",
],
},
]
display_segments: List[Segment] = []
new_label_name: str = ""
new_label_keywords_str: str = ""
selected_label_name: Optional[str] = None
available_colors: List[Tuple[str, str]] = _COLOR_CYCLE
new_label_selected_color_index: int = 0
_segment_id_counter: int = 0
def _get_next_segment_id(self) -> int:
self._segment_id_counter += 1
return self._segment_id_counter
def _reset_segment_ids(self):
self._segment_id_counter = 0
@rx.event
def process_text_on_load(self):
"""Processes the raw text to identify and segment entities based on current labels."""
self._reset_segment_ids()
|
initial_segments: List[Segment] = [
{
"id": self._get_next_segment_id(),
"text": part,
"label_name": None,
"bg_color": None,
"text_color": None,
}
for part in initial_parts
if part
]
for entity in self.entities:
for keyword in entity["keywords"]:
keyword_segments = re.split("(\\s+|\\b)", keyword)
keyword_words = [kw for kw in keyword_segments if kw and kw.strip()]
if not keyword_words:
continue
i = 0
while i <= len(initial_segments) - len(keyword_words):
match = True
temp_indices = []
current_kw_idx = 0
current_seg_idx = i
while current_kw_idx < len(keyword_words):
while current_seg_idx < len(initial_se | initial_parts = re.split("(\\s+|\\b)", self._raw_text) |
available_colors: List[Tuple[str, str]] = _COLOR_CYCLE
new_label_selected_color_index: int = 0
_segment_id_counter: int = 0
def _get_next_segment_id(self) -> int:
self._segment_id_counter += 1
return self._segment_id_counter
def _reset_segment_ids(self):
self._segment_id_counter = 0
@rx.event
def process_text_on_load(self):
"""Processes the raw text to identify and segment entities based on current labels."""
self._reset_segment_ids()
initial_parts = re.split("(\\s+|\\b)", self._raw_text)
initial_segments: List[Segment] = [
{
"id": self._get_next_segment_id(),
"text": part,
"label_name": None,
"bg_color": None,
"text_color": None,
}
for part in initial_parts
if part
]
for entity in self.entities:
for keyword in entity["keywords"]:
|
keyword_words = [kw for kw in keyword_segments if kw and kw.strip()]
if not keyword_words:
continue
i = 0
while i <= len(initial_segments) - len(keyword_words):
match = True
temp_indices = []
current_kw_idx = 0
current_seg_idx = i
while current_kw_idx < len(keyword_words):
while current_seg_idx < len(initial_segments) and (
not initial_segments[current_seg_idx]["text"].strip()
):
current_seg_idx += 1
if current_seg_idx >= len(initial_segments):
match = False
break
if (
initial_segments[current_seg_idx]["text"]
!= keyword_words[current_kw_idx]
| keyword_segments = re.split("(\\s+|\\b)", keyword) |
abel_selected_color_index: int = 0
_segment_id_counter: int = 0
def _get_next_segment_id(self) -> int:
self._segment_id_counter += 1
return self._segment_id_counter
def _reset_segment_ids(self):
self._segment_id_counter = 0
@rx.event
def process_text_on_load(self):
"""Processes the raw text to identify and segment entities based on current labels."""
self._reset_segment_ids()
initial_parts = re.split("(\\s+|\\b)", self._raw_text)
initial_segments: List[Segment] = [
{
"id": self._get_next_segment_id(),
"text": part,
"label_name": None,
"bg_color": None,
"text_color": None,
}
for part in initial_parts
if part
]
for entity in self.entities:
for keyword in entity["keywords"]:
keyword_segments = re.split("(\\s+|\\b)", keyword)
|
if not keyword_words:
continue
i = 0
while i <= len(initial_segments) - len(keyword_words):
match = True
temp_indices = []
current_kw_idx = 0
current_seg_idx = i
while current_kw_idx < len(keyword_words):
while current_seg_idx < len(initial_segments) and (
not initial_segments[current_seg_idx]["text"].strip()
):
current_seg_idx += 1
if current_seg_idx >= len(initial_segments):
match = False
break
if (
initial_segments[current_seg_idx]["text"]
!= keyword_words[current_kw_idx]
):
match = False
| keyword_words = [kw for kw in keyword_segments if kw and kw.strip()] |
t_segment_id(self) -> int:
self._segment_id_counter += 1
return self._segment_id_counter
def _reset_segment_ids(self):
self._segment_id_counter = 0
@rx.event
def process_text_on_load(self):
"""Processes the raw text to identify and segment entities based on current labels."""
self._reset_segment_ids()
initial_parts = re.split("(\\s+|\\b)", self._raw_text)
initial_segments: List[Segment] = [
{
"id": self._get_next_segment_id(),
"text": part,
"label_name": None,
"bg_color": None,
"text_color": None,
}
for part in initial_parts
if part
]
for entity in self.entities:
for keyword in entity["keywords"]:
keyword_segments = re.split("(\\s+|\\b)", keyword)
keyword_words = [kw for kw in keyword_segments if kw and kw.strip()]
|
i = 0
while i <= len(initial_segments) - len(keyword_words):
match = True
temp_indices = []
current_kw_idx = 0
current_seg_idx = i
while current_kw_idx < len(keyword_words):
while current_seg_idx < len(initial_segments) and (
not initial_segments[current_seg_idx]["text"].strip()
):
current_seg_idx += 1
if current_seg_idx >= len(initial_segments):
match = False
break
if (
initial_segments[current_seg_idx]["text"]
!= keyword_words[current_kw_idx]
):
match = False
break
temp_indices.append(current | if not keyword_words:
continue |
_counter = 0
@rx.event
def process_text_on_load(self):
"""Processes the raw text to identify and segment entities based on current labels."""
self._reset_segment_ids()
initial_parts = re.split("(\\s+|\\b)", self._raw_text)
initial_segments: List[Segment] = [
{
"id": self._get_next_segment_id(),
"text": part,
"label_name": None,
"bg_color": None,
"text_color": None,
}
for part in initial_parts
if part
]
for entity in self.entities:
for keyword in entity["keywords"]:
keyword_segments = re.split("(\\s+|\\b)", keyword)
keyword_words = [kw for kw in keyword_segments if kw and kw.strip()]
if not keyword_words:
continue
i = 0
while i <= len(initial_segments) - len(keyword_words):
|
temp_indices = []
current_kw_idx = 0
current_seg_idx = i
while current_kw_idx < len(keyword_words):
while current_seg_idx < len(initial_segments) and (
not initial_segments[current_seg_idx]["text"].strip()
):
current_seg_idx += 1
if current_seg_idx >= len(initial_segments):
match = False
break
if (
initial_segments[current_seg_idx]["text"]
!= keyword_words[current_kw_idx]
):
match = False
break
temp_indices.append(current_seg_idx)
current_kw_idx += 1
current_seg_idx += 1
if matc | match = True |
ef process_text_on_load(self):
"""Processes the raw text to identify and segment entities based on current labels."""
self._reset_segment_ids()
initial_parts = re.split("(\\s+|\\b)", self._raw_text)
initial_segments: List[Segment] = [
{
"id": self._get_next_segment_id(),
"text": part,
"label_name": None,
"bg_color": None,
"text_color": None,
}
for part in initial_parts
if part
]
for entity in self.entities:
for keyword in entity["keywords"]:
keyword_segments = re.split("(\\s+|\\b)", keyword)
keyword_words = [kw for kw in keyword_segments if kw and kw.strip()]
if not keyword_words:
continue
i = 0
while i <= len(initial_segments) - len(keyword_words):
match = True
|
current_kw_idx = 0
current_seg_idx = i
while current_kw_idx < len(keyword_words):
while current_seg_idx < len(initial_segments) and (
not initial_segments[current_seg_idx]["text"].strip()
):
current_seg_idx += 1
if current_seg_idx >= len(initial_segments):
match = False
break
if (
initial_segments[current_seg_idx]["text"]
!= keyword_words[current_kw_idx]
):
match = False
break
temp_indices.append(current_seg_idx)
current_kw_idx += 1
current_seg_idx += 1
if match:
applied_lab | temp_indices = [] |
"""Processes the raw text to identify and segment entities based on current labels."""
self._reset_segment_ids()
initial_parts = re.split("(\\s+|\\b)", self._raw_text)
initial_segments: List[Segment] = [
{
"id": self._get_next_segment_id(),
"text": part,
"label_name": None,
"bg_color": None,
"text_color": None,
}
for part in initial_parts
if part
]
for entity in self.entities:
for keyword in entity["keywords"]:
keyword_segments = re.split("(\\s+|\\b)", keyword)
keyword_words = [kw for kw in keyword_segments if kw and kw.strip()]
if not keyword_words:
continue
i = 0
while i <= len(initial_segments) - len(keyword_words):
match = True
temp_indices = []
|
current_seg_idx = i
while current_kw_idx < len(keyword_words):
while current_seg_idx < len(initial_segments) and (
not initial_segments[current_seg_idx]["text"].strip()
):
current_seg_idx += 1
if current_seg_idx >= len(initial_segments):
match = False
break
if (
initial_segments[current_seg_idx]["text"]
!= keyword_words[current_kw_idx]
):
match = False
break
temp_indices.append(current_seg_idx)
current_kw_idx += 1
current_seg_idx += 1
if match:
applied_label = False
can_ | current_kw_idx = 0 |
and segment entities based on current labels."""
self._reset_segment_ids()
initial_parts = re.split("(\\s+|\\b)", self._raw_text)
initial_segments: List[Segment] = [
{
"id": self._get_next_segment_id(),
"text": part,
"label_name": None,
"bg_color": None,
"text_color": None,
}
for part in initial_parts
if part
]
for entity in self.entities:
for keyword in entity["keywords"]:
keyword_segments = re.split("(\\s+|\\b)", keyword)
keyword_words = [kw for kw in keyword_segments if kw and kw.strip()]
if not keyword_words:
continue
i = 0
while i <= len(initial_segments) - len(keyword_words):
match = True
temp_indices = []
current_kw_idx = 0
|
while current_kw_idx < len(keyword_words):
while current_seg_idx < len(initial_segments) and (
not initial_segments[current_seg_idx]["text"].strip()
):
current_seg_idx += 1
if current_seg_idx >= len(initial_segments):
match = False
break
if (
initial_segments[current_seg_idx]["text"]
!= keyword_words[current_kw_idx]
):
match = False
break
temp_indices.append(current_seg_idx)
current_kw_idx += 1
current_seg_idx += 1
if match:
applied_label = False
can_apply = all(
| current_seg_idx = i |
bels."""
self._reset_segment_ids()
initial_parts = re.split("(\\s+|\\b)", self._raw_text)
initial_segments: List[Segment] = [
{
"id": self._get_next_segment_id(),
"text": part,
"label_name": None,
"bg_color": None,
"text_color": None,
}
for part in initial_parts
if part
]
for entity in self.entities:
for keyword in entity["keywords"]:
keyword_segments = re.split("(\\s+|\\b)", keyword)
keyword_words = [kw for kw in keyword_segments if kw and kw.strip()]
if not keyword_words:
continue
i = 0
while i <= len(initial_segments) - len(keyword_words):
match = True
temp_indices = []
current_kw_idx = 0
current_seg_idx = i
|
if match:
applied_label = False
can_apply = all(
(
initial_segments[idx]["label_name"] is None
for idx in temp_indices
)
)
if can_apply:
for idx in temp_indices:
initial_segments[idx]["label_name"] = entity["name"]
initial_segments[idx]["bg_color"] = entity["color"]
initial_segments[idx]["text_color"] = entity[
"text_color"
]
applied_label = True
if applied_label:
i = temp_indices[-1] + 1
else:
next_word_idx = i + 1
| while current_kw_idx < len(keyword_words):
while current_seg_idx < len(initial_segments) and (
not initial_segments[current_seg_idx]["text"].strip()
):
current_seg_idx += 1
if current_seg_idx >= len(initial_segments):
match = False
break
if (
initial_segments[current_seg_idx]["text"]
!= keyword_words[current_kw_idx]
):
match = False
break
temp_indices.append(current_seg_idx)
current_kw_idx += 1
current_seg_idx += 1 |
re.split("(\\s+|\\b)", self._raw_text)
initial_segments: List[Segment] = [
{
"id": self._get_next_segment_id(),
"text": part,
"label_name": None,
"bg_color": None,
"text_color": None,
}
for part in initial_parts
if part
]
for entity in self.entities:
for keyword in entity["keywords"]:
keyword_segments = re.split("(\\s+|\\b)", keyword)
keyword_words = [kw for kw in keyword_segments if kw and kw.strip()]
if not keyword_words:
continue
i = 0
while i <= len(initial_segments) - len(keyword_words):
match = True
temp_indices = []
current_kw_idx = 0
current_seg_idx = i
while current_kw_idx < len(keyword_words):
|
if current_seg_idx >= len(initial_segments):
match = False
break
if (
initial_segments[current_seg_idx]["text"]
!= keyword_words[current_kw_idx]
):
match = False
break
temp_indices.append(current_seg_idx)
current_kw_idx += 1
current_seg_idx += 1
if match:
applied_label = False
can_apply = all(
(
initial_segments[idx]["label_name"] is None
for idx in temp_indices
)
)
if can_apply:
for idx in temp_indices:
| while current_seg_idx < len(initial_segments) and (
not initial_segments[current_seg_idx]["text"].strip()
):
current_seg_idx += 1 |
color": None,
"text_color": None,
}
for part in initial_parts
if part
]
for entity in self.entities:
for keyword in entity["keywords"]:
keyword_segments = re.split("(\\s+|\\b)", keyword)
keyword_words = [kw for kw in keyword_segments if kw and kw.strip()]
if not keyword_words:
continue
i = 0
while i <= len(initial_segments) - len(keyword_words):
match = True
temp_indices = []
current_kw_idx = 0
current_seg_idx = i
while current_kw_idx < len(keyword_words):
while current_seg_idx < len(initial_segments) and (
not initial_segments[current_seg_idx]["text"].strip()
):
current_seg_idx += 1
|
if (
initial_segments[current_seg_idx]["text"]
!= keyword_words[current_kw_idx]
):
match = False
break
temp_indices.append(current_seg_idx)
current_kw_idx += 1
current_seg_idx += 1
if match:
applied_label = False
can_apply = all(
(
initial_segments[idx]["label_name"] is None
for idx in temp_indices
)
)
if can_apply:
for idx in temp_indices:
initial_segments[idx]["label_name"] = entity["name"]
initial_segments[idx]["bg_color"] = entity[ | if current_seg_idx >= len(initial_segments):
match = False
break |
for part in initial_parts
if part
]
for entity in self.entities:
for keyword in entity["keywords"]:
keyword_segments = re.split("(\\s+|\\b)", keyword)
keyword_words = [kw for kw in keyword_segments if kw and kw.strip()]
if not keyword_words:
continue
i = 0
while i <= len(initial_segments) - len(keyword_words):
match = True
temp_indices = []
current_kw_idx = 0
current_seg_idx = i
while current_kw_idx < len(keyword_words):
while current_seg_idx < len(initial_segments) and (
not initial_segments[current_seg_idx]["text"].strip()
):
current_seg_idx += 1
if current_seg_idx >= len(initial_segments):
|
break
if (
initial_segments[current_seg_idx]["text"]
!= keyword_words[current_kw_idx]
):
match = False
break
temp_indices.append(current_seg_idx)
current_kw_idx += 1
current_seg_idx += 1
if match:
applied_label = False
can_apply = all(
(
initial_segments[idx]["label_name"] is None
for idx in temp_indices
)
)
if can_apply:
for idx in temp_indices:
initial_segments[idx]["label_name"] = entity["name"]
initial_s | match = False |
entity in self.entities:
for keyword in entity["keywords"]:
keyword_segments = re.split("(\\s+|\\b)", keyword)
keyword_words = [kw for kw in keyword_segments if kw and kw.strip()]
if not keyword_words:
continue
i = 0
while i <= len(initial_segments) - len(keyword_words):
match = True
temp_indices = []
current_kw_idx = 0
current_seg_idx = i
while current_kw_idx < len(keyword_words):
while current_seg_idx < len(initial_segments) and (
not initial_segments[current_seg_idx]["text"].strip()
):
current_seg_idx += 1
if current_seg_idx >= len(initial_segments):
match = False
break
|
temp_indices.append(current_seg_idx)
current_kw_idx += 1
current_seg_idx += 1
if match:
applied_label = False
can_apply = all(
(
initial_segments[idx]["label_name"] is None
for idx in temp_indices
)
)
if can_apply:
for idx in temp_indices:
initial_segments[idx]["label_name"] = entity["name"]
initial_segments[idx]["bg_color"] = entity["color"]
initial_segments[idx]["text_color"] = entity[
"text_color"
]
applied_label = True
if applied_label:
| if (
initial_segments[current_seg_idx]["text"]
!= keyword_words[current_kw_idx]
):
match = False
break |
d_segments if kw and kw.strip()]
if not keyword_words:
continue
i = 0
while i <= len(initial_segments) - len(keyword_words):
match = True
temp_indices = []
current_kw_idx = 0
current_seg_idx = i
while current_kw_idx < len(keyword_words):
while current_seg_idx < len(initial_segments) and (
not initial_segments[current_seg_idx]["text"].strip()
):
current_seg_idx += 1
if current_seg_idx >= len(initial_segments):
match = False
break
if (
initial_segments[current_seg_idx]["text"]
!= keyword_words[current_kw_idx]
):
|
break
temp_indices.append(current_seg_idx)
current_kw_idx += 1
current_seg_idx += 1
if match:
applied_label = False
can_apply = all(
(
initial_segments[idx]["label_name"] is None
for idx in temp_indices
)
)
if can_apply:
for idx in temp_indices:
initial_segments[idx]["label_name"] = entity["name"]
initial_segments[idx]["bg_color"] = entity["color"]
initial_segments[idx]["text_color"] = entity[
"text_color"
]
applied_label = True
| match = False |
ndices = []
current_kw_idx = 0
current_seg_idx = i
while current_kw_idx < len(keyword_words):
while current_seg_idx < len(initial_segments) and (
not initial_segments[current_seg_idx]["text"].strip()
):
current_seg_idx += 1
if current_seg_idx >= len(initial_segments):
match = False
break
if (
initial_segments[current_seg_idx]["text"]
!= keyword_words[current_kw_idx]
):
match = False
break
temp_indices.append(current_seg_idx)
current_kw_idx += 1
current_seg_idx += 1
if match:
|
can_apply = all(
(
initial_segments[idx]["label_name"] is None
for idx in temp_indices
)
)
if can_apply:
for idx in temp_indices:
initial_segments[idx]["label_name"] = entity["name"]
initial_segments[idx]["bg_color"] = entity["color"]
initial_segments[idx]["text_color"] = entity[
"text_color"
]
applied_label = True
if applied_label:
i = temp_indices[-1] + 1
else:
next_word_idx = i + 1
while next_word_idx < len(initial_segments) and (
| applied_label = False |
= 0
current_seg_idx = i
while current_kw_idx < len(keyword_words):
while current_seg_idx < len(initial_segments) and (
not initial_segments[current_seg_idx]["text"].strip()
):
current_seg_idx += 1
if current_seg_idx >= len(initial_segments):
match = False
break
if (
initial_segments[current_seg_idx]["text"]
!= keyword_words[current_kw_idx]
):
match = False
break
temp_indices.append(current_seg_idx)
current_kw_idx += 1
current_seg_idx += 1
if match:
applied_label = False
|
if can_apply:
for idx in temp_indices:
initial_segments[idx]["label_name"] = entity["name"]
initial_segments[idx]["bg_color"] = entity["color"]
initial_segments[idx]["text_color"] = entity[
"text_color"
]
applied_label = True
if applied_label:
i = temp_indices[-1] + 1
else:
next_word_idx = i + 1
while next_word_idx < len(initial_segments) and (
not initial_segments[next_word_idx]["text"].strip()
):
next_word_idx += 1
i = next_word_idx
else:
next_word_idx | can_apply = all(
(
initial_segments[idx]["label_name"] is None
for idx in temp_indices
)
) |
trip()
):
current_seg_idx += 1
if current_seg_idx >= len(initial_segments):
match = False
break
if (
initial_segments[current_seg_idx]["text"]
!= keyword_words[current_kw_idx]
):
match = False
break
temp_indices.append(current_seg_idx)
current_kw_idx += 1
current_seg_idx += 1
if match:
applied_label = False
can_apply = all(
(
initial_segments[idx]["label_name"] is None
for idx in temp_indices
)
)
|
if applied_label:
i = temp_indices[-1] + 1
else:
next_word_idx = i + 1
while next_word_idx < len(initial_segments) and (
not initial_segments[next_word_idx]["text"].strip()
):
next_word_idx += 1
i = next_word_idx
else:
next_word_idx = i + 1
while next_word_idx < len(initial_segments) and (
not initial_segments[next_word_idx]["text"].strip()
):
next_word_idx += 1
i = next_word_idx
self.display_segments = initial_segments
self.selected_label_name = None
@rx.event
def select_label(self, label_name: Optional[str]):
"""Selects a label to app | if can_apply:
for idx in temp_indices:
initial_segments[idx]["label_name"] = entity["name"]
initial_segments[idx]["bg_color"] = entity["color"]
initial_segments[idx]["text_color"] = entity[
"text_color"
]
applied_label = True |
current_seg_idx += 1
if current_seg_idx >= len(initial_segments):
match = False
break
if (
initial_segments[current_seg_idx]["text"]
!= keyword_words[current_kw_idx]
):
match = False
break
temp_indices.append(current_seg_idx)
current_kw_idx += 1
current_seg_idx += 1
if match:
applied_label = False
can_apply = all(
(
initial_segments[idx]["label_name"] is None
for idx in temp_indices
)
)
if can_apply:
|
applied_label = True
if applied_label:
i = temp_indices[-1] + 1
else:
next_word_idx = i + 1
while next_word_idx < len(initial_segments) and (
not initial_segments[next_word_idx]["text"].strip()
):
next_word_idx += 1
i = next_word_idx
else:
next_word_idx = i + 1
while next_word_idx < len(initial_segments) and (
not initial_segments[next_word_idx]["text"].strip()
):
next_word_idx += 1
i = next_word_idx
self.display_segments = initial_segments
self.selected_label_name = None
@rx.event
def select_label(self, label_name: | for idx in temp_indices:
initial_segments[idx]["label_name"] = entity["name"]
initial_segments[idx]["bg_color"] = entity["color"]
initial_segments[idx]["text_color"] = entity[
"text_color"
] |
if current_seg_idx >= len(initial_segments):
match = False
break
if (
initial_segments[current_seg_idx]["text"]
!= keyword_words[current_kw_idx]
):
match = False
break
temp_indices.append(current_seg_idx)
current_kw_idx += 1
current_seg_idx += 1
if match:
applied_label = False
can_apply = all(
(
initial_segments[idx]["label_name"] is None
for idx in temp_indices
)
)
if can_apply:
for idx in temp_indices:
|
initial_segments[idx]["bg_color"] = entity["color"]
initial_segments[idx]["text_color"] = entity[
"text_color"
]
applied_label = True
if applied_label:
i = temp_indices[-1] + 1
else:
next_word_idx = i + 1
while next_word_idx < len(initial_segments) and (
not initial_segments[next_word_idx]["text"].strip()
):
next_word_idx += 1
i = next_word_idx
else:
next_word_idx = i + 1
while next_word_idx < len(initial_segments) and (
not initial_segments[next_word_idx]["text"].strip()
| initial_segments[idx]["label_name"] = entity["name"] |
initial_segments[current_seg_idx]["text"]
!= keyword_words[current_kw_idx]
):
match = False
break
temp_indices.append(current_seg_idx)
current_kw_idx += 1
current_seg_idx += 1
if match:
applied_label = False
can_apply = all(
(
initial_segments[idx]["label_name"] is None
for idx in temp_indices
)
)
if can_apply:
for idx in temp_indices:
initial_segments[idx]["label_name"] = entity["name"]
initial_segments[idx]["bg_color"] = entity["color"]
|
applied_label = True
if applied_label:
i = temp_indices[-1] + 1
else:
next_word_idx = i + 1
while next_word_idx < len(initial_segments) and (
not initial_segments[next_word_idx]["text"].strip()
):
next_word_idx += 1
i = next_word_idx
else:
next_word_idx = i + 1
while next_word_idx < len(initial_segments) and (
not initial_segments[next_word_idx]["text"].strip()
):
next_word_idx += 1
i = next_word_idx
self.display_segments = initial_segments
self.selected_label_name = None
@rx.event
def select_label(self, label_name: | initial_segments[idx]["text_color"] = entity[
"text_color"
] |
match = False
break
temp_indices.append(current_seg_idx)
current_kw_idx += 1
current_seg_idx += 1
if match:
applied_label = False
can_apply = all(
(
initial_segments[idx]["label_name"] is None
for idx in temp_indices
)
)
if can_apply:
for idx in temp_indices:
initial_segments[idx]["label_name"] = entity["name"]
initial_segments[idx]["bg_color"] = entity["color"]
initial_segments[idx]["text_color"] = entity[
"text_color"
]
|
if applied_label:
i = temp_indices[-1] + 1
else:
next_word_idx = i + 1
while next_word_idx < len(initial_segments) and (
not initial_segments[next_word_idx]["text"].strip()
):
next_word_idx += 1
i = next_word_idx
else:
next_word_idx = i + 1
while next_word_idx < len(initial_segments) and (
not initial_segments[next_word_idx]["text"].strip()
):
next_word_idx += 1
i = next_word_idx
self.display_segments = initial_segments
self.selected_label_name = None
@rx.event
def select_label(self, label_name: Optional[str]):
"""Selects a label to app | applied_label = True |
break
temp_indices.append(current_seg_idx)
current_kw_idx += 1
current_seg_idx += 1
if match:
applied_label = False
can_apply = all(
(
initial_segments[idx]["label_name"] is None
for idx in temp_indices
)
)
if can_apply:
for idx in temp_indices:
initial_segments[idx]["label_name"] = entity["name"]
initial_segments[idx]["bg_color"] = entity["color"]
initial_segments[idx]["text_color"] = entity[
"text_color"
]
applied_label = True
|
else:
next_word_idx = i + 1
while next_word_idx < len(initial_segments) and (
not initial_segments[next_word_idx]["text"].strip()
):
next_word_idx += 1
i = next_word_idx
self.display_segments = initial_segments
self.selected_label_name = None
@rx.event
def select_label(self, label_name: Optional[str]):
"""Selects a label to apply or deselects if the same label is clicked again."""
if self.selected_label_name == label_name:
self.selected_label_name = None
else:
self.selected_label_name = label_name
@rx.event
def apply_label(self, segment_id: int):
"""Applies the selected label to the clicked segment or removes it."""
if self.selected_label_name is None:
return rx.toast("Select a label first!", duration=2000)
| if applied_label:
i = temp_indices[-1] + 1
else:
next_word_idx = i + 1
while next_word_idx < len(initial_segments) and (
not initial_segments[next_word_idx]["text"].strip()
):
next_word_idx += 1
i = next_word_idx |
emp_indices.append(current_seg_idx)
current_kw_idx += 1
current_seg_idx += 1
if match:
applied_label = False
can_apply = all(
(
initial_segments[idx]["label_name"] is None
for idx in temp_indices
)
)
if can_apply:
for idx in temp_indices:
initial_segments[idx]["label_name"] = entity["name"]
initial_segments[idx]["bg_color"] = entity["color"]
initial_segments[idx]["text_color"] = entity[
"text_color"
]
applied_label = True
if applied_label:
|
else:
next_word_idx = i + 1
while next_word_idx < len(initial_segments) and (
not initial_segments[next_word_idx]["text"].strip()
):
next_word_idx += 1
i = next_word_idx
else:
next_word_idx = i + 1
while next_word_idx < len(initial_segments) and (
not initial_segments[next_word_idx]["text"].strip()
):
next_word_idx += 1
i = next_word_idx
self.display_segments = initial_segments
self.selected_label_name = None
@rx.event
def select_label(self, label_name: Optional[str]):
"""Selects a label to apply or deselects if the same label is clicked again."""
if self.selected_label_name == l | i = temp_indices[-1] + 1 |
current_seg_idx += 1
if match:
applied_label = False
can_apply = all(
(
initial_segments[idx]["label_name"] is None
for idx in temp_indices
)
)
if can_apply:
for idx in temp_indices:
initial_segments[idx]["label_name"] = entity["name"]
initial_segments[idx]["bg_color"] = entity["color"]
initial_segments[idx]["text_color"] = entity[
"text_color"
]
applied_label = True
if applied_label:
i = temp_indices[-1] + 1
else:
|
while next_word_idx < len(initial_segments) and (
not initial_segments[next_word_idx]["text"].strip()
):
next_word_idx += 1
i = next_word_idx
else:
next_word_idx = i + 1
while next_word_idx < len(initial_segments) and (
not initial_segments[next_word_idx]["text"].strip()
):
next_word_idx += 1
i = next_word_idx
self.display_segments = initial_segments
self.selected_label_name = None
@rx.event
def select_label(self, label_name: Optional[str]):
"""Selects a label to apply or deselects if the same label is clicked again."""
if self.selected_label_name == label_name:
self.selected_label_name = None
else:
| next_word_idx = i + 1 |
if match:
applied_label = False
can_apply = all(
(
initial_segments[idx]["label_name"] is None
for idx in temp_indices
)
)
if can_apply:
for idx in temp_indices:
initial_segments[idx]["label_name"] = entity["name"]
initial_segments[idx]["bg_color"] = entity["color"]
initial_segments[idx]["text_color"] = entity[
"text_color"
]
applied_label = True
if applied_label:
i = temp_indices[-1] + 1
else:
next_word_idx = i + 1
|
i = next_word_idx
else:
next_word_idx = i + 1
while next_word_idx < len(initial_segments) and (
not initial_segments[next_word_idx]["text"].strip()
):
next_word_idx += 1
i = next_word_idx
self.display_segments = initial_segments
self.selected_label_name = None
@rx.event
def select_label(self, label_name: Optional[str]):
"""Selects a label to apply or deselects if the same label is clicked again."""
if self.selected_label_name == label_name:
self.selected_label_name = None
else:
self.selected_label_name = label_name
@rx.event
def apply_label(self, segment_id: int):
"""Applies the selected label to the clicked segment or removes it."""
if self.selected_label_name is None:
return rx. | while next_word_idx < len(initial_segments) and (
not initial_segments[next_word_idx]["text"].strip()
):
next_word_idx += 1 |
for idx in temp_indices
)
)
if can_apply:
for idx in temp_indices:
initial_segments[idx]["label_name"] = entity["name"]
initial_segments[idx]["bg_color"] = entity["color"]
initial_segments[idx]["text_color"] = entity[
"text_color"
]
applied_label = True
if applied_label:
i = temp_indices[-1] + 1
else:
next_word_idx = i + 1
while next_word_idx < len(initial_segments) and (
not initial_segments[next_word_idx]["text"].strip()
):
next_word_idx += 1
|
else:
next_word_idx = i + 1
while next_word_idx < len(initial_segments) and (
not initial_segments[next_word_idx]["text"].strip()
):
next_word_idx += 1
i = next_word_idx
self.display_segments = initial_segments
self.selected_label_name = None
@rx.event
def select_label(self, label_name: Optional[str]):
"""Selects a label to apply or deselects if the same label is clicked again."""
if self.selected_label_name == label_name:
self.selected_label_name = None
else:
self.selected_label_name = label_name
@rx.event
def apply_label(self, segment_id: int):
"""Applies the selected label to the clicked segment or removes it."""
if self.selected_label_name is None:
return rx.toast("Select a label first!", duration=2000)
| i = next_word_idx |
)
if can_apply:
for idx in temp_indices:
initial_segments[idx]["label_name"] = entity["name"]
initial_segments[idx]["bg_color"] = entity["color"]
initial_segments[idx]["text_color"] = entity[
"text_color"
]
applied_label = True
if applied_label:
i = temp_indices[-1] + 1
else:
next_word_idx = i + 1
while next_word_idx < len(initial_segments) and (
not initial_segments[next_word_idx]["text"].strip()
):
next_word_idx += 1
i = next_word_idx
else:
|
while next_word_idx < len(initial_segments) and (
not initial_segments[next_word_idx]["text"].strip()
):
next_word_idx += 1
i = next_word_idx
self.display_segments = initial_segments
self.selected_label_name = None
@rx.event
def select_label(self, label_name: Optional[str]):
"""Selects a label to apply or deselects if the same label is clicked again."""
if self.selected_label_name == label_name:
self.selected_label_name = None
else:
self.selected_label_name = label_name
@rx.event
def apply_label(self, segment_id: int):
"""Applies the selected label to the clicked segment or removes it."""
if self.selected_label_name is None:
return rx.toast("Select a label first!", duration=2000)
target_segment_index = -1
for i, seg in enumerate(self.d | next_word_idx = i + 1 |
apply:
for idx in temp_indices:
initial_segments[idx]["label_name"] = entity["name"]
initial_segments[idx]["bg_color"] = entity["color"]
initial_segments[idx]["text_color"] = entity[
"text_color"
]
applied_label = True
if applied_label:
i = temp_indices[-1] + 1
else:
next_word_idx = i + 1
while next_word_idx < len(initial_segments) and (
not initial_segments[next_word_idx]["text"].strip()
):
next_word_idx += 1
i = next_word_idx
else:
next_word_idx = i + 1
|
i = next_word_idx
self.display_segments = initial_segments
self.selected_label_name = None
@rx.event
def select_label(self, label_name: Optional[str]):
"""Selects a label to apply or deselects if the same label is clicked again."""
if self.selected_label_name == label_name:
self.selected_label_name = None
else:
self.selected_label_name = label_name
@rx.event
def apply_label(self, segment_id: int):
"""Applies the selected label to the clicked segment or removes it."""
if self.selected_label_name is None:
return rx.toast("Select a label first!", duration=2000)
target_segment_index = -1
for i, seg in enumerate(self.display_segments):
if seg["id"] == segment_id:
target_segment_index = i
break
if target_segment_index == -1:
return rx.toast("Segment not found.", duration=2000)
| while next_word_idx < len(initial_segments) and (
not initial_segments[next_word_idx]["text"].strip()
):
next_word_idx += 1 |
initial_segments[idx]["text_color"] = entity[
"text_color"
]
applied_label = True
if applied_label:
i = temp_indices[-1] + 1
else:
next_word_idx = i + 1
while next_word_idx < len(initial_segments) and (
not initial_segments[next_word_idx]["text"].strip()
):
next_word_idx += 1
i = next_word_idx
else:
next_word_idx = i + 1
while next_word_idx < len(initial_segments) and (
not initial_segments[next_word_idx]["text"].strip()
):
next_word_idx += 1
|
self.display_segments = initial_segments
self.selected_label_name = None
@rx.event
def select_label(self, label_name: Optional[str]):
"""Selects a label to apply or deselects if the same label is clicked again."""
if self.selected_label_name == label_name:
self.selected_label_name = None
else:
self.selected_label_name = label_name
@rx.event
def apply_label(self, segment_id: int):
"""Applies the selected label to the clicked segment or removes it."""
if self.selected_label_name is None:
return rx.toast("Select a label first!", duration=2000)
target_segment_index = -1
for i, seg in enumerate(self.display_segments):
if seg["id"] == segment_id:
target_segment_index = i
break
if target_segment_index == -1:
return rx.toast("Segment not found.", duration=2000)
if not self.display_segments[target_s | i = next_word_idx |
initial_segments[idx]["text_color"] = entity[
"text_color"
]
applied_label = True
if applied_label:
i = temp_indices[-1] + 1
else:
next_word_idx = i + 1
while next_word_idx < len(initial_segments) and (
not initial_segments[next_word_idx]["text"].strip()
):
next_word_idx += 1
i = next_word_idx
else:
next_word_idx = i + 1
while next_word_idx < len(initial_segments) and (
not initial_segments[next_word_idx]["text"].strip()
):
next_word_idx += 1
i = next_word_idx
|
self.selected_label_name = None
@rx.event
def select_label(self, label_name: Optional[str]):
"""Selects a label to apply or deselects if the same label is clicked again."""
if self.selected_label_name == label_name:
self.selected_label_name = None
else:
self.selected_label_name = label_name
@rx.event
def apply_label(self, segment_id: int):
"""Applies the selected label to the clicked segment or removes it."""
if self.selected_label_name is None:
return rx.toast("Select a label first!", duration=2000)
target_segment_index = -1
for i, seg in enumerate(self.display_segments):
if seg["id"] == segment_id:
target_segment_index = i
break
if target_segment_index == -1:
return rx.toast("Segment not found.", duration=2000)
if not self.display_segments[target_segment_index]["text"].strip():
return | self.display_segments = initial_segments |
ty[
"text_color"
]
applied_label = True
if applied_label:
i = temp_indices[-1] + 1
else:
next_word_idx = i + 1
while next_word_idx < len(initial_segments) and (
not initial_segments[next_word_idx]["text"].strip()
):
next_word_idx += 1
i = next_word_idx
else:
next_word_idx = i + 1
while next_word_idx < len(initial_segments) and (
not initial_segments[next_word_idx]["text"].strip()
):
next_word_idx += 1
i = next_word_idx
self.display_segments = initial_segments
|
@rx.event
def select_label(self, label_name: Optional[str]):
"""Selects a label to apply or deselects if the same label is clicked again."""
if self.selected_label_name == label_name:
self.selected_label_name = None
else:
self.selected_label_name = label_name
@rx.event
def apply_label(self, segment_id: int):
"""Applies the selected label to the clicked segment or removes it."""
if self.selected_label_name is None:
return rx.toast("Select a label first!", duration=2000)
target_segment_index = -1
for i, seg in enumerate(self.display_segments):
if seg["id"] == segment_id:
target_segment_index = i
break
if target_segment_index == -1:
return rx.toast("Segment not found.", duration=2000)
if not self.display_segments[target_segment_index]["text"].strip():
return
selected_entity = None
| self.selected_label_name = None |
"
]
applied_label = True
if applied_label:
i = temp_indices[-1] + 1
else:
next_word_idx = i + 1
while next_word_idx < len(initial_segments) and (
not initial_segments[next_word_idx]["text"].strip()
):
next_word_idx += 1
i = next_word_idx
else:
next_word_idx = i + 1
while next_word_idx < len(initial_segments) and (
not initial_segments[next_word_idx]["text"].strip()
):
next_word_idx += 1
i = next_word_idx
self.display_segments = initial_segments
self.selected_label_name = None
@rx.event
|
@rx.event
def apply_label(self, segment_id: int):
"""Applies the selected label to the clicked segment or removes it."""
if self.selected_label_name is None:
return rx.toast("Select a label first!", duration=2000)
target_segment_index = -1
for i, seg in enumerate(self.display_segments):
if seg["id"] == segment_id:
target_segment_index = i
break
if target_segment_index == -1:
return rx.toast("Segment not found.", duration=2000)
if not self.display_segments[target_segment_index]["text"].strip():
return
selected_entity = None
for entity in self.entities:
if entity["name"] == self.selected_label_name:
selected_entity = entity
break
if selected_entity:
current_label = self.display_segments[target_segment_index]["label_name"]
if current_label == self.selected_label_ | def select_label(self, label_name: Optional[str]):
"""Selects a label to apply or deselects if the same label is clicked again."""
if self.selected_label_name == label_name:
self.selected_label_name = None
else:
self.selected_label_name = label_name |
i = temp_indices[-1] + 1
else:
next_word_idx = i + 1
while next_word_idx < len(initial_segments) and (
not initial_segments[next_word_idx]["text"].strip()
):
next_word_idx += 1
i = next_word_idx
else:
next_word_idx = i + 1
while next_word_idx < len(initial_segments) and (
not initial_segments[next_word_idx]["text"].strip()
):
next_word_idx += 1
i = next_word_idx
self.display_segments = initial_segments
self.selected_label_name = None
@rx.event
def select_label(self, label_name: Optional[str]):
"""Selects a label to apply or deselects if the same label is clicked again."""
|
@rx.event
def apply_label(self, segment_id: int):
"""Applies the selected label to the clicked segment or removes it."""
if self.selected_label_name is None:
return rx.toast("Select a label first!", duration=2000)
target_segment_index = -1
for i, seg in enumerate(self.display_segments):
if seg["id"] == segment_id:
target_segment_index = i
break
if target_segment_index == -1:
return rx.toast("Segment not found.", duration=2000)
if not self.display_segments[target_segment_index]["text"].strip():
return
selected_entity = None
for entity in self.entities:
if entity["name"] == self.selected_label_name:
selected_entity = entity
break
if selected_entity:
current_label = self.display_segments[target_segment_index]["label_name"]
if current_label == self.selected_label_ | if self.selected_label_name == label_name:
self.selected_label_name = None
else:
self.selected_label_name = label_name |
else:
next_word_idx = i + 1
while next_word_idx < len(initial_segments) and (
not initial_segments[next_word_idx]["text"].strip()
):
next_word_idx += 1
i = next_word_idx
else:
next_word_idx = i + 1
while next_word_idx < len(initial_segments) and (
not initial_segments[next_word_idx]["text"].strip()
):
next_word_idx += 1
i = next_word_idx
self.display_segments = initial_segments
self.selected_label_name = None
@rx.event
def select_label(self, label_name: Optional[str]):
"""Selects a label to apply or deselects if the same label is clicked again."""
if self.selected_label_name == label_name:
|
else:
self.selected_label_name = label_name
@rx.event
def apply_label(self, segment_id: int):
"""Applies the selected label to the clicked segment or removes it."""
if self.selected_label_name is None:
return rx.toast("Select a label first!", duration=2000)
target_segment_index = -1
for i, seg in enumerate(self.display_segments):
if seg["id"] == segment_id:
target_segment_index = i
break
if target_segment_index == -1:
return rx.toast("Segment not found.", duration=2000)
if not self.display_segments[target_segment_index]["text"].strip():
return
selected_entity = None
for entity in self.entities:
if entity["name"] == self.selected_label_name:
selected_entity = entity
break
if selected_entity:
current_label = self.display_segments[target_segment_index]["l | self.selected_label_name = None |
while next_word_idx < len(initial_segments) and (
not initial_segments[next_word_idx]["text"].strip()
):
next_word_idx += 1
i = next_word_idx
else:
next_word_idx = i + 1
while next_word_idx < len(initial_segments) and (
not initial_segments[next_word_idx]["text"].strip()
):
next_word_idx += 1
i = next_word_idx
self.display_segments = initial_segments
self.selected_label_name = None
@rx.event
def select_label(self, label_name: Optional[str]):
"""Selects a label to apply or deselects if the same label is clicked again."""
if self.selected_label_name == label_name:
self.selected_label_name = None
else:
|
@rx.event
def apply_label(self, segment_id: int):
"""Applies the selected label to the clicked segment or removes it."""
if self.selected_label_name is None:
return rx.toast("Select a label first!", duration=2000)
target_segment_index = -1
for i, seg in enumerate(self.display_segments):
if seg["id"] == segment_id:
target_segment_index = i
break
if target_segment_index == -1:
return rx.toast("Segment not found.", duration=2000)
if not self.display_segments[target_segment_index]["text"].strip():
return
selected_entity = None
for entity in self.entities:
if entity["name"] == self.selected_label_name:
selected_entity = entity
break
if selected_entity:
current_label = self.display_segments[target_segment_index]["label_name"]
if current_label == self.selected_label_ | self.selected_label_name = label_name |
):
next_word_idx += 1
i = next_word_idx
else:
next_word_idx = i + 1
while next_word_idx < len(initial_segments) and (
not initial_segments[next_word_idx]["text"].strip()
):
next_word_idx += 1
i = next_word_idx
self.display_segments = initial_segments
self.selected_label_name = None
@rx.event
def select_label(self, label_name: Optional[str]):
"""Selects a label to apply or deselects if the same label is clicked again."""
if self.selected_label_name == label_name:
self.selected_label_name = None
else:
self.selected_label_name = label_name
@rx.event
def apply_label(self, segment_id: int):
"""Applies the selected label to the clicked segment or removes it."""
|
target_segment_index = -1
for i, seg in enumerate(self.display_segments):
if seg["id"] == segment_id:
target_segment_index = i
break
if target_segment_index == -1:
return rx.toast("Segment not found.", duration=2000)
if not self.display_segments[target_segment_index]["text"].strip():
return
selected_entity = None
for entity in self.entities:
if entity["name"] == self.selected_label_name:
selected_entity = entity
break
if selected_entity:
current_label = self.display_segments[target_segment_index]["label_name"]
if current_label == self.selected_label_name:
self.display_segments[target_segment_index]["label_name"] = None
self.display_segments[target_segment_index]["bg_color"] = None
self.display_segments[target_segment_index]["text_color"] = None
| if self.selected_label_name is None:
return rx.toast("Select a label first!", duration=2000) |
else:
next_word_idx = i + 1
while next_word_idx < len(initial_segments) and (
not initial_segments[next_word_idx]["text"].strip()
):
next_word_idx += 1
i = next_word_idx
self.display_segments = initial_segments
self.selected_label_name = None
@rx.event
def select_label(self, label_name: Optional[str]):
"""Selects a label to apply or deselects if the same label is clicked again."""
if self.selected_label_name == label_name:
self.selected_label_name = None
else:
self.selected_label_name = label_name
@rx.event
def apply_label(self, segment_id: int):
"""Applies the selected label to the clicked segment or removes it."""
if self.selected_label_name is None:
return rx.toast("Select a label first!", duration=2000)
|
for i, seg in enumerate(self.display_segments):
if seg["id"] == segment_id:
target_segment_index = i
break
if target_segment_index == -1:
return rx.toast("Segment not found.", duration=2000)
if not self.display_segments[target_segment_index]["text"].strip():
return
selected_entity = None
for entity in self.entities:
if entity["name"] == self.selected_label_name:
selected_entity = entity
break
if selected_entity:
current_label = self.display_segments[target_segment_index]["label_name"]
if current_label == self.selected_label_name:
self.display_segments[target_segment_index]["label_name"] = None
self.display_segments[target_segment_index]["bg_color"] = None
self.display_segments[target_segment_index]["text_color"] = None
else:
self | target_segment_index = -1 |
next_word_idx = i + 1
while next_word_idx < len(initial_segments) and (
not initial_segments[next_word_idx]["text"].strip()
):
next_word_idx += 1
i = next_word_idx
self.display_segments = initial_segments
self.selected_label_name = None
@rx.event
def select_label(self, label_name: Optional[str]):
"""Selects a label to apply or deselects if the same label is clicked again."""
if self.selected_label_name == label_name:
self.selected_label_name = None
else:
self.selected_label_name = label_name
@rx.event
def apply_label(self, segment_id: int):
"""Applies the selected label to the clicked segment or removes it."""
if self.selected_label_name is None:
return rx.toast("Select a label first!", duration=2000)
target_segment_index = -1
|
if target_segment_index == -1:
return rx.toast("Segment not found.", duration=2000)
if not self.display_segments[target_segment_index]["text"].strip():
return
selected_entity = None
for entity in self.entities:
if entity["name"] == self.selected_label_name:
selected_entity = entity
break
if selected_entity:
current_label = self.display_segments[target_segment_index]["label_name"]
if current_label == self.selected_label_name:
self.display_segments[target_segment_index]["label_name"] = None
self.display_segments[target_segment_index]["bg_color"] = None
self.display_segments[target_segment_index]["text_color"] = None
else:
self.display_segments[target_segment_index]["label_name"] = (
selected_entity["name"]
)
self.display_segments[t | for i, seg in enumerate(self.display_segments):
if seg["id"] == segment_id:
target_segment_index = i
break |
next_word_idx < len(initial_segments) and (
not initial_segments[next_word_idx]["text"].strip()
):
next_word_idx += 1
i = next_word_idx
self.display_segments = initial_segments
self.selected_label_name = None
@rx.event
def select_label(self, label_name: Optional[str]):
"""Selects a label to apply or deselects if the same label is clicked again."""
if self.selected_label_name == label_name:
self.selected_label_name = None
else:
self.selected_label_name = label_name
@rx.event
def apply_label(self, segment_id: int):
"""Applies the selected label to the clicked segment or removes it."""
if self.selected_label_name is None:
return rx.toast("Select a label first!", duration=2000)
target_segment_index = -1
for i, seg in enumerate(self.display_segments):
|
if target_segment_index == -1:
return rx.toast("Segment not found.", duration=2000)
if not self.display_segments[target_segment_index]["text"].strip():
return
selected_entity = None
for entity in self.entities:
if entity["name"] == self.selected_label_name:
selected_entity = entity
break
if selected_entity:
current_label = self.display_segments[target_segment_index]["label_name"]
if current_label == self.selected_label_name:
self.display_segments[target_segment_index]["label_name"] = None
self.display_segments[target_segment_index]["bg_color"] = None
self.display_segments[target_segment_index]["text_color"] = None
else:
self.display_segments[target_segment_index]["label_name"] = (
selected_entity["name"]
)
self.display_segments[t | if seg["id"] == segment_id:
target_segment_index = i
break |
not initial_segments[next_word_idx]["text"].strip()
):
next_word_idx += 1
i = next_word_idx
self.display_segments = initial_segments
self.selected_label_name = None
@rx.event
def select_label(self, label_name: Optional[str]):
"""Selects a label to apply or deselects if the same label is clicked again."""
if self.selected_label_name == label_name:
self.selected_label_name = None
else:
self.selected_label_name = label_name
@rx.event
def apply_label(self, segment_id: int):
"""Applies the selected label to the clicked segment or removes it."""
if self.selected_label_name is None:
return rx.toast("Select a label first!", duration=2000)
target_segment_index = -1
for i, seg in enumerate(self.display_segments):
if seg["id"] == segment_id:
|
break
if target_segment_index == -1:
return rx.toast("Segment not found.", duration=2000)
if not self.display_segments[target_segment_index]["text"].strip():
return
selected_entity = None
for entity in self.entities:
if entity["name"] == self.selected_label_name:
selected_entity = entity
break
if selected_entity:
current_label = self.display_segments[target_segment_index]["label_name"]
if current_label == self.selected_label_name:
self.display_segments[target_segment_index]["label_name"] = None
self.display_segments[target_segment_index]["bg_color"] = None
self.display_segments[target_segment_index]["text_color"] = None
else:
self.display_segments[target_segment_index]["label_name"] = (
selected_entity["name"]
)
s | target_segment_index = i |
word_idx]["text"].strip()
):
next_word_idx += 1
i = next_word_idx
self.display_segments = initial_segments
self.selected_label_name = None
@rx.event
def select_label(self, label_name: Optional[str]):
"""Selects a label to apply or deselects if the same label is clicked again."""
if self.selected_label_name == label_name:
self.selected_label_name = None
else:
self.selected_label_name = label_name
@rx.event
def apply_label(self, segment_id: int):
"""Applies the selected label to the clicked segment or removes it."""
if self.selected_label_name is None:
return rx.toast("Select a label first!", duration=2000)
target_segment_index = -1
for i, seg in enumerate(self.display_segments):
if seg["id"] == segment_id:
target_segment_index = i
break
|
if not self.display_segments[target_segment_index]["text"].strip():
return
selected_entity = None
for entity in self.entities:
if entity["name"] == self.selected_label_name:
selected_entity = entity
break
if selected_entity:
current_label = self.display_segments[target_segment_index]["label_name"]
if current_label == self.selected_label_name:
self.display_segments[target_segment_index]["label_name"] = None
self.display_segments[target_segment_index]["bg_color"] = None
self.display_segments[target_segment_index]["text_color"] = None
else:
self.display_segments[target_segment_index]["label_name"] = (
selected_entity["name"]
)
self.display_segments[target_segment_index]["bg_color"] = (
selected_entity["color"]
)
| if target_segment_index == -1:
return rx.toast("Segment not found.", duration=2000) |
i = next_word_idx
self.display_segments = initial_segments
self.selected_label_name = None
@rx.event
def select_label(self, label_name: Optional[str]):
"""Selects a label to apply or deselects if the same label is clicked again."""
if self.selected_label_name == label_name:
self.selected_label_name = None
else:
self.selected_label_name = label_name
@rx.event
def apply_label(self, segment_id: int):
"""Applies the selected label to the clicked segment or removes it."""
if self.selected_label_name is None:
return rx.toast("Select a label first!", duration=2000)
target_segment_index = -1
for i, seg in enumerate(self.display_segments):
if seg["id"] == segment_id:
target_segment_index = i
break
if target_segment_index == -1:
return rx.toast("Segment not found.", duration=2000)
|
selected_entity = None
for entity in self.entities:
if entity["name"] == self.selected_label_name:
selected_entity = entity
break
if selected_entity:
current_label = self.display_segments[target_segment_index]["label_name"]
if current_label == self.selected_label_name:
self.display_segments[target_segment_index]["label_name"] = None
self.display_segments[target_segment_index]["bg_color"] = None
self.display_segments[target_segment_index]["text_color"] = None
else:
self.display_segments[target_segment_index]["label_name"] = (
selected_entity["name"]
)
self.display_segments[target_segment_index]["bg_color"] = (
selected_entity["color"]
)
self.display_segments[target_segment_index]["text_color"] = (
s | if not self.display_segments[target_segment_index]["text"].strip():
return |
self.selected_label_name = None
@rx.event
def select_label(self, label_name: Optional[str]):
"""Selects a label to apply or deselects if the same label is clicked again."""
if self.selected_label_name == label_name:
self.selected_label_name = None
else:
self.selected_label_name = label_name
@rx.event
def apply_label(self, segment_id: int):
"""Applies the selected label to the clicked segment or removes it."""
if self.selected_label_name is None:
return rx.toast("Select a label first!", duration=2000)
target_segment_index = -1
for i, seg in enumerate(self.display_segments):
if seg["id"] == segment_id:
target_segment_index = i
break
if target_segment_index == -1:
return rx.toast("Segment not found.", duration=2000)
if not self.display_segments[target_segment_index]["text"].strip():
return
|
for entity in self.entities:
if entity["name"] == self.selected_label_name:
selected_entity = entity
break
if selected_entity:
current_label = self.display_segments[target_segment_index]["label_name"]
if current_label == self.selected_label_name:
self.display_segments[target_segment_index]["label_name"] = None
self.display_segments[target_segment_index]["bg_color"] = None
self.display_segments[target_segment_index]["text_color"] = None
else:
self.display_segments[target_segment_index]["label_name"] = (
selected_entity["name"]
)
self.display_segments[target_segment_index]["bg_color"] = (
selected_entity["color"]
)
self.display_segments[target_segment_index]["text_color"] = (
selected_entity["text_color"]
| selected_entity = None |
, label_name: Optional[str]):
"""Selects a label to apply or deselects if the same label is clicked again."""
if self.selected_label_name == label_name:
self.selected_label_name = None
else:
self.selected_label_name = label_name
@rx.event
def apply_label(self, segment_id: int):
"""Applies the selected label to the clicked segment or removes it."""
if self.selected_label_name is None:
return rx.toast("Select a label first!", duration=2000)
target_segment_index = -1
for i, seg in enumerate(self.display_segments):
if seg["id"] == segment_id:
target_segment_index = i
break
if target_segment_index == -1:
return rx.toast("Segment not found.", duration=2000)
if not self.display_segments[target_segment_index]["text"].strip():
return
selected_entity = None
for entity in self.entities:
|
if selected_entity:
current_label = self.display_segments[target_segment_index]["label_name"]
if current_label == self.selected_label_name:
self.display_segments[target_segment_index]["label_name"] = None
self.display_segments[target_segment_index]["bg_color"] = None
self.display_segments[target_segment_index]["text_color"] = None
else:
self.display_segments[target_segment_index]["label_name"] = (
selected_entity["name"]
)
self.display_segments[target_segment_index]["bg_color"] = (
selected_entity["color"]
)
self.display_segments[target_segment_index]["text_color"] = (
selected_entity["text_color"]
)
else:
return rx.toast(
f"Label '{self.selected_label_name}' definition not found.",
duratio | if entity["name"] == self.selected_label_name:
selected_entity = entity
break |
ly or deselects if the same label is clicked again."""
if self.selected_label_name == label_name:
self.selected_label_name = None
else:
self.selected_label_name = label_name
@rx.event
def apply_label(self, segment_id: int):
"""Applies the selected label to the clicked segment or removes it."""
if self.selected_label_name is None:
return rx.toast("Select a label first!", duration=2000)
target_segment_index = -1
for i, seg in enumerate(self.display_segments):
if seg["id"] == segment_id:
target_segment_index = i
break
if target_segment_index == -1:
return rx.toast("Segment not found.", duration=2000)
if not self.display_segments[target_segment_index]["text"].strip():
return
selected_entity = None
for entity in self.entities:
if entity["name"] == self.selected_label_name:
|
break
if selected_entity:
current_label = self.display_segments[target_segment_index]["label_name"]
if current_label == self.selected_label_name:
self.display_segments[target_segment_index]["label_name"] = None
self.display_segments[target_segment_index]["bg_color"] = None
self.display_segments[target_segment_index]["text_color"] = None
else:
self.display_segments[target_segment_index]["label_name"] = (
selected_entity["name"]
)
self.display_segments[target_segment_index]["bg_color"] = (
selected_entity["color"]
)
self.display_segments[target_segment_index]["text_color"] = (
selected_entity["text_color"]
)
else:
return rx.toast(
f"Label '{self.selected_label_name}' definition not found.",
| selected_entity = entity |
if self.selected_label_name == label_name:
self.selected_label_name = None
else:
self.selected_label_name = label_name
@rx.event
def apply_label(self, segment_id: int):
"""Applies the selected label to the clicked segment or removes it."""
if self.selected_label_name is None:
return rx.toast("Select a label first!", duration=2000)
target_segment_index = -1
for i, seg in enumerate(self.display_segments):
if seg["id"] == segment_id:
target_segment_index = i
break
if target_segment_index == -1:
return rx.toast("Segment not found.", duration=2000)
if not self.display_segments[target_segment_index]["text"].strip():
return
selected_entity = None
for entity in self.entities:
if entity["name"] == self.selected_label_name:
selected_entity = entity
break
|
@rx.event
def set_new_label_name(self, name: str):
"""Updates the name for the new label being created."""
self.new_label_name = name
@rx.event
def set_new_label_keywords_str(self, keywords: str):
"""Updates the keywords string for the new label being created."""
self.new_label_keywords_str = keywords
@rx.event
def set_new_label_color_index(self, index: int):
"""Updates the selected color index for the new label."""
self.new_label_selected_color_index = index
@rx.event
def add_new_label(self):
"""Adds a new label to the entities list using the selected color."""
name = self.new_label_name.strip().upper()
if not name:
return rx.toast("Label name cannot be empty.", duration=3000)
if any((entity["name"] == name for entity in self.entities)):
return rx.toast(
f"Label '{name}' already exists.",
duration=3000,
| if selected_entity:
current_label = self.display_segments[target_segment_index]["label_name"]
if current_label == self.selected_label_name:
self.display_segments[target_segment_index]["label_name"] = None
self.display_segments[target_segment_index]["bg_color"] = None
self.display_segments[target_segment_index]["text_color"] = None
else:
self.display_segments[target_segment_index]["label_name"] = (
selected_entity["name"]
)
self.display_segments[target_segment_index]["bg_color"] = (
selected_entity["color"]
)
self.display_segments[target_segment_index]["text_color"] = (
selected_entity["text_color"]
)
else:
return rx.toast(
f"Label '{self.selected_label_name}' definition not found.",
duration=3000,
) |
ame == label_name:
self.selected_label_name = None
else:
self.selected_label_name = label_name
@rx.event
def apply_label(self, segment_id: int):
"""Applies the selected label to the clicked segment or removes it."""
if self.selected_label_name is None:
return rx.toast("Select a label first!", duration=2000)
target_segment_index = -1
for i, seg in enumerate(self.display_segments):
if seg["id"] == segment_id:
target_segment_index = i
break
if target_segment_index == -1:
return rx.toast("Segment not found.", duration=2000)
if not self.display_segments[target_segment_index]["text"].strip():
return
selected_entity = None
for entity in self.entities:
if entity["name"] == self.selected_label_name:
selected_entity = entity
break
if selected_entity:
|
if current_label == self.selected_label_name:
self.display_segments[target_segment_index]["label_name"] = None
self.display_segments[target_segment_index]["bg_color"] = None
self.display_segments[target_segment_index]["text_color"] = None
else:
self.display_segments[target_segment_index]["label_name"] = (
selected_entity["name"]
)
self.display_segments[target_segment_index]["bg_color"] = (
selected_entity["color"]
)
self.display_segments[target_segment_index]["text_color"] = (
selected_entity["text_color"]
)
else:
return rx.toast(
f"Label '{self.selected_label_name}' definition not found.",
duration=3000,
)
@rx.event
def set_new_label_name(self, name: str):
"""Updates the name for | current_label = self.display_segments[target_segment_index]["label_name"] |
self.selected_label_name = label_name
@rx.event
def apply_label(self, segment_id: int):
"""Applies the selected label to the clicked segment or removes it."""
if self.selected_label_name is None:
return rx.toast("Select a label first!", duration=2000)
target_segment_index = -1
for i, seg in enumerate(self.display_segments):
if seg["id"] == segment_id:
target_segment_index = i
break
if target_segment_index == -1:
return rx.toast("Segment not found.", duration=2000)
if not self.display_segments[target_segment_index]["text"].strip():
return
selected_entity = None
for entity in self.entities:
if entity["name"] == self.selected_label_name:
selected_entity = entity
break
if selected_entity:
current_label = self.display_segments[target_segment_index]["label_name"]
|
else:
return rx.toast(
f"Label '{self.selected_label_name}' definition not found.",
duration=3000,
)
@rx.event
def set_new_label_name(self, name: str):
"""Updates the name for the new label being created."""
self.new_label_name = name
@rx.event
def set_new_label_keywords_str(self, keywords: str):
"""Updates the keywords string for the new label being created."""
self.new_label_keywords_str = keywords
@rx.event
def set_new_label_color_index(self, index: int):
"""Updates the selected color index for the new label."""
self.new_label_selected_color_index = index
@rx.event
def add_new_label(self):
"""Adds a new label to the entities list using the selected color."""
name = self.new_label_name.strip().upper()
if not name:
return rx.toast("Label name cannot be empty.", duration=3000)
if any((entity["nam | if current_label == self.selected_label_name:
self.display_segments[target_segment_index]["label_name"] = None
self.display_segments[target_segment_index]["bg_color"] = None
self.display_segments[target_segment_index]["text_color"] = None
else:
self.display_segments[target_segment_index]["label_name"] = (
selected_entity["name"]
)
self.display_segments[target_segment_index]["bg_color"] = (
selected_entity["color"]
)
self.display_segments[target_segment_index]["text_color"] = (
selected_entity["text_color"]
) |
f apply_label(self, segment_id: int):
"""Applies the selected label to the clicked segment or removes it."""
if self.selected_label_name is None:
return rx.toast("Select a label first!", duration=2000)
target_segment_index = -1
for i, seg in enumerate(self.display_segments):
if seg["id"] == segment_id:
target_segment_index = i
break
if target_segment_index == -1:
return rx.toast("Segment not found.", duration=2000)
if not self.display_segments[target_segment_index]["text"].strip():
return
selected_entity = None
for entity in self.entities:
if entity["name"] == self.selected_label_name:
selected_entity = entity
break
if selected_entity:
current_label = self.display_segments[target_segment_index]["label_name"]
if current_label == self.selected_label_name:
|
self.display_segments[target_segment_index]["bg_color"] = None
self.display_segments[target_segment_index]["text_color"] = None
else:
self.display_segments[target_segment_index]["label_name"] = (
selected_entity["name"]
)
self.display_segments[target_segment_index]["bg_color"] = (
selected_entity["color"]
)
self.display_segments[target_segment_index]["text_color"] = (
selected_entity["text_color"]
)
else:
return rx.toast(
f"Label '{self.selected_label_name}' definition not found.",
duration=3000,
)
@rx.event
def set_new_label_name(self, name: str):
"""Updates the name for the new label being created."""
self.new_label_name = name
@rx.event
def set_new_label_keywords_str(self, keywords: str):
| self.display_segments[target_segment_index]["label_name"] = None |
e clicked segment or removes it."""
if self.selected_label_name is None:
return rx.toast("Select a label first!", duration=2000)
target_segment_index = -1
for i, seg in enumerate(self.display_segments):
if seg["id"] == segment_id:
target_segment_index = i
break
if target_segment_index == -1:
return rx.toast("Segment not found.", duration=2000)
if not self.display_segments[target_segment_index]["text"].strip():
return
selected_entity = None
for entity in self.entities:
if entity["name"] == self.selected_label_name:
selected_entity = entity
break
if selected_entity:
current_label = self.display_segments[target_segment_index]["label_name"]
if current_label == self.selected_label_name:
self.display_segments[target_segment_index]["label_name"] = None
|
self.display_segments[target_segment_index]["text_color"] = None
else:
self.display_segments[target_segment_index]["label_name"] = (
selected_entity["name"]
)
self.display_segments[target_segment_index]["bg_color"] = (
selected_entity["color"]
)
self.display_segments[target_segment_index]["text_color"] = (
selected_entity["text_color"]
)
else:
return rx.toast(
f"Label '{self.selected_label_name}' definition not found.",
duration=3000,
)
@rx.event
def set_new_label_name(self, name: str):
"""Updates the name for the new label being created."""
self.new_label_name = name
@rx.event
def set_new_label_keywords_str(self, keywords: str):
"""Updates the keywords string for the new label being created."""
| self.display_segments[target_segment_index]["bg_color"] = None |
:
return rx.toast("Select a label first!", duration=2000)
target_segment_index = -1
for i, seg in enumerate(self.display_segments):
if seg["id"] == segment_id:
target_segment_index = i
break
if target_segment_index == -1:
return rx.toast("Segment not found.", duration=2000)
if not self.display_segments[target_segment_index]["text"].strip():
return
selected_entity = None
for entity in self.entities:
if entity["name"] == self.selected_label_name:
selected_entity = entity
break
if selected_entity:
current_label = self.display_segments[target_segment_index]["label_name"]
if current_label == self.selected_label_name:
self.display_segments[target_segment_index]["label_name"] = None
self.display_segments[target_segment_index]["bg_color"] = None
|
else:
self.display_segments[target_segment_index]["label_name"] = (
selected_entity["name"]
)
self.display_segments[target_segment_index]["bg_color"] = (
selected_entity["color"]
)
self.display_segments[target_segment_index]["text_color"] = (
selected_entity["text_color"]
)
else:
return rx.toast(
f"Label '{self.selected_label_name}' definition not found.",
duration=3000,
)
@rx.event
def set_new_label_name(self, name: str):
"""Updates the name for the new label being created."""
self.new_label_name = name
@rx.event
def set_new_label_keywords_str(self, keywords: str):
"""Updates the keywords string for the new label being created."""
self.new_label_keywords_str = keywords
@rx.event
def set_new_label_c | self.display_segments[target_segment_index]["text_color"] = None |
= -1
for i, seg in enumerate(self.display_segments):
if seg["id"] == segment_id:
target_segment_index = i
break
if target_segment_index == -1:
return rx.toast("Segment not found.", duration=2000)
if not self.display_segments[target_segment_index]["text"].strip():
return
selected_entity = None
for entity in self.entities:
if entity["name"] == self.selected_label_name:
selected_entity = entity
break
if selected_entity:
current_label = self.display_segments[target_segment_index]["label_name"]
if current_label == self.selected_label_name:
self.display_segments[target_segment_index]["label_name"] = None
self.display_segments[target_segment_index]["bg_color"] = None
self.display_segments[target_segment_index]["text_color"] = None
else:
|
self.display_segments[target_segment_index]["bg_color"] = (
selected_entity["color"]
)
self.display_segments[target_segment_index]["text_color"] = (
selected_entity["text_color"]
)
else:
return rx.toast(
f"Label '{self.selected_label_name}' definition not found.",
duration=3000,
)
@rx.event
def set_new_label_name(self, name: str):
"""Updates the name for the new label being created."""
self.new_label_name = name
@rx.event
def set_new_label_keywords_str(self, keywords: str):
"""Updates the keywords string for the new label being created."""
self.new_label_keywords_str = keywords
@rx.event
def set_new_label_color_index(self, index: int):
"""Updates the selected color index for the new label."""
self.new_label_selected_color_index = index
@rx.e | self.display_segments[target_segment_index]["label_name"] = (
selected_entity["name"]
) |
i
break
if target_segment_index == -1:
return rx.toast("Segment not found.", duration=2000)
if not self.display_segments[target_segment_index]["text"].strip():
return
selected_entity = None
for entity in self.entities:
if entity["name"] == self.selected_label_name:
selected_entity = entity
break
if selected_entity:
current_label = self.display_segments[target_segment_index]["label_name"]
if current_label == self.selected_label_name:
self.display_segments[target_segment_index]["label_name"] = None
self.display_segments[target_segment_index]["bg_color"] = None
self.display_segments[target_segment_index]["text_color"] = None
else:
self.display_segments[target_segment_index]["label_name"] = (
selected_entity["name"]
)
|
self.display_segments[target_segment_index]["text_color"] = (
selected_entity["text_color"]
)
else:
return rx.toast(
f"Label '{self.selected_label_name}' definition not found.",
duration=3000,
)
@rx.event
def set_new_label_name(self, name: str):
"""Updates the name for the new label being created."""
self.new_label_name = name
@rx.event
def set_new_label_keywords_str(self, keywords: str):
"""Updates the keywords string for the new label being created."""
self.new_label_keywords_str = keywords
@rx.event
def set_new_label_color_index(self, index: int):
"""Updates the selected color index for the new label."""
self.new_label_selected_color_index = index
@rx.event
def add_new_label(self):
"""Adds a new label to the entities list using the selected color."""
name = self.new_lab | self.display_segments[target_segment_index]["bg_color"] = (
selected_entity["color"]
) |
not self.display_segments[target_segment_index]["text"].strip():
return
selected_entity = None
for entity in self.entities:
if entity["name"] == self.selected_label_name:
selected_entity = entity
break
if selected_entity:
current_label = self.display_segments[target_segment_index]["label_name"]
if current_label == self.selected_label_name:
self.display_segments[target_segment_index]["label_name"] = None
self.display_segments[target_segment_index]["bg_color"] = None
self.display_segments[target_segment_index]["text_color"] = None
else:
self.display_segments[target_segment_index]["label_name"] = (
selected_entity["name"]
)
self.display_segments[target_segment_index]["bg_color"] = (
selected_entity["color"]
)
|
else:
return rx.toast(
f"Label '{self.selected_label_name}' definition not found.",
duration=3000,
)
@rx.event
def set_new_label_name(self, name: str):
"""Updates the name for the new label being created."""
self.new_label_name = name
@rx.event
def set_new_label_keywords_str(self, keywords: str):
"""Updates the keywords string for the new label being created."""
self.new_label_keywords_str = keywords
@rx.event
def set_new_label_color_index(self, index: int):
"""Updates the selected color index for the new label."""
self.new_label_selected_color_index = index
@rx.event
def add_new_label(self):
"""Adds a new label to the entities list using the selected color."""
name = self.new_label_name.strip().upper()
if not name:
return rx.toast("Label name cannot be empty.", duration=3000)
if any((entity["nam | self.display_segments[target_segment_index]["text_color"] = (
selected_entity["text_color"]
) |
current_label = self.display_segments[target_segment_index]["label_name"]
if current_label == self.selected_label_name:
self.display_segments[target_segment_index]["label_name"] = None
self.display_segments[target_segment_index]["bg_color"] = None
self.display_segments[target_segment_index]["text_color"] = None
else:
self.display_segments[target_segment_index]["label_name"] = (
selected_entity["name"]
)
self.display_segments[target_segment_index]["bg_color"] = (
selected_entity["color"]
)
self.display_segments[target_segment_index]["text_color"] = (
selected_entity["text_color"]
)
else:
return rx.toast(
f"Label '{self.selected_label_name}' definition not found.",
duration=3000,
)
@rx.event
|
@rx.event
def set_new_label_keywords_str(self, keywords: str):
"""Updates the keywords string for the new label being created."""
self.new_label_keywords_str = keywords
@rx.event
def set_new_label_color_index(self, index: int):
"""Updates the selected color index for the new label."""
self.new_label_selected_color_index = index
@rx.event
def add_new_label(self):
"""Adds a new label to the entities list using the selected color."""
name = self.new_label_name.strip().upper()
if not name:
return rx.toast("Label name cannot be empty.", duration=3000)
if any((entity["name"] == name for entity in self.entities)):
return rx.toast(
f"Label '{name}' already exists.",
duration=3000,
)
keywords = [
k.strip() for k in self.new_label_keywords_str.split(",") if k.strip()
]
if not 0 <= self.new_label_selecte | def set_new_label_name(self, name: str):
"""Updates the name for the new label being created."""
self.new_label_name = name |
lected_label_name:
self.display_segments[target_segment_index]["label_name"] = None
self.display_segments[target_segment_index]["bg_color"] = None
self.display_segments[target_segment_index]["text_color"] = None
else:
self.display_segments[target_segment_index]["label_name"] = (
selected_entity["name"]
)
self.display_segments[target_segment_index]["bg_color"] = (
selected_entity["color"]
)
self.display_segments[target_segment_index]["text_color"] = (
selected_entity["text_color"]
)
else:
return rx.toast(
f"Label '{self.selected_label_name}' definition not found.",
duration=3000,
)
@rx.event
def set_new_label_name(self, name: str):
"""Updates the name for the new label being created."""
|
@rx.event
def set_new_label_keywords_str(self, keywords: str):
"""Updates the keywords string for the new label being created."""
self.new_label_keywords_str = keywords
@rx.event
def set_new_label_color_index(self, index: int):
"""Updates the selected color index for the new label."""
self.new_label_selected_color_index = index
@rx.event
def add_new_label(self):
"""Adds a new label to the entities list using the selected color."""
name = self.new_label_name.strip().upper()
if not name:
return rx.toast("Label name cannot be empty.", duration=3000)
if any((entity["name"] == name for entity in self.entities)):
return rx.toast(
f"Label '{name}' already exists.",
duration=3000,
)
keywords = [
k.strip() for k in self.new_label_keywords_str.split(",") if k.strip()
]
if not 0 <= self.new_label_selecte | self.new_label_name = name |
y_segments[target_segment_index]["label_name"] = None
self.display_segments[target_segment_index]["bg_color"] = None
self.display_segments[target_segment_index]["text_color"] = None
else:
self.display_segments[target_segment_index]["label_name"] = (
selected_entity["name"]
)
self.display_segments[target_segment_index]["bg_color"] = (
selected_entity["color"]
)
self.display_segments[target_segment_index]["text_color"] = (
selected_entity["text_color"]
)
else:
return rx.toast(
f"Label '{self.selected_label_name}' definition not found.",
duration=3000,
)
@rx.event
def set_new_label_name(self, name: str):
"""Updates the name for the new label being created."""
self.new_label_name = name
@rx.event
|
@rx.event
def set_new_label_color_index(self, index: int):
"""Updates the selected color index for the new label."""
self.new_label_selected_color_index = index
@rx.event
def add_new_label(self):
"""Adds a new label to the entities list using the selected color."""
name = self.new_label_name.strip().upper()
if not name:
return rx.toast("Label name cannot be empty.", duration=3000)
if any((entity["name"] == name for entity in self.entities)):
return rx.toast(
f"Label '{name}' already exists.",
duration=3000,
)
keywords = [
k.strip() for k in self.new_label_keywords_str.split(",") if k.strip()
]
if not 0 <= self.new_label_selected_color_index < len(self.available_colors):
self.new_label_selected_color_index = 0
bg_color, text_color = self.available_colors[
self.new_label_selected_color_in | def set_new_label_keywords_str(self, keywords: str):
"""Updates the keywords string for the new label being created."""
self.new_label_keywords_str = keywords |
self.display_segments[target_segment_index]["text_color"] = None
else:
self.display_segments[target_segment_index]["label_name"] = (
selected_entity["name"]
)
self.display_segments[target_segment_index]["bg_color"] = (
selected_entity["color"]
)
self.display_segments[target_segment_index]["text_color"] = (
selected_entity["text_color"]
)
else:
return rx.toast(
f"Label '{self.selected_label_name}' definition not found.",
duration=3000,
)
@rx.event
def set_new_label_name(self, name: str):
"""Updates the name for the new label being created."""
self.new_label_name = name
@rx.event
def set_new_label_keywords_str(self, keywords: str):
"""Updates the keywords string for the new label being created."""
|
@rx.event
def set_new_label_color_index(self, index: int):
"""Updates the selected color index for the new label."""
self.new_label_selected_color_index = index
@rx.event
def add_new_label(self):
"""Adds a new label to the entities list using the selected color."""
name = self.new_label_name.strip().upper()
if not name:
return rx.toast("Label name cannot be empty.", duration=3000)
if any((entity["name"] == name for entity in self.entities)):
return rx.toast(
f"Label '{name}' already exists.",
duration=3000,
)
keywords = [
k.strip() for k in self.new_label_keywords_str.split(",") if k.strip()
]
if not 0 <= self.new_label_selected_color_index < len(self.available_colors):
self.new_label_selected_color_index = 0
bg_color, text_color = self.available_colors[
self.new_label_selected_color_in | self.new_label_keywords_str = keywords |
text_color"] = None
else:
self.display_segments[target_segment_index]["label_name"] = (
selected_entity["name"]
)
self.display_segments[target_segment_index]["bg_color"] = (
selected_entity["color"]
)
self.display_segments[target_segment_index]["text_color"] = (
selected_entity["text_color"]
)
else:
return rx.toast(
f"Label '{self.selected_label_name}' definition not found.",
duration=3000,
)
@rx.event
def set_new_label_name(self, name: str):
"""Updates the name for the new label being created."""
self.new_label_name = name
@rx.event
def set_new_label_keywords_str(self, keywords: str):
"""Updates the keywords string for the new label being created."""
self.new_label_keywords_str = keywords
@rx.event
|
@rx.event
def add_new_label(self):
"""Adds a new label to the entities list using the selected color."""
name = self.new_label_name.strip().upper()
if not name:
return rx.toast("Label name cannot be empty.", duration=3000)
if any((entity["name"] == name for entity in self.entities)):
return rx.toast(
f"Label '{name}' already exists.",
duration=3000,
)
keywords = [
k.strip() for k in self.new_label_keywords_str.split(",") if k.strip()
]
if not 0 <= self.new_label_selected_color_index < len(self.available_colors):
self.new_label_selected_color_index = 0
bg_color, text_color = self.available_colors[
self.new_label_selected_color_index
]
new_entity: EntityInfo = {
"name": name,
"color": bg_color,
"text_color": text_color,
"keywords": keywords,
| def set_new_label_color_index(self, index: int):
"""Updates the selected color index for the new label."""
self.new_label_selected_color_index = index |
selected_entity["name"]
)
self.display_segments[target_segment_index]["bg_color"] = (
selected_entity["color"]
)
self.display_segments[target_segment_index]["text_color"] = (
selected_entity["text_color"]
)
else:
return rx.toast(
f"Label '{self.selected_label_name}' definition not found.",
duration=3000,
)
@rx.event
def set_new_label_name(self, name: str):
"""Updates the name for the new label being created."""
self.new_label_name = name
@rx.event
def set_new_label_keywords_str(self, keywords: str):
"""Updates the keywords string for the new label being created."""
self.new_label_keywords_str = keywords
@rx.event
def set_new_label_color_index(self, index: int):
"""Updates the selected color index for the new label."""
|
@rx.event
def add_new_label(self):
"""Adds a new label to the entities list using the selected color."""
name = self.new_label_name.strip().upper()
if not name:
return rx.toast("Label name cannot be empty.", duration=3000)
if any((entity["name"] == name for entity in self.entities)):
return rx.toast(
f"Label '{name}' already exists.",
duration=3000,
)
keywords = [
k.strip() for k in self.new_label_keywords_str.split(",") if k.strip()
]
if not 0 <= self.new_label_selected_color_index < len(self.available_colors):
self.new_label_selected_color_index = 0
bg_color, text_color = self.available_colors[
self.new_label_selected_color_index
]
new_entity: EntityInfo = {
"name": name,
"color": bg_color,
"text_color": text_color,
"keywords": keywords,
| self.new_label_selected_color_index = index |
self.display_segments[target_segment_index]["bg_color"] = (
selected_entity["color"]
)
self.display_segments[target_segment_index]["text_color"] = (
selected_entity["text_color"]
)
else:
return rx.toast(
f"Label '{self.selected_label_name}' definition not found.",
duration=3000,
)
@rx.event
def set_new_label_name(self, name: str):
"""Updates the name for the new label being created."""
self.new_label_name = name
@rx.event
def set_new_label_keywords_str(self, keywords: str):
"""Updates the keywords string for the new label being created."""
self.new_label_keywords_str = keywords
@rx.event
def set_new_label_color_index(self, index: int):
"""Updates the selected color index for the new label."""
self.new_label_selected_color_index = index
@rx.event
|
@rx.event
def remove_label(self, label_name: str):
"""Removes a label definition and unlabels segments with that label."""
self.entities = [
entity for entity in self.entities if entity["name"] != label_name
]
updated_segments = []
for seg in self.display_segments:
if seg["label_name"] == label_name:
updated_segments.append(
{
**seg,
"label_name": None,
"bg_color": None,
"text_color": None,
}
)
else:
updated_segments.append(seg)
self.display_segments = updated_segments
if self.selected_label_name == label_name:
self.selected_label_name = None
yield rx.toast(f"Label '{label_name}' removed.", duration=2000)
@rx.var
def annotated_text_json(self) -> str:
"""Creates a JSON | def add_new_label(self):
"""Adds a new label to the entities list using the selected color."""
name = self.new_label_name.strip().upper()
if not name:
return rx.toast("Label name cannot be empty.", duration=3000)
if any((entity["name"] == name for entity in self.entities)):
return rx.toast(
f"Label '{name}' already exists.",
duration=3000,
)
keywords = [
k.strip() for k in self.new_label_keywords_str.split(",") if k.strip()
]
if not 0 <= self.new_label_selected_color_index < len(self.available_colors):
self.new_label_selected_color_index = 0
bg_color, text_color = self.available_colors[
self.new_label_selected_color_index
]
new_entity: EntityInfo = {
"name": name,
"color": bg_color,
"text_color": text_color,
"keywords": keywords,
}
self.entities.append(new_entity)
self.new_label_name = ""
self.new_label_keywords_str = ""
self.new_label_selected_color_index = 0
yield rx.toast(
f"Label '{name}' added successfully.",
duration=3000,
)
if keywords:
yield NerState.process_text_on_load |
]
)
self.display_segments[target_segment_index]["text_color"] = (
selected_entity["text_color"]
)
else:
return rx.toast(
f"Label '{self.selected_label_name}' definition not found.",
duration=3000,
)
@rx.event
def set_new_label_name(self, name: str):
"""Updates the name for the new label being created."""
self.new_label_name = name
@rx.event
def set_new_label_keywords_str(self, keywords: str):
"""Updates the keywords string for the new label being created."""
self.new_label_keywords_str = keywords
@rx.event
def set_new_label_color_index(self, index: int):
"""Updates the selected color index for the new label."""
self.new_label_selected_color_index = index
@rx.event
def add_new_label(self):
"""Adds a new label to the entities list using the selected color."""
|
if not name:
return rx.toast("Label name cannot be empty.", duration=3000)
if any((entity["name"] == name for entity in self.entities)):
return rx.toast(
f"Label '{name}' already exists.",
duration=3000,
)
keywords = [
k.strip() for k in self.new_label_keywords_str.split(",") if k.strip()
]
if not 0 <= self.new_label_selected_color_index < len(self.available_colors):
self.new_label_selected_color_index = 0
bg_color, text_color = self.available_colors[
self.new_label_selected_color_index
]
new_entity: EntityInfo = {
"name": name,
"color": bg_color,
"text_color": text_color,
"keywords": keywords,
}
self.entities.append(new_entity)
self.new_label_name = ""
self.new_label_keywords_str = ""
self.new_label_selected_color_index = 0
| name = self.new_label_name.strip().upper() |
gments[target_segment_index]["text_color"] = (
selected_entity["text_color"]
)
else:
return rx.toast(
f"Label '{self.selected_label_name}' definition not found.",
duration=3000,
)
@rx.event
def set_new_label_name(self, name: str):
"""Updates the name for the new label being created."""
self.new_label_name = name
@rx.event
def set_new_label_keywords_str(self, keywords: str):
"""Updates the keywords string for the new label being created."""
self.new_label_keywords_str = keywords
@rx.event
def set_new_label_color_index(self, index: int):
"""Updates the selected color index for the new label."""
self.new_label_selected_color_index = index
@rx.event
def add_new_label(self):
"""Adds a new label to the entities list using the selected color."""
name = self.new_label_name.strip().upper()
|
if any((entity["name"] == name for entity in self.entities)):
return rx.toast(
f"Label '{name}' already exists.",
duration=3000,
)
keywords = [
k.strip() for k in self.new_label_keywords_str.split(",") if k.strip()
]
if not 0 <= self.new_label_selected_color_index < len(self.available_colors):
self.new_label_selected_color_index = 0
bg_color, text_color = self.available_colors[
self.new_label_selected_color_index
]
new_entity: EntityInfo = {
"name": name,
"color": bg_color,
"text_color": text_color,
"keywords": keywords,
}
self.entities.append(new_entity)
self.new_label_name = ""
self.new_label_keywords_str = ""
self.new_label_selected_color_index = 0
yield rx.toast(
f"Label '{name}' added successfully.",
duration=3000,
| if not name:
return rx.toast("Label name cannot be empty.", duration=3000) |
]
)
else:
return rx.toast(
f"Label '{self.selected_label_name}' definition not found.",
duration=3000,
)
@rx.event
def set_new_label_name(self, name: str):
"""Updates the name for the new label being created."""
self.new_label_name = name
@rx.event
def set_new_label_keywords_str(self, keywords: str):
"""Updates the keywords string for the new label being created."""
self.new_label_keywords_str = keywords
@rx.event
def set_new_label_color_index(self, index: int):
"""Updates the selected color index for the new label."""
self.new_label_selected_color_index = index
@rx.event
def add_new_label(self):
"""Adds a new label to the entities list using the selected color."""
name = self.new_label_name.strip().upper()
if not name:
return rx.toast("Label name cannot be empty.", duration=3000)
|
keywords = [
k.strip() for k in self.new_label_keywords_str.split(",") if k.strip()
]
if not 0 <= self.new_label_selected_color_index < len(self.available_colors):
self.new_label_selected_color_index = 0
bg_color, text_color = self.available_colors[
self.new_label_selected_color_index
]
new_entity: EntityInfo = {
"name": name,
"color": bg_color,
"text_color": text_color,
"keywords": keywords,
}
self.entities.append(new_entity)
self.new_label_name = ""
self.new_label_keywords_str = ""
self.new_label_selected_color_index = 0
yield rx.toast(
f"Label '{name}' added successfully.",
duration=3000,
)
if keywords:
yield NerState.process_text_on_load
@rx.event
def remove_label(self, label_name: str):
"""Removes a label definition and unlabels segmen | if any((entity["name"] == name for entity in self.entities)):
return rx.toast(
f"Label '{name}' already exists.",
duration=3000,
) |
vent
def set_new_label_name(self, name: str):
"""Updates the name for the new label being created."""
self.new_label_name = name
@rx.event
def set_new_label_keywords_str(self, keywords: str):
"""Updates the keywords string for the new label being created."""
self.new_label_keywords_str = keywords
@rx.event
def set_new_label_color_index(self, index: int):
"""Updates the selected color index for the new label."""
self.new_label_selected_color_index = index
@rx.event
def add_new_label(self):
"""Adds a new label to the entities list using the selected color."""
name = self.new_label_name.strip().upper()
if not name:
return rx.toast("Label name cannot be empty.", duration=3000)
if any((entity["name"] == name for entity in self.entities)):
return rx.toast(
f"Label '{name}' already exists.",
duration=3000,
)
|
if not 0 <= self.new_label_selected_color_index < len(self.available_colors):
self.new_label_selected_color_index = 0
bg_color, text_color = self.available_colors[
self.new_label_selected_color_index
]
new_entity: EntityInfo = {
"name": name,
"color": bg_color,
"text_color": text_color,
"keywords": keywords,
}
self.entities.append(new_entity)
self.new_label_name = ""
self.new_label_keywords_str = ""
self.new_label_selected_color_index = 0
yield rx.toast(
f"Label '{name}' added successfully.",
duration=3000,
)
if keywords:
yield NerState.process_text_on_load
@rx.event
def remove_label(self, label_name: str):
"""Removes a label definition and unlabels segments with that label."""
self.entities = [
entity for entity in self.entities if entity["name"] | keywords = [
k.strip() for k in self.new_label_keywords_str.split(",") if k.strip()
] |
self.new_label_name = name
@rx.event
def set_new_label_keywords_str(self, keywords: str):
"""Updates the keywords string for the new label being created."""
self.new_label_keywords_str = keywords
@rx.event
def set_new_label_color_index(self, index: int):
"""Updates the selected color index for the new label."""
self.new_label_selected_color_index = index
@rx.event
def add_new_label(self):
"""Adds a new label to the entities list using the selected color."""
name = self.new_label_name.strip().upper()
if not name:
return rx.toast("Label name cannot be empty.", duration=3000)
if any((entity["name"] == name for entity in self.entities)):
return rx.toast(
f"Label '{name}' already exists.",
duration=3000,
)
keywords = [
k.strip() for k in self.new_label_keywords_str.split(",") if k.strip()
]
|
bg_color, text_color = self.available_colors[
self.new_label_selected_color_index
]
new_entity: EntityInfo = {
"name": name,
"color": bg_color,
"text_color": text_color,
"keywords": keywords,
}
self.entities.append(new_entity)
self.new_label_name = ""
self.new_label_keywords_str = ""
self.new_label_selected_color_index = 0
yield rx.toast(
f"Label '{name}' added successfully.",
duration=3000,
)
if keywords:
yield NerState.process_text_on_load
@rx.event
def remove_label(self, label_name: str):
"""Removes a label definition and unlabels segments with that label."""
self.entities = [
entity for entity in self.entities if entity["name"] != label_name
]
updated_segments = []
for seg in self.display_segments:
if seg["label_name"] == label_ | if not 0 <= self.new_label_selected_color_index < len(self.available_colors):
self.new_label_selected_color_index = 0 |
keywords: str):
"""Updates the keywords string for the new label being created."""
self.new_label_keywords_str = keywords
@rx.event
def set_new_label_color_index(self, index: int):
"""Updates the selected color index for the new label."""
self.new_label_selected_color_index = index
@rx.event
def add_new_label(self):
"""Adds a new label to the entities list using the selected color."""
name = self.new_label_name.strip().upper()
if not name:
return rx.toast("Label name cannot be empty.", duration=3000)
if any((entity["name"] == name for entity in self.entities)):
return rx.toast(
f"Label '{name}' already exists.",
duration=3000,
)
keywords = [
k.strip() for k in self.new_label_keywords_str.split(",") if k.strip()
]
if not 0 <= self.new_label_selected_color_index < len(self.available_colors):
|
bg_color, text_color = self.available_colors[
self.new_label_selected_color_index
]
new_entity: EntityInfo = {
"name": name,
"color": bg_color,
"text_color": text_color,
"keywords": keywords,
}
self.entities.append(new_entity)
self.new_label_name = ""
self.new_label_keywords_str = ""
self.new_label_selected_color_index = 0
yield rx.toast(
f"Label '{name}' added successfully.",
duration=3000,
)
if keywords:
yield NerState.process_text_on_load
@rx.event
def remove_label(self, label_name: str):
"""Removes a label definition and unlabels segments with that label."""
self.entities = [
entity for entity in self.entities if entity["name"] != label_name
]
updated_segments = []
for seg in self.display_segments:
if seg["label_name"] == label_ | self.new_label_selected_color_index = 0 |
string for the new label being created."""
self.new_label_keywords_str = keywords
@rx.event
def set_new_label_color_index(self, index: int):
"""Updates the selected color index for the new label."""
self.new_label_selected_color_index = index
@rx.event
def add_new_label(self):
"""Adds a new label to the entities list using the selected color."""
name = self.new_label_name.strip().upper()
if not name:
return rx.toast("Label name cannot be empty.", duration=3000)
if any((entity["name"] == name for entity in self.entities)):
return rx.toast(
f"Label '{name}' already exists.",
duration=3000,
)
keywords = [
k.strip() for k in self.new_label_keywords_str.split(",") if k.strip()
]
if not 0 <= self.new_label_selected_color_index < len(self.available_colors):
self.new_label_selected_color_index = 0
|
new_entity: EntityInfo = {
"name": name,
"color": bg_color,
"text_color": text_color,
"keywords": keywords,
}
self.entities.append(new_entity)
self.new_label_name = ""
self.new_label_keywords_str = ""
self.new_label_selected_color_index = 0
yield rx.toast(
f"Label '{name}' added successfully.",
duration=3000,
)
if keywords:
yield NerState.process_text_on_load
@rx.event
def remove_label(self, label_name: str):
"""Removes a label definition and unlabels segments with that label."""
self.entities = [
entity for entity in self.entities if entity["name"] != label_name
]
updated_segments = []
for seg in self.display_segments:
if seg["label_name"] == label_name:
updated_segments.append(
{
**seg,
| bg_color, text_color = self.available_colors[
self.new_label_selected_color_index
] |
"""Adds a new label to the entities list using the selected color."""
name = self.new_label_name.strip().upper()
if not name:
return rx.toast("Label name cannot be empty.", duration=3000)
if any((entity["name"] == name for entity in self.entities)):
return rx.toast(
f"Label '{name}' already exists.",
duration=3000,
)
keywords = [
k.strip() for k in self.new_label_keywords_str.split(",") if k.strip()
]
if not 0 <= self.new_label_selected_color_index < len(self.available_colors):
self.new_label_selected_color_index = 0
bg_color, text_color = self.available_colors[
self.new_label_selected_color_index
]
new_entity: EntityInfo = {
"name": name,
"color": bg_color,
"text_color": text_color,
"keywords": keywords,
}
self.entities.append(new_entity)
|
self.new_label_keywords_str = ""
self.new_label_selected_color_index = 0
yield rx.toast(
f"Label '{name}' added successfully.",
duration=3000,
)
if keywords:
yield NerState.process_text_on_load
@rx.event
def remove_label(self, label_name: str):
"""Removes a label definition and unlabels segments with that label."""
self.entities = [
entity for entity in self.entities if entity["name"] != label_name
]
updated_segments = []
for seg in self.display_segments:
if seg["label_name"] == label_name:
updated_segments.append(
{
**seg,
"label_name": None,
"bg_color": None,
"text_color": None,
}
)
else:
updated_segments.append(seg)
self.display_segmen | self.new_label_name = "" |
ties list using the selected color."""
name = self.new_label_name.strip().upper()
if not name:
return rx.toast("Label name cannot be empty.", duration=3000)
if any((entity["name"] == name for entity in self.entities)):
return rx.toast(
f"Label '{name}' already exists.",
duration=3000,
)
keywords = [
k.strip() for k in self.new_label_keywords_str.split(",") if k.strip()
]
if not 0 <= self.new_label_selected_color_index < len(self.available_colors):
self.new_label_selected_color_index = 0
bg_color, text_color = self.available_colors[
self.new_label_selected_color_index
]
new_entity: EntityInfo = {
"name": name,
"color": bg_color,
"text_color": text_color,
"keywords": keywords,
}
self.entities.append(new_entity)
self.new_label_name = ""
|
self.new_label_selected_color_index = 0
yield rx.toast(
f"Label '{name}' added successfully.",
duration=3000,
)
if keywords:
yield NerState.process_text_on_load
@rx.event
def remove_label(self, label_name: str):
"""Removes a label definition and unlabels segments with that label."""
self.entities = [
entity for entity in self.entities if entity["name"] != label_name
]
updated_segments = []
for seg in self.display_segments:
if seg["label_name"] == label_name:
updated_segments.append(
{
**seg,
"label_name": None,
"bg_color": None,
"text_color": None,
}
)
else:
updated_segments.append(seg)
self.display_segments = updated_segments
if self.sel | self.new_label_keywords_str = "" |
name = self.new_label_name.strip().upper()
if not name:
return rx.toast("Label name cannot be empty.", duration=3000)
if any((entity["name"] == name for entity in self.entities)):
return rx.toast(
f"Label '{name}' already exists.",
duration=3000,
)
keywords = [
k.strip() for k in self.new_label_keywords_str.split(",") if k.strip()
]
if not 0 <= self.new_label_selected_color_index < len(self.available_colors):
self.new_label_selected_color_index = 0
bg_color, text_color = self.available_colors[
self.new_label_selected_color_index
]
new_entity: EntityInfo = {
"name": name,
"color": bg_color,
"text_color": text_color,
"keywords": keywords,
}
self.entities.append(new_entity)
self.new_label_name = ""
self.new_label_keywords_str = ""
|
yield rx.toast(
f"Label '{name}' added successfully.",
duration=3000,
)
if keywords:
yield NerState.process_text_on_load
@rx.event
def remove_label(self, label_name: str):
"""Removes a label definition and unlabels segments with that label."""
self.entities = [
entity for entity in self.entities if entity["name"] != label_name
]
updated_segments = []
for seg in self.display_segments:
if seg["label_name"] == label_name:
updated_segments.append(
{
**seg,
"label_name": None,
"bg_color": None,
"text_color": None,
}
)
else:
updated_segments.append(seg)
self.display_segments = updated_segments
if self.selected_label_name == label_name:
self | self.new_label_selected_color_index = 0 |
entity["name"] == name for entity in self.entities)):
return rx.toast(
f"Label '{name}' already exists.",
duration=3000,
)
keywords = [
k.strip() for k in self.new_label_keywords_str.split(",") if k.strip()
]
if not 0 <= self.new_label_selected_color_index < len(self.available_colors):
self.new_label_selected_color_index = 0
bg_color, text_color = self.available_colors[
self.new_label_selected_color_index
]
new_entity: EntityInfo = {
"name": name,
"color": bg_color,
"text_color": text_color,
"keywords": keywords,
}
self.entities.append(new_entity)
self.new_label_name = ""
self.new_label_keywords_str = ""
self.new_label_selected_color_index = 0
yield rx.toast(
f"Label '{name}' added successfully.",
duration=3000,
)
|
@rx.event
def remove_label(self, label_name: str):
"""Removes a label definition and unlabels segments with that label."""
self.entities = [
entity for entity in self.entities if entity["name"] != label_name
]
updated_segments = []
for seg in self.display_segments:
if seg["label_name"] == label_name:
updated_segments.append(
{
**seg,
"label_name": None,
"bg_color": None,
"text_color": None,
}
)
else:
updated_segments.append(seg)
self.display_segments = updated_segments
if self.selected_label_name == label_name:
self.selected_label_name = None
yield rx.toast(f"Label '{label_name}' removed.", duration=2000)
@rx.var
def annotated_text_json(self) -> str:
"""Creates a JSON | if keywords:
yield NerState.process_text_on_load |
t(
f"Label '{name}' already exists.",
duration=3000,
)
keywords = [
k.strip() for k in self.new_label_keywords_str.split(",") if k.strip()
]
if not 0 <= self.new_label_selected_color_index < len(self.available_colors):
self.new_label_selected_color_index = 0
bg_color, text_color = self.available_colors[
self.new_label_selected_color_index
]
new_entity: EntityInfo = {
"name": name,
"color": bg_color,
"text_color": text_color,
"keywords": keywords,
}
self.entities.append(new_entity)
self.new_label_name = ""
self.new_label_keywords_str = ""
self.new_label_selected_color_index = 0
yield rx.toast(
f"Label '{name}' added successfully.",
duration=3000,
)
if keywords:
yield NerState.process_text_on_load
@rx.event
|
@rx.var
def annotated_text_json(self) -> str:
"""Creates a JSON string representation of the annotated text."""
output_data = []
current_entity_text = ""
current_entity_label = None
for segment in self.display_segments:
if segment["label_name"] != current_entity_label:
if current_entity_label and current_entity_text:
output_data.append(
{
"text": current_entity_text,
"label": current_entity_label,
}
)
current_entity_text = segment["text"]
current_entity_label = segment["label_name"]
else:
current_entity_text += segment["text"]
if current_entity_label and current_entity_text:
output_data.append(
{
"text": current_entity_text,
"label": | def remove_label(self, label_name: str):
"""Removes a label definition and unlabels segments with that label."""
self.entities = [
entity for entity in self.entities if entity["name"] != label_name
]
updated_segments = []
for seg in self.display_segments:
if seg["label_name"] == label_name:
updated_segments.append(
{
**seg,
"label_name": None,
"bg_color": None,
"text_color": None,
}
)
else:
updated_segments.append(seg)
self.display_segments = updated_segments
if self.selected_label_name == label_name:
self.selected_label_name = None
yield rx.toast(f"Label '{label_name}' removed.", duration=2000) |
k.strip() for k in self.new_label_keywords_str.split(",") if k.strip()
]
if not 0 <= self.new_label_selected_color_index < len(self.available_colors):
self.new_label_selected_color_index = 0
bg_color, text_color = self.available_colors[
self.new_label_selected_color_index
]
new_entity: EntityInfo = {
"name": name,
"color": bg_color,
"text_color": text_color,
"keywords": keywords,
}
self.entities.append(new_entity)
self.new_label_name = ""
self.new_label_keywords_str = ""
self.new_label_selected_color_index = 0
yield rx.toast(
f"Label '{name}' added successfully.",
duration=3000,
)
if keywords:
yield NerState.process_text_on_load
@rx.event
def remove_label(self, label_name: str):
"""Removes a label definition and unlabels segments with that label."""
|
updated_segments = []
for seg in self.display_segments:
if seg["label_name"] == label_name:
updated_segments.append(
{
**seg,
"label_name": None,
"bg_color": None,
"text_color": None,
}
)
else:
updated_segments.append(seg)
self.display_segments = updated_segments
if self.selected_label_name == label_name:
self.selected_label_name = None
yield rx.toast(f"Label '{label_name}' removed.", duration=2000)
@rx.var
def annotated_text_json(self) -> str:
"""Creates a JSON string representation of the annotated text."""
output_data = []
current_entity_text = ""
current_entity_label = None
for segment in self.display_segments:
if segment["label_name"] != current_entity_label:
| self.entities = [
entity for entity in self.entities if entity["name"] != label_name
] |
bel_selected_color_index < len(self.available_colors):
self.new_label_selected_color_index = 0
bg_color, text_color = self.available_colors[
self.new_label_selected_color_index
]
new_entity: EntityInfo = {
"name": name,
"color": bg_color,
"text_color": text_color,
"keywords": keywords,
}
self.entities.append(new_entity)
self.new_label_name = ""
self.new_label_keywords_str = ""
self.new_label_selected_color_index = 0
yield rx.toast(
f"Label '{name}' added successfully.",
duration=3000,
)
if keywords:
yield NerState.process_text_on_load
@rx.event
def remove_label(self, label_name: str):
"""Removes a label definition and unlabels segments with that label."""
self.entities = [
entity for entity in self.entities if entity["name"] != label_name
]
|
for seg in self.display_segments:
if seg["label_name"] == label_name:
updated_segments.append(
{
**seg,
"label_name": None,
"bg_color": None,
"text_color": None,
}
)
else:
updated_segments.append(seg)
self.display_segments = updated_segments
if self.selected_label_name == label_name:
self.selected_label_name = None
yield rx.toast(f"Label '{label_name}' removed.", duration=2000)
@rx.var
def annotated_text_json(self) -> str:
"""Creates a JSON string representation of the annotated text."""
output_data = []
current_entity_text = ""
current_entity_label = None
for segment in self.display_segments:
if segment["label_name"] != current_entity_label:
if current_entity_l | updated_segments = [] |
(self.available_colors):
self.new_label_selected_color_index = 0
bg_color, text_color = self.available_colors[
self.new_label_selected_color_index
]
new_entity: EntityInfo = {
"name": name,
"color": bg_color,
"text_color": text_color,
"keywords": keywords,
}
self.entities.append(new_entity)
self.new_label_name = ""
self.new_label_keywords_str = ""
self.new_label_selected_color_index = 0
yield rx.toast(
f"Label '{name}' added successfully.",
duration=3000,
)
if keywords:
yield NerState.process_text_on_load
@rx.event
def remove_label(self, label_name: str):
"""Removes a label definition and unlabels segments with that label."""
self.entities = [
entity for entity in self.entities if entity["name"] != label_name
]
updated_segments = []
|
self.display_segments = updated_segments
if self.selected_label_name == label_name:
self.selected_label_name = None
yield rx.toast(f"Label '{label_name}' removed.", duration=2000)
@rx.var
def annotated_text_json(self) -> str:
"""Creates a JSON string representation of the annotated text."""
output_data = []
current_entity_text = ""
current_entity_label = None
for segment in self.display_segments:
if segment["label_name"] != current_entity_label:
if current_entity_label and current_entity_text:
output_data.append(
{
"text": current_entity_text,
"label": current_entity_label,
}
)
current_entity_text = segment["text"]
current_entity_label = segment["label_name"]
else:
current_ | for seg in self.display_segments:
if seg["label_name"] == label_name:
updated_segments.append(
{
**seg,
"label_name": None,
"bg_color": None,
"text_color": None,
}
)
else:
updated_segments.append(seg) |
label_selected_color_index = 0
bg_color, text_color = self.available_colors[
self.new_label_selected_color_index
]
new_entity: EntityInfo = {
"name": name,
"color": bg_color,
"text_color": text_color,
"keywords": keywords,
}
self.entities.append(new_entity)
self.new_label_name = ""
self.new_label_keywords_str = ""
self.new_label_selected_color_index = 0
yield rx.toast(
f"Label '{name}' added successfully.",
duration=3000,
)
if keywords:
yield NerState.process_text_on_load
@rx.event
def remove_label(self, label_name: str):
"""Removes a label definition and unlabels segments with that label."""
self.entities = [
entity for entity in self.entities if entity["name"] != label_name
]
updated_segments = []
for seg in self.display_segments:
|
self.display_segments = updated_segments
if self.selected_label_name == label_name:
self.selected_label_name = None
yield rx.toast(f"Label '{label_name}' removed.", duration=2000)
@rx.var
def annotated_text_json(self) -> str:
"""Creates a JSON string representation of the annotated text."""
output_data = []
current_entity_text = ""
current_entity_label = None
for segment in self.display_segments:
if segment["label_name"] != current_entity_label:
if current_entity_label and current_entity_text:
output_data.append(
{
"text": current_entity_text,
"label": current_entity_label,
}
)
current_entity_text = segment["text"]
current_entity_label = segment["label_name"]
else:
current_ | if seg["label_name"] == label_name:
updated_segments.append(
{
**seg,
"label_name": None,
"bg_color": None,
"text_color": None,
}
)
else:
updated_segments.append(seg) |
new_label_name = ""
self.new_label_keywords_str = ""
self.new_label_selected_color_index = 0
yield rx.toast(
f"Label '{name}' added successfully.",
duration=3000,
)
if keywords:
yield NerState.process_text_on_load
@rx.event
def remove_label(self, label_name: str):
"""Removes a label definition and unlabels segments with that label."""
self.entities = [
entity for entity in self.entities if entity["name"] != label_name
]
updated_segments = []
for seg in self.display_segments:
if seg["label_name"] == label_name:
updated_segments.append(
{
**seg,
"label_name": None,
"bg_color": None,
"text_color": None,
}
)
else:
updated_segments.append(seg)
|
if self.selected_label_name == label_name:
self.selected_label_name = None
yield rx.toast(f"Label '{label_name}' removed.", duration=2000)
@rx.var
def annotated_text_json(self) -> str:
"""Creates a JSON string representation of the annotated text."""
output_data = []
current_entity_text = ""
current_entity_label = None
for segment in self.display_segments:
if segment["label_name"] != current_entity_label:
if current_entity_label and current_entity_text:
output_data.append(
{
"text": current_entity_text,
"label": current_entity_label,
}
)
current_entity_text = segment["text"]
current_entity_label = segment["label_name"]
else:
current_entity_text += segment["text"]
if current | self.display_segments = updated_segments |
ds_str = ""
self.new_label_selected_color_index = 0
yield rx.toast(
f"Label '{name}' added successfully.",
duration=3000,
)
if keywords:
yield NerState.process_text_on_load
@rx.event
def remove_label(self, label_name: str):
"""Removes a label definition and unlabels segments with that label."""
self.entities = [
entity for entity in self.entities if entity["name"] != label_name
]
updated_segments = []
for seg in self.display_segments:
if seg["label_name"] == label_name:
updated_segments.append(
{
**seg,
"label_name": None,
"bg_color": None,
"text_color": None,
}
)
else:
updated_segments.append(seg)
self.display_segments = updated_segments
|
yield rx.toast(f"Label '{label_name}' removed.", duration=2000)
@rx.var
def annotated_text_json(self) -> str:
"""Creates a JSON string representation of the annotated text."""
output_data = []
current_entity_text = ""
current_entity_label = None
for segment in self.display_segments:
if segment["label_name"] != current_entity_label:
if current_entity_label and current_entity_text:
output_data.append(
{
"text": current_entity_text,
"label": current_entity_label,
}
)
current_entity_text = segment["text"]
current_entity_label = segment["label_name"]
else:
current_entity_text += segment["text"]
if current_entity_label and current_entity_text:
output_data.append(
{
| if self.selected_label_name == label_name:
self.selected_label_name = None |
= 0
yield rx.toast(
f"Label '{name}' added successfully.",
duration=3000,
)
if keywords:
yield NerState.process_text_on_load
@rx.event
def remove_label(self, label_name: str):
"""Removes a label definition and unlabels segments with that label."""
self.entities = [
entity for entity in self.entities if entity["name"] != label_name
]
updated_segments = []
for seg in self.display_segments:
if seg["label_name"] == label_name:
updated_segments.append(
{
**seg,
"label_name": None,
"bg_color": None,
"text_color": None,
}
)
else:
updated_segments.append(seg)
self.display_segments = updated_segments
if self.selected_label_name == label_name:
|
yield rx.toast(f"Label '{label_name}' removed.", duration=2000)
@rx.var
def annotated_text_json(self) -> str:
"""Creates a JSON string representation of the annotated text."""
output_data = []
current_entity_text = ""
current_entity_label = None
for segment in self.display_segments:
if segment["label_name"] != current_entity_label:
if current_entity_label and current_entity_text:
output_data.append(
{
"text": current_entity_text,
"label": current_entity_label,
}
)
current_entity_text = segment["text"]
current_entity_label = segment["label_name"]
else:
current_entity_text += segment["text"]
if current_entity_label and current_entity_text:
output_data.append(
{
| self.selected_label_name = None |
tr):
"""Removes a label definition and unlabels segments with that label."""
self.entities = [
entity for entity in self.entities if entity["name"] != label_name
]
updated_segments = []
for seg in self.display_segments:
if seg["label_name"] == label_name:
updated_segments.append(
{
**seg,
"label_name": None,
"bg_color": None,
"text_color": None,
}
)
else:
updated_segments.append(seg)
self.display_segments = updated_segments
if self.selected_label_name == label_name:
self.selected_label_name = None
yield rx.toast(f"Label '{label_name}' removed.", duration=2000)
@rx.var
def annotated_text_json(self) -> str:
"""Creates a JSON string representation of the annotated text."""
|
current_entity_text = ""
current_entity_label = None
for segment in self.display_segments:
if segment["label_name"] != current_entity_label:
if current_entity_label and current_entity_text:
output_data.append(
{
"text": current_entity_text,
"label": current_entity_label,
}
)
current_entity_text = segment["text"]
current_entity_label = segment["label_name"]
else:
current_entity_text += segment["text"]
if current_entity_label and current_entity_text:
output_data.append(
{
"text": current_entity_text,
"label": current_entity_label,
}
)
elif not current_entity_label and current_entity_text:
output_data.append({"text | output_data = [] |
label definition and unlabels segments with that label."""
self.entities = [
entity for entity in self.entities if entity["name"] != label_name
]
updated_segments = []
for seg in self.display_segments:
if seg["label_name"] == label_name:
updated_segments.append(
{
**seg,
"label_name": None,
"bg_color": None,
"text_color": None,
}
)
else:
updated_segments.append(seg)
self.display_segments = updated_segments
if self.selected_label_name == label_name:
self.selected_label_name = None
yield rx.toast(f"Label '{label_name}' removed.", duration=2000)
@rx.var
def annotated_text_json(self) -> str:
"""Creates a JSON string representation of the annotated text."""
output_data = []
|
current_entity_label = None
for segment in self.display_segments:
if segment["label_name"] != current_entity_label:
if current_entity_label and current_entity_text:
output_data.append(
{
"text": current_entity_text,
"label": current_entity_label,
}
)
current_entity_text = segment["text"]
current_entity_label = segment["label_name"]
else:
current_entity_text += segment["text"]
if current_entity_label and current_entity_text:
output_data.append(
{
"text": current_entity_text,
"label": current_entity_label,
}
)
elif not current_entity_label and current_entity_text:
output_data.append({"text": current_entity_text, "label": | current_entity_text = "" |
gments with that label."""
self.entities = [
entity for entity in self.entities if entity["name"] != label_name
]
updated_segments = []
for seg in self.display_segments:
if seg["label_name"] == label_name:
updated_segments.append(
{
**seg,
"label_name": None,
"bg_color": None,
"text_color": None,
}
)
else:
updated_segments.append(seg)
self.display_segments = updated_segments
if self.selected_label_name == label_name:
self.selected_label_name = None
yield rx.toast(f"Label '{label_name}' removed.", duration=2000)
@rx.var
def annotated_text_json(self) -> str:
"""Creates a JSON string representation of the annotated text."""
output_data = []
current_entity_text = ""
|
for segment in self.display_segments:
if segment["label_name"] != current_entity_label:
if current_entity_label and current_entity_text:
output_data.append(
{
"text": current_entity_text,
"label": current_entity_label,
}
)
current_entity_text = segment["text"]
current_entity_label = segment["label_name"]
else:
current_entity_text += segment["text"]
if current_entity_label and current_entity_text:
output_data.append(
{
"text": current_entity_text,
"label": current_entity_label,
}
)
elif not current_entity_label and current_entity_text:
output_data.append({"text": current_entity_text, "label": None})
final_output = []
| current_entity_label = None |
elf.entities = [
entity for entity in self.entities if entity["name"] != label_name
]
updated_segments = []
for seg in self.display_segments:
if seg["label_name"] == label_name:
updated_segments.append(
{
**seg,
"label_name": None,
"bg_color": None,
"text_color": None,
}
)
else:
updated_segments.append(seg)
self.display_segments = updated_segments
if self.selected_label_name == label_name:
self.selected_label_name = None
yield rx.toast(f"Label '{label_name}' removed.", duration=2000)
@rx.var
def annotated_text_json(self) -> str:
"""Creates a JSON string representation of the annotated text."""
output_data = []
current_entity_text = ""
current_entity_label = None
|
if current_entity_label and current_entity_text:
output_data.append(
{
"text": current_entity_text,
"label": current_entity_label,
}
)
elif not current_entity_label and current_entity_text:
output_data.append({"text": current_entity_text, "label": None})
final_output = []
temp_text = ""
for item in output_data:
if item["label"] is None:
temp_text += item["text"]
else:
if temp_text:
final_output.append({"text": temp_text, "label": None})
temp_text = ""
final_output.append(item)
if temp_text:
final_output.append({"text": temp_text, "label": None})
return json.dumps(
{
"annotations": final_output,
"labels": self.entities,
},
indent=2,
| for segment in self.display_segments:
if segment["label_name"] != current_entity_label:
if current_entity_label and current_entity_text:
output_data.append(
{
"text": current_entity_text,
"label": current_entity_label,
}
)
current_entity_text = segment["text"]
current_entity_label = segment["label_name"]
else:
current_entity_text += segment["text"] |
self.entities if entity["name"] != label_name
]
updated_segments = []
for seg in self.display_segments:
if seg["label_name"] == label_name:
updated_segments.append(
{
**seg,
"label_name": None,
"bg_color": None,
"text_color": None,
}
)
else:
updated_segments.append(seg)
self.display_segments = updated_segments
if self.selected_label_name == label_name:
self.selected_label_name = None
yield rx.toast(f"Label '{label_name}' removed.", duration=2000)
@rx.var
def annotated_text_json(self) -> str:
"""Creates a JSON string representation of the annotated text."""
output_data = []
current_entity_text = ""
current_entity_label = None
for segment in self.display_segments:
|
if current_entity_label and current_entity_text:
output_data.append(
{
"text": current_entity_text,
"label": current_entity_label,
}
)
elif not current_entity_label and current_entity_text:
output_data.append({"text": current_entity_text, "label": None})
final_output = []
temp_text = ""
for item in output_data:
if item["label"] is None:
temp_text += item["text"]
else:
if temp_text:
final_output.append({"text": temp_text, "label": None})
temp_text = ""
final_output.append(item)
if temp_text:
final_output.append({"text": temp_text, "label": None})
return json.dumps(
{
"annotations": final_output,
"labels": self.entities,
},
indent=2,
| if segment["label_name"] != current_entity_label:
if current_entity_label and current_entity_text:
output_data.append(
{
"text": current_entity_text,
"label": current_entity_label,
}
)
current_entity_text = segment["text"]
current_entity_label = segment["label_name"]
else:
current_entity_text += segment["text"] |
dated_segments = []
for seg in self.display_segments:
if seg["label_name"] == label_name:
updated_segments.append(
{
**seg,
"label_name": None,
"bg_color": None,
"text_color": None,
}
)
else:
updated_segments.append(seg)
self.display_segments = updated_segments
if self.selected_label_name == label_name:
self.selected_label_name = None
yield rx.toast(f"Label '{label_name}' removed.", duration=2000)
@rx.var
def annotated_text_json(self) -> str:
"""Creates a JSON string representation of the annotated text."""
output_data = []
current_entity_text = ""
current_entity_label = None
for segment in self.display_segments:
if segment["label_name"] != current_entity_label:
|
current_entity_text = segment["text"]
current_entity_label = segment["label_name"]
else:
current_entity_text += segment["text"]
if current_entity_label and current_entity_text:
output_data.append(
{
"text": current_entity_text,
"label": current_entity_label,
}
)
elif not current_entity_label and current_entity_text:
output_data.append({"text": current_entity_text, "label": None})
final_output = []
temp_text = ""
for item in output_data:
if item["label"] is None:
temp_text += item["text"]
else:
if temp_text:
final_output.append({"text": temp_text, "label": None})
temp_text = ""
final_output.append(item)
if temp_text:
final_output.append({"text": temp_t | if current_entity_label and current_entity_text:
output_data.append(
{
"text": current_entity_text,
"label": current_entity_label,
}
) |
"text_color": None,
}
)
else:
updated_segments.append(seg)
self.display_segments = updated_segments
if self.selected_label_name == label_name:
self.selected_label_name = None
yield rx.toast(f"Label '{label_name}' removed.", duration=2000)
@rx.var
def annotated_text_json(self) -> str:
"""Creates a JSON string representation of the annotated text."""
output_data = []
current_entity_text = ""
current_entity_label = None
for segment in self.display_segments:
if segment["label_name"] != current_entity_label:
if current_entity_label and current_entity_text:
output_data.append(
{
"text": current_entity_text,
"label": current_entity_label,
}
)
|
current_entity_label = segment["label_name"]
else:
current_entity_text += segment["text"]
if current_entity_label and current_entity_text:
output_data.append(
{
"text": current_entity_text,
"label": current_entity_label,
}
)
elif not current_entity_label and current_entity_text:
output_data.append({"text": current_entity_text, "label": None})
final_output = []
temp_text = ""
for item in output_data:
if item["label"] is None:
temp_text += item["text"]
else:
if temp_text:
final_output.append({"text": temp_text, "label": None})
temp_text = ""
final_output.append(item)
if temp_text:
final_output.append({"text": temp_text, "label": None})
return json.dumps(
| current_entity_text = segment["text"] |
}
)
else:
updated_segments.append(seg)
self.display_segments = updated_segments
if self.selected_label_name == label_name:
self.selected_label_name = None
yield rx.toast(f"Label '{label_name}' removed.", duration=2000)
@rx.var
def annotated_text_json(self) -> str:
"""Creates a JSON string representation of the annotated text."""
output_data = []
current_entity_text = ""
current_entity_label = None
for segment in self.display_segments:
if segment["label_name"] != current_entity_label:
if current_entity_label and current_entity_text:
output_data.append(
{
"text": current_entity_text,
"label": current_entity_label,
}
)
current_entity_text = segment["text"]
|
else:
current_entity_text += segment["text"]
if current_entity_label and current_entity_text:
output_data.append(
{
"text": current_entity_text,
"label": current_entity_label,
}
)
elif not current_entity_label and current_entity_text:
output_data.append({"text": current_entity_text, "label": None})
final_output = []
temp_text = ""
for item in output_data:
if item["label"] is None:
temp_text += item["text"]
else:
if temp_text:
final_output.append({"text": temp_text, "label": None})
temp_text = ""
final_output.append(item)
if temp_text:
final_output.append({"text": temp_text, "label": None})
return json.dumps(
{
"annotations": final_output,
| current_entity_label = segment["label_name"] |
d_segments
if self.selected_label_name == label_name:
self.selected_label_name = None
yield rx.toast(f"Label '{label_name}' removed.", duration=2000)
@rx.var
def annotated_text_json(self) -> str:
"""Creates a JSON string representation of the annotated text."""
output_data = []
current_entity_text = ""
current_entity_label = None
for segment in self.display_segments:
if segment["label_name"] != current_entity_label:
if current_entity_label and current_entity_text:
output_data.append(
{
"text": current_entity_text,
"label": current_entity_label,
}
)
current_entity_text = segment["text"]
current_entity_label = segment["label_name"]
else:
current_entity_text += segment["text"]
|
final_output = []
temp_text = ""
for item in output_data:
if item["label"] is None:
temp_text += item["text"]
else:
if temp_text:
final_output.append({"text": temp_text, "label": None})
temp_text = ""
final_output.append(item)
if temp_text:
final_output.append({"text": temp_text, "label": None})
return json.dumps(
{
"annotations": final_output,
"labels": self.entities,
},
indent=2,
)
| if current_entity_label and current_entity_text:
output_data.append(
{
"text": current_entity_text,
"label": current_entity_label,
}
)
elif not current_entity_label and current_entity_text:
output_data.append({"text": current_entity_text, "label": None}) |
"""Creates a JSON string representation of the annotated text."""
output_data = []
current_entity_text = ""
current_entity_label = None
for segment in self.display_segments:
if segment["label_name"] != current_entity_label:
if current_entity_label and current_entity_text:
output_data.append(
{
"text": current_entity_text,
"label": current_entity_label,
}
)
current_entity_text = segment["text"]
current_entity_label = segment["label_name"]
else:
current_entity_text += segment["text"]
if current_entity_label and current_entity_text:
output_data.append(
{
"text": current_entity_text,
"label": current_entity_label,
}
)
|
final_output = []
temp_text = ""
for item in output_data:
if item["label"] is None:
temp_text += item["text"]
else:
if temp_text:
final_output.append({"text": temp_text, "label": None})
temp_text = ""
final_output.append(item)
if temp_text:
final_output.append({"text": temp_text, "label": None})
return json.dumps(
{
"annotations": final_output,
"labels": self.entities,
},
indent=2,
)
| elif not current_entity_label and current_entity_text:
output_data.append({"text": current_entity_text, "label": None}) |
t_entity_label = None
for segment in self.display_segments:
if segment["label_name"] != current_entity_label:
if current_entity_label and current_entity_text:
output_data.append(
{
"text": current_entity_text,
"label": current_entity_label,
}
)
current_entity_text = segment["text"]
current_entity_label = segment["label_name"]
else:
current_entity_text += segment["text"]
if current_entity_label and current_entity_text:
output_data.append(
{
"text": current_entity_text,
"label": current_entity_label,
}
)
elif not current_entity_label and current_entity_text:
output_data.append({"text": current_entity_text, "label": None})
|
temp_text = ""
for item in output_data:
if item["label"] is None:
temp_text += item["text"]
else:
if temp_text:
final_output.append({"text": temp_text, "label": None})
temp_text = ""
final_output.append(item)
if temp_text:
final_output.append({"text": temp_text, "label": None})
return json.dumps(
{
"annotations": final_output,
"labels": self.entities,
},
indent=2,
)
| final_output = [] |
for segment in self.display_segments:
if segment["label_name"] != current_entity_label:
if current_entity_label and current_entity_text:
output_data.append(
{
"text": current_entity_text,
"label": current_entity_label,
}
)
current_entity_text = segment["text"]
current_entity_label = segment["label_name"]
else:
current_entity_text += segment["text"]
if current_entity_label and current_entity_text:
output_data.append(
{
"text": current_entity_text,
"label": current_entity_label,
}
)
elif not current_entity_label and current_entity_text:
output_data.append({"text": current_entity_text, "label": None})
final_output = []
|
for item in output_data:
if item["label"] is None:
temp_text += item["text"]
else:
if temp_text:
final_output.append({"text": temp_text, "label": None})
temp_text = ""
final_output.append(item)
if temp_text:
final_output.append({"text": temp_text, "label": None})
return json.dumps(
{
"annotations": final_output,
"labels": self.entities,
},
indent=2,
)
| temp_text = "" |
.display_segments:
if segment["label_name"] != current_entity_label:
if current_entity_label and current_entity_text:
output_data.append(
{
"text": current_entity_text,
"label": current_entity_label,
}
)
current_entity_text = segment["text"]
current_entity_label = segment["label_name"]
else:
current_entity_text += segment["text"]
if current_entity_label and current_entity_text:
output_data.append(
{
"text": current_entity_text,
"label": current_entity_label,
}
)
elif not current_entity_label and current_entity_text:
output_data.append({"text": current_entity_text, "label": None})
final_output = []
temp_text = ""
|
if temp_text:
final_output.append({"text": temp_text, "label": None})
return json.dumps(
{
"annotations": final_output,
"labels": self.entities,
},
indent=2,
)
| for item in output_data:
if item["label"] is None:
temp_text += item["text"]
else:
if temp_text:
final_output.append({"text": temp_text, "label": None})
temp_text = ""
final_output.append(item) |
ment["label_name"] != current_entity_label:
if current_entity_label and current_entity_text:
output_data.append(
{
"text": current_entity_text,
"label": current_entity_label,
}
)
current_entity_text = segment["text"]
current_entity_label = segment["label_name"]
else:
current_entity_text += segment["text"]
if current_entity_label and current_entity_text:
output_data.append(
{
"text": current_entity_text,
"label": current_entity_label,
}
)
elif not current_entity_label and current_entity_text:
output_data.append({"text": current_entity_text, "label": None})
final_output = []
temp_text = ""
for item in output_data:
|
if temp_text:
final_output.append({"text": temp_text, "label": None})
return json.dumps(
{
"annotations": final_output,
"labels": self.entities,
},
indent=2,
)
| if item["label"] is None:
temp_text += item["text"]
else:
if temp_text:
final_output.append({"text": temp_text, "label": None})
temp_text = ""
final_output.append(item) |
_text:
output_data.append(
{
"text": current_entity_text,
"label": current_entity_label,
}
)
current_entity_text = segment["text"]
current_entity_label = segment["label_name"]
else:
current_entity_text += segment["text"]
if current_entity_label and current_entity_text:
output_data.append(
{
"text": current_entity_text,
"label": current_entity_label,
}
)
elif not current_entity_label and current_entity_text:
output_data.append({"text": current_entity_text, "label": None})
final_output = []
temp_text = ""
for item in output_data:
if item["label"] is None:
temp_text += item["text"]
else:
|
final_output.append(item)
if temp_text:
final_output.append({"text": temp_text, "label": None})
return json.dumps(
{
"annotations": final_output,
"labels": self.entities,
},
indent=2,
)
| if temp_text:
final_output.append({"text": temp_text, "label": None})
temp_text = "" |
urrent_entity_text,
"label": current_entity_label,
}
)
current_entity_text = segment["text"]
current_entity_label = segment["label_name"]
else:
current_entity_text += segment["text"]
if current_entity_label and current_entity_text:
output_data.append(
{
"text": current_entity_text,
"label": current_entity_label,
}
)
elif not current_entity_label and current_entity_text:
output_data.append({"text": current_entity_text, "label": None})
final_output = []
temp_text = ""
for item in output_data:
if item["label"] is None:
temp_text += item["text"]
else:
if temp_text:
final_output.append({"text": temp_text, "label": None})
|
final_output.append(item)
if temp_text:
final_output.append({"text": temp_text, "label": None})
return json.dumps(
{
"annotations": final_output,
"labels": self.entities,
},
indent=2,
)
| temp_text = "" |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.