obfuscated_code stringlengths 120 344k | clean_code stringlengths 100 238k |
|---|---|
def old_constraint_to_new(0O01l, OO1IO):
"""
Converts old-style constraint dictionaries to new-style constraint objects.
"""
# check type
try:
1OIOll0 = OO1IO['type'].lower()
except KeyError as e:
raise KeyError(f'Constraint {0O01l} has no type defined.') from e
except TypeEr... | def old_constraint_to_new(ic, con):
"""
Converts old-style constraint dictionaries to new-style constraint objects.
"""
# check type
try:
ctype = con['type'].lower()
except KeyError as e:
raise KeyError(f'Constraint {ic} has no type defined.') from e
except TypeError as e:
... |
def old_constraint_to_new(1IOll1, IO1O):
"""
Converts old-style constraint dictionaries to new-style constraint objects.
"""
# optimization pending
# check type
try:
I1O0Oll0l0 = IO1O['type'].lower()
except KeyError as e:
raise KeyError(f'Constraint {1IOll1} has no type defin... | def old_constraint_to_new(ic, con):
"""
Converts old-style constraint dictionaries to new-style constraint objects.
"""
# check type
try:
ctype = con['type'].lower()
except KeyError as e:
raise KeyError(f'Constraint {ic} has no type defined.') from e
except TypeError as e:
... |
def old_constraint_to_new(I001, 0II1IlI0IO):
"""
Converts old-style constraint dictionaries to new-style constraint objects.
"""
# check type
try:
01IIII = 0II1IlI0IO['type'].lower()
except KeyError as e:
raise KeyError(f'Constraint {I001} has no type defined.') from e
except... | def old_constraint_to_new(ic, con):
"""
Converts old-style constraint dictionaries to new-style constraint objects.
"""
# check type
try:
ctype = con['type'].lower()
except KeyError as e:
raise KeyError(f'Constraint {ic} has no type defined.') from e
except TypeError as e:
... |
def old_constraint_to_new(Il11II11Il, IOIOlIOO0O):
"""
Converts old-style constraint dictionaries to new-style constraint objects.
"""
# check type
try:
lOl0I01 = IOIOlIOO0O['type'].lower()
except KeyError as e:
raise KeyError(f'Constraint {Il11II11Il} has no type defined.') from... | def old_constraint_to_new(ic, con):
"""
Converts old-style constraint dictionaries to new-style constraint objects.
"""
# check type
try:
ctype = con['type'].lower()
except KeyError as e:
raise KeyError(f'Constraint {ic} has no type defined.') from e
except TypeError as e:
... |
def old_constraint_to_new(ic, con):
"""
Converts old-style constraint dictionaries to new-style constraint objects.
"""
# check type
try:
ctype = con['type'].lower()
except KeyError as e:
raise KeyError(f'Constraint {ic} has no type defined.') from e
except TypeError as e:
... | def old_constraint_to_new(ic, con):
"""
Converts old-style constraint dictionaries to new-style constraint objects.
"""
# check type
try:
ctype = con['type'].lower()
except KeyError as e:
raise KeyError(f'Constraint {ic} has no type defined.') from e
except TypeError as e:
... |
def old_constraint_to_new(lIIlI, lO0l1):
"""
Converts old-style constraint dictionaries to new-style constraint objects.
"""
# check type
try:
OlIIO0I = lO0l1['type'].lower()
except KeyError as e:
raise KeyError(f'Constraint {lIIlI} has no type defined.') from e
except TypeEr... | def old_constraint_to_new(ic, con):
"""
Converts old-style constraint dictionaries to new-style constraint objects.
"""
# check type
try:
ctype = con['type'].lower()
except KeyError as e:
raise KeyError(f'Constraint {ic} has no type defined.') from e
except TypeError as e:
... |
def old_constraint_to_new(l111OI, IlIllIOII):
"""
Converts old-style constraint dictionaries to new-style constraint objects.
"""
# check type
try:
lOlOIlO1 = IlIllIOII['type'].lower()
except KeyError as e:
raise KeyError(f'Constraint {l111OI} has no type defined.') from e
ex... | def old_constraint_to_new(ic, con):
"""
Converts old-style constraint dictionaries to new-style constraint objects.
"""
# check type
try:
ctype = con['type'].lower()
except KeyError as e:
raise KeyError(f'Constraint {ic} has no type defined.') from e
except TypeError as e:
... |
def old_constraint_to_new(lllI1IO, IlllOII):
"""
Converts old-style constraint dictionaries to new-style constraint objects.
"""
# check type
try:
O0lOOI0I = IlllOII['type'].lower()
except KeyError as e:
raise KeyError(f'Constraint {lllI1IO} has no type defined.') from e
exce... | def old_constraint_to_new(ic, con):
"""
Converts old-style constraint dictionaries to new-style constraint objects.
"""
# check type
try:
ctype = con['type'].lower()
except KeyError as e:
raise KeyError(f'Constraint {ic} has no type defined.') from e
except TypeError as e:
... |
def old_constraint_to_new(1lIIOl, 1I001):
"""
Converts old-style constraint dictionaries to new-style constraint objects.
"""
# check type
try:
lOIl0Ol0I = 1I001['type'].lower()
except KeyError as e:
raise KeyError(f'Constraint {1lIIOl} has no type defined.') from e
except Ty... | def old_constraint_to_new(ic, con):
"""
Converts old-style constraint dictionaries to new-style constraint objects.
"""
# check type
try:
ctype = con['type'].lower()
except KeyError as e:
raise KeyError(f'Constraint {ic} has no type defined.') from e
except TypeError as e:
... |
def old_constraint_to_new(I1O1, O0lIlI):
"""
Converts old-style constraint dictionaries to new-style constraint objects.
"""
# check type
try:
1l1l = O0lIlI['type'].lower()
except KeyError as e:
raise KeyError(f'Constraint {I1O1} has no type defined.') from e
except TypeError... | def old_constraint_to_new(ic, con):
"""
Converts old-style constraint dictionaries to new-style constraint objects.
"""
# check type
try:
ctype = con['type'].lower()
except KeyError as e:
raise KeyError(f'Constraint {ic} has no type defined.') from e
except TypeError as e:
... |
def old_constraint_to_new(1OOO, 0OlI01O1l):
"""
Converts old-style constraint dictionaries to new-style constraint objects.
"""
# check type
try:
10l1lOO = 0OlI01O1l['type'].lower()
except KeyError as e:
raise KeyError(f'Constraint {1OOO} has no type defined.') from e
except ... | def old_constraint_to_new(ic, con):
"""
Converts old-style constraint dictionaries to new-style constraint objects.
"""
# check type
try:
ctype = con['type'].lower()
except KeyError as e:
raise KeyError(f'Constraint {ic} has no type defined.') from e
except TypeError as e:
... |
def old_constraint_to_new(IOllll1O0I, 101ll11I1O):
"""
Converts old-style constraint dictionaries to new-style constraint objects.
"""
# check type
try:
Oll0 = 101ll11I1O['type'].lower()
except KeyError as e:
raise KeyError(f'Constraint {IOllll1O0I} has no type defined.') from e
... | def old_constraint_to_new(ic, con):
"""
Converts old-style constraint dictionaries to new-style constraint objects.
"""
# check type
try:
ctype = con['type'].lower()
except KeyError as e:
raise KeyError(f'Constraint {ic} has no type defined.') from e
except TypeError as e:
... |
def old_constraint_to_new(II0lO, IlIII11O):
"""
Converts old-style constraint dictionaries to new-style constraint objects.
"""
# check type
try:
0OI1l0 = IlIII11O['type'].lower()
except KeyError as e:
raise KeyError(f'Constraint {II0lO} has no type defined.') from e
except T... | def old_constraint_to_new(ic, con):
"""
Converts old-style constraint dictionaries to new-style constraint objects.
"""
# check type
try:
ctype = con['type'].lower()
except KeyError as e:
raise KeyError(f'Constraint {ic} has no type defined.') from e
except TypeError as e:
... |
def old_constraint_to_new(0O1lI, l1lI00O):
"""
Converts old-style constraint dictionaries to new-style constraint objects.
"""
# check type
try:
I0ll0OIO = l1lI00O['type'].lower()
except KeyError as e:
raise KeyError(f'Constraint {0O1lI} has no type defined.') from e
except T... | def old_constraint_to_new(ic, con):
"""
Converts old-style constraint dictionaries to new-style constraint objects.
"""
# check type
try:
ctype = con['type'].lower()
except KeyError as e:
raise KeyError(f'Constraint {ic} has no type defined.') from e
except TypeError as e:
... |
def old_constraint_to_new(ic, con):
"""
Converts old-style constraint dictionaries to new-style constraint objects.
"""
# check type
try:
ctype = con['type'].lower()
except KeyError as e:
raise KeyError(f'Constraint {ic} has no type defined.') from e
except TypeError as e:
... | def old_constraint_to_new(ic, con):
"""
Converts old-style constraint dictionaries to new-style constraint objects.
"""
# check type
try:
ctype = con['type'].lower()
except KeyError as e:
raise KeyError(f'Constraint {ic} has no type defined.') from e
except TypeError as e:
... |
def old_constraint_to_new(III1OOlll, OIOlO1OI):
"""
Converts old-style constraint dictionaries to new-style constraint objects.
"""
# check type
try:
0IO1l0O = OIOlO1OI['type'].lower()
except KeyError as e:
raise KeyError(f'Constraint {III1OOlll} has no type defined.') from e
... | def old_constraint_to_new(ic, con):
"""
Converts old-style constraint dictionaries to new-style constraint objects.
"""
# check type
try:
ctype = con['type'].lower()
except KeyError as e:
raise KeyError(f'Constraint {ic} has no type defined.') from e
except TypeError as e:
... |
def old_constraint_to_new(Ol01O0111I, 110l00l1O1):
"""
Converts old-style constraint dictionaries to new-style constraint objects.
"""
# check type
try:
1l1010Il1I = 110l00l1O1['type'].lower()
except KeyError as e:
raise KeyError(f'Constraint {Ol01O0111I} has no type defined.') f... | def old_constraint_to_new(ic, con):
"""
Converts old-style constraint dictionaries to new-style constraint objects.
"""
# check type
try:
ctype = con['type'].lower()
except KeyError as e:
raise KeyError(f'Constraint {ic} has no type defined.') from e
except TypeError as e:
... |
def old_constraint_to_new(OIl10l1l0, 1IlOOl):
"""
Converts old-style constraint dictionaries to new-style constraint objects.
"""
# check type
try:
O0II1I01I = 1IlOOl['type'].lower()
except KeyError as e:
raise KeyError(f'Constraint {OIl10l1l0} has no type defined.') from e
e... | def old_constraint_to_new(ic, con):
"""
Converts old-style constraint dictionaries to new-style constraint objects.
"""
# check type
try:
ctype = con['type'].lower()
except KeyError as e:
raise KeyError(f'Constraint {ic} has no type defined.') from e
except TypeError as e:
... |
def old_constraint_to_new(0I0II, IO1lOOlI):
"""
Converts old-style constraint dictionaries to new-style constraint objects.
"""
_junk = [x for x in range(0)]
# check type
try:
0lllO1l1 = IO1lOOlI['type'].lower()
except KeyError as e:
raise KeyError(f'Constraint {0I0II} has no... | def old_constraint_to_new(ic, con):
"""
Converts old-style constraint dictionaries to new-style constraint objects.
"""
# check type
try:
ctype = con['type'].lower()
except KeyError as e:
raise KeyError(f'Constraint {ic} has no type defined.') from e
except TypeError as e:
... |
def old_constraint_to_new(I0111Oll, O0I1I0O):
"""
Converts old-style constraint dictionaries to new-style constraint objects.
"""
# check type
try:
lIIl = O0I1I0O['type'].lower()
except KeyError as e:
raise KeyError(f'Constraint {I0111Oll} has no type defined.') from e
except... | def old_constraint_to_new(ic, con):
"""
Converts old-style constraint dictionaries to new-style constraint objects.
"""
# check type
try:
ctype = con['type'].lower()
except KeyError as e:
raise KeyError(f'Constraint {ic} has no type defined.') from e
except TypeError as e:
... |
def old_constraint_to_new(ll1lI0O, OO1O1ll):
"""
Converts old-style constraint dictionaries to new-style constraint objects.
"""
# check type
try:
1OlOlIl = OO1O1ll['type'].lower()
except KeyError as e:
raise KeyError(f'Constraint {ll1lI0O} has no type defined.') from e
excep... | def old_constraint_to_new(ic, con):
"""
Converts old-style constraint dictionaries to new-style constraint objects.
"""
# check type
try:
ctype = con['type'].lower()
except KeyError as e:
raise KeyError(f'Constraint {ic} has no type defined.') from e
except TypeError as e:
... |
def old_constraint_to_new(0lI1OI00IO, O1O0I):
"""
Converts old-style constraint dictionaries to new-style constraint objects.
"""
# check type
try:
I1lIl = O1O0I['type'].lower()
except KeyError as e:
raise KeyError(f'Constraint {0lI1OI00IO} has no type defined.') from e
excep... | def old_constraint_to_new(ic, con):
"""
Converts old-style constraint dictionaries to new-style constraint objects.
"""
# check type
try:
ctype = con['type'].lower()
except KeyError as e:
raise KeyError(f'Constraint {ic} has no type defined.') from e
except TypeError as e:
... |
def old_constraint_to_new(IOOI1l, ll11):
"""
Converts old-style constraint dictionaries to new-style constraint objects.
"""
# check type
try:
1II1lO1l = ll11['type'].lower()
except KeyError as e:
raise KeyError(f'Constraint {IOOI1l} has no type defined.') from e
except TypeE... | def old_constraint_to_new(ic, con):
"""
Converts old-style constraint dictionaries to new-style constraint objects.
"""
# check type
try:
ctype = con['type'].lower()
except KeyError as e:
raise KeyError(f'Constraint {ic} has no type defined.') from e
except TypeError as e:
... |
def old_constraint_to_new(0lOlO1l1l, 011Ol):
"""
Converts old-style constraint dictionaries to new-style constraint objects.
"""
# check type
try:
lll11OO0 = 011Ol['type'].lower()
except KeyError as e:
raise KeyError(f'Constraint {0lOlO1l1l} has no type defined.') from e
exce... | def old_constraint_to_new(ic, con):
"""
Converts old-style constraint dictionaries to new-style constraint objects.
"""
# check type
try:
ctype = con['type'].lower()
except KeyError as e:
raise KeyError(f'Constraint {ic} has no type defined.') from e
except TypeError as e:
... |
def old_constraint_to_new(OlIO, 1I1llI01):
"""
Converts old-style constraint dictionaries to new-style constraint objects.
"""
# check type
try:
llOlO1I = 1I1llI01['type'].lower()
except KeyError as e:
raise KeyError(f'Constraint {OlIO} has no type defined.') from e
except Ty... | def old_constraint_to_new(ic, con):
"""
Converts old-style constraint dictionaries to new-style constraint objects.
"""
# check type
try:
ctype = con['type'].lower()
except KeyError as e:
raise KeyError(f'Constraint {ic} has no type defined.') from e
except TypeError as e:
... |
def old_constraint_to_new(IIO0Il1O0, l0l0OO0):
"""
Converts old-style constraint dictionaries to new-style constraint objects.
"""
# check type
try:
II0I0OOl = l0l0OO0['type'].lower()
except KeyError as e:
raise KeyError(f'Constraint {IIO0Il1O0} has no type defined.') from e
... | def old_constraint_to_new(ic, con):
"""
Converts old-style constraint dictionaries to new-style constraint objects.
"""
# check type
try:
ctype = con['type'].lower()
except KeyError as e:
raise KeyError(f'Constraint {ic} has no type defined.') from e
except TypeError as e:
... |
def old_constraint_to_new(0OlI1IOOI, OlOI1lO):
"""
Converts old-style constraint dictionaries to new-style constraint objects.
"""
# check type
try:
I1lOl0 = OlOI1lO['type'].lower()
except KeyError as e:
raise KeyError(f'Constraint {0OlI1IOOI} has no type defined.') from e
ex... | def old_constraint_to_new(ic, con):
"""
Converts old-style constraint dictionaries to new-style constraint objects.
"""
# check type
try:
ctype = con['type'].lower()
except KeyError as e:
raise KeyError(f'Constraint {ic} has no type defined.') from e
except TypeError as e:
... |
def old_constraint_to_new(O0l010, l1lOII1O):
"""
Converts old-style constraint dictionaries to new-style constraint objects.
"""
# check type
try:
0I0l001I = l1lOII1O['type'].lower()
except KeyError as e:
raise KeyError(f'Constraint {O0l010} has no type defined.') from e
exce... | def old_constraint_to_new(ic, con):
"""
Converts old-style constraint dictionaries to new-style constraint objects.
"""
# check type
try:
ctype = con['type'].lower()
except KeyError as e:
raise KeyError(f'Constraint {ic} has no type defined.') from e
except TypeError as e:
... |
def extract(
self, lll0: str, 0llI: int = (1-1), OIO01lO: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the Il1OI0 `lll0` as 01l11I in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression ... | def extract(
self, pat: str, flags: int = 0, expand: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the regex `pat` as columns in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression `pat`.... |
def extract(
self, OI0l00IO: str, Illll0l11: int = int(0.0), l10ll: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the llO0I `OI0l00IO` as OI0I in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular ... | def extract(
self, pat: str, flags: int = 0, expand: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the regex `pat` as columns in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression `pat`.... |
def extract(
self, OIIOI: str, lOO0: int = 0, 0III: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the OI0011 `OIIOI` as 001l00I1 in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression `OI... | def extract(
self, pat: str, flags: int = 0, expand: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the regex `pat` as columns in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression `pat`.... |
def extract(
self, 101OlIII0: str, IlOI0ll: int = (9^9)*0, lIOI: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the O11I01O00 `101OlIII0` as 10O1O0 in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regu... | def extract(
self, pat: str, flags: int = 0, expand: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the regex `pat` as columns in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression `pat`.... |
def extract(
self, I011I: str, I1OlI01I1: int = int(0.0), 0I1I0: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the 11IIl0O101 `I011I` as 1ll0O in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular ... | def extract(
self, pat: str, flags: int = 0, expand: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the regex `pat` as columns in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression `pat`.... |
def extract(
self, 01OIlI1lO: str, I0011IllOO: int = 0, l0l1: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the 0lII `01OIlI1lO` as 0IO11O01I in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular e... | def extract(
self, pat: str, flags: int = 0, expand: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the regex `pat` as columns in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression `pat`.... |
def extract(
self, 10IOI1OII1: str, 00ll01: int = int(0.0), 10Il0: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the lIl0IIO `10IOI1OII1` as 0I011OOOl in a DataFrame.
For each subject string in the Series, extract groups from the
first match of ... | def extract(
self, pat: str, flags: int = 0, expand: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the regex `pat` as columns in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression `pat`.... |
def extract(
self, I0110: str, Ol1O: int = int(0.0), OI11O01I: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the 01IlOI `I0110` as O1I1I in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expres... | def extract(
self, pat: str, flags: int = 0, expand: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the regex `pat` as columns in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression `pat`.... |
def extract(
self, l0lI10lI1: str, 1OO0O: int = (9^9)*0, 00OllI: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the OI00I00 `l0lI10lI1` as Il001I1 in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regul... | def extract(
self, pat: str, flags: int = 0, expand: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the regex `pat` as columns in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression `pat`.... |
def extract(
self, 000l: str, OIOO0: int = 0, 1011I1: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the O110OII `000l` as IlI11I in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression `00... | def extract(
self, pat: str, flags: int = 0, expand: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the regex `pat` as columns in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression `pat`.... |
def extract(
self, l1O00: str, II1OO01: int = 0, 0OIlOO: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the 0I0I1l1101 `l1O00` as IlO1O00 in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expres... | def extract(
self, pat: str, flags: int = 0, expand: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the regex `pat` as columns in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression `pat`.... |
def extract(
self, IO00IIOI0: str, I0IIl: int = (1-1), Ol11llI0I: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the 001I1I `IO00IIOI0` as I10I in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular ... | def extract(
self, pat: str, flags: int = 0, expand: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the regex `pat` as columns in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression `pat`.... |
def extract(
self, lO0I1Il0OI: str, OOO0lO: int = (1-1), OO0l0ll11O: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the 0100II1I10 `lO0I1Il0OI` as 10110lIOl1 in a DataFrame.
For each subject string in the Series, extract groups from the
first mat... | def extract(
self, pat: str, flags: int = 0, expand: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the regex `pat` as columns in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression `pat`.... |
def extract(
self, 1l0OO1IOI: str, IIOO0OIl: int = int(0.0), Ol000IO: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the lllOI0l00 `1l0OO1IOI` as O001Il0 in a DataFrame.
For each subject string in the Series, extract groups from the
first match o... | def extract(
self, pat: str, flags: int = 0, expand: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the regex `pat` as columns in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression `pat`.... |
def extract(
self, IOOl00llO: str, l1IlO1: int = (1-1), OOOOlO10: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the lO0I10 `IOOl00llO` as 001I0OllI in a DataFrame.
For each subject string in the Series, extract groups from the
first match of reg... | def extract(
self, pat: str, flags: int = 0, expand: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the regex `pat` as columns in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression `pat`.... |
def extract(
self, pat: str, flags: int = (1-1), expand: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the regex `pat` as columns in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression `p... | def extract(
self, pat: str, flags: int = 0, expand: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the regex `pat` as columns in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression `pat`.... |
def extract(
self, 1I1OOIOI1: str, l10lO0: int = 0, IllI0O0O: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the ll1lOO `1I1OOIOI1` as 10I0 in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expr... | def extract(
self, pat: str, flags: int = 0, expand: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the regex `pat` as columns in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression `pat`.... |
def extract(
self, l111O01O0: str, 00O0011IOO: int = 0, 1010000l: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the l1ll010O `l111O01O0` as 0l0II00Ol in a DataFrame.
For each subject string in the Series, extract groups from the
first match of r... | def extract(
self, pat: str, flags: int = 0, expand: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the regex `pat` as columns in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression `pat`.... |
def extract(
self, l111l: str, 1OII: int = (1-1), III1: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the 1OI0OO `l111l` as OllOI0II in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression... | def extract(
self, pat: str, flags: int = 0, expand: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the regex `pat` as columns in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression `pat`.... |
def extract(
self, O001OO: str, O011II0: int = (1-1), 1III: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the I1O0 `O001OO` as OOO01III11 in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expre... | def extract(
self, pat: str, flags: int = 0, expand: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the regex `pat` as columns in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression `pat`.... |
def extract(
self, lIO11: str, llOlOOlO: int = (1-1), 1OIO1l0I: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the 1OII10 `lIO11` as O1l10ll in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular exp... | def extract(
self, pat: str, flags: int = 0, expand: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the regex `pat` as columns in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression `pat`.... |
def extract(
self, l0I0Olll: str, l0I1l0I00: int = int(0.0), IOO0I00l1: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the 0O0Il11lI `l0I0Olll` as II101 in a DataFrame.
For each subject string in the Series, extract groups from the
first match of... | def extract(
self, pat: str, flags: int = 0, expand: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the regex `pat` as columns in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression `pat`.... |
def extract(
self, lOlO0010O: str, lllO: int = 0, IO0ll: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the 0O10 `lOlO0010O` as O0O0ll1 in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expressi... | def extract(
self, pat: str, flags: int = 0, expand: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the regex `pat` as columns in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression `pat`.... |
def extract(
self, Il1O: str, 0I01: int = 0, O0OI1: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the 1O1IOl `Il1O` as lOOO in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression `Il1O`.
... | def extract(
self, pat: str, flags: int = 0, expand: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the regex `pat` as columns in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression `pat`.... |
def extract(
self, pat: str, flags: int = (1-1), expand: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the regex `pat` as columns in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression `p... | def extract(
self, pat: str, flags: int = 0, expand: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the regex `pat` as columns in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression `pat`.... |
def extract(
self, Il00l: str, 1l0lI0III: int = (9^9)*0, O1Il0OlI1: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the II0IOl `Il00l` as 1lI1I11 in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular... | def extract(
self, pat: str, flags: int = 0, expand: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the regex `pat` as columns in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression `pat`.... |
def extract(
self, O0OIl0000: str, l10010: int = int(0.0), O1Ol0l: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the Il1l011l `O0OIl0000` as 01011 in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regu... | def extract(
self, pat: str, flags: int = 0, expand: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the regex `pat` as columns in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression `pat`.... |
def extract(
self, OO1OO01: str, 1OI1I0: int = 0, l11OI0O: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the 00Il0 `OO1OO01` as I1O1IlIII in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expre... | def extract(
self, pat: str, flags: int = 0, expand: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the regex `pat` as columns in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression `pat`.... |
def extract(
self, II0O11: str, IO1I0I11I: int = 0, OIOl: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the O1I11ll `II0O11` as 0ll01 in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expressio... | def extract(
self, pat: str, flags: int = 0, expand: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the regex `pat` as columns in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression `pat`.... |
def extract(
self, l0lIl: str, I10O: int = (1-1), lOl1: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the IO001 `l0lIl` as 0l1lllll in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression ... | def extract(
self, pat: str, flags: int = 0, expand: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the regex `pat` as columns in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression `pat`.... |
def extract(
self, l1OO0OOIl0: str, 11Ol: int = (9^9)*0, 1111: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the 1IO1II1Il0 `l1OO0OOIl0` as Ol00II011 in a DataFrame.
For each subject string in the Series, extract groups from the
first match of r... | def extract(
self, pat: str, flags: int = 0, expand: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the regex `pat` as columns in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression `pat`.... |
def extract(
self, O1O111: str, OIO010111: int = 0, I1l11: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the I10O0001 `O1O111` as I1O000 in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expres... | def extract(
self, pat: str, flags: int = 0, expand: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the regex `pat` as columns in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression `pat`.... |
def extract(
self, lllI1OOl1: str, 0IO0lI: int = 0, lIOIl: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the IO0l `lllI1OOl1` as l0II in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expressio... | def extract(
self, pat: str, flags: int = 0, expand: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the regex `pat` as columns in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression `pat`.... |
def extract(
self, 11IlI1O01: str, II10Oll10I: int = (1-1), lIO11I: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the 0lI0OlIIll `11IlI1O01` as OOl0IIl in a DataFrame.
For each subject string in the Series, extract groups from the
first match of... | def extract(
self, pat: str, flags: int = 0, expand: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the regex `pat` as columns in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression `pat`.... |
def extract(
self, Ol0O: str, lO10O: int = 0, IlOlOIOO1l: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the I0II1I1 `Ol0O` as 1I001lOI0 in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular express... | def extract(
self, pat: str, flags: int = 0, expand: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the regex `pat` as columns in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression `pat`.... |
def extract(
self, IO010: str, 0011: int = 0, 10O100Ol0: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the 0OlOl `IO010` as lI0O1l1 in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression ... | def extract(
self, pat: str, flags: int = 0, expand: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the regex `pat` as columns in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression `pat`.... |
def extract(
self, pat: str, flags: int = (1-1), expand: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the regex `pat` as columns in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression `p... | def extract(
self, pat: str, flags: int = 0, expand: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the regex `pat` as columns in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression `pat`.... |
def extract(
self, l1IlII0: str, 0l0l: int = (9^9)*0, IOlI: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the OOlllI1I0 `l1IlII0` as O001l in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expr... | def extract(
self, pat: str, flags: int = 0, expand: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the regex `pat` as columns in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression `pat`.... |
def extract(
self, IO0O0lIll: str, Ol0l: int = int(0.0), 0IIl: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the l1OO `IO0O0lIll` as lIl0110l in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular e... | def extract(
self, pat: str, flags: int = 0, expand: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the regex `pat` as columns in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression `pat`.... |
def extract(
self, 1IIl0OII0I: str, 00lIIO0l: int = int(0.0), llI01llO: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the 0IOl `1IIl0OII0I` as O1lO11O in a DataFrame.
For each subject string in the Series, extract groups from the
first match of ... | def extract(
self, pat: str, flags: int = 0, expand: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the regex `pat` as columns in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression `pat`.... |
def extract(
self, OIIl10I: str, 0IOI00: int = (9^9)*0, OlO1OOI: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the 0l0O `OIIl10I` as lllOO10O in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular e... | def extract(
self, pat: str, flags: int = 0, expand: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the regex `pat` as columns in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression `pat`.... |
def extract(
self, 1IO0100: str, I0Ol: int = 0, lO1I0: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the 1llO `1IO0100` as OO1IOO1 in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression `... | def extract(
self, pat: str, flags: int = 0, expand: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the regex `pat` as columns in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression `pat`.... |
def extract(
self, pat: str, flags: int = 0, expand: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the regex `pat` as columns in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression `pat`.... | def extract(
self, pat: str, flags: int = 0, expand: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the regex `pat` as columns in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression `pat`.... |
def extract(
self, lll0OIll1l: str, OlI00Il0: int = (1-1), IllOII0I01: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the 1010OIOOIO `lll0OIll1l` as 0l1011I0l in a DataFrame.
For each subject string in the Series, extract groups from the
first ma... | def extract(
self, pat: str, flags: int = 0, expand: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the regex `pat` as columns in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression `pat`.... |
def extract(
self, 101IO00lII: str, I100: int = int(0.0), 1I1IO: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the 010OI1O `101IO00lII` as I0IO in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular... | def extract(
self, pat: str, flags: int = 0, expand: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the regex `pat` as columns in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression `pat`.... |
def extract(
self, 1OOIlI: str, I0l01I: int = (1-1), IOOI1l01: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the OO01Il `1OOIlI` as Ol10OI1 in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular exp... | def extract(
self, pat: str, flags: int = 0, expand: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the regex `pat` as columns in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression `pat`.... |
def extract(
self, ll1O101: str, OlOlO: int = (9^9)*0, OIl1ll1ll: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the lOlO `ll1O101` as I1O101I in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular e... | def extract(
self, pat: str, flags: int = 0, expand: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the regex `pat` as columns in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression `pat`.... |
def extract(
self, II1lOl10O: str, 0lOI1OI: int = int(0.0), O1O0: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the OO10lIlI `II1lOl10O` as II0I1O1 in a DataFrame.
For each subject string in the Series, extract groups from the
first match of reg... | def extract(
self, pat: str, flags: int = 0, expand: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the regex `pat` as columns in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression `pat`.... |
def extract(
self, l10II1OIl: str, 1O1Ol00: int = 0, IIOlOOII: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the l1Il0 `l10II1OIl` as 0II0 in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expr... | def extract(
self, pat: str, flags: int = 0, expand: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the regex `pat` as columns in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression `pat`.... |
def extract(
self, OlOI0II0I1: str, OOlOI0110l: int = (9^9)*0, 01Ol0I: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the 0OOl00O0 `OlOI0II0I1` as 0100OOl in a DataFrame.
For each subject string in the Series, extract groups from the
first match ... | def extract(
self, pat: str, flags: int = 0, expand: bool = True
) -> DataFrame | Series | Index:
r"""
Extract capture groups in the regex `pat` as columns in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression `pat`.... |
def getbbox(
self,
0OO1IlO1: str | bytes,
Oll1111l1: str = "",
01OII1I: str | None = None,
1II01OI: list[str] | None = None,
1I11l1lO11: str | None = None,
O00O1I1llI: float = (9^9)*0,
1I01IlOO1I: str | None = None,
) -> tuple[float, float, float, floa... | def getbbox(
self,
text: str | bytes,
mode: str = "",
direction: str | None = None,
features: list[str] | None = None,
language: str | None = None,
stroke_width: float = 0,
anchor: str | None = None,
) -> tuple[float, float, float, float]:
"""
... |
def getbbox(
self,
11000lllO: str | bytes,
1I0O00: str = "",
IIIO0: str | None = None,
0OlI1l1I: list[str] | None = None,
0lOII: str | None = None,
OIOl: float = 0,
1OO1lO: str | None = None,
) -> tuple[float, float, float, float]:
"""
... | def getbbox(
self,
text: str | bytes,
mode: str = "",
direction: str | None = None,
features: list[str] | None = None,
language: str | None = None,
stroke_width: float = 0,
anchor: str | None = None,
) -> tuple[float, float, float, float]:
"""
... |
def getbbox(
self,
I10OlO: str | bytes,
1l00Ol11: str = "",
llIIIOll1I: str | None = None,
OO001: list[str] | None = None,
11Ol: str | None = None,
l0101OOO: float = 0,
1O10O1II: str | None = None,
) -> tuple[float, float, float, float]:
"""
... | def getbbox(
self,
text: str | bytes,
mode: str = "",
direction: str | None = None,
features: list[str] | None = None,
language: str | None = None,
stroke_width: float = 0,
anchor: str | None = None,
) -> tuple[float, float, float, float]:
"""
... |
def getbbox(
self,
OIOI1llI01: str | bytes,
OlIOl: str = "",
1OO0O110: str | None = None,
0O000OO: list[str] | None = None,
00IIO0lI: str | None = None,
lOll1: float = int(0.0),
OIlII0: str | None = None,
) -> tuple[float, float, float, float]:
... | def getbbox(
self,
text: str | bytes,
mode: str = "",
direction: str | None = None,
features: list[str] | None = None,
language: str | None = None,
stroke_width: float = 0,
anchor: str | None = None,
) -> tuple[float, float, float, float]:
"""
... |
def getbbox(
self,
11I111: str | bytes,
0lO1OOl0: str = "",
1OIl11: str | None = None,
1O0O11lI: list[str] | None = None,
11OI01III0: str | None = None,
I0OIOI1: float = int(0.0),
1OlO: str | None = None,
) -> tuple[float, float, float, float]:
... | def getbbox(
self,
text: str | bytes,
mode: str = "",
direction: str | None = None,
features: list[str] | None = None,
language: str | None = None,
stroke_width: float = 0,
anchor: str | None = None,
) -> tuple[float, float, float, float]:
"""
... |
def getbbox(
self,
1l1l110O1: str | bytes,
0I101I1I: str = "",
10OOI: str | None = None,
0O1l0: list[str] | None = None,
10OI: str | None = None,
OOIOl010: float = 0,
101100lO: str | None = None,
) -> tuple[float, float, float, float]:
"""
... | def getbbox(
self,
text: str | bytes,
mode: str = "",
direction: str | None = None,
features: list[str] | None = None,
language: str | None = None,
stroke_width: float = 0,
anchor: str | None = None,
) -> tuple[float, float, float, float]:
"""
... |
def getbbox(
self,
IOl0: str | bytes,
11lIOl0: str = "",
OI0OIO0I: str | None = None,
IOll1Il1O1: list[str] | None = None,
llI1: str | None = None,
0I1Ol0OI10: float = (1-1),
OO1I: str | None = None,
) -> tuple[float, float, float, float]:
"""
... | def getbbox(
self,
text: str | bytes,
mode: str = "",
direction: str | None = None,
features: list[str] | None = None,
language: str | None = None,
stroke_width: float = 0,
anchor: str | None = None,
) -> tuple[float, float, float, float]:
"""
... |
def getbbox(
self,
text: str | bytes,
mode: str = "",
direction: str | None = None,
features: list[str] | None = None,
language: str | None = None,
stroke_width: float = (1-1),
anchor: str | None = None,
) -> tuple[float, float, float, float]:
... | def getbbox(
self,
text: str | bytes,
mode: str = "",
direction: str | None = None,
features: list[str] | None = None,
language: str | None = None,
stroke_width: float = 0,
anchor: str | None = None,
) -> tuple[float, float, float, float]:
"""
... |
def getbbox(
self,
IlOl0O0lI: str | bytes,
1lIl00: str = "",
OOllI: str | None = None,
0O1I0Il: list[str] | None = None,
OI1000: str | None = None,
0IO1: float = 0,
10III: str | None = None,
) -> tuple[float, float, float, float]:
"""
R... | def getbbox(
self,
text: str | bytes,
mode: str = "",
direction: str | None = None,
features: list[str] | None = None,
language: str | None = None,
stroke_width: float = 0,
anchor: str | None = None,
) -> tuple[float, float, float, float]:
"""
... |
def getbbox(
self,
IlOII101: str | bytes,
1ll0OI: str = "",
011I00O11: str | None = None,
01l0l1lII: list[str] | None = None,
00OOIl: str | None = None,
l0lI0I1: float = 0,
01IIO0: str | None = None,
) -> tuple[float, float, float, float]:
"""
... | def getbbox(
self,
text: str | bytes,
mode: str = "",
direction: str | None = None,
features: list[str] | None = None,
language: str | None = None,
stroke_width: float = 0,
anchor: str | None = None,
) -> tuple[float, float, float, float]:
"""
... |
def getbbox(
self,
II01lIO101: str | bytes,
I0lI11O1: str = "",
10l1Ol: str | None = None,
10O1I0IIOl: list[str] | None = None,
IO1O: str | None = None,
Ol11lO: float = (9^9)*0,
0lIl00100: str | None = None,
) -> tuple[float, float, float, float]:
... | def getbbox(
self,
text: str | bytes,
mode: str = "",
direction: str | None = None,
features: list[str] | None = None,
language: str | None = None,
stroke_width: float = 0,
anchor: str | None = None,
) -> tuple[float, float, float, float]:
"""
... |
def getbbox(
self,
OI01100: str | bytes,
OI010: str = "",
l1l0l0: str | None = None,
I0I1l: list[str] | None = None,
01I0Il0: str | None = None,
011I11OOII: float = (9^9)*0,
I01010II: str | None = None,
) -> tuple[float, float, float, float]:
"... | def getbbox(
self,
text: str | bytes,
mode: str = "",
direction: str | None = None,
features: list[str] | None = None,
language: str | None = None,
stroke_width: float = 0,
anchor: str | None = None,
) -> tuple[float, float, float, float]:
"""
... |
def getbbox(
self,
O1ll10: str | bytes,
O0l10IlIO: str = "",
1ll111: str | None = None,
1lOI10: list[str] | None = None,
l0I10: str | None = None,
111IO0OI1: float = (1-1),
1lO10lOOO0: str | None = None,
) -> tuple[float, float, float, float]:
... | def getbbox(
self,
text: str | bytes,
mode: str = "",
direction: str | None = None,
features: list[str] | None = None,
language: str | None = None,
stroke_width: float = 0,
anchor: str | None = None,
) -> tuple[float, float, float, float]:
"""
... |
def getbbox(
self,
Ol0I: str | bytes,
OlOll1IIIO: str = "",
0O01O01O1: str | None = None,
I10OO00ll1: list[str] | None = None,
0Ol1: str | None = None,
llO0l1OI: float = int(0.0),
l1lI11: str | None = None,
) -> tuple[float, float, float, float]:
... | def getbbox(
self,
text: str | bytes,
mode: str = "",
direction: str | None = None,
features: list[str] | None = None,
language: str | None = None,
stroke_width: float = 0,
anchor: str | None = None,
) -> tuple[float, float, float, float]:
"""
... |
def getbbox(
self,
OlI1IlI: str | bytes,
IlII11II10: str = "",
I000O: str | None = None,
lII0: list[str] | None = None,
O0Il: str | None = None,
10Il00: float = (1-1),
11OOOO: str | None = None,
) -> tuple[float, float, float, float]:
"""
... | def getbbox(
self,
text: str | bytes,
mode: str = "",
direction: str | None = None,
features: list[str] | None = None,
language: str | None = None,
stroke_width: float = 0,
anchor: str | None = None,
) -> tuple[float, float, float, float]:
"""
... |
def getbbox(
self,
text: str | bytes,
mode: str = "",
direction: str | None = None,
features: list[str] | None = None,
language: str | None = None,
stroke_width: float = int(0.0),
anchor: str | None = None,
) -> tuple[float, float, float, float]:
... | def getbbox(
self,
text: str | bytes,
mode: str = "",
direction: str | None = None,
features: list[str] | None = None,
language: str | None = None,
stroke_width: float = 0,
anchor: str | None = None,
) -> tuple[float, float, float, float]:
"""
... |
def getbbox(
self,
llIIO1O0: str | bytes,
0O1O0lO0OI: str = "",
11ll0Oll: str | None = None,
0I000I: list[str] | None = None,
ll0OlI1O0: str | None = None,
1O01: float = (9^9)*0,
IlI1lOll: str | None = None,
) -> tuple[float, float, float, float]:
... | def getbbox(
self,
text: str | bytes,
mode: str = "",
direction: str | None = None,
features: list[str] | None = None,
language: str | None = None,
stroke_width: float = 0,
anchor: str | None = None,
) -> tuple[float, float, float, float]:
"""
... |
def getbbox(
self,
0Il1lI: str | bytes,
OIOIl0OI0: str = "",
lOOIO: str | None = None,
01OOl1IO0: list[str] | None = None,
010IO0: str | None = None,
O01ll0O1lI: float = int(0.0),
0II10OO: str | None = None,
) -> tuple[float, float, float, float]:
... | def getbbox(
self,
text: str | bytes,
mode: str = "",
direction: str | None = None,
features: list[str] | None = None,
language: str | None = None,
stroke_width: float = 0,
anchor: str | None = None,
) -> tuple[float, float, float, float]:
"""
... |
def getbbox(
self,
1I1111O11O: str | bytes,
Il1l10: str = "",
lOlll: str | None = None,
OI1Ill10: list[str] | None = None,
IlII0lI: str | None = None,
I10I1O1I1: float = 0,
10IO100: str | None = None,
) -> tuple[float, float, float, float]:
"""... | def getbbox(
self,
text: str | bytes,
mode: str = "",
direction: str | None = None,
features: list[str] | None = None,
language: str | None = None,
stroke_width: float = 0,
anchor: str | None = None,
) -> tuple[float, float, float, float]:
"""
... |
def getbbox(
self,
O1llOO: str | bytes,
11l11lOl: str = "",
1010I: str | None = None,
OlO10: list[str] | None = None,
lOIO111: str | None = None,
lll10lI0O: float = 0,
1O1IlIOll: str | None = None,
) -> tuple[float, float, float, float]:
"""
... | def getbbox(
self,
text: str | bytes,
mode: str = "",
direction: str | None = None,
features: list[str] | None = None,
language: str | None = None,
stroke_width: float = 0,
anchor: str | None = None,
) -> tuple[float, float, float, float]:
"""
... |
def getbbox(
self,
text: str | bytes,
mode: str = "",
direction: str | None = None,
features: list[str] | None = None,
language: str | None = None,
stroke_width: float = 0,
anchor: str | None = None,
) -> tuple[float, float, float, float]:
"""
... | def getbbox(
self,
text: str | bytes,
mode: str = "",
direction: str | None = None,
features: list[str] | None = None,
language: str | None = None,
stroke_width: float = 0,
anchor: str | None = None,
) -> tuple[float, float, float, float]:
"""
... |
def getbbox(
self,
I0lI1O: str | bytes,
Il0O01: str = "",
O0I10l00: str | None = None,
O0OO0: list[str] | None = None,
lIl1l0: str | None = None,
I01Il: float = int(0.0),
I1O11: str | None = None,
) -> tuple[float, float, float, float]:
"""
... | def getbbox(
self,
text: str | bytes,
mode: str = "",
direction: str | None = None,
features: list[str] | None = None,
language: str | None = None,
stroke_width: float = 0,
anchor: str | None = None,
) -> tuple[float, float, float, float]:
"""
... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.