signature stringlengths 8 3.44k | body stringlengths 0 1.41M | docstring stringlengths 1 122k | id stringlengths 5 17 |
|---|---|---|---|
def __init__(self, *args, **kwargs): | <EOL>arg = args[<NUM_LIT:0>] if args else kwargs<EOL>is_dict = isinstance(arg, dict)<EOL>if is_dict and not all([isinstance(k, util.string) and isinstance(v, util.string) for k, v in arg.items()]):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>elif not is_dict and not all([isinstance(k, util.string) and isinstance(v, util.string) for k, v in arg]):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>super(Namespaces, self).__init__(*args, **kwargs)<EOL> | Initialize. | f13612:c2:m0 |
def __init__(self, *args, **kwargs): | <EOL>arg = args[<NUM_LIT:0>] if args else kwargs<EOL>is_dict = isinstance(arg, dict)<EOL>if is_dict and not all([isinstance(k, util.string) and isinstance(v, util.string) for k, v in arg.items()]):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>elif not is_dict and not all([isinstance(k, util.string) and isinstance(v, util.string) for k, v in arg]):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>super(CustomSelectors, self).__init__(*args, **kwargs)<EOL> | Initialize. | f13612:c3:m0 |
def __init__(<EOL>self, tag, ids, classes, attributes, nth, selectors,<EOL>relation, rel_type, contains, lang, flags<EOL>): | super(Selector, self).__init__(<EOL>tag=tag,<EOL>ids=ids,<EOL>classes=classes,<EOL>attributes=attributes,<EOL>nth=nth,<EOL>selectors=selectors,<EOL>relation=relation,<EOL>rel_type=rel_type,<EOL>contains=contains,<EOL>lang=lang,<EOL>flags=flags<EOL>)<EOL> | Initialize. | f13612:c4:m0 |
def __init__(self): | super(SelectorNull, self).__init__()<EOL> | Initialize. | f13612:c5:m0 |
def __init__(self, name, prefix): | super(SelectorTag, self).__init__(<EOL>name=name,<EOL>prefix=prefix<EOL>)<EOL> | Initialize. | f13612:c6:m0 |
def __init__(self, attribute, prefix, pattern, xml_type_pattern): | super(SelectorAttribute, self).__init__(<EOL>attribute=attribute,<EOL>prefix=prefix,<EOL>pattern=pattern,<EOL>xml_type_pattern=xml_type_pattern<EOL>)<EOL> | Initialize. | f13612:c7:m0 |
def __init__(self, text): | super(SelectorContains, self).__init__(<EOL>text=text<EOL>)<EOL> | Initialize. | f13612:c8:m0 |
def __init__(self, a, n, b, of_type, last, selectors): | super(SelectorNth, self).__init__(<EOL>a=a,<EOL>n=n,<EOL>b=b,<EOL>of_type=of_type,<EOL>last=last,<EOL>selectors=selectors<EOL>)<EOL> | Initialize. | f13612:c9:m0 |
def __init__(self, languages): | super(SelectorLang, self).__init__(<EOL>languages=tuple(languages)<EOL>)<EOL> | Initialize. | f13612:c10:m0 |
def __iter__(self): | return iter(self.languages)<EOL> | Iterator. | f13612:c10:m1 |
def __len__(self): | return len(self.languages)<EOL> | Length. | f13612:c10:m2 |
def __getitem__(self, index): | return self.languages[index]<EOL> | Get item. | f13612:c10:m3 |
def __init__(self, selectors=tuple(), is_not=False, is_html=False): | super(SelectorList, self).__init__(<EOL>selectors=tuple(selectors),<EOL>is_not=is_not,<EOL>is_html=is_html<EOL>)<EOL> | Initialize. | f13612:c11:m0 |
def __iter__(self): | return iter(self.selectors)<EOL> | Iterator. | f13612:c11:m1 |
def __len__(self): | return len(self.selectors)<EOL> | Length. | f13612:c11:m2 |
def __getitem__(self, index): | return self.selectors[index]<EOL> | Get item. | f13612:c11:m3 |
@util.lru_cache(maxsize=_MAXCACHE)<EOL>def _cached_css_compile(pattern, namespaces, custom, flags): | custom_selectors = process_custom(custom)<EOL>return cm.SoupSieve(<EOL>pattern,<EOL>CSSParser(pattern, custom=custom_selectors, flags=flags).process_selectors(),<EOL>namespaces,<EOL>custom,<EOL>flags<EOL>)<EOL> | Cached CSS compile. | f13613:m0 |
def _purge_cache(): | _cached_css_compile.cache_clear()<EOL> | Purge the cache. | f13613:m1 |
def process_custom(custom): | custom_selectors = {}<EOL>if custom is not None:<EOL><INDENT>for key, value in custom.items():<EOL><INDENT>name = util.lower(key)<EOL>if RE_CUSTOM.match(name) is None:<EOL><INDENT>raise SelectorSyntaxError("<STR_LIT>".format(name))<EOL><DEDENT>if name in custom_selectors:<EOL><INDENT>raise KeyError("<STR_LIT>".format(name))<EOL><DEDENT>custom_selectors[css_unescape(name)] = value<EOL><DEDENT><DEDENT>return custom_selectors<EOL> | Process custom. | f13613:m2 |
def css_unescape(content, string=False): | def replace(m):<EOL><INDENT>"""<STR_LIT>"""<EOL>if m.group(<NUM_LIT:1>):<EOL><INDENT>codepoint = int(m.group(<NUM_LIT:1>)[<NUM_LIT:1>:], <NUM_LIT:16>)<EOL>if codepoint == <NUM_LIT:0>:<EOL><INDENT>codepoint = UNICODE_REPLACEMENT_CHAR<EOL><DEDENT>value = util.uchr(codepoint)<EOL><DEDENT>elif m.group(<NUM_LIT:2>):<EOL><INDENT>value = m.group(<NUM_LIT:2>)[<NUM_LIT:1>:]<EOL><DEDENT>elif m.group(<NUM_LIT:3>):<EOL><INDENT>value = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>value = '<STR_LIT>'<EOL><DEDENT>return value<EOL><DEDENT>return (RE_CSS_ESC if not string else RE_CSS_STR_ESC).sub(replace, content)<EOL> | Unescape CSS value.
Strings allow for spanning the value on multiple strings by escaping a new line. | f13613:m3 |
def escape(ident): | string = []<EOL>length = len(ident)<EOL>start_dash = length > <NUM_LIT:0> and ident[<NUM_LIT:0>] == '<STR_LIT:->'<EOL>if length == <NUM_LIT:1> and start_dash:<EOL><INDENT>string.append('<STR_LIT>'.format(ident))<EOL><DEDENT>else:<EOL><INDENT>for index, c in enumerate(ident):<EOL><INDENT>codepoint = util.uord(c)<EOL>if codepoint == <NUM_LIT>:<EOL><INDENT>string.append('<STR_LIT>')<EOL><DEDENT>elif (<NUM_LIT> <= codepoint <= <NUM_LIT>) or codepoint == <NUM_LIT>:<EOL><INDENT>string.append('<STR_LIT>'.format(codepoint))<EOL><DEDENT>elif (index == <NUM_LIT:0> or (start_dash and index == <NUM_LIT:1>)) and (<NUM_LIT> <= codepoint <= <NUM_LIT>):<EOL><INDENT>string.append('<STR_LIT>'.format(codepoint))<EOL><DEDENT>elif (<EOL>codepoint in (<NUM_LIT>, <NUM_LIT>) or codepoint >= <NUM_LIT> or (<NUM_LIT> <= codepoint <= <NUM_LIT>) or<EOL>(<NUM_LIT> <= codepoint <= <NUM_LIT>) or (<NUM_LIT> <= codepoint <= <NUM_LIT>) or (<NUM_LIT> <= codepoint <= <NUM_LIT>)<EOL>):<EOL><INDENT>string.append(c)<EOL><DEDENT>else:<EOL><INDENT>string.append('<STR_LIT>'.format(c))<EOL><DEDENT><DEDENT><DEDENT>return '<STR_LIT>'.join(string)<EOL> | Escape identifier. | f13613:m4 |
def __init__(self, name, pattern): | self.name = name<EOL>self.re_pattern = re.compile(pattern, re.I | re.X | re.U)<EOL> | Initialize. | f13613:c0:m0 |
def get_name(self): | return self.name<EOL> | Get name. | f13613:c0:m1 |
def enabled(self, flags): | return True<EOL> | Enabled. | f13613:c0:m2 |
def match(self, selector, index): | return self.re_pattern.match(selector, index)<EOL> | Match the selector. | f13613:c0:m3 |
def __init__(self, patterns): | self.patterns = {}<EOL>for p in patterns:<EOL><INDENT>name = p[<NUM_LIT:0>]<EOL>pattern = SelectorPattern(name, p[<NUM_LIT:2>])<EOL>for pseudo in p[<NUM_LIT:1>]:<EOL><INDENT>self.patterns[pseudo] = pattern<EOL><DEDENT><DEDENT>self.matched_name = None<EOL>self.re_pseudo_name = re.compile(PAT_PSEUDO_CLASS_SPECIAL, re.I | re.X | re.U)<EOL> | Initialize. | f13613:c1:m0 |
def get_name(self): | return self.matched_name.get_name()<EOL> | Get name. | f13613:c1:m1 |
def enabled(self, flags): | return True<EOL> | Enabled. | f13613:c1:m2 |
def match(self, selector, index): | pseudo = None<EOL>m = self.re_pseudo_name.match(selector, index)<EOL>if m:<EOL><INDENT>name = util.lower(css_unescape(m.group('<STR_LIT:name>')))<EOL>pattern = self.patterns.get(name)<EOL>if pattern:<EOL><INDENT>pseudo = pattern.match(selector, index)<EOL>if pseudo:<EOL><INDENT>self.matched_name = pattern<EOL><DEDENT><DEDENT><DEDENT>return pseudo<EOL> | Match the selector. | f13613:c1:m3 |
def enabled(self, flags): | return flags & util._QUIRKS<EOL> | Enabled if quirks flag is present. | f13613:c2:m0 |
def __init__(self, **kwargs): | self.tag = kwargs.get('<STR_LIT>', None)<EOL>self.ids = kwargs.get('<STR_LIT>', [])<EOL>self.classes = kwargs.get('<STR_LIT>', [])<EOL>self.attributes = kwargs.get('<STR_LIT>', [])<EOL>self.nth = kwargs.get('<STR_LIT>', [])<EOL>self.selectors = kwargs.get('<STR_LIT>', [])<EOL>self.relations = kwargs.get('<STR_LIT>', [])<EOL>self.rel_type = kwargs.get('<STR_LIT>', None)<EOL>self.contains = kwargs.get('<STR_LIT>', [])<EOL>self.lang = kwargs.get('<STR_LIT>', [])<EOL>self.flags = kwargs.get('<STR_LIT>', <NUM_LIT:0>)<EOL>self.no_match = kwargs.get('<STR_LIT>', False)<EOL> | Initialize. | f13613:c3:m0 |
def _freeze_relations(self, relations): | if relations:<EOL><INDENT>sel = relations[<NUM_LIT:0>]<EOL>sel.relations.extend(relations[<NUM_LIT:1>:])<EOL>return ct.SelectorList([sel.freeze()])<EOL><DEDENT>else:<EOL><INDENT>return ct.SelectorList()<EOL><DEDENT> | Freeze relation. | f13613:c3:m1 |
def freeze(self): | if self.no_match:<EOL><INDENT>return ct.SelectorNull()<EOL><DEDENT>else:<EOL><INDENT>return ct.Selector(<EOL>self.tag,<EOL>tuple(self.ids),<EOL>tuple(self.classes),<EOL>tuple(self.attributes),<EOL>tuple(self.nth),<EOL>tuple(self.selectors),<EOL>self._freeze_relations(self.relations),<EOL>self.rel_type,<EOL>tuple(self.contains),<EOL>tuple(self.lang),<EOL>self.flags<EOL>)<EOL><DEDENT> | Freeze self. | f13613:c3:m2 |
def __str__(self): | return (<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>).format(<EOL>self.tag, self.ids, self.classes, self.attributes, self.nth, self.selectors,<EOL>self.relations, self.rel_type, self.contains, self.lang, self.flags, self.no_match<EOL>)<EOL> | String representation. | f13613:c3:m3 |
def __init__(self, selector, custom=None, flags=<NUM_LIT:0>): | self.pattern = selector.replace('<STR_LIT:\x00>', '<STR_LIT>')<EOL>self.flags = flags<EOL>self.debug = self.flags & util.DEBUG<EOL>self.quirks = self.flags & util._QUIRKS<EOL>self.custom = {} if custom is None else custom<EOL> | Initialize. | f13613:c4:m0 |
def parse_attribute_selector(self, sel, m, has_selector, quirks): | inverse = False<EOL>op = m.group('<STR_LIT>')<EOL>case = util.lower(m.group('<STR_LIT>')) if m.group('<STR_LIT>') else None<EOL>parts = [css_unescape(a) for a in m.group('<STR_LIT>').split('<STR_LIT:|>')]<EOL>ns = '<STR_LIT>'<EOL>is_type = False<EOL>pattern2 = None<EOL>if len(parts) > <NUM_LIT:1>:<EOL><INDENT>ns = parts[<NUM_LIT:0>]<EOL>attr = parts[<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>attr = parts[<NUM_LIT:0>]<EOL><DEDENT>if case:<EOL><INDENT>flags = re.I if case == '<STR_LIT:i>' else <NUM_LIT:0><EOL><DEDENT>elif util.lower(attr) == '<STR_LIT:type>':<EOL><INDENT>flags = re.I<EOL>is_type = True<EOL><DEDENT>else:<EOL><INDENT>flags = <NUM_LIT:0><EOL><DEDENT>if op:<EOL><INDENT>if m.group('<STR_LIT:value>').startswith(('<STR_LIT:">', "<STR_LIT:'>")) and not quirks:<EOL><INDENT>value = css_unescape(m.group('<STR_LIT:value>')[<NUM_LIT:1>:-<NUM_LIT:1>], True)<EOL><DEDENT>else:<EOL><INDENT>value = css_unescape(m.group('<STR_LIT:value>'))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>value = None<EOL><DEDENT>if not op:<EOL><INDENT>pattern = None<EOL><DEDENT>elif op.startswith('<STR_LIT>'):<EOL><INDENT>pattern = re.compile(r'<STR_LIT>' % re.escape(value), flags)<EOL><DEDENT>elif op.startswith('<STR_LIT:$>'):<EOL><INDENT>pattern = re.compile(r'<STR_LIT>' % re.escape(value), flags)<EOL><DEDENT>elif op.startswith('<STR_LIT:*>'):<EOL><INDENT>pattern = re.compile(r'<STR_LIT>' % re.escape(value), flags)<EOL><DEDENT>elif op.startswith('<STR_LIT>'):<EOL><INDENT>value = r'<STR_LIT>' if not value or RE_WS.search(value) else re.escape(value)<EOL>pattern = re.compile(r'<STR_LIT>' % value, flags)<EOL><DEDENT>elif op.startswith('<STR_LIT:|>'):<EOL><INDENT>pattern = re.compile(r'<STR_LIT>' % re.escape(value), flags)<EOL><DEDENT>elif op.startswith('<STR_LIT:!>'):<EOL><INDENT>pattern = re.compile(r'<STR_LIT>' % re.escape(value), flags)<EOL>inverse = True<EOL><DEDENT>else:<EOL><INDENT>pattern = re.compile(r'<STR_LIT>' % re.escape(value), flags)<EOL><DEDENT>if is_type and pattern:<EOL><INDENT>pattern2 = re.compile(pattern.pattern)<EOL><DEDENT>sel_attr = ct.SelectorAttribute(attr, ns, pattern, pattern2)<EOL>if inverse:<EOL><INDENT>sub_sel = _Selector()<EOL>sub_sel.attributes.append(sel_attr)<EOL>not_list = ct.SelectorList([sub_sel.freeze()], True, False)<EOL>sel.selectors.append(not_list)<EOL><DEDENT>else:<EOL><INDENT>sel.attributes.append(sel_attr)<EOL><DEDENT>has_selector = True<EOL>return has_selector<EOL> | Create attribute selector from the returned regex match. | f13613:c4:m1 |
def parse_tag_pattern(self, sel, m, has_selector): | parts = [css_unescape(x) for x in m.group(<NUM_LIT:0>).split('<STR_LIT:|>')]<EOL>if len(parts) > <NUM_LIT:1>:<EOL><INDENT>prefix = parts[<NUM_LIT:0>]<EOL>tag = parts[<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>tag = parts[<NUM_LIT:0>]<EOL>prefix = None<EOL><DEDENT>sel.tag = ct.SelectorTag(tag, prefix)<EOL>has_selector = True<EOL>return has_selector<EOL> | Parse tag pattern from regex match. | f13613:c4:m2 |
def parse_pseudo_class_custom(self, sel, m, has_selector): | pseudo = util.lower(css_unescape(m.group('<STR_LIT:name>')))<EOL>selector = self.custom.get(pseudo)<EOL>if selector is None:<EOL><INDENT>raise SelectorSyntaxError(<EOL>"<STR_LIT>".format(pseudo, m.end(<NUM_LIT:0>)),<EOL>self.pattern,<EOL>m.end(<NUM_LIT:0>)<EOL>)<EOL><DEDENT>if not isinstance(selector, ct.SelectorList):<EOL><INDENT>self.custom[pseudo] = None<EOL>selector = CSSParser(<EOL>selector, custom=self.custom, flags=self.flags<EOL>).process_selectors(flags=FLG_PSEUDO)<EOL>self.custom[pseudo] = selector<EOL><DEDENT>sel.selectors.append(selector)<EOL>has_selector = True<EOL>return has_selector<EOL> | Parse custom pseudo class alias.
Compile custom selectors as we need them. When compiling a custom selector,
set it to `None` in the dictionary so we can avoid an infinite loop. | f13613:c4:m3 |
def parse_pseudo_class(self, sel, m, has_selector, iselector, is_html): | complex_pseudo = False<EOL>pseudo = util.lower(css_unescape(m.group('<STR_LIT:name>')))<EOL>if m.group('<STR_LIT>'):<EOL><INDENT>complex_pseudo = True<EOL><DEDENT>if complex_pseudo and pseudo in PSEUDO_COMPLEX:<EOL><INDENT>has_selector = self.parse_pseudo_open(sel, pseudo, has_selector, iselector, m.end(<NUM_LIT:0>))<EOL><DEDENT>elif not complex_pseudo and pseudo in PSEUDO_SIMPLE:<EOL><INDENT>if pseudo == '<STR_LIT>':<EOL><INDENT>sel.flags |= ct.SEL_ROOT<EOL><DEDENT>elif pseudo == '<STR_LIT>':<EOL><INDENT>sel.flags |= ct.SEL_DEFINED<EOL>is_html = True<EOL><DEDENT>elif pseudo == '<STR_LIT>':<EOL><INDENT>sel.flags |= ct.SEL_SCOPE<EOL><DEDENT>elif pseudo == '<STR_LIT>':<EOL><INDENT>sel.flags |= ct.SEL_EMPTY<EOL><DEDENT>elif pseudo in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>sel.selectors.append(CSS_LINK)<EOL><DEDENT>elif pseudo == '<STR_LIT>':<EOL><INDENT>sel.selectors.append(CSS_CHECKED)<EOL><DEDENT>elif pseudo == '<STR_LIT>':<EOL><INDENT>sel.selectors.append(CSS_DEFAULT)<EOL><DEDENT>elif pseudo == '<STR_LIT>':<EOL><INDENT>sel.selectors.append(CSS_INDETERMINATE)<EOL><DEDENT>elif pseudo == "<STR_LIT>":<EOL><INDENT>sel.selectors.append(CSS_DISABLED)<EOL><DEDENT>elif pseudo == "<STR_LIT>":<EOL><INDENT>sel.selectors.append(CSS_ENABLED)<EOL><DEDENT>elif pseudo == "<STR_LIT>":<EOL><INDENT>sel.selectors.append(CSS_REQUIRED)<EOL><DEDENT>elif pseudo == "<STR_LIT>":<EOL><INDENT>sel.selectors.append(CSS_OPTIONAL)<EOL><DEDENT>elif pseudo == "<STR_LIT>":<EOL><INDENT>sel.selectors.append(CSS_READ_ONLY)<EOL><DEDENT>elif pseudo == "<STR_LIT>":<EOL><INDENT>sel.selectors.append(CSS_READ_WRITE)<EOL><DEDENT>elif pseudo == "<STR_LIT>":<EOL><INDENT>sel.selectors.append(CSS_IN_RANGE)<EOL><DEDENT>elif pseudo == "<STR_LIT>":<EOL><INDENT>sel.selectors.append(CSS_OUT_OF_RANGE)<EOL><DEDENT>elif pseudo == "<STR_LIT>":<EOL><INDENT>sel.selectors.append(CSS_PLACEHOLDER_SHOWN)<EOL><DEDENT>elif pseudo == '<STR_LIT>':<EOL><INDENT>sel.nth.append(ct.SelectorNth(<NUM_LIT:1>, False, <NUM_LIT:0>, False, False, ct.SelectorList()))<EOL><DEDENT>elif pseudo == '<STR_LIT>':<EOL><INDENT>sel.nth.append(ct.SelectorNth(<NUM_LIT:1>, False, <NUM_LIT:0>, False, True, ct.SelectorList()))<EOL><DEDENT>elif pseudo == '<STR_LIT>':<EOL><INDENT>sel.nth.append(ct.SelectorNth(<NUM_LIT:1>, False, <NUM_LIT:0>, True, False, ct.SelectorList()))<EOL><DEDENT>elif pseudo == '<STR_LIT>':<EOL><INDENT>sel.nth.append(ct.SelectorNth(<NUM_LIT:1>, False, <NUM_LIT:0>, True, True, ct.SelectorList()))<EOL><DEDENT>elif pseudo == '<STR_LIT>':<EOL><INDENT>sel.nth.extend(<EOL>[<EOL>ct.SelectorNth(<NUM_LIT:1>, False, <NUM_LIT:0>, False, False, ct.SelectorList()),<EOL>ct.SelectorNth(<NUM_LIT:1>, False, <NUM_LIT:0>, False, True, ct.SelectorList())<EOL>]<EOL>)<EOL><DEDENT>elif pseudo == '<STR_LIT>':<EOL><INDENT>sel.nth.extend(<EOL>[<EOL>ct.SelectorNth(<NUM_LIT:1>, False, <NUM_LIT:0>, True, False, ct.SelectorList()),<EOL>ct.SelectorNth(<NUM_LIT:1>, False, <NUM_LIT:0>, True, True, ct.SelectorList())<EOL>]<EOL>)<EOL><DEDENT>has_selector = True<EOL><DEDENT>elif complex_pseudo and pseudo in PSEUDO_COMPLEX_NO_MATCH:<EOL><INDENT>self.parse_selectors(iselector, m.end(<NUM_LIT:0>), FLG_PSEUDO | FLG_OPEN)<EOL>sel.no_match = True<EOL>has_selector = True<EOL><DEDENT>elif not complex_pseudo and pseudo in PSEUDO_SIMPLE_NO_MATCH:<EOL><INDENT>sel.no_match = True<EOL>has_selector = True<EOL><DEDENT>elif pseudo in PSEUDO_SUPPORTED:<EOL><INDENT>raise SelectorSyntaxError(<EOL>"<STR_LIT>".format(pseudo),<EOL>self.pattern,<EOL>m.start(<NUM_LIT:0>)<EOL>)<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError(<EOL>"<STR_LIT>".format(pseudo)<EOL>)<EOL><DEDENT>return has_selector, is_html<EOL> | Parse pseudo class. | f13613:c4:m4 |
def parse_pseudo_nth(self, sel, m, has_selector, iselector): | mdict = m.groupdict()<EOL>if mdict.get('<STR_LIT>'):<EOL><INDENT>postfix = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>postfix = '<STR_LIT>'<EOL><DEDENT>mdict['<STR_LIT:name>'] = util.lower(css_unescape(mdict['<STR_LIT:name>']))<EOL>content = util.lower(mdict.get('<STR_LIT>' + postfix))<EOL>if content == '<STR_LIT>':<EOL><INDENT>s1 = <NUM_LIT:2><EOL>s2 = <NUM_LIT:0><EOL>var = True<EOL><DEDENT>elif content == '<STR_LIT>':<EOL><INDENT>s1 = <NUM_LIT:2><EOL>s2 = <NUM_LIT:1><EOL>var = True<EOL><DEDENT>else:<EOL><INDENT>nth_parts = RE_NTH.match(content)<EOL>s1 = '<STR_LIT:->' if nth_parts.group('<STR_LIT>') and nth_parts.group('<STR_LIT>') == '<STR_LIT:->' else '<STR_LIT>'<EOL>a = nth_parts.group('<STR_LIT:a>')<EOL>var = a.endswith('<STR_LIT:n>')<EOL>if a.startswith('<STR_LIT:n>'):<EOL><INDENT>s1 += '<STR_LIT:1>'<EOL><DEDENT>elif var:<EOL><INDENT>s1 += a[:-<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>s1 += a<EOL><DEDENT>s2 = '<STR_LIT:->' if nth_parts.group('<STR_LIT>') and nth_parts.group('<STR_LIT>') == '<STR_LIT:->' else '<STR_LIT>'<EOL>if nth_parts.group('<STR_LIT:b>'):<EOL><INDENT>s2 += nth_parts.group('<STR_LIT:b>')<EOL><DEDENT>else:<EOL><INDENT>s2 = '<STR_LIT:0>'<EOL><DEDENT>s1 = int(s1, <NUM_LIT:10>)<EOL>s2 = int(s2, <NUM_LIT:10>)<EOL><DEDENT>pseudo_sel = mdict['<STR_LIT:name>']<EOL>if postfix == '<STR_LIT>':<EOL><INDENT>if m.group('<STR_LIT>'):<EOL><INDENT>nth_sel = self.parse_selectors(iselector, m.end(<NUM_LIT:0>), FLG_PSEUDO | FLG_OPEN)<EOL><DEDENT>else:<EOL><INDENT>nth_sel = CSS_NTH_OF_S_DEFAULT<EOL><DEDENT>if pseudo_sel == '<STR_LIT>':<EOL><INDENT>sel.nth.append(ct.SelectorNth(s1, var, s2, False, False, nth_sel))<EOL><DEDENT>elif pseudo_sel == '<STR_LIT>':<EOL><INDENT>sel.nth.append(ct.SelectorNth(s1, var, s2, False, True, nth_sel))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if pseudo_sel == '<STR_LIT>':<EOL><INDENT>sel.nth.append(ct.SelectorNth(s1, var, s2, True, False, ct.SelectorList()))<EOL><DEDENT>elif pseudo_sel == '<STR_LIT>':<EOL><INDENT>sel.nth.append(ct.SelectorNth(s1, var, s2, True, True, ct.SelectorList()))<EOL><DEDENT><DEDENT>has_selector = True<EOL>return has_selector<EOL> | Parse `nth` pseudo. | f13613:c4:m5 |
def parse_pseudo_open(self, sel, name, has_selector, iselector, index): | flags = FLG_PSEUDO | FLG_OPEN<EOL>if name == '<STR_LIT>':<EOL><INDENT>flags |= FLG_NOT<EOL><DEDENT>if name == '<STR_LIT>':<EOL><INDENT>flags |= FLG_RELATIVE<EOL><DEDENT>sel.selectors.append(self.parse_selectors(iselector, index, flags))<EOL>has_selector = True<EOL>return has_selector<EOL> | Parse pseudo with opening bracket. | f13613:c4:m6 |
def parse_has_combinator(self, sel, m, has_selector, selectors, rel_type, index): | combinator = m.group('<STR_LIT>').strip()<EOL>if not combinator:<EOL><INDENT>combinator = WS_COMBINATOR<EOL><DEDENT>if combinator == COMMA_COMBINATOR:<EOL><INDENT>if not has_selector:<EOL><INDENT>raise SelectorSyntaxError(<EOL>"<STR_LIT>".format(combinator, index),<EOL>self.pattern,<EOL>index<EOL>)<EOL><DEDENT>sel.rel_type = rel_type<EOL>selectors[-<NUM_LIT:1>].relations.append(sel)<EOL>rel_type = "<STR_LIT::>" + WS_COMBINATOR<EOL>selectors.append(_Selector())<EOL><DEDENT>else:<EOL><INDENT>if has_selector:<EOL><INDENT>sel.rel_type = rel_type<EOL>selectors[-<NUM_LIT:1>].relations.append(sel)<EOL><DEDENT>elif rel_type[<NUM_LIT:1>:] != WS_COMBINATOR:<EOL><INDENT>raise SelectorSyntaxError(<EOL>'<STR_LIT>'.format(index),<EOL>self.pattern,<EOL>index<EOL>)<EOL><DEDENT>rel_type = '<STR_LIT::>' + combinator<EOL><DEDENT>sel = _Selector()<EOL>has_selector = False<EOL>return has_selector, sel, rel_type<EOL> | Parse combinator tokens. | f13613:c4:m7 |
def parse_combinator(self, sel, m, has_selector, selectors, relations, is_pseudo, index): | combinator = m.group('<STR_LIT>').strip()<EOL>if not combinator:<EOL><INDENT>combinator = WS_COMBINATOR<EOL><DEDENT>if not has_selector:<EOL><INDENT>if (not self.quirks or is_pseudo or combinator == COMMA_COMBINATOR or relations):<EOL><INDENT>raise SelectorSyntaxError(<EOL>"<STR_LIT>".format(combinator, index),<EOL>self.pattern,<EOL>index<EOL>)<EOL><DEDENT>util.warn_quirks(<EOL>'<STR_LIT>'.format(index),<EOL>'<STR_LIT>',<EOL>self.pattern,<EOL>index<EOL>)<EOL>sel.flags |= ct.SEL_SCOPE<EOL><DEDENT>if combinator == COMMA_COMBINATOR:<EOL><INDENT>if not sel.tag and not is_pseudo:<EOL><INDENT>sel.tag = ct.SelectorTag('<STR_LIT:*>', None)<EOL><DEDENT>sel.relations.extend(relations)<EOL>selectors.append(sel)<EOL>del relations[:]<EOL><DEDENT>else:<EOL><INDENT>sel.relations.extend(relations)<EOL>sel.rel_type = combinator<EOL>del relations[:]<EOL>relations.append(sel)<EOL><DEDENT>sel = _Selector()<EOL>has_selector = False<EOL>return has_selector, sel<EOL> | Parse combinator tokens. | f13613:c4:m8 |
def parse_class_id(self, sel, m, has_selector): | selector = m.group(<NUM_LIT:0>)<EOL>if selector.startswith('<STR_LIT:.>'):<EOL><INDENT>sel.classes.append(css_unescape(selector[<NUM_LIT:1>:]))<EOL><DEDENT>else:<EOL><INDENT>sel.ids.append(css_unescape(selector[<NUM_LIT:1>:]))<EOL><DEDENT>has_selector = True<EOL>return has_selector<EOL> | Parse HTML classes and ids. | f13613:c4:m9 |
def parse_pseudo_contains(self, sel, m, has_selector): | values = m.group('<STR_LIT>')<EOL>patterns = []<EOL>for token in RE_VALUES.finditer(values):<EOL><INDENT>if token.group('<STR_LIT>'):<EOL><INDENT>continue<EOL><DEDENT>value = token.group('<STR_LIT:value>')<EOL>if value.startswith(("<STR_LIT:'>", '<STR_LIT:">')):<EOL><INDENT>value = css_unescape(value[<NUM_LIT:1>:-<NUM_LIT:1>], True)<EOL><DEDENT>else:<EOL><INDENT>value = css_unescape(value)<EOL><DEDENT>patterns.append(value)<EOL><DEDENT>sel.contains.append(ct.SelectorContains(tuple(patterns)))<EOL>has_selector = True<EOL>return has_selector<EOL> | Parse contains. | f13613:c4:m10 |
def parse_pseudo_lang(self, sel, m, has_selector): | values = m.group('<STR_LIT>')<EOL>patterns = []<EOL>for token in RE_VALUES.finditer(values):<EOL><INDENT>if token.group('<STR_LIT>'):<EOL><INDENT>continue<EOL><DEDENT>value = token.group('<STR_LIT:value>')<EOL>if value.startswith(('<STR_LIT:">', "<STR_LIT:'>")):<EOL><INDENT>parts = css_unescape(value[<NUM_LIT:1>:-<NUM_LIT:1>], True).split('<STR_LIT:->')<EOL><DEDENT>else:<EOL><INDENT>parts = css_unescape(value).split('<STR_LIT:->')<EOL><DEDENT>new_parts = []<EOL>first = True<EOL>for part in parts:<EOL><INDENT>if part == '<STR_LIT:*>' and first:<EOL><INDENT>new_parts.append('<STR_LIT>')<EOL><DEDENT>elif part != '<STR_LIT:*>':<EOL><INDENT>new_parts.append(('<STR_LIT>' if first else '<STR_LIT>') + re.escape(part))<EOL><DEDENT>if first:<EOL><INDENT>first = False<EOL><DEDENT><DEDENT>patterns.append(re.compile(r'<STR_LIT>'.format('<STR_LIT>'.join(new_parts)), re.I))<EOL><DEDENT>sel.lang.append(ct.SelectorLang(patterns))<EOL>has_selector = True<EOL>return has_selector<EOL> | Parse pseudo language. | f13613:c4:m11 |
def parse_pseudo_dir(self, sel, m, has_selector): | value = ct.SEL_DIR_LTR if util.lower(m.group('<STR_LIT>')) == '<STR_LIT>' else ct.SEL_DIR_RTL<EOL>sel.flags |= value<EOL>has_selector = True<EOL>return has_selector<EOL> | Parse pseudo direction. | f13613:c4:m12 |
def parse_selectors(self, iselector, index=<NUM_LIT:0>, flags=<NUM_LIT:0>): | sel = _Selector()<EOL>selectors = []<EOL>has_selector = False<EOL>closed = False<EOL>relations = []<EOL>rel_type = "<STR_LIT::>" + WS_COMBINATOR<EOL>is_open = bool(flags & FLG_OPEN)<EOL>is_pseudo = bool(flags & FLG_PSEUDO)<EOL>is_relative = bool(flags & FLG_RELATIVE)<EOL>is_not = bool(flags & FLG_NOT)<EOL>is_html = bool(flags & FLG_HTML)<EOL>is_default = bool(flags & FLG_DEFAULT)<EOL>is_indeterminate = bool(flags & FLG_INDETERMINATE)<EOL>is_in_range = bool(flags & FLG_IN_RANGE)<EOL>is_out_of_range = bool(flags & FLG_OUT_OF_RANGE)<EOL>if self.debug: <EOL><INDENT>if is_pseudo:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>if is_open:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>if is_relative:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>if is_not:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>if is_html:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>if is_default:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>if is_indeterminate:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>if is_in_range:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>if is_out_of_range:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT><DEDENT>if is_relative:<EOL><INDENT>selectors.append(_Selector())<EOL><DEDENT>try:<EOL><INDENT>while True:<EOL><INDENT>key, m = next(iselector)<EOL>if key == "<STR_LIT>":<EOL><INDENT>raise NotImplementedError("<STR_LIT>".format(m.start(<NUM_LIT:0>)))<EOL><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>has_selector = self.parse_pseudo_class_custom(sel, m, has_selector)<EOL><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>has_selector, is_html = self.parse_pseudo_class(sel, m, has_selector, iselector, is_html)<EOL><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>raise NotImplementedError("<STR_LIT>".format(m.start(<NUM_LIT:0>)))<EOL><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>has_selector = self.parse_pseudo_contains(sel, m, has_selector)<EOL><DEDENT>elif key in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>has_selector = self.parse_pseudo_nth(sel, m, has_selector, iselector)<EOL><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>has_selector = self.parse_pseudo_lang(sel, m, has_selector)<EOL><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>has_selector = self.parse_pseudo_dir(sel, m, has_selector)<EOL>is_html = True<EOL><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>if not has_selector:<EOL><INDENT>raise SelectorSyntaxError(<EOL>"<STR_LIT>".format(m.start(<NUM_LIT:0>)),<EOL>self.pattern,<EOL>m.start(<NUM_LIT:0>)<EOL>)<EOL><DEDENT>if is_open:<EOL><INDENT>closed = True<EOL>break<EOL><DEDENT>else:<EOL><INDENT>raise SelectorSyntaxError(<EOL>"<STR_LIT>".format(m.start(<NUM_LIT:0>)),<EOL>self.pattern,<EOL>m.start(<NUM_LIT:0>)<EOL>)<EOL><DEDENT><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>if is_relative:<EOL><INDENT>has_selector, sel, rel_type = self.parse_has_combinator(<EOL>sel, m, has_selector, selectors, rel_type, index<EOL>)<EOL><DEDENT>else:<EOL><INDENT>has_selector, sel = self.parse_combinator(<EOL>sel, m, has_selector, selectors, relations, is_pseudo, index<EOL>)<EOL><DEDENT><DEDENT>elif key in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>quirks = key == '<STR_LIT>'<EOL>if quirks:<EOL><INDENT>temp_index = index + m.group(<NUM_LIT:0>).find('<STR_LIT:=>') + <NUM_LIT:1><EOL>util.warn_quirks(<EOL>"<STR_LIT>" +<EOL>"<STR_LIT>".format(temp_index),<EOL>"<STR_LIT>",<EOL>self.pattern,<EOL>temp_index<EOL>)<EOL><DEDENT>has_selector = self.parse_attribute_selector(sel, m, has_selector, quirks)<EOL><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>if has_selector:<EOL><INDENT>raise SelectorSyntaxError(<EOL>"<STR_LIT>".format(m.start(<NUM_LIT:0>)),<EOL>self.pattern,<EOL>m.start(<NUM_LIT:0>)<EOL>)<EOL><DEDENT>has_selector = self.parse_tag_pattern(sel, m, has_selector)<EOL><DEDENT>elif key in ('<STR_LIT:class>', '<STR_LIT:id>'):<EOL><INDENT>has_selector = self.parse_class_id(sel, m, has_selector)<EOL><DEDENT>index = m.end(<NUM_LIT:0>)<EOL><DEDENT><DEDENT>except StopIteration:<EOL><INDENT>pass<EOL><DEDENT>if is_open and not closed:<EOL><INDENT>raise SelectorSyntaxError(<EOL>"<STR_LIT>".format(index),<EOL>self.pattern,<EOL>index<EOL>)<EOL><DEDENT>if has_selector:<EOL><INDENT>if not sel.tag and not is_pseudo:<EOL><INDENT>sel.tag = ct.SelectorTag('<STR_LIT:*>', None)<EOL><DEDENT>if is_relative:<EOL><INDENT>sel.rel_type = rel_type<EOL>selectors[-<NUM_LIT:1>].relations.append(sel)<EOL><DEDENT>else:<EOL><INDENT>sel.relations.extend(relations)<EOL>del relations[:]<EOL>selectors.append(sel)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise SelectorSyntaxError(<EOL>'<STR_LIT>'.format(index),<EOL>self.pattern,<EOL>index<EOL>)<EOL><DEDENT>if is_default:<EOL><INDENT>selectors[-<NUM_LIT:1>].flags = ct.SEL_DEFAULT<EOL><DEDENT>if is_indeterminate:<EOL><INDENT>selectors[-<NUM_LIT:1>].flags = ct.SEL_INDETERMINATE<EOL><DEDENT>if is_in_range:<EOL><INDENT>selectors[-<NUM_LIT:1>].flags = ct.SEL_IN_RANGE<EOL><DEDENT>if is_out_of_range:<EOL><INDENT>selectors[-<NUM_LIT:1>].flags = ct.SEL_OUT_OF_RANGE<EOL><DEDENT>return ct.SelectorList([s.freeze() for s in selectors], is_not, is_html)<EOL> | Parse selectors. | f13613:c4:m13 |
def selector_iter(self, pattern): | <EOL>m = RE_WS_BEGIN.search(pattern)<EOL>index = m.end(<NUM_LIT:0>) if m else <NUM_LIT:0><EOL>m = RE_WS_END.search(pattern)<EOL>end = (m.start(<NUM_LIT:0>) - <NUM_LIT:1>) if m else (len(pattern) - <NUM_LIT:1>)<EOL>if self.debug: <EOL><INDENT>if self.quirks:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>print('<STR_LIT>'.format(pattern))<EOL><DEDENT>while index <= end:<EOL><INDENT>m = None<EOL>for v in self.css_tokens:<EOL><INDENT>if not v.enabled(self.flags): <EOL><INDENT>continue<EOL><DEDENT>m = v.match(pattern, index)<EOL>if m:<EOL><INDENT>name = v.get_name()<EOL>if self.debug: <EOL><INDENT>print("<STR_LIT>".format(name, m.group(<NUM_LIT:0>), m.start(<NUM_LIT:0>)))<EOL><DEDENT>index = m.end(<NUM_LIT:0>)<EOL>yield name, m<EOL>break<EOL><DEDENT><DEDENT>if m is None:<EOL><INDENT>c = pattern[index]<EOL>if c == '<STR_LIT:[>':<EOL><INDENT>msg = "<STR_LIT>".format(index)<EOL><DEDENT>elif c == '<STR_LIT:.>':<EOL><INDENT>msg = "<STR_LIT>".format(index)<EOL><DEDENT>elif c == '<STR_LIT:#>':<EOL><INDENT>msg = "<STR_LIT>".format(index)<EOL><DEDENT>elif c == '<STR_LIT::>':<EOL><INDENT>msg = "<STR_LIT>".format(index)<EOL><DEDENT>else:<EOL><INDENT>msg = "<STR_LIT>".format(c, index)<EOL><DEDENT>raise SelectorSyntaxError(msg, self.pattern, index)<EOL><DEDENT><DEDENT>if self.debug: <EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT> | Iterate selector tokens. | f13613:c4:m14 |
def process_selectors(self, index=<NUM_LIT:0>, flags=<NUM_LIT:0>): | return self.parse_selectors(self.selector_iter(self.pattern), index, flags)<EOL> | Process selectors.
We do our own selectors as BeautifulSoup4 has some annoying quirks,
and we don't really need to do nth selectors or siblings or
descendants etc. | f13613:c4:m15 |
def compile(pattern, namespaces=None, flags=<NUM_LIT:0>, **kwargs): | if namespaces is not None:<EOL><INDENT>namespaces = ct.Namespaces(**namespaces)<EOL><DEDENT>custom = kwargs.get('<STR_LIT>')<EOL>if custom is not None:<EOL><INDENT>custom = ct.CustomSelectors(**custom)<EOL><DEDENT>if isinstance(pattern, SoupSieve):<EOL><INDENT>if flags:<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT>elif namespaces is not None:<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT>elif custom is not None:<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT>return pattern<EOL><DEDENT>return cp._cached_css_compile(pattern, namespaces, custom, flags)<EOL> | Compile CSS pattern. | f13614:m0 |
def purge(): | cp._purge_cache()<EOL> | Purge cached patterns. | f13614:m1 |
def closest(select, tag, namespaces=None, flags=<NUM_LIT:0>, **kwargs): | return compile(select, namespaces, flags, **kwargs).closest(tag)<EOL> | Match closest ancestor. | f13614:m2 |
def match(select, tag, namespaces=None, flags=<NUM_LIT:0>, **kwargs): | return compile(select, namespaces, flags, **kwargs).match(tag)<EOL> | Match node. | f13614:m3 |
def filter(select, iterable, namespaces=None, flags=<NUM_LIT:0>, **kwargs): | return compile(select, namespaces, flags, **kwargs).filter(iterable)<EOL> | Filter list of nodes. | f13614:m4 |
@deprecated("<STR_LIT>")<EOL>def comments(tag, limit=<NUM_LIT:0>, flags=<NUM_LIT:0>, **kwargs): | return [comment for comment in cm.CommentsMatch(tag).get_comments(limit)]<EOL> | Get comments only. | f13614:m5 |
@deprecated("<STR_LIT>")<EOL>def icomments(tag, limit=<NUM_LIT:0>, flags=<NUM_LIT:0>, **kwargs): | for comment in cm.CommentsMatch(tag).get_comments(limit):<EOL><INDENT>yield comment<EOL><DEDENT> | Iterate comments only. | f13614:m6 |
def select_one(select, tag, namespaces=None, flags=<NUM_LIT:0>, **kwargs): | return compile(select, namespaces, flags, **kwargs).select_one(tag)<EOL> | Select a single tag. | f13614:m7 |
def select(select, tag, namespaces=None, limit=<NUM_LIT:0>, flags=<NUM_LIT:0>, **kwargs): | return compile(select, namespaces, flags, **kwargs).select(tag, limit)<EOL> | Select the specified tags. | f13614:m8 |
def iselect(select, tag, namespaces=None, limit=<NUM_LIT:0>, flags=<NUM_LIT:0>, **kwargs): | for el in compile(select, namespaces, flags, **kwargs).iselect(tag, limit):<EOL><INDENT>yield el<EOL><DEDENT> | Iterate the specified tags. | f13614:m9 |
def escape(ident): | return cp.escape(ident)<EOL> | Escape identifier. | f13614:m10 |
def parse_version(ver, pre=False): | m = RE_VER.match(ver)<EOL>major = int(m.group('<STR_LIT>'))<EOL>minor = int(m.group('<STR_LIT>')) if m.group('<STR_LIT>') else <NUM_LIT:0><EOL>micro = int(m.group('<STR_LIT>')) if m.group('<STR_LIT>') else <NUM_LIT:0><EOL>if m.group('<STR_LIT:type>'):<EOL><INDENT>release = PRE_REL_MAP[m.group('<STR_LIT:type>')]<EOL>pre = int(m.group('<STR_LIT>'))<EOL><DEDENT>else:<EOL><INDENT>release = "<STR_LIT>"<EOL>pre = <NUM_LIT:0><EOL><DEDENT>dev = m.group('<STR_LIT>') if m.group('<STR_LIT>') else <NUM_LIT:0><EOL>if m.group('<STR_LIT>'):<EOL><INDENT>dev = int(m.group('<STR_LIT>'))<EOL>release = '<STR_LIT>' + release if pre else '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>dev = <NUM_LIT:0><EOL><DEDENT>post = int(m.group('<STR_LIT>')) if m.group('<STR_LIT>') else <NUM_LIT:0><EOL>return Version(major, minor, micro, release, pre, post, dev)<EOL> | Parse version into a comparable Version tuple. | f13615:m0 |
def __new__(cls, major, minor, micro, release="<STR_LIT>", pre=<NUM_LIT:0>, post=<NUM_LIT:0>, dev=<NUM_LIT:0>): | <EOL>for value in (major, minor, micro, pre, post):<EOL><INDENT>if not (isinstance(value, int) and value >= <NUM_LIT:0>):<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT><DEDENT>if release not in REL_MAP:<EOL><INDENT>raise ValueError("<STR_LIT>".format(release))<EOL><DEDENT>if "<STR_LIT>" < release < "<STR_LIT>":<EOL><INDENT>if pre == <NUM_LIT:0>:<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT>elif dev:<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT>elif post:<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT><DEDENT>elif release < "<STR_LIT>":<EOL><INDENT>if release > "<STR_LIT>" and pre == <NUM_LIT:0>:<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT>elif post:<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if pre:<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT>elif dev:<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT><DEDENT>return super(Version, cls).__new__(cls, major, minor, micro, release, pre, post, dev)<EOL> | Validate version info. | f13615:c0:m0 |
def _is_pre(self): | return self.pre > <NUM_LIT:0><EOL> | Is prerelease. | f13615:c0:m1 |
def _is_dev(self): | return bool(self.release < "<STR_LIT>")<EOL> | Is development. | f13615:c0:m2 |
def _is_post(self): | return self.post > <NUM_LIT:0><EOL> | Is post. | f13615:c0:m3 |
def _get_dev_status(self): | return DEV_STATUS[self.release]<EOL> | Get development status string. | f13615:c0:m4 |
def _get_canonical(self): | <EOL>if self.micro == <NUM_LIT:0>:<EOL><INDENT>ver = "<STR_LIT>".format(self.major, self.minor)<EOL><DEDENT>else:<EOL><INDENT>ver = "<STR_LIT>".format(self.major, self.minor, self.micro)<EOL><DEDENT>if self._is_pre():<EOL><INDENT>ver += '<STR_LIT>'.format(REL_MAP[self.release], self.pre)<EOL><DEDENT>if self._is_post():<EOL><INDENT>ver += "<STR_LIT>".format(self.post)<EOL><DEDENT>if self._is_dev():<EOL><INDENT>ver += "<STR_LIT>".format(self.dev)<EOL><DEDENT>return ver<EOL> | Get the canonical output string. | f13615:c0:m5 |
def __init__(self, element): | self.contents = [element]<EOL> | Initialize. | f13616:c0:m0 |
def __len__(self): | return len(self.contents)<EOL> | Length. | f13616:c0:m1 |
@classmethod<EOL><INDENT>def assert_valid_input(cls, tag):<DEDENT> | <EOL>if not cls.is_tag(tag):<EOL><INDENT>raise TypeError("<STR_LIT>".format(type(tag)))<EOL><DEDENT> | Check if valid input tag or document. | f13616:c1:m0 |
@staticmethod<EOL><INDENT>def is_doc(obj):<DEDENT> | import bs4<EOL>return isinstance(obj, bs4.BeautifulSoup)<EOL> | Is `BeautifulSoup` object. | f13616:c1:m1 |
@staticmethod<EOL><INDENT>def is_tag(obj):<DEDENT> | import bs4<EOL>return isinstance(obj, bs4.Tag)<EOL> | Is tag. | f13616:c1:m2 |
@staticmethod<EOL><INDENT>def is_comment(obj):<DEDENT> | import bs4<EOL>return isinstance(obj, bs4.Comment)<EOL> | Is comment. | f13616:c1:m3 |
@staticmethod<EOL><INDENT>def is_declaration(obj): <DEDENT> | import bs4<EOL>return isinstance(obj, bs4.Declaration)<EOL> | Is declaration. | f13616:c1:m4 |
@staticmethod<EOL><INDENT>def is_cdata(obj): <DEDENT> | import bs4<EOL>return isinstance(obj, bs4.Declaration)<EOL> | Is CDATA. | f13616:c1:m5 |
@staticmethod<EOL><INDENT>def is_processing_instruction(obj): <DEDENT> | import bs4<EOL>return isinstance(obj, bs4.ProcessingInstruction)<EOL> | Is processing instruction. | f13616:c1:m6 |
@staticmethod<EOL><INDENT>def is_navigable_string(obj):<DEDENT> | import bs4<EOL>return isinstance(obj, bs4.NavigableString)<EOL> | Is navigable string. | f13616:c1:m7 |
@staticmethod<EOL><INDENT>def is_special_string(obj):<DEDENT> | import bs4<EOL>return isinstance(obj, (bs4.Comment, bs4.Declaration, bs4.CData, bs4.ProcessingInstruction))<EOL> | Is special string. | f13616:c1:m8 |
@classmethod<EOL><INDENT>def is_content_string(cls, obj):<DEDENT> | return cls.is_navigable_string(obj) and not cls.is_special_string(obj)<EOL> | Check if node is content string. | f13616:c1:m9 |
@staticmethod<EOL><INDENT>def create_fake_parent(el):<DEDENT> | return FakeParent(el)<EOL> | Create fake parent for a given element. | f13616:c1:m10 |
@staticmethod<EOL><INDENT>def is_xml_tree(el):<DEDENT> | return el._is_xml<EOL> | Check if element (or document) is from a XML tree. | f13616:c1:m11 |
def is_iframe(self, el): | return ((el.name if self.is_xml_tree(el) else util.lower(el.name)) == '<STR_LIT>') and self.is_html_tag(el)<EOL> | Check if element is an `iframe`. | f13616:c1:m12 |
def is_root(self, el): | root = self.root and self.root is el<EOL>if not root:<EOL><INDENT>parent = self.get_parent(el)<EOL>root = parent is not None and self.is_html and self.is_iframe(parent)<EOL><DEDENT>return root<EOL> | Return whether element is a root element.
We check that the element is the root of the tree (which we have already pre-calculated),
and we check if it is the root element under an `iframe`. | f13616:c1:m13 |
def get_contents(self, el, no_iframe=False): | if not no_iframe or not self.is_iframe(el):<EOL><INDENT>for content in el.contents:<EOL><INDENT>yield content<EOL><DEDENT><DEDENT> | Get contents or contents in reverse. | f13616:c1:m14 |
def get_children(self, el, start=None, reverse=False, tags=True, no_iframe=False): | if not no_iframe or not self.is_iframe(el):<EOL><INDENT>last = len(el.contents) - <NUM_LIT:1><EOL>if start is None:<EOL><INDENT>index = last if reverse else <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>index = start<EOL><DEDENT>end = -<NUM_LIT:1> if reverse else last + <NUM_LIT:1><EOL>incr = -<NUM_LIT:1> if reverse else <NUM_LIT:1><EOL>if <NUM_LIT:0> <= index <= last:<EOL><INDENT>while index != end:<EOL><INDENT>node = el.contents[index]<EOL>index += incr<EOL>if not tags or self.is_tag(node):<EOL><INDENT>yield node<EOL><DEDENT><DEDENT><DEDENT><DEDENT> | Get children. | f13616:c1:m15 |
def get_descendants(self, el, tags=True, no_iframe=False): | if not no_iframe or not self.is_iframe(el):<EOL><INDENT>next_good = None<EOL>for child in el.descendants:<EOL><INDENT>if next_good is not None:<EOL><INDENT>if child is not next_good:<EOL><INDENT>continue<EOL><DEDENT>next_good = None<EOL><DEDENT>is_tag = self.is_tag(child)<EOL>if no_iframe and is_tag and self.is_iframe(child):<EOL><INDENT>if child.next_sibling is not None:<EOL><INDENT>next_good = child.next_sibling<EOL><DEDENT>else:<EOL><INDENT>last_child = child<EOL>while self.is_tag(last_child) and last_child.contents:<EOL><INDENT>last_child = last_child.contents[-<NUM_LIT:1>]<EOL><DEDENT>next_good = last_child.next_element<EOL><DEDENT>yield child<EOL>if next_good is None:<EOL><INDENT>break<EOL><DEDENT>continue <EOL><DEDENT>if not tags or is_tag:<EOL><INDENT>yield child<EOL><DEDENT><DEDENT><DEDENT> | Get descendants. | f13616:c1:m16 |
def get_parent(self, el, no_iframe=False): | parent = el.parent<EOL>if no_iframe and parent is not None and self.is_iframe(parent):<EOL><INDENT>parent = None<EOL><DEDENT>return parent<EOL> | Get parent. | f13616:c1:m17 |
@staticmethod<EOL><INDENT>def get_tag_name(el):<DEDENT> | return el.name<EOL> | Get tag. | f13616:c1:m18 |
@staticmethod<EOL><INDENT>def get_prefix_name(el):<DEDENT> | return el.prefix<EOL> | Get prefix. | f13616:c1:m19 |
@classmethod<EOL><INDENT>def get_next_tag(cls, el):<DEDENT> | sibling = el.next_sibling<EOL>while not cls.is_tag(sibling) and sibling is not None:<EOL><INDENT>sibling = sibling.next_sibling<EOL><DEDENT>return sibling<EOL> | Get next sibling tag. | f13616:c1:m20 |
@classmethod<EOL><INDENT>def get_previous_tag(cls, el):<DEDENT> | sibling = el.previous_sibling<EOL>while not cls.is_tag(sibling) and sibling is not None:<EOL><INDENT>sibling = sibling.previous_sibling<EOL><DEDENT>return sibling<EOL> | Get previous sibling tag. | f13616:c1:m21 |
@staticmethod<EOL><INDENT>def has_html_ns(el):<DEDENT> | ns = getattr(el, '<STR_LIT>') if el else None<EOL>return ns and ns == NS_XHTML<EOL> | Check if element has an HTML namespace.
This is a bit different than whether a element is treated as having an HTML namespace,
like we do in the case of `is_html_tag`. | f13616:c1:m22 |
@staticmethod<EOL><INDENT>def split_namespace(el, attr_name):<DEDENT> | return getattr(attr_name, '<STR_LIT>', None), getattr(attr_name, '<STR_LIT:name>', None)<EOL> | Return namespace and attribute name without the prefix. | f13616:c1:m23 |
@staticmethod<EOL><INDENT>def get_attribute_by_name(el, name, default=None):<DEDENT> | value = default<EOL>if el._is_xml:<EOL><INDENT>try:<EOL><INDENT>value = el.attrs[name]<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for k, v in el.attrs.items():<EOL><INDENT>if util.lower(k) == name:<EOL><INDENT>value = v<EOL>break<EOL><DEDENT><DEDENT><DEDENT>return value<EOL> | Get attribute by name. | f13616:c1:m24 |
@staticmethod<EOL><INDENT>def iter_attributes(el):<DEDENT> | for k, v in el.attrs.items():<EOL><INDENT>yield k, v<EOL><DEDENT> | Iterate attributes. | f13616:c1:m25 |
@classmethod<EOL><INDENT>def get_classes(cls, el):<DEDENT> | classes = cls.get_attribute_by_name(el, '<STR_LIT:class>', [])<EOL>if isinstance(classes, util.ustr):<EOL><INDENT>classes = RE_NOT_WS.findall(classes)<EOL><DEDENT>return classes<EOL> | Get classes. | f13616:c1:m26 |
def get_text(self, el, no_iframe=False): | return '<STR_LIT>'.join(<EOL>[node for node in self.get_descendants(el, tags=False, no_iframe=no_iframe) if self.is_content_string(node)]<EOL>)<EOL> | Get text. | f13616:c1:m27 |
@staticmethod<EOL><INDENT>def validate_day(year, month, day):<DEDENT> | max_days = LONG_MONTH<EOL>if month == FEB:<EOL><INDENT>max_days = FEB_LEAP_MONTH if ((year % <NUM_LIT:4> == <NUM_LIT:0>) and (year % <NUM_LIT:100> != <NUM_LIT:0>)) or (year % <NUM_LIT> == <NUM_LIT:0>) else FEB_MONTH<EOL><DEDENT>elif month in MONTHS_30:<EOL><INDENT>max_days = SHORT_MONTH<EOL><DEDENT>return <NUM_LIT:1> <= day <= max_days<EOL> | Validate day. | f13616:c2:m0 |
@staticmethod<EOL><INDENT>def validate_week(year, week):<DEDENT> | max_week = datetime.strptime("<STR_LIT>".format(<NUM_LIT:12>, <NUM_LIT>, year), "<STR_LIT>").isocalendar()[<NUM_LIT:1>]<EOL>if max_week == <NUM_LIT:1>:<EOL><INDENT>max_week = <NUM_LIT><EOL><DEDENT>return <NUM_LIT:1> <= week <= max_week<EOL> | Validate week. | f13616:c2:m1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.