File manager - Edit - /home/newsbmcs.com/public_html/static/img/logo/soupsieve.tar
Back
css_types.py 0000644 00000023720 15030227305 0007133 0 ustar 00 """CSS selector structure items.""" from __future__ import annotations import copyreg from .pretty import pretty from typing import Any, Iterator, Hashable, Pattern, Iterable, Mapping __all__ = ( 'Selector', 'SelectorNull', 'SelectorTag', 'SelectorAttribute', 'SelectorContains', 'SelectorNth', 'SelectorLang', 'SelectorList', 'Namespaces', 'CustomSelectors' ) SEL_EMPTY = 0x1 SEL_ROOT = 0x2 SEL_DEFAULT = 0x4 SEL_INDETERMINATE = 0x8 SEL_SCOPE = 0x10 SEL_DIR_LTR = 0x20 SEL_DIR_RTL = 0x40 SEL_IN_RANGE = 0x80 SEL_OUT_OF_RANGE = 0x100 SEL_DEFINED = 0x200 SEL_PLACEHOLDER_SHOWN = 0x400 class Immutable: """Immutable.""" __slots__: tuple[str, ...] = ('_hash',) _hash: int def __init__(self, **kwargs: Any) -> None: """Initialize.""" temp = [] for k, v in kwargs.items(): temp.append(type(v)) temp.append(v) super().__setattr__(k, v) super().__setattr__('_hash', hash(tuple(temp))) @classmethod def __base__(cls) -> type[Immutable]: """Get base class.""" return cls def __eq__(self, other: Any) -> bool: """Equal.""" return ( isinstance(other, self.__base__()) and all(getattr(other, key) == getattr(self, key) for key in self.__slots__ if key != '_hash') ) def __ne__(self, other: Any) -> bool: """Equal.""" return ( not isinstance(other, self.__base__()) or any(getattr(other, key) != getattr(self, key) for key in self.__slots__ if key != '_hash') ) def __hash__(self) -> int: """Hash.""" return self._hash def __setattr__(self, name: str, value: Any) -> None: """Prevent mutability.""" raise AttributeError(f"'{self.__class__.__name__}' is immutable") def __repr__(self) -> str: # pragma: no cover """Representation.""" r = ', '.join([f"{k}={getattr(self, k)!r}" for k in self.__slots__[:-1]]) return f"{self.__class__.__name__}({r})" __str__ = __repr__ def pretty(self) -> None: # pragma: no cover """Pretty print.""" print(pretty(self)) class ImmutableDict(Mapping[Any, Any]): """Hashable, immutable dictionary.""" def __init__( self, arg: dict[Any, Any] | Iterable[tuple[Any, Any]] ) -> None: """Initialize.""" self._validate(arg) self._d = dict(arg) self._hash = hash(tuple([(type(x), x, type(y), y) for x, y in sorted(self._d.items())])) def _validate(self, arg: dict[Any, Any] | Iterable[tuple[Any, Any]]) -> None: """Validate arguments.""" if isinstance(arg, dict): if not all(isinstance(v, Hashable) for v in arg.values()): raise TypeError(f'{self.__class__.__name__} values must be hashable') elif not all(isinstance(k, Hashable) and isinstance(v, Hashable) for k, v in arg): raise TypeError(f'{self.__class__.__name__} values must be hashable') def __iter__(self) -> Iterator[Any]: """Iterator.""" return iter(self._d) def __len__(self) -> int: """Length.""" return len(self._d) def __getitem__(self, key: Any) -> Any: """Get item: `namespace['key']`.""" return self._d[key] def __hash__(self) -> int: """Hash.""" return self._hash def __repr__(self) -> str: # pragma: no cover """Representation.""" return f"{self._d!r}" __str__ = __repr__ class Namespaces(ImmutableDict): """Namespaces.""" def __init__(self, arg: dict[str, str] | Iterable[tuple[str, str]]) -> None: """Initialize.""" super().__init__(arg) def _validate(self, arg: dict[str, str] | Iterable[tuple[str, str]]) -> None: """Validate arguments.""" if isinstance(arg, dict): if not all(isinstance(v, str) for v in arg.values()): raise TypeError(f'{self.__class__.__name__} values must be hashable') elif not all(isinstance(k, str) and isinstance(v, str) for k, v in arg): raise TypeError(f'{self.__class__.__name__} keys and values must be Unicode strings') class CustomSelectors(ImmutableDict): """Custom selectors.""" def __init__(self, arg: dict[str, str] | Iterable[tuple[str, str]]) -> None: """Initialize.""" super().__init__(arg) def _validate(self, arg: dict[str, str] | Iterable[tuple[str, str]]) -> None: """Validate arguments.""" if isinstance(arg, dict): if not all(isinstance(v, str) for v in arg.values()): raise TypeError(f'{self.__class__.__name__} values must be hashable') elif not all(isinstance(k, str) and isinstance(v, str) for k, v in arg): raise TypeError(f'{self.__class__.__name__} keys and values must be Unicode strings') class Selector(Immutable): """Selector.""" __slots__ = ( 'tag', 'ids', 'classes', 'attributes', 'nth', 'selectors', 'relation', 'rel_type', 'contains', 'lang', 'flags', '_hash' ) tag: SelectorTag | None ids: tuple[str, ...] classes: tuple[str, ...] attributes: tuple[SelectorAttribute, ...] nth: tuple[SelectorNth, ...] selectors: tuple[SelectorList, ...] relation: SelectorList rel_type: str | None contains: tuple[SelectorContains, ...] lang: tuple[SelectorLang, ...] flags: int def __init__( self, tag: SelectorTag | None, ids: tuple[str, ...], classes: tuple[str, ...], attributes: tuple[SelectorAttribute, ...], nth: tuple[SelectorNth, ...], selectors: tuple[SelectorList, ...], relation: SelectorList, rel_type: str | None, contains: tuple[SelectorContains, ...], lang: tuple[SelectorLang, ...], flags: int ): """Initialize.""" super().__init__( tag=tag, ids=ids, classes=classes, attributes=attributes, nth=nth, selectors=selectors, relation=relation, rel_type=rel_type, contains=contains, lang=lang, flags=flags ) class SelectorNull(Immutable): """Null Selector.""" def __init__(self) -> None: """Initialize.""" super().__init__() class SelectorTag(Immutable): """Selector tag.""" __slots__ = ("name", "prefix", "_hash") name: str prefix: str | None def __init__(self, name: str, prefix: str | None) -> None: """Initialize.""" super().__init__(name=name, prefix=prefix) class SelectorAttribute(Immutable): """Selector attribute rule.""" __slots__ = ("attribute", "prefix", "pattern", "xml_type_pattern", "_hash") attribute: str prefix: str pattern: Pattern[str] | None xml_type_pattern: Pattern[str] | None def __init__( self, attribute: str, prefix: str, pattern: Pattern[str] | None, xml_type_pattern: Pattern[str] | None ) -> None: """Initialize.""" super().__init__( attribute=attribute, prefix=prefix, pattern=pattern, xml_type_pattern=xml_type_pattern ) class SelectorContains(Immutable): """Selector contains rule.""" __slots__ = ("text", "own", "_hash") text: tuple[str, ...] own: bool def __init__(self, text: Iterable[str], own: bool) -> None: """Initialize.""" super().__init__(text=tuple(text), own=own) class SelectorNth(Immutable): """Selector nth type.""" __slots__ = ("a", "n", "b", "of_type", "last", "selectors", "_hash") a: int n: bool b: int of_type: bool last: bool selectors: SelectorList def __init__(self, a: int, n: bool, b: int, of_type: bool, last: bool, selectors: SelectorList) -> None: """Initialize.""" super().__init__( a=a, n=n, b=b, of_type=of_type, last=last, selectors=selectors ) class SelectorLang(Immutable): """Selector language rules.""" __slots__ = ("languages", "_hash",) languages: tuple[str, ...] def __init__(self, languages: Iterable[str]): """Initialize.""" super().__init__(languages=tuple(languages)) def __iter__(self) -> Iterator[str]: """Iterator.""" return iter(self.languages) def __len__(self) -> int: # pragma: no cover """Length.""" return len(self.languages) def __getitem__(self, index: int) -> str: # pragma: no cover """Get item.""" return self.languages[index] class SelectorList(Immutable): """Selector list.""" __slots__ = ("selectors", "is_not", "is_html", "_hash") selectors: tuple[Selector | SelectorNull, ...] is_not: bool is_html: bool def __init__( self, selectors: Iterable[Selector | SelectorNull] | None = None, is_not: bool = False, is_html: bool = False ) -> None: """Initialize.""" super().__init__( selectors=tuple(selectors) if selectors is not None else (), is_not=is_not, is_html=is_html ) def __iter__(self) -> Iterator[Selector | SelectorNull]: """Iterator.""" return iter(self.selectors) def __len__(self) -> int: """Length.""" return len(self.selectors) def __getitem__(self, index: int) -> Selector | SelectorNull: """Get item.""" return self.selectors[index] def _pickle(p: Any) -> Any: return p.__base__(), tuple([getattr(p, s) for s in p.__slots__[:-1]]) def pickle_register(obj: Any) -> None: """Allow object to be pickled.""" copyreg.pickle(obj, _pickle) pickle_register(Selector) pickle_register(SelectorNull) pickle_register(SelectorTag) pickle_register(SelectorAttribute) pickle_register(SelectorContains) pickle_register(SelectorNth) pickle_register(SelectorLang) pickle_register(SelectorList) __meta__.py 0000644 00000015156 15030227305 0006645 0 ustar 00 """Meta related things.""" from __future__ import annotations from collections import namedtuple import re RE_VER = re.compile( r'''(?x) (?P<major>\d+)(?:\.(?P<minor>\d+))?(?:\.(?P<micro>\d+))? (?:(?P<type>a|b|rc)(?P<pre>\d+))? (?:\.post(?P<post>\d+))? (?:\.dev(?P<dev>\d+))? ''' ) REL_MAP = { ".dev": "", ".dev-alpha": "a", ".dev-beta": "b", ".dev-candidate": "rc", "alpha": "a", "beta": "b", "candidate": "rc", "final": "" } DEV_STATUS = { ".dev": "2 - Pre-Alpha", ".dev-alpha": "2 - Pre-Alpha", ".dev-beta": "2 - Pre-Alpha", ".dev-candidate": "2 - Pre-Alpha", "alpha": "3 - Alpha", "beta": "4 - Beta", "candidate": "4 - Beta", "final": "5 - Production/Stable" } PRE_REL_MAP = {"a": 'alpha', "b": 'beta', "rc": 'candidate'} class Version(namedtuple("Version", ["major", "minor", "micro", "release", "pre", "post", "dev"])): """ Get the version (PEP 440). A biased approach to the PEP 440 semantic version. Provides a tuple structure which is sorted for comparisons `v1 > v2` etc. (major, minor, micro, release type, pre-release build, post-release build, development release build) Release types are named in is such a way they are comparable with ease. Accessors to check if a development, pre-release, or post-release build. Also provides accessor to get development status for setup files. How it works (currently): - You must specify a release type as either `final`, `alpha`, `beta`, or `candidate`. - To define a development release, you can use either `.dev`, `.dev-alpha`, `.dev-beta`, or `.dev-candidate`. The dot is used to ensure all development specifiers are sorted before `alpha`. You can specify a `dev` number for development builds, but do not have to as implicit development releases are allowed. - You must specify a `pre` value greater than zero if using a prerelease as this project (not PEP 440) does not allow implicit prereleases. - You can optionally set `post` to a value greater than zero to make the build a post release. While post releases are technically allowed in prereleases, it is strongly discouraged, so we are rejecting them. It should be noted that we do not allow `post0` even though PEP 440 does not restrict this. This project specifically does not allow implicit post releases. - It should be noted that we do not support epochs `1!` or local versions `+some-custom.version-1`. Acceptable version releases: ``` Version(1, 0, 0, "final") 1.0 Version(1, 2, 0, "final") 1.2 Version(1, 2, 3, "final") 1.2.3 Version(1, 2, 0, ".dev-alpha", pre=4) 1.2a4 Version(1, 2, 0, ".dev-beta", pre=4) 1.2b4 Version(1, 2, 0, ".dev-candidate", pre=4) 1.2rc4 Version(1, 2, 0, "final", post=1) 1.2.post1 Version(1, 2, 3, ".dev") 1.2.3.dev0 Version(1, 2, 3, ".dev", dev=1) 1.2.3.dev1 ``` """ def __new__( cls, major: int, minor: int, micro: int, release: str = "final", pre: int = 0, post: int = 0, dev: int = 0 ) -> Version: """Validate version info.""" # Ensure all parts are positive integers. for value in (major, minor, micro, pre, post): if not (isinstance(value, int) and value >= 0): raise ValueError("All version parts except 'release' should be integers.") if release not in REL_MAP: raise ValueError(f"'{release}' is not a valid release type.") # Ensure valid pre-release (we do not allow implicit pre-releases). if ".dev-candidate" < release < "final": if pre == 0: raise ValueError("Implicit pre-releases not allowed.") elif dev: raise ValueError("Version is not a development release.") elif post: raise ValueError("Post-releases are not allowed with pre-releases.") # Ensure valid development or development/pre release elif release < "alpha": if release > ".dev" and pre == 0: raise ValueError("Implicit pre-release not allowed.") elif post: raise ValueError("Post-releases are not allowed with pre-releases.") # Ensure a valid normal release else: if pre: raise ValueError("Version is not a pre-release.") elif dev: raise ValueError("Version is not a development release.") return super().__new__(cls, major, minor, micro, release, pre, post, dev) def _is_pre(self) -> bool: """Is prerelease.""" return bool(self.pre > 0) def _is_dev(self) -> bool: """Is development.""" return bool(self.release < "alpha") def _is_post(self) -> bool: """Is post.""" return bool(self.post > 0) def _get_dev_status(self) -> str: # pragma: no cover """Get development status string.""" return DEV_STATUS[self.release] def _get_canonical(self) -> str: """Get the canonical output string.""" # Assemble major, minor, micro version and append `pre`, `post`, or `dev` if needed.. if self.micro == 0: ver = f"{self.major}.{self.minor}" else: ver = f"{self.major}.{self.minor}.{self.micro}" if self._is_pre(): ver += f'{REL_MAP[self.release]}{self.pre}' if self._is_post(): ver += f".post{self.post}" if self._is_dev(): ver += f".dev{self.dev}" return ver def parse_version(ver: str) -> Version: """Parse version into a comparable Version tuple.""" m = RE_VER.match(ver) if m is None: raise ValueError(f"'{ver}' is not a valid version") # Handle major, minor, micro major = int(m.group('major')) minor = int(m.group('minor')) if m.group('minor') else 0 micro = int(m.group('micro')) if m.group('micro') else 0 # Handle pre releases if m.group('type'): release = PRE_REL_MAP[m.group('type')] pre = int(m.group('pre')) else: release = "final" pre = 0 # Handle development releases dev = m.group('dev') if m.group('dev') else 0 if m.group('dev'): dev = int(m.group('dev')) release = '.dev-' + release if pre else '.dev' else: dev = 0 # Handle post post = int(m.group('post')) if m.group('post') else 0 return Version(major, minor, micro, release, pre, post, dev) __version_info__ = Version(2, 7, 0, "final") __version__ = __version_info__._get_canonical() __pycache__/util.cpython-310.pyc 0000644 00000006534 15030227305 0012437 0 ustar 00 o �h � @ s� d Z ddlmZ ddlmZmZ ddlZddlZddlm Z m Z dZ e� d�Z ed�Zed �Zed d �d"dd��ZG dd� de�Zd#d$dd�Zd#d%dd �Zd&d d!�ZdS )'zUtility.� )� annotations)�wraps� lru_cacheN)�Callable�Any� z(?:\r\n|(?!\r\n)[\n\r])|$�A�Zi )�maxsize�string�str�returnc C sN g }| D ] }t |�}|�t| krtkr n nt|d �n|� qd�|�S )zLower.� � )�ord�append�UC_A�UC_Z�chr�join)r � new_string�c�o� r �A/usr/local/CyberCP/lib/python3.10/site-packages/soupsieve/util.py�lower s 0 r c s$ e Zd ZdZd d� fd d � Z� ZS )�SelectorSyntaxErrorz Syntax error in a CSS selector.N�msgr �pattern� str | None�index� int | Noner �Nonec s` d| _ d| _d| _|dur(|dur(t||�\| _| _ | _|� d| j � d| j� �}t� �|� dS )z Initialize.Nz line z: )�line�col�context�get_pattern_context�super�__init__)�selfr r r �� __class__r r r( s z SelectorSyntaxError.__init__)NN)r r r r r r! r r" )�__name__� __module__� __qualname__�__doc__r( � __classcell__r r r* r r s r � �message� stacklevel�int�Callable[..., Any]c s d� �fdd� }|S )z� Raise a `DeprecationWarning` when wrapped function/method is called. Usage: @deprecated("This method will be removed in version X; use Y instead.") def some_method()" pass �funcr5 r c s t � �d� ��fdd� �}|S )N�argsr �kwargsr c s, t jd� j� d�� �t�d� � | i |��S )N�'z' is deprecated. ��categoryr3 )�warnings�warnr, �DeprecationWarning)r7 r8 )r6 r2 r3 r r �_deprecated_func9 s �z6deprecated.<locals>._wrapper.<locals>._deprecated_func)r7 r r8 r r r )r )r6 r? �r2 r3 )r6 r �_wrapper8 s z deprecated.<locals>._wrapperN)r6 r5 r r5 r )r2 r3 rA r r@ r � deprecated- s rB r" c C s t j| t|d� dS )zWarn deprecated.r: N)r< r= r> r@ r r r �warn_deprecatedE s �rC r r �tuple[str, int, int]c C s* d}d}d}g }d}d}t �| �D ]{}| ||�d�� } t|�d��s2t|�s2d} d}|| d }n)|| kr?|�d�k rWn nd} ||�d�krLdndd }|| d }nd} d}t|�rd|�d � |�| � | � �� |dur�|�d � |�d || d � |}|d7 }|�d�}qd�|�||fS ) zGet the pattern context.r r Nr ���z--> � z � � �^)�RE_PATTERN_LINE_SPLIT�finditer�start�len�group�endr r ) r r �last� current_liner$ �textr# �offset�m�linetext�indentr r r r& O s8 r& )r r r r )r1 )r2 r r3 r4 r r5 )r2 r r3 r4 r r" )r r r r4 r rD )r/ � __future__r � functoolsr r r< �re�typingr r �DEBUG�compilerJ r r r r � Exceptionr rB rC r& r r r r �<module> s __pycache__/__init__.cpython-310.pyc 0000644 00000010547 15030227305 0013220 0 ustar 00 o �h� � @ s0 d Z ddlmZ ddlmZmZ ddlmZ ddlm Z ddlm Z ddl mZmZ dd lZdd lmZmZmZ d Ze jZ d5d d �d6dd�Zd7dd �Z d5d d �d8d!d"�Z d5d d �d9d$d%�Z d5d d �d:d)d*�Z d5d d �d8d+d,�Z d;d d �d<d.d �Z d;d d �d=d0d1�Z d>d3d4�Z d S )?ad Soup Sieve. A CSS selector filter for BeautifulSoup4. MIT License Copyright (c) 2018 Isaac Muse Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. � )� annotations� )� __version__�__version_info__)� css_parser)� css_match)� css_types)�DEBUG�SelectorSyntaxErrorN)�Any�Iterator�Iterable) r r � SoupSieve�closest�compile�filter�iselect�match�select� select_one)�custom�pattern�str� namespaces�dict[str, str] | None�flags�intr �kwargsr �return� cm.SoupSievec K sr t | t�r |r td��|durtd��|durtd��| S t�| |dur)t�|�n||dur5t�|�|�S ||�S )zCompile CSS pattern.z;Cannot process 'flags' argument on a compiled selector listNz@Cannot process 'namespaces' argument on a compiled selector listz<Cannot process 'custom' argument on a compiled selector list)� isinstancer � ValueError�cp�_cached_css_compile�ct� Namespaces�CustomSelectors)r r r r r � r' �E/usr/local/CyberCP/lib/python3.10/site-packages/soupsieve/__init__.pyr . s" ��r �Nonec C s t �� dS )zPurge cached patterns.N)r" � _purge_cacher' r' r' r( �purgeI s r+ r �tag�bs4.Tag�bs4.Tag | Nonec K � t | ||fi |���|�S )zMatch closest ancestor.)r r �r r, r r r r r' r' r( r O � r �boolc K r/ )z Match node.)r r r0 r' r' r( r ] r1 r �iterable�Iterable[bs4.Tag]� list[bs4.Tag]c K r/ )zFilter list of nodes.)r r )r r3 r r r r r' r' r( r k r1 r c K r/ )zSelect a single tag.)r r r0 r' r' r( r y r1 r �limitc K s t | ||fi |���||�S )zSelect the specified tags.)r r �r r, r r6 r r r r' r' r( r � s �Iterator[bs4.Tag]c k s( � t | ||fi |���||�E dH dS )zIterate the specified tags.N)r r r7 r' r' r( r � s �& r �identc C s t �| �S )zEscape identifier.)r" �escape)r9 r' r' r( r: � s r: )Nr ) r r r r r r r r r r r r )r r) )r r r, r- r r r r r r r r r r. )r r r, r- r r r r r r r r r r2 )r r r3 r4 r r r r r r r r r r5 )Nr r )r r r, r- r r r6 r r r r r r r r r5 )r r r, r- r r r6 r r r r r r r r r8 )r9 r r r ) �__doc__� __future__r �__meta__r r � r r" r �cmr r$ �utilr r �bs4�typingr r r �__all__r r r+ r r r r r r r: r' r' r' r( �<module> sd �� ������������ __pycache__/css_match.cpython-310.pyc 0000644 00000113614 15030227305 0013424 0 ustar 00 o �hz� � @ s� d Z ddlmZ ddlmZ ddlmZ ddlZddlmZ ddl Z ddl Z ddl m Z m Z mZmZmZmZmZ e�d �Ze�d �Zd Zd Zd ZdZdZdZdZdZ dZ dZ ej ej B Z!ej"ej#B Z$ej ej dd�Z%e�d�Z&e�d�Z'e�d�Z(e�d�Z)e�d�Z*e�d�Z+e�d �Z,d Z-d Z.d Z/d Z0d!Z1d"Z2d#Z3G d$d%� d%�Z4G d&d'� d'�Z5G d(d)� d)�Z6G d*d+� d+e5�Z7G d,d-� d-ej8�Z9e�:e9� dS ).z CSS matcher.� )� annotations)�datetime� )�utilN)� css_types)�Iterator�Iterable�Any�Callable�Sequencer �castz[^ ]z [^ ]+� �>�~�+z: z:>z:~z:+z http://www.w3.org/1999/xhtmlz$http://www.w3.org/XML/1998/namespace)�ltr�rtl�autoz0^(?P<value>-?(?:[0-9]{1,}(\.[0-9]+)?|\.[0-9]+))$z*^(?P<hour>[0-9]{2}):(?P<minutes>[0-9]{2})$z)^(?P<year>[0-9]{4,})-(?P<month>[0-9]{2})$z)^(?P<year>[0-9]{4,})-W(?P<week>[0-9]{2})$z;^(?P<year>[0-9]{4,})-(?P<month>[0-9]{2})-(?P<day>[0-9]{2})$zd^(?P<year>[0-9]{4,})-(?P<month>[0-9]{2})-(?P<day>[0-9]{2})T(?P<hour>[0-9]{2}):(?P<minutes>[0-9]{2})$z (?:(?:-\*-)(?:\*(?:-|$))*|-\*$))� � � � � � � � � � c @ s$ e Zd ZdZd dd�Zd d d �Zd S )� _FakeParentz� Fake parent class. When we have a fragment with no `BeautifulSoup` document object, we can't evaluate `nth` selectors properly. Create a temporary fake parent so we can traverse the root element as a child. �element�bs4.Tag�return�Nonec C s |g| _ dS )� Initialize.N)�contents)�selfr � r& �F/usr/local/CyberCP/lib/python3.10/site-packages/soupsieve/css_match.py�__init__D � z_FakeParent.__init__�intc C s t | j�S )zLength.)�lenr$ �r% r& r& r' �__len__I � z_FakeParent.__len__N)r r r! r" )r! r* )�__name__� __module__� __qualname__�__doc__r( r- r& r& r& r' r ; s r c @ s� e Zd ZdZedgdd��Zedhd d ��Zedhd d��Zedhdd��Z edhdd��Z edhdd��Z edhdd��Z edhdd��Z edhdd��Zedid d ��Zedjd!d"��Zdjd#d$�Zdkd%d&�Zdldmd*d+�Z , ' 'dndod1d2�Z , ' ' 'dpdqd4d5�Z 'dldrd6d7�Z ' 'dsdtd8d9�Zdldud:d;�Zedvd=d>��Zedwd?d@��ZedvdAdB��ZedxdCdD��Z edldydEdF��Z edzd{dHdI��Z edldydJdK��Z edjdLdM��Z ed|dQdR��Z!ed}dUdV��Z"e ,d~ddZd[��Z#ed�d]d^��Z$ed�d`da��Z%dld�dbdc�Z&dld�dedf�Z'd,S )�� _DocumentNavz#Navigate a Beautiful Soup document.�tagr r! r" c C s | � |�stdt|�� ���dS )z%Check if valid input tag or document.z:Expected a BeautifulSoup 'Tag', but instead received type N)�is_tag� TypeError�type)�clsr4 r& r& r' �assert_valid_inputR s �z _DocumentNav.assert_valid_input�obj� bs4.element.PageElement | None�boolc C � t | tj�S )zIs `BeautifulSoup` object.)� isinstance�bs4� BeautifulSoup�r: r& r& r' �is_docZ r) z_DocumentNav.is_docc C r= )zIs tag.)r> r? �TagrA r& r& r' r5 _ r) z_DocumentNav.is_tagc C r= )zIs declaration.)r> r? � DeclarationrA r& r& r' �is_declarationd r) z_DocumentNav.is_declarationc C r= )z Is CDATA.)r> r? �CDatarA r& r& r' �is_cdatai r) z_DocumentNav.is_cdatac C r= )zIs processing instruction.)r> r? �ProcessingInstructionrA r& r& r' �is_processing_instructionn r) z&_DocumentNav.is_processing_instructionc C s t | tjj�S )zIs navigable string.)r> r? r �NavigableStringrA r& r& r' �is_navigable_strings � z _DocumentNav.is_navigable_stringc C s t | tjtjtjtjtjf�S )zIs special string.)r> r? �CommentrD rF rH �DoctyperA r& r& r' �is_special_stringx s z _DocumentNav.is_special_stringc C s | � |�o | �|� S )z Check if node is content string.)rK rO )r8 r: r& r& r' �is_content_string} s z _DocumentNav.is_content_string�elr r c C s t | �S )z'Create fake parent for a given element.)r �rQ r& r& r' �create_fake_parent� � z _DocumentNav.create_fake_parent�bs4.Tag | Nonec C s | duot | j�S )z2Check if element (or document) is from a XML tree.N)r< �_is_xmlrR r& r& r' � is_xml_tree� � z_DocumentNav.is_xml_treec C s: |du rdS t | �|�r|jnt�|j�dko| �|��S )z Check if element is an `iframe`.NF�iframe)r< rW �namer �lower� is_html_tag�r% rQ r& r& r' � is_iframe� s �z_DocumentNav.is_iframec C s: | j o| j |u }|s| �|�}|duo| jo| �|�}|S )z� 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`. N)�root� get_parent�is_htmlr^ )r% rQ r_ �parentr& r& r' �is_root� s z_DocumentNav.is_rootF� no_iframe�!Iterator[bs4.element.PageElement]c c s0 � |dur|r | � |�s|jE dH dS dS dS )z$Get contents or contents in reverse.N)r^ r$ �r% rQ rd r& r& r' � get_contents� s ��z_DocumentNav.get_contentsN�start� int | None�reverse�Iterator[bs4.Tag]c C s | � |||d|�S )zGet tag children.T)� get_children)r% rQ rh rj rd r& r& r' �get_tag_children� s z _DocumentNav.get_tag_children�tagsc c s� � |durX|r | � |�sZt|j�d }|du r |r|nd}n|}|r$dn|d }|r,dnd} d| kr8|kr\n dS ||kr^|j| } || 7 }|rO| �| �rR| V ||ks?dS dS dS dS dS )z Get children.Nr r ���)r^ r+ r$ r5 ) r% rQ rh rj rn rd �last�index�end�incr�noder& r& r' rl � s$ � �� z_DocumentNav.get_childrenc c s � | j |d|d�E dH dS )z!Specifically get tag descendants.T)rn rd N)�get_descendantsrf r& r& r' �get_tag_descendants� s �z _DocumentNav.get_tag_descendantsc c s� � |dure|r | � |�sgd}|jD ]W}|dur ||ur qd}t|tj�r_|r[| � |�r[|jdur4|j}n |}t|tj�rM|jrM|jd }t|tj�rM|js?|j}|V |du rZ dS q|V q|sd|V qdS dS dS )zGet descendants.Nro )r^ � descendantsr> r? rC � next_siblingr$ � next_element)r% rQ rn rd � next_good�child� last_childr& r& r' ru � s6 � ���z _DocumentNav.get_descendantsc C s0 |dur|j nd}|r|dur| �|�rd}|S )z Get parent.N)rb r^ )r% rQ rd rb r& r& r' r` s z_DocumentNav.get_parent� str | Nonec C � | dur| j S dS �zGet tag.N)rZ rR r& r& r' � get_tag_name rX z_DocumentNav.get_tag_namec C s | j S )� Get prefix.)�prefixrR r& r& r' �get_prefix_name s z _DocumentNav.get_prefix_namec C r~ )zGet namespace `URI`.N)� namespacerR r& r& r' �get_uri rX z_DocumentNav.get_uric C s | j |dd�S )�Get next sibling tag.T)rn )�get_next)r8 rQ r& r& r' � get_next_tag s z_DocumentNav.get_next_tagc C �T |j }|r t|tj�s |dur |j }|r t|tj�s |dus|r(t|tj�s(d}|S )r� N)rx r> r? rC �r8 rQ rn �siblingr& r& r' r� ! � �z_DocumentNav.get_nextTc C s | � |d�S )�Get previous sibling tag.T)� get_previous)r8 rQ rn r& r& r' �get_previous_tag. s z _DocumentNav.get_previous_tagc C r� )r� N)�previous_siblingr> r? rC r� r& r& r' r� 4 r� z_DocumentNav.get_previousc C s& | dur t | d�nd}t|o|tk�S )z� 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`. Nr� )�getattrr< �NS_XHTML)rQ �nsr& r& r' � has_html_nsA s z_DocumentNav.has_html_ns� attr_name�str� tuple[str | None, str | None]c C s$ | du rdS t |dd�t |dd�fS )z7Return namespace and attribute name without the prefix.N)NNr� rZ )r� )rQ r� r& r& r' �split_namespaceM s z _DocumentNav.split_namespace�value�str | Sequence[str]c C s� |du rdS t |t�r |S t |t�r|�d�S t |t�rDg }|D ]!}t |ttf�s6t |t�r6|�t|�� q |�tt| �|��� q |S t|�S )z6Normalize the value to be a string or list of strings.N� �utf8)r> r� �bytes�decoder �appendr �normalize_value)r8 r� � new_value�vr& r& r' r� V s z _DocumentNav.normalize_valuerZ �default�str | Sequence[str] | Nonec C sl |}|j rz | �|j| �}W |S ty Y |S w |j�� D ]\}}t�|�|kr3| �|�} |S q |S )zGet attribute by name.)rV r� �attrs�KeyError�itemsr r[ )r8 rQ rZ r� r� �kr� r& r& r' �get_attribute_by_namew s �� �z"_DocumentNav.get_attribute_by_name�0Iterator[tuple[str, str | Sequence[str] | None]]c c s6 � |dur|j �� D ]\}}|| �|�fV q dS dS )zIterate attributes.N)r� r� r� )r8 rQ r� r� r& r& r' �iter_attributes� s ��z _DocumentNav.iter_attributes� Sequence[str]c C s0 | � |dg �}t|t�rt�|�}ttt |�S )z Get classes.�class)r� r> r� � RE_NOT_WS�findallr r )r8 rQ �classesr& r& r' � get_classes� s z_DocumentNav.get_classesc s" d� � fdd�� j||d�D ��S )z Get text.r� c � g | ] }� � |�r|�qS r& �rP ��.0rt r, r& r' � <listcomp>� s ��z)_DocumentNav.get_text.<locals>.<listcomp>�rd )�joinru rf r& r, r' �get_text� s ��z_DocumentNav.get_text� list[str]c s � fdd�� j ||d�D �S )z Get Own Text.c r� r& r� r� r, r& r' r� � s ��z-_DocumentNav.get_own_text.<locals>.<listcomp>r� )rg rf r& r, r' � get_own_text� s �z_DocumentNav.get_own_text)r4 r r! r" )r: r; r! r< )rQ r r! r �rQ rU r! r< �rQ r r! r< �F)rQ rU rd r< r! re )NFF) rQ rU rh ri rj r< rd r< r! rk )NFFF) rQ rU rh ri rj r< rn r< rd r< r! re )rQ rU rd r< r! rk )FF)rQ rU rn r< rd r< r! re )rQ rU rd r< r! rU �rQ rU r! r} �rQ r r! r} �rQ r r! rU )rQ r rn r< r! r; )T)rQ r rn r< r! rU )rQ rU r� r� r! r� )r� r r! r� �N)rQ r rZ r� r� r� r! r� )rQ rU r! r� )rQ r r! r� )rQ r rd r< r! r� )rQ r rd r< r! r� )(r/ r0 r1 r2 � classmethodr9 � staticmethodrB r5 rE rG rI rK rO rP rS rW r^ rc rg rm rl rv ru r` r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r& r& r& r' r3 O s� � � � � $ � r3 c @ sr e Zd ZdZed dd ��Zed d d ��Zed!d d��Zed"dd��Zed#dd��Z ed$dd��Z e d%d d ��Z d S )&�Inputsz-Class for parsing and validating input items.�yearr* �month�dayr! r< c C s^ t }|tkr | d dkr| d dks| d dkrtnt}n|tv r#t}d| ko,|kS S )z Validate day.r r �d i� r )� LONG_MONTH�FEB�FEB_LEAP_MONTH� FEB_MONTH� MONTHS_30� SHORT_MONTH)r� r� r� �max_daysr& r& r' � validate_day� s .zInputs.validate_day�weekc C sH t �d� dd� d| � �d��� d }|dkrd}d| ko!|kS S )zValidate week.� �-r z%m-%d-%Yr �5 )r �strptime� isocalendar)r� r� �max_weekr& r& r' � validate_week� s $zInputs.validate_weekc C � d| ko dkS S )zValidate month.r r� r& )r� r& r& r' �validate_month� � zInputs.validate_monthc C s d| kS )zValidate year.r r& )r� r& r& r' � validate_year� rT zInputs.validate_year�hourc C r� )zValidate hour.r � r& )r� r& r& r' � validate_hour� r� zInputs.validate_hour�minutesc C r� )zValidate minutes.r �; r& )r� r& r& r' �validate_minutes� r� zInputs.validate_minutes�ityper� r� r} �tuple[float, ...] | Nonec C st d}|du r|S |dkrCt �|�}|rAt|�d�d�}t|�d�d�}t|�d�d�}| �|�rA| �|�rA| �|||�rA|||f}|S |dkrnt�|�}|rlt|�d�d�}t|�d�d�}| �|�rl| �|�rl||f}|S |dkr�t�|�}|r�t|�d�d�}t|�d�d�}| �|�r�| � ||�r�||f}|S |dkr�t �|�}|r�t|�d �d�} t|�d �d�} | � | �r�| � | �r�| | f}|S |d k�r#t �|�}|�r!t|�d�d�}t|�d�d�}t|�d�d�}t|�d �d�} t|�d �d�} | �|��r!| �|��r!| �|||��r!| � | ��r!| � | ��r!|||| | f}|S |d v �r8t�|�}|�r8t|�d ��f}|S )zParse the input value.N�dater� � r� r� r� �timer� r� �datetime-local)�number�ranger� )�RE_DATE�matchr* �groupr� r� r� �RE_MONTH�RE_WEEKr� �RE_TIMEr� r� � RE_DATETIME�RE_NUM�float) r8 r� r� �parsed�mr� r� r� r� r� r� r& r& r' � parse_value� sz " '� � � � �� ��� � zInputs.parse_valueN)r� r* r� r* r� r* r! r< )r� r* r� r* r! r< )r� r* r! r< )r� r* r! r< )r� r* r! r< )r� r* r! r< )r� r� r� r} r! r� ) r/ r0 r1 r2 r� r� r� r� r� r� r� r� r� r& r& r& r' r� � s r� c @ s� e Zd ZdZd~d d �Zddd�Zd�dd�Zd�dd�Zd�dd�Zd�dd �Z d�d d �Z d�d"d#�Z d�d'd(�Z d�d+d,�Z d�d/d0�Zd�d1d2�Zd�d4d5�Zd�d7d8�Zd�d�d<d=�Zd�d>d?�Zd�d@dA�Zd�dDdE�Zd�dGdH�Zd�dIdJ�Zd�dKdL�Zd�dNdO�Zd�dRdS�Zd�dTdU�Zd�dWdX�Z d�d[d\�Z d�d]d^�Z d�d_d`�Z d�dcdd�Z d�dfdg�Z!d�didj�Z"d�dkdl�Z#d�dmdn�Z$d�dodp�Z%d�d�dtdu�Z&d�dvdw�Z'd�dydz�Z(d�d{d|�Z)d}S )��CSSMatchzPerform CSS matching.� selectors�ct.SelectorList�scoperU � namespaces�ct.Namespaces | None�flagsr* r! r" c C s� | � |� || _g | _g | _g | _|| _|du ri n|| _|| _d| _|}| � |�}|r5|}| � |�}|s,d}| � |�s?|}n | � |�D ]}|} || _ ||urR|n|| _ | �|�| _| �|�| _| j pg| j| _dS )r# NF)r9 r4 �cached_meta_lang�cached_default_forms�cached_indeterminate_formsr� r� r� �iframe_restrictr` rB rm r_ r� r� �has_html_namespacerW �is_xmlra ) r% r� r� r� r� �docrb r_ r{ r& r& r' r( s4 � zCSSMatch.__init__r< c C s | j p| jS )z3Check if namespaces are supported in the HTML type.)r r r, r& r& r' �supports_namespacesC r) z CSSMatch.supports_namespacesrQ r� c C s6 d}|du r|S | � � r| �|�}|r|}|S t}|S )zGet tag namespace.r� N)r r� r� )r% rQ r� r� r& r& r' � get_tag_nsH s �zCSSMatch.get_tag_nsc C s | � |�tkS )z"Check if tag is in HTML namespace.)r r� r] r& r& r' r\ W rL zCSSMatch.is_html_tagr} c C �& | � |�}|dur| jst�|�S |S r )r� r r r[ �r% rQ rZ r& r& r' �get_tag\ � zCSSMatch.get_tagr c C r )r� N)r� r r r[ )r% rQ r� r& r& r' � get_prefixb r zCSSMatch.get_prefixri c C s� | � |�D ]Z}| �|�r=t�t�| �|dd��d�}| �|�}|r%|dv s.| �|�r.|dur/q| � |�}|dur<| S q| � |�rCq|D ]}t � |�}|dv r^|dkrWt jnt j S qEqdS )z%Get directionality from element text.�dirr� N)�bdi�script�style�textarearY ��AL�R�Lr )rl r5 �DIR_MAP�getr r[ r� r r\ � find_bidirO � unicodedata� bidirectional�ct� SEL_DIR_LTR� SEL_DIR_RTL)r% rQ rt � directionrZ r� �c�bidir& r& r' r h s0 �� ��zCSSMatch.find_bidi� lang_range�lang_tagc C s* d}t �d|��� }|�d�}|�� �d�}t|�}t|�}d}d} || } || } |dkr:|dkr:| s:| | kr:dS | dkrB| | ksL| dkrN|dkrN| sNd}|d7 }| d7 } |r�||k r�|| } z|| } W n tyq d}Y qVw | swd}qV| | kr�|d7 }n t| �dkr�d}qV| d7 } |r�||k s\|S )zFilter the language tags.Tr� r r �*F)� RE_WILD_STRIP�subr[ �splitr+ � IndexError) r% r! r" r� �ranges�subtags�length�slength�rindex�sindex�r�sr& r& r' �extended_language_filter� sF $ � � z!CSSMatch.extended_language_filter�attrr� r� c C s d}| � � rsd}|r| j�|�}|du r|dkrdS nd}| �|�D ]N\}}| �||�\}} |du rL| jr9||ksF| jsKt�|�t�|�krK|} |S q"|du sX||krY|dkrYq"| jsgt�|�t�| �krln|| krlq"|} |S |S | �|�D ]\}}t�|�t�|�kr�qx|} |S |S )z3Match attribute name and return value if it exists.Nr# )r r� r r� r� r r r[ ) r% rQ r1 r� r� r� r� r� r� rZ r& r& r' �match_attribute_name� s< �(�$�z CSSMatch.match_attribute_namer4 �ct.SelectorTagc C s� d}| � |�}| j�d�}|jdu rdn| j�|j�}|jdu r,|dur,||kr,d}|S |jdur<|jdkr<|r<d}|S |jrN|jdkrN|du sL||krNd}|S )z#Match the namespace of the element.Tr� NFr# )r r� r r� )r% rQ r4 r� r� �default_namespace�tag_nsr& r& r' �match_namespace� s ���zCSSMatch.match_namespace� attributes� tuple[ct.SelectorAttribute, ...]c C s� d}|rD|D ]=}| � ||j|j�}| jr|jr|jn|j}|du r&d} |S t|t�r-|nd�|�}|du r7q|� |�du rCd} |S q|S )zMatch attributes.TNFr ) r2 � attributer� r �xml_type_pattern�patternr> r� r� r� )r% rQ r7 r� �a�tempr; r� r& r& r' �match_attributes s$ ��zCSSMatch.match_attributesc C s> | j s|jdurt�|j�n|j}|duo || �|�dfv S )zMatch tag name.Nr# )r rZ r r[ r )r% rQ r4 rZ r& r& r' � match_tagname" s "�zCSSMatch.match_tagname�ct.SelectorTag | Nonec C s0 d}|dur| � ||�sd}| �||�sd}|S )zMatch the tag.TNF)r6 r? )r% rQ r4 r� r& r& r' � match_tag+ s zCSSMatch.match_tag�relationc C s d}t |d tj�r |S |d jtkr3| j|| jd�}|s1|r1| �||�}| j|| jd�}|s1|s |S |d jtkrL| j|| jd�}|rJ| �||�}|S |d jt krm| � |�}|sk|rk| �||�}| � |�}|sk|s\|S |d jt kr�| � |�}|r�| � |�r�| �||�}|S )zMatch past relationship.Fr r� ) r> r � SelectorNull�rel_type� REL_PARENTr` r �match_selectors�REL_CLOSE_PARENT� REL_SIBLINGr� �REL_CLOSE_SIBLINGr5 )r% rQ rB �foundrb r� r& r& r' �match_past_relations7 s6 �� � �� z CSSMatch.match_past_relationsFrb � recursivec C sD d}|r| j }n| j}||| jd�D ] }| �||�}|r |S q|S )zMatch future child.Fr� )rv rm r rF )r% rb rB rL r� �childrenr{ r& r& r' �match_future_childS s �zCSSMatch.match_future_childc C s� d}t |d tj�r |S |d jtkr | �||d�}|S |d jtkr+| �||�}|S |d jtkrL| �|�}|sJ|rJ| � ||�}| �|�}|sJ|s;|S |d jt kre| �|�}|re| � |�re| � ||�}|S )zMatch future relationship.Fr T) r> r rC rD �REL_HAS_PARENTrN �REL_HAS_CLOSE_PARENT�REL_HAS_SIBLINGr� rF �REL_HAS_CLOSE_SIBLINGr5 )r% rQ rB rJ r� r& r& r' �match_future_relationsa s* � � �� z CSSMatch.match_future_relationsc C sV d}t |d tj�s|d jdu r|S |d j�d�r#| �||�}|S | �||�}|S )z%Match relationship to other elements.Fr N�:)r> r rC rD � startswithrS rK )r% rQ rB rJ r& r& r' �match_relationsx s �zCSSMatch.match_relations�ids�tuple[str, ...]c C s. d}|D ]}|| � |dd�krd} |S q|S )zMatch element's ID.T�idr� F)r� )r% rQ rW rJ �ir& r& r' �match_id� s �zCSSMatch.match_idr� c C s. | � |�}d}|D ] }||vrd} |S q |S )zMatch element's classes.TF)r� )r% rQ r� �current_classesrJ r r& r& r' � match_classes� s �zCSSMatch.match_classesc C s� | � |�}|r3| �|�}|r3|dur3| �|�s%| �|�r |�� s%| �|�r(d}n| �|�}|r3|dus|ra| �|�}|ra|dura| �|�sS| �|�rN|�� sS| �|�rVd}n| �|�}|ra|dus@|S )zMatch element as root.NF)rc r� r5 rP �striprG r� )r% rQ rc r� r& r& r' � match_root� s< ���� � ���� �zCSSMatch.match_rootc C s | j |u S )zMatch element as scope.)r� r] r& r& r' � match_scope� r. zCSSMatch.match_scoper{ c C s( | � |�| � |�ko| �|�| �|�kS )z!Match tag type for `nth` matches.)r r )r% rQ r{ r& r& r' �match_nth_tag_type� s �zCSSMatch.match_nth_tag_type�nth�tuple[ct.SelectorNth, ...]c C s d}|D �]�}d}|j r| �||j �s |S | �|�}|du r'td| �|��}|j}t|�d }|r4|nd}d} |j} |j} |j } d} d}|rIdnd}| rS| | | n| }}| r�d}|dk sc||kr�|dk r�d| }|durt|dkrtnNd}| |7 } | r�| | | n| }}d| }||kr�n3n*|| }|dur�|dkr�n%d}| |7 } | r�| | | n| }}|| }||kr�n |}|dk sc||ksc| }| dk r�|dkr�| }| |7 } | r�| | | n| }}|dks�d}|} | r�| | | n| }}d| kr�|d k�r�n n�d}| j |||dk d�D ]E}||7 }t |t j ��s �q |j �r*| �||j ��s*�q |j�r7| �||��s7�q | d7 } | |k�rJ||u �rHd}n n ||u �rQ n�q ||u �rYn,|}| |7 } | dk �ren | �rn| | | n| }||k�rvnd| k�r�|d k�sn |�s� |S q|S ) zMatch `nth` elements.TFNr r r ro )rh rj )r� rF r` r rS rp r+ r< �b�nrl r> r? rC �of_typera )r% rQ rb �matchedre rb rp � last_indexrq �relative_indexr< rd �var�count� count_incr�factor�idx�last_idx�adjust�diff_low�diff� diff_high�lowestr{ r& r& r' � match_nth� s� [ � ��� � � �zCSSMatch.match_nthc C sJ d}| � |�D ]}| �|�rd} |S | �|�r"t�|�r"d} |S q|S )z)Check if element is empty (if requested).TF)rl r5 rP � RE_NOT_EMPTY�search)r% rQ �is_emptyr{ r& r& r' � match_empty( s �� zCSSMatch.match_empty�tuple[ct.SelectorList, ...]c C s" d}|D ] }| � ||�sd}q|S )zMatch selectors.TF)rF )r% rQ r� r� �selr& r& r' �match_subselectors5 s �zCSSMatch.match_subselectors�contains� tuple[ct.SelectorContains, ...]c C s� d}d}|D ]C}|du r |j r| j|| jd�}n| j|| jd�}d}|jD ] }|j r<|D ] }||v r6d} nq,|r; n q%||v rDd} nq%|sId}q|S )z"Match element if it contains text.TNr� F)�ownr� ra r� �text) r% rQ r} r� �content� contain_listrJ r� r r& r& r' �match_contains> s4 ����zCSSMatch.match_containsc C s d}d}| j |dd�}|r-|du r-| �|�dkr | �|�r |}n| j |dd�}|r-|du s|dur�d}| jD ]\}}||u rHd}||u rFd} nq6|s�| j|dd�D ]3}| �|�} | dkr` |S | dv r�| �|dd�} | r�t�| �d kr�| j�||f� ||u r�d} |S qR|S ) �Match default.FNTr� �form)�input�buttonr7 r� �submit) r` r r\ r rv r� r r[ r� ) r% rQ r� r� rb � found_form�f�tr{ rZ r� r& r& r' � match_defaultZ sB �� �� zCSSMatch.match_defaultc s\ d}t t� �|d��}d� fdd� }||�}|d ur�d}� jD ]\}}} ||u r6||kr6d }| d u r4d } nq |s�d} � j|d d �D ]\} | |u rIqB� �| �} | d kr�d} d}d}� �| �D ]<\}}t�|�d krrt�|�dkrrd } nt�|�dkr�||kr�d }n t�|�dkr�d }| r�|r�|r�|| �|u r�d } nq]| r� nqB| s�d }� j� |||f� |S )r� FrZ rQ r r! rU c sl d}� j | dd�}|du r4� �|�dkr � �|�r |} |S |}� j |dd�}|du r0|} |S |du s |S )zFind this input's form.NTr� r� )r` r r\ )rQ r� rb � last_parentr, r& r' �get_parent_form� s �� z5CSSMatch.match_indeterminate.<locals>.get_parent_formNTr� r� r7 �radio�checkedr� ) r r� r� r rv r r� r r[ r� )r% rQ r� rZ r� r� r� r� re rZ r� r{ �tag_name�is_radio�check�has_namer� r� r& r, r' �match_indeterminate� sR � ��z CSSMatch.match_indeterminate�langs�tuple[ct.SelectorLang, ...]c C s� d}| � � }| j}| j}|}d}d} |sq| �|�} | �|�D ]8\} } | �|| �\} }|r.| r:| js6t�| �n| dksR|rV| sV| t krV| jsN|durNt�|�n|dkrV| } nq |} | j || j d�}|du ro| }| �|�}| }n|r|du r�| j r�| j D ] }||d u r�|d }q{|du �rA| jr�|�rA|�rA|j dk�rAd}dD ]%}d}| j|| j d�D ]}| �|�|kr�| �|�r�d }|} nq�|s� nq�|�rA|du�rA|D ]`}t|tj��r)| �|�d k�r)| �|��r)d}d}| �|�D ]8\} } t�| �d k�rt�| �d k�rd }t�| �d k�r| }|�r(|�r(|}| j �tt|�tt|�f� nq�|du�r0 nq�|du �rA| j �tt|�df� |du�rf|D ] }d}|D ]}| �|tt|���r\d }�qN|�sd |S �qH|S )zMatch languages.FN�langr� r r �html)r� �headT�metaz http-equivzcontent-languager� r� )r r_ r r� r� r� r r r[ �NS_XMLr` ra r� rZ rm r r\ r> r? rC r� r r� r0 )r% rQ r� r� �has_nsr_ r rb � found_langrp r� r� r� �attr_nsr1 �cacherJ r4 r{ �child2�c_langr� �patternsr; r& r& r' � match_lang� s� ���� � � �(��* � � ��zCSSMatch.match_lang�directionalityc s |t j@ r |t j@ r dS |du s� �|�sdS t�t�� �|dd��d�}|dvr-||kS � � |�}|r=|du r=t j|kS � � |�}|dk}|dk}|dk}|rZt�� �|d d��nd} |rk| d krk|du rkt j|kS |rq| d v ss|r�|d kr�|r�d� � fd d�� j |dd�D ��} n t t� �|dd��} | r�| D ]} t�| �} | dv r�| dkr�t jnt j}||k S q�t j|kS |r�t j|kS � �� j|dd�|�S |r�|du s�|d kr�� �|�}|dur�||kS |r�t j|kS � �� j|dd�|�S � �� j|dd�|�S )zCheck directionality.FNr r� )Nr r� r r r7 �tel)r� rw r� �url�emailr c 3 s � | ] }� � |�r|V qd S r� r� r� r, r& r' � <genexpr>6 s � z%CSSMatch.match_dir.<locals>.<genexpr>Tr� r� r r )r r r r\ r r r r[ r� rc r r� rg r r� r r � match_dirr` r ) r% rQ r� r rc rZ �is_input� is_textarea�is_bdir� r� r r r& r, r' r� sP $ � zCSSMatch.match_dir� conditionc C s2 d}t �| �|d��}t�|tt| �|dd���}t�|tt| �|dd���}|du r1|du r1dS t�|tt| �|dd���}|dur�|dv r^|durQ||k rQd}|s]|dur]||kr]d}n1|d kr�|dury|dury||kry||k rx||krxd}n|dur�||k r�d}|s�|dur�||kr�d}|tj@ r�| S |S ) ac Match range. Behavior is modeled after what we see in browsers. Browsers seem to evaluate if the value is out of range, and if not, it is in range. So a missing value will not evaluate out of range; therefore, value is in range. Personally, I feel like this should evaluate as neither in or out of range. Fr7 �minN�maxr� )r� r� r� r� r� r� Tr� ) r r[ r� r� r� r r� r � SEL_IN_RANGE)r% rQ r� � out_of_ranger� �mn�mxr� r& r& r' � match_rangeQ s0 ��zCSSMatch.match_rangec C s< | � |�}|duo |�d�dkp |�d�dkp | �|�duS )a� Match defined. `:defined` is related to custom elements in a browser. - If the document is XML (not XHTML), all tags will match. - Tags that are not custom (don't have a hyphen) are marked defined. - If the tag has a prefix (without or without a namespace), it will not match. This is of course requires the parser to provide us with the proper prefix and namespace info, if it doesn't, there is nothing we can do. Nr� ro rT )r �findr r r& r& r' � match_definedy s � �zCSSMatch.match_definedc C s d}| � |�}|dv r d}|S )z� Match placeholder shown according to HTML spec. - text area should be checked if they have content. A single newline does not count as content. F)r� � T)r� )r% rQ r� r� r& r& r' �match_placeholder_shown� s z CSSMatch.match_placeholder_shownc C s d}|j }|j}|r| j}| j}dti| _d| _|r | jr�|D ]�}|}t|tj�r*q | �||j �s2q |j tj @ r>| � |�s>q |j tj @ rJ| �|�sJq |j tj@ rV| �|�sVq |j tj@ rb| �|�sbq | �||j�sjq |j tj@ rv| �|�svq |jr�| �||j�s�q |jr�| �||j�s�q | �||j �s�q |j t @ r�| � ||j t @ �s�q |j r�| � ||j �s�q |j!r�| �"||j!�s�q |j#r�| �$||j#�s�q |j tj%@ r�| �&|�s�q |j tj'@ r�| �(|�s�q |j t)@ r�| �*||j t)@ �s�q |j+r�| �,||j+�s�q | } |�r|| _|| _|S )z.Check if element matches one of the selectors.Fr� T)-�is_notra r� r r� r> r rC rA r4 r� � SEL_DEFINEDr� �SEL_ROOTr_ � SEL_SCOPEr` �SEL_PLACEHOLDER_SHOWNr� ru rb � SEL_EMPTYry rW r[ r� r] r> r7 �RANGESr� r� r� r� r| rB rV � SEL_DEFAULTr� �SEL_INDETERMINATEr� � DIR_FLAGSr� r} r� ) r% rQ r� r� r� ra r� r �selectorr& r& r' rF � sn zCSSMatch.match_selectorsr �limitrk c c sV � |dk rdn|}| � | j�D ]}| �|�r(|V |dur(|d8 }|dk r( dS qdS )z&Match all tags under the targeted tag.r N)rv r4 r� )r% r� �limr{ r& r& r' �select� s � ��zCSSMatch.selectc C sH | j }d}|du r"|dur"| �|�r|}n| �|�}|du r"|dus |S )�Match closest ancestor.N)r4 r� r` )r% �current�closestr& r& r' r� s �zCSSMatch.closest� list[bs4.Tag]c s � fdd�� � � j�D �S )zFilter tag's children.c s& g | ]}t |tj�r� �|�r|�qS r& )r> r? rC r� )r� r4 r, r& r' r� s ���z#CSSMatch.filter.<locals>.<listcomp>)rg r4 r, r& r, r' �filter s �zCSSMatch.filterc C s$ | � |� o| �|�o| �|| j�S �zMatch.)rB r5 rF r� r] r& r& r' r� s $zCSSMatch.matchN) r� r� r� rU r� r� r� r* r! r" )r! r< )rQ rU r! r� r� r� r� )rQ r r! ri )r! r� r" r� r! r< )rQ r r1 r� r� r} r! r� )rQ r r4 r3 r! r< )rQ r r7 r8 r! r< )rQ r r4 r@ r! r< )rQ r rB r� r! r< r� )rb r rB r� rL r< r! r< )rQ r rW rX r! r< )rQ r r� rX r! r< r� )rQ r r{ r r! r< )rQ r rb rc r! r< )rQ r r� rz r! r< )rQ r r} r~ r! r< )rQ r r� r� r! r< )rQ rU r� r* r! r< )rQ r r� r* r! r< )rQ r r� r� r! r< �r )r� r* r! rk )r! rU )r! r� )*r/ r0 r1 r2 r( r r r\ r r r r0 r2 r6 r> r? rA rK rN rS rV r[ r] r_ r` ra ru ry r| r� r� r� r� r� r� r� r� rF r� r� r� r� r& r& r& r' r� sP ) % 8 5 e ( > V ; ( T r� c s� e Zd ZU dZded< ded< ded< ded < d ed < d Zd)� fdd� Zd*dd�Zd+dd�Zd,d d �Z d+d d �Z d-d.d"d#�Z d-d/d%d&�Z d0d'd(�Z e Z� ZS )1� SoupSievez-Compiled Soup Sieve selector matching object.r� r; r� r� r� r� zdict[str, str]�customr* r� )r; r� r� r� r� �_hash�ct.CustomSelectors | Nonec s t � j|||||d� dS )r# )r; r� r� r� r� N)�superr( )r% r; r� r� r� r� �� __class__r& r' r( % s �zSoupSieve.__init__r4 r r! r< c C s t | j|| j| j��|�S r� )r� r� r� r� r� �r% r4 r& r& r' r� 7 s zSoupSieve.matchrU c C s t | j|| j| j��� S )r� )r� r� r� r� r� r� r& r& r' r� < s zSoupSieve.closest�iterable�Iterable[bs4.Tag]r� c s6 t |tj�rt� j|� j� j��� S � fdd�|D �S )a� Filter. `CSSMatch` can cache certain searches for tags of the same document, so if we are given a tag, all tags are from the same document, and we can take advantage of the optimization. Any other kind of iterable could have tags from different documents or detached tags, so for those, we use a new `CSSMatch` for each item in the iterable. c s$ g | ]}t �|�s� �|�r|�qS r& )r� rK r� r� r, r& r' r� P s $ z$SoupSieve.filter.<locals>.<listcomp>)r> r? rC r� r� r� r� r� )r% r� r& r, r' r� A s zSoupSieve.filterc C s | j |dd�}|r |d S dS )zSelect a single tag.r )r� r N)r� )r% r4 rn r& r& r' � select_oneR s zSoupSieve.select_oner r� c C s t | �||��S )zSelect the specified tags.)�list�iselect�r% r4 r� r& r& r' r� X s zSoupSieve.selectrk c c s& � t | j|| j| j��|�E dH dS )zIterate the specified tags.N)r� r� r� r� r� r� r& r& r' r� ] s �$zSoupSieve.iselectc C s& d| j �d| j�d| j�d| j�d� S )zRepresentation.zSoupSieve(pattern=z , namespaces=z , custom=z, flags=�))r; r� r� r� r, r& r& r' �__repr__b s ���zSoupSieve.__repr__) r; r� r� r� r� r� r� r� r� r* )r4 r r! r< )r4 r r! rU )r� r� r! r� r� )r4 r r� r* r! r� )r4 r r� r* r! rk )r! r� )r/ r0 r1 r2 �__annotations__� __slots__r( r� r� r� r� r� r� r� �__str__� __classcell__r& r& r� r' r� s" r� );r2 � __future__r r r� r �rer r r r? �typingr r r r r r �compilerv r� rE rG rH rI rO rP rQ rR r� r� r r r� r� �SEL_OUT_OF_RANGEr� r r� r� r� r� r� r� r$ r� r� r� r� r� r� � DAYS_IN_WEEKr r3 r� r� � Immutabler� �pickle_registerr& r& r& r' �<module> sv $ � � cg S __pycache__/__meta__.cpython-310.pyc 0000644 00000013553 15030227305 0013203 0 ustar 00 o �hn � @ s� d Z ddlmZ ddlmZ ddlZe�d�Zdddd ddd dd �Zd d d d d d d dd �Z dddd�Z G dd� dedg d���Z d dd�Z e dd dd �Z e �� ZdS ) zMeta related things.� )� annotations)� namedtupleNz�(?x) (?P<major>\d+)(?:\.(?P<minor>\d+))?(?:\.(?P<micro>\d+))? (?:(?P<type>a|b|rc)(?P<pre>\d+))? (?:\.post(?P<post>\d+))? (?:\.dev(?P<dev>\d+))? � �a�b�rc)�.devz .dev-alphaz .dev-beta�.dev-candidate�alpha�beta� candidate�finalz 2 - Pre-Alphaz 3 - Alphaz4 - Betaz5 - Production/Stabler r r )r r r c sZ e Zd ZdZ dd � fdd� Zd dd�Zd dd�Zd dd�Zd dd�Zd dd�Z � Z S ) �Versional Get the version (PEP 440). A biased approach to the PEP 440 semantic version. Provides a tuple structure which is sorted for comparisons `v1 > v2` etc. (major, minor, micro, release type, pre-release build, post-release build, development release build) Release types are named in is such a way they are comparable with ease. Accessors to check if a development, pre-release, or post-release build. Also provides accessor to get development status for setup files. How it works (currently): - You must specify a release type as either `final`, `alpha`, `beta`, or `candidate`. - To define a development release, you can use either `.dev`, `.dev-alpha`, `.dev-beta`, or `.dev-candidate`. The dot is used to ensure all development specifiers are sorted before `alpha`. You can specify a `dev` number for development builds, but do not have to as implicit development releases are allowed. - You must specify a `pre` value greater than zero if using a prerelease as this project (not PEP 440) does not allow implicit prereleases. - You can optionally set `post` to a value greater than zero to make the build a post release. While post releases are technically allowed in prereleases, it is strongly discouraged, so we are rejecting them. It should be noted that we do not allow `post0` even though PEP 440 does not restrict this. This project specifically does not allow implicit post releases. - It should be noted that we do not support epochs `1!` or local versions `+some-custom.version-1`. Acceptable version releases: ``` Version(1, 0, 0, "final") 1.0 Version(1, 2, 0, "final") 1.2 Version(1, 2, 3, "final") 1.2.3 Version(1, 2, 0, ".dev-alpha", pre=4) 1.2a4 Version(1, 2, 0, ".dev-beta", pre=4) 1.2b4 Version(1, 2, 0, ".dev-candidate", pre=4) 1.2rc4 Version(1, 2, 0, "final", post=1) 1.2.post1 Version(1, 2, 3, ".dev") 1.2.3.dev0 Version(1, 2, 3, ".dev", dev=1) 1.2.3.dev1 ``` r r �major�int�minor�micro�release�str�pre�post�dev�returnc s� |||||fD ]}t |t�r|dkstd��q|tvr#td|� d���d| k r-dk rDn n|dkr7td��|r=td��|rCtd ��n#|d k r[|d krT|dkrTtd ��|rZtd ��n |ratd ��|rgtd��t� �| |||||||�S )zValidate version info.r z6All version parts except 'release' should be integers.�'z ' is not a valid release type.r r z"Implicit pre-releases not allowed.z%Version is not a development release.z0Post-releases are not allowed with pre-releases.r r z!Implicit pre-release not allowed.z Version is not a pre-release.)� isinstancer � ValueError�REL_MAP�super�__new__) �clsr r r r r r r �value�� __class__� �E/usr/local/CyberCP/lib/python3.10/site-packages/soupsieve/__meta__.pyr S s2 ���zVersion.__new__�boolc C � t | jdk�S )zIs prerelease.r )r% r ��selfr# r# r$ �_is_pre{ � zVersion._is_prec C s t | jdk �S )zIs development.r )r% r r' r# r# r$ �_is_dev� r* zVersion._is_devc C r& )zIs post.r )r% r r' r# r# r$ �_is_post� r* zVersion._is_postc C s t | j S )z Get development status string.)� DEV_STATUSr r' r# r# r$ �_get_dev_status� s zVersion._get_dev_statusc C s� | j dkr| j� d| j� �}n | j� d| j� d| j � �}| �� r,|t| j � | j� �7 }| �� r8|d| j� �7 }| � � rD|d| j � �7 }|S )z Get the canonical output string.r �.z.postr ) r r r r) r r r r, r r+ r )r( �verr# r# r$ �_get_canonical� s zVersion._get_canonical)r r r r )r r r r r r r r r r r r r r r r )r r% )r r ) �__name__� __module__� __qualname__�__doc__r r) r+ r, r. r1 � __classcell__r# r# r! r$ r ( s ,� ( r )r r r r r r r r0 r r c C s t �| �}|du rtd| � d���t|�d��}|�d�r$t|�d��nd}|�d�r2t|�d��nd}|�d�rHt|�d� }t|�d ��}nd }d}|�d �rV|�d �nd}|�d �rmt|�d ��}|rjd | nd }nd}|�d�r{t|�d��nd}t|||||||�S )z.Parse version into a comparable Version tuple.Nr z' is not a valid versionr r r r �typer r r z.dev-r r )�RE_VER�matchr r �group� PRE_REL_MAPr ) r0 �mr r r r r r r r# r# r$ � parse_version� s$ r= � � r )r0 r r r )r5 � __future__r � collectionsr �re�compiler8 r r- r; r r= �__version_info__r1 � __version__r# r# r# r$ �<module> s< � � � y# __pycache__/css_types.cpython-310.pyc 0000644 00000030733 15030227305 0013474 0 ustar 00 o �h�' � @ s� d Z ddlmZ ddlZddlmZ ddlmZmZmZm Z m Z m Z dZ dZ dZd Zd Zd Zd Zd ZdZdZdZdZG dd� d�ZG dd� de eef �ZG dd� de�ZG dd� de�ZG dd� de�Z G d d � d e�Z G d d � d e�Z G d d!� d!e�Z G d"d#� d#e�Z G d$d%� d%e�Z!G d&d'� d'e�Z"G d(d)� d)e�Z#d3d-d.�Z$d4d1d2�Z%e%e � e%e � e%e � e%e � e%e � e%e!� e%e"� e%e#� dS )5z CSS selector structure items.� )� annotationsN� )�pretty)�Any�Iterator�Hashable�Pattern�Iterable�Mapping) �Selector� SelectorNull� SelectorTag�SelectorAttribute�SelectorContains� SelectorNth� SelectorLang� SelectorList� Namespaces�CustomSelectors� � � � � �@ � � i i c s� e Zd ZU dZdZded< ded< d!� fd d � Zed"dd��Zd#dd�Z d#dd�Z d$dd�Z d%dd �Z d&d d �Z e Zd'd d �Z� ZS )(� Immutablez Immutable.��_hash�tuple[str, ...]� __slots__�intr �kwargsr �return�Nonec sV g }|� � D ]\}}|�t|�� |�|� t� �||� qt� �dtt|��� dS )� Initialize.r N)�items�append�type�super� __setattr__�hash�tuple)�selfr# �temp�k�v�� __class__� �F/usr/local/CyberCP/lib/python3.10/site-packages/soupsieve/css_types.py�__init__) s zImmutable.__init__�type[Immutable]c C s | S )zGet base class.r4 )�clsr4 r4 r5 �__base__3 s zImmutable.__base__�other�boolc s( t � ��� �ot� �fdd��jD ��S )�Equal.c 3 s, � | ]}|d krt � |�t �|�kV qdS �r N��getattr��.0�key�r: r. r4 r5 � <genexpr>> � �* z#Immutable.__eq__.<locals>.<genexpr>)� isinstancer9 �allr! �r. r: r4 rC r5 �__eq__9 s �zImmutable.__eq__c s* t � ��� � pt� �fdd��jD ��S )r< c 3 s, � | ]}|d krt � |�t �|�kV qdS r= r> r@ rC r4 r5 rD F rE z#Immutable.__ne__.<locals>.<genexpr>)rF r9 �anyr! rH r4 rC r5 �__ne__A s �zImmutable.__ne__c C � | j S �zHash.r �r. r4 r4 r5 �__hash__I � zImmutable.__hash__�name�str�valuec C s t d| jj� d���)zPrevent mutability.�'z' is immutable)�AttributeErrorr3 �__name__)r. rQ rS r4 r4 r5 r+ N � zImmutable.__setattr__c s6 d� � fdd�� jdd� D ��}� jj� d|� d�S )�Representation.z, c s g | ] }|� d t � |����qS )�=r> )rA r0 rN r4 r5 � <listcomp>V s z&Immutable.__repr__.<locals>.<listcomp>N����(�))�joinr! r3 rV )r. �rr4 rN r5 �__repr__S s "zImmutable.__repr__c C s t t| �� dS )z Pretty print.N)�printr rN r4 r4 r5 r [ � zImmutable.pretty)r# r r$ r% )r$ r7 )r: r r$ r; �r$ r" )rQ rR rS r r$ r% �r$ rR �r$ r% )rV � __module__� __qualname__�__doc__r! �__annotations__r6 � classmethodr9 rI rK rO r+ r` �__str__r � __classcell__r4 r4 r2 r5 r " s r c @ sZ e Zd ZdZddd�Zddd �Zdd d �Zd dd�Zd dd�Zd dd�Z d dd�Z e Z dS ) � ImmutableDictz Hashable, immutable dictionary.�arg�*dict[Any, Any] | Iterable[tuple[Any, Any]]r$ r% c C s: | � |� t|�| _ttdd� t| j�� �D ���| _dS )r& c S s$ g | ]\}}t |�|t |�|f�qS r4 )r) )rA �x�yr4 r4 r5 rZ l s $ z*ImmutableDict.__init__.<locals>.<listcomp>N)� _validate�dict�_dr, r- �sortedr' r �r. rn r4 r4 r5 r6 d s &zImmutableDict.__init__c C s^ t |t�rtdd� |�� D ��st| jj� d���dS tdd� |D ��s-t| jj� d���dS )�Validate arguments.c s � � | ]}t |t�V qd S �N�rF r �rA r1 r4 r4 r5 rD r � � z*ImmutableDict._validate.<locals>.<genexpr>� values must be hashablec s �( � | ]\}}t |t�ot |t�V qd S ry rz �rA r0 r1 r4 r4 r5 rD t � �& N�rF rs rG �values� TypeErrorr3 rV rv r4 r4 r5 rr n � ��zImmutableDict._validate� Iterator[Any]c C � t | j�S �z Iterator.)�iterrt rN r4 r4 r5 �__iter__w � zImmutableDict.__iter__r" c C r� �zLength.)�lenrt rN r4 r4 r5 �__len__| r� zImmutableDict.__len__rB r c C � | j | S )z Get item: `namespace['key']`.�rt )r. rB r4 r4 r5 � __getitem__� r� zImmutableDict.__getitem__c C rL rM r rN r4 r4 r5 rO � rP zImmutableDict.__hash__rR c C s | j �S )rX r� rN r4 r4 r5 r` � s zImmutableDict.__repr__N)rn ro r$ r% )r$ r� rc )rB r r$ r rd ) rV rf rg rh r6 rr r� r� r� rO r` rk r4 r4 r4 r5 rm a s rm c �, e Zd ZdZd � fdd� Zd dd �Z� ZS ) r z Namespaces.rn �*dict[str, str] | Iterable[tuple[str, str]]r$ r% c � t � �|� dS �r& N�r* r6 rv r2 r4 r5 r6 � rb zNamespaces.__init__c C �^ t |t�rtdd� |�� D ��st| jj� d���dS tdd� |D ��s-t| jj� d���dS )rw c s rx ry �rF rR r{ r4 r4 r5 rD � r| z'Namespaces._validate.<locals>.<genexpr>r} c s r~ ry r� r r4 r4 r5 rD � r� �( keys and values must be Unicode stringsNr� rv r4 r4 r5 rr � r� zNamespaces._validate�rn r� r$ r% �rV rf rg rh r6 rr rl r4 r4 r2 r5 r � � r c r� ) r zCustom selectors.rn r� r$ r% c r� r� r� rv r2 r4 r5 r6 � rb zCustomSelectors.__init__c C r� )rw c s rx ry r� r{ r4 r4 r5 rD � r| z,CustomSelectors._validate.<locals>.<genexpr>r} c s r~ ry r� r r4 r4 r5 rD � r� r� Nr� rv r4 r4 r5 rr � r� zCustomSelectors._validater� r� r4 r4 r2 r5 r � r� r c s� e Zd ZU dZdZded< ded< ded< ded < d ed < d ed < ded< ded< ded< ded< ded< d� fdd� Z� ZS )r z Selector.) �tag�ids�classes� attributes�nth� selectors�relation�rel_type�contains�lang�flagsr �SelectorTag | Noner� r r� r� � tuple[SelectorAttribute, ...]r� �tuple[SelectorNth, ...]r� �tuple[SelectorList, ...]r� r r� � str | Noner� � tuple[SelectorContains, ...]r� �tuple[SelectorLang, ...]r� r" r� c s& t � j||||||||| | | d� dS )r& ) r� r� r� r� r� r� r� r� r� r� r� Nr� ) r. r� r� r� r� r� r� r� r� r� r� r� r2 r4 r5 r6 � s �zSelector.__init__)r� r� r� r r� r r� r� r� r� r� r� r� r r� r� r� r� r� r� r� r" �rV rf rg rh r! ri r6 rl r4 r4 r2 r5 r � s r c s" e Zd ZdZd� fdd� Z� ZS )r zNull Selector.r$ r% c s t � �� dS r� r� rN r2 r4 r5 r6 � s zSelectorNull.__init__re )rV rf rg rh r6 rl r4 r4 r2 r5 r � s r c s8 e Zd ZU dZdZded< ded< d � fd d � Z� ZS ) r z Selector tag.)rQ �prefixr rR rQ r� r� r$ r% c s t � j||d� dS )r& )rQ r� Nr� )r. rQ r� r2 r4 r5 r6 � rW zSelectorTag.__init__)rQ rR r� r� r$ r% r� r4 r4 r2 r5 r � � r c sH e Zd ZU dZdZded< ded< ded< ded< d � fd d � Z� ZS )r zSelector attribute rule.)� attributer� �pattern�xml_type_patternr rR r� r� �Pattern[str] | Noner� r� r$ r% c s t � j||||d� dS )r& )r� r� r� r� Nr� )r. r� r� r� r� r2 r4 r5 r6 s �zSelectorAttribute.__init__) r� rR r� rR r� r� r� r� r$ r% r� r4 r4 r2 r5 r s r c s8 e Zd ZU dZdZded< ded< d � fd d � Z� ZS ) r zSelector contains rule.)�text�ownr r r� r; r� � Iterable[str]r$ r% c s t � jt|�|d� dS )r& )r� r� N�r* r6 r- )r. r� r� r2 r4 r5 r6 $ s zSelectorContains.__init__)r� r� r� r; r$ r% r� r4 r4 r2 r5 r r� r c sX e Zd ZU dZdZded< ded< ded< ded< ded < d ed < d� fdd� Z� ZS )r zSelector nth type.)�a�n�b�of_type�lastr� r r" r� r; r� r� r� r� r r� r$ r% c s t � j||||||d� dS )r& )r� r� r� r� r� r� Nr� )r. r� r� r� r� r� r� r2 r4 r5 r6 6 s �zSelectorNth.__init__)r� r" r� r; r� r" r� r; r� r; r� r r$ r% r� r4 r4 r2 r5 r * s r c sN e Zd ZU dZdZded< d� fdd� Zdd d �Zdd d�Zddd�Z � Z S )r zSelector language rules.)� languagesr r r� r� c s t � jt|�d� dS )r& �r� Nr� )r. r� r2 r4 r5 r6 J s zSelectorLang.__init__r$ � Iterator[str]c C r� r� )r� r� rN r4 r4 r5 r� O r� zSelectorLang.__iter__r" c C r� r� )r� r� rN r4 r4 r5 r� T r� zSelectorLang.__len__�indexrR c C r� �z Get item.r� �r. r� r4 r4 r5 r� Y r� zSelectorLang.__getitem__)r� r� )r$ r� rc )r� r" r$ rR � rV rf rg rh r! ri r6 r� r� r� rl r4 r4 r2 r5 r C s r c sf e Zd ZU dZdZded< ded< ded< dd� fd d� Zddd�Zd dd�Zd dd�Z � Z S ) r zSelector list.)r� �is_not�is_htmlr z#tuple[Selector | SelectorNull, ...]r� r; r� r� NF�(Iterable[Selector | SelectorNull] | Noner$ r% c s& t � j|dur t|�nd||d� dS )r& Nr4 )r� r� r� r� )r. r� r� r� r2 r4 r5 r6 h s �zSelectorList.__init__�!Iterator[Selector | SelectorNull]c C r� r� )r� r� rN r4 r4 r5 r� v r� zSelectorList.__iter__r" c C r� r� )r� r� rN r4 r4 r5 r� { r� zSelectorList.__len__r� �Selector | SelectorNullc C r� r� )r� r� r4 r4 r5 r� � r� zSelectorList.__getitem__)NFF)r� r� r� r; r� r; r$ r% )r$ r� rc )r� r" r$ r� r� r4 r4 r2 r5 r _ s � r �pr r$ c s( � � � t� fdd�� jd d� D ��fS )Nc s g | ]}t � |��qS r4 r> )rA �s�r� r4 r5 rZ � s z_pickle.<locals>.<listcomp>r[ )r9 r- r! r� r4 r� r5 �_pickle� s (r� �objr% c C s t �| t� dS )zAllow object to be pickled.N)�copyreg�pickler� )r� r4 r4 r5 �pickle_register� rb r� )r� r r$ r )r� r r$ r% )&rh � __future__r r� r �typingr r r r r r �__all__� SEL_EMPTY�SEL_ROOT� SEL_DEFAULT�SEL_INDETERMINATE� SEL_SCOPE� SEL_DIR_LTR� SEL_DIR_RTL� SEL_IN_RANGE�SEL_OUT_OF_RANGE� SEL_DEFINED�SEL_PLACEHOLDER_SHOWNr rm r r r r r r r r r r r� r� r4 r4 r4 r5 �<module> sN ?23 ' __pycache__/css_parser.cpython-310.pyc 0000644 00000070661 15030227305 0013630 0 ustar 00 o �hw� � @ sh d Z ddlmZ ddlZddlmZ ddlmZ ddlmZ ddlm Z dd lm Z ddl Z dd lmZmZmZmZ d Zh d �Zh d �Zh d�Zh d�Zh d�ZeeB eB eB eB ZdZde� d�ZdZ de� de � d�Z de� d�Z de� de� d�Z de � d e � d �Z d e � d e � d �Z!d!e� d"e� d#e � d$�Z"de � d%e � d&e"� d'e � d(e � d)� Z#d*e � �Z$d+e � �Z%d,e � d-e � d.�Z&d/e � d0e � d1e � de#� �Z'd2e � d3e � d4�Z(d2e � d3e � d5�Z)d6e � d�Z*d7Z+e � d8�Z,d9e(� �Z-d:e � �Z.d;e)� d<e!� d=e � d>e � d?e� e � d@e � d?e� e � dA�Z/dBe)� dCe!� dDe � dE�Z0e)� dFe"� de � dGe � d?e"� dHe � d8� Z1e)� dIe � d8�Z2e � dJe� dKe � d?�Z3e)� dFe"� de � dGe � d?e"� dHe � d8� Z4e�5dLe � dM�ej6�Z7e�5dLe� dNe� d�ej6�Z8e�5dOe � dPe � dQ�ej6�Z9e�5dRe"� dSe � dGe � dT�ej:�Z;e�5e�Z<e�5dUe � d?��Z=e�5e � dV��Z>e�5dUe*� dW�ej:�Z?dXZ@dYZAdZBdZZCd[ZDd\ZEd]ZFd^ZGd_ZHd`ZIdaZJdbZKdcZLddZMeeMde�d�dpdq��ZNd�dsdt�ZOd�dvdw�ZPd�d�d|d}�ZQd�dd��ZRG d�d�� d��ZSG d�d�� d�eS�ZTG d�d�� d��ZUG d�d�� d��ZVeVd��jWeBeFB d��ZXeVd��jWeBeFB d��ZYeVd��jWeBeFB eEB d��ZZeVd��jWeBeFB eGB d��Z[eVd��jWeBeFB d��Z\eVd��jWeBeFB d��Z]eVd��jWeBeFB d��Z^eVd��jWeBeFB d��Z_eVd��jWeBeFB eKB d��Z`eVd��jWeBd��ZaeVd��jWeBeFB d��ZbeVd��jWeBeFB d��ZceVd��jWeBeIB eFB d��ZdeVd��jWeBeJB eFB d��ZeeVd��jWeBeFB d��ZfeVd��jWeBeFB d��ZgdS )�zCSS selector parser.� )� annotationsN)� lru_cache� )�util)� css_match)� css_types)�SelectorSyntaxError)�Match�Any�Iterator�casti�� > �:link�:open�:root�:empty�:muted�:scope�:checked�:default�:defined�:enabled� :any-link� :disabled� :in-range� :optional� :required� :read-only� :last-child� :only-child� :read-write� :first-child� :last-of-type� :only-of-type� :out-of-range�:first-of-type�:indeterminate�:placeholder-shown> �:past�:focus�:hover�:active�:future�:paused�:target�:playing�:seeking�:stalled�:visited� :autofill� :buffering� :fullscreen� :local-link� :focus-within� :popover-open� :user-invalid�:focus-visible�:target-within�:volume-locked�:picture-in-picture�:host�:current> �:matches�:is�:has�:not�:where� :contains�:-soup-contains�:-soup-contains-own> � :host-contextr= r> > �:dir�:lang� :nth-child� :nth-of-type�:nth-last-child�:nth-last-of-typez(?:\r\n|(?!\r\n)[\n\f\r])z (?:[ \t]|�)z"(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/)z(?:�|z(?:\\(?:[a-f0-9]{1,6}z?|[^\r\n\f]|$))z?|[^\r\n\f]|$|z))z8 (?:(?:-?(?:[^\x00-\x2f\x30-\x40\x5B-\x5E\x60\x7B-\x9f]|z>)+|--) (?:[^\x00-\x2c\x2e\x2f\x3A-\x40\x5B-\x5E\x60\x7B-\x9f]|z)*) z (?:[-+])?(?:[0-9]+n?|n)(?:(?<=n)z *(?:[-+])z *(?:[0-9]+))?z(?:"(?:\\(?:.|z )|[^\\"\r\n\f]+)*?"|'(?:\\(?:.|z)|[^\\'\r\n\f]+)*?'|z+)z*(?P<cmp>[!~^|*$]?=)z *(?P<value>z)(?:z*(?P<case>[is]))?)?z*\]z\#z\.z(?P<tag_ns>(?:z|\*)?\|)?(?P<tag_name>z|\*)z\[z*(?P<attr_ns>(?:z|\*)?\|)?(?P<attr_name>z (?P<name>:z )(?P<open>\(z*)?z*)z(?P<name>:(?=--)�&z*\)�:z@Pz (?P<pseudo_nth_child>z (?P<nth_child>z|even|odd))(?:z *\)|(?P<of>�*z*ofz*)) z (?P<pseudo_nth_type>z (?P<nth_type>z |even|odd))z*\) z (?P<values>z*,z)*)z(?P<dir>ltr|rtl)z*?(?P<relation>[,+>~]|z (?![,+>~]))z(?:(\\[a-f0-9]{1,6}z?)|(\\[^\r\n\f])|(\\$))z?)|(\\[^\r\n\f])|(\\$)|(\\z'(?P<s1>[-+])?(?P<a>[0-9]+n?|n)(?:(?<=n)z *(?P<s2>[-+])z*(?P<b>[0-9]+))?z (?:(?P<value>z )|(?P<split>z*))�^z*$�$�,� � � � � � �@ � � i i i� )�maxsize�pattern�str� namespaces�ct.Namespaces | None�custom�ct.CustomSelectors | None�flags�int�return� cm.SoupSievec C s( t |�}t�| t| ||d��� |||�S )zCached CSS compile.�rd rf )�process_custom�cm� SoupSieve� CSSParser�process_selectors)r` rb rd rf �custom_selectors� rq �G/usr/local/CyberCP/lib/python3.10/site-packages/soupsieve/css_parser.py�_cached_css_compile� s ��rs �Nonec C s t �� dS )zPurge the cache.N)rs � cache_clearrq rq rq rr � _purge_cache� s rv � dict[str, str | ct.SelectorList]c C sn i }| dur5| � � D ]*\}}t�|�}t�|�du r"td|� d���||v r.td|� d���||t|�< q |S )zProcess custom.Nz The name 'z)' is not a valid custom pseudo-class namezThe custom selector 'z ' has already been registered)�itemsr �lower� RE_CUSTOM�matchr �KeyError� css_unescape)rd rp �key�value�namerq rq rr rk � s rk F�content�string�boolc C s ddd�}|s t nt�|| �S ) zs Unescape CSS value. Strings allow for spanning the value on multiple strings by escaping a new line. �m� Match[str]rh ra c S st | � d�r t| � d�dd� d�}|dkrt}t|�}|S | � d�r-| � d�dd� }|S | � d�r6d}|S d}|S ) z(Replace with the appropriate substitute.r NrZ r rW � � �� )�grouprg �UNICODE_REPLACEMENT_CHAR�chr)r� � codepointr rq rq rr �replace� s � ��z css_unescape.<locals>.replaceN)r� r� rh ra )� RE_CSS_ESC�RE_CSS_STR_ESC�sub)r� r� r� rq rq rr r} � s r} �identc C sr g }t | �}|dko| d dk}|dkr |r |�d| � �� n�t| �D ]�\}}t|�}|dkr5|�d� q#d| kr?dksDn |dkrO|�d|d�d �� q#|dksY|rp|dkrpd | krcd krpn n |�d|d�d �� q#|d v s�|d ks�d | kr�d ks�n d | kr�d ks�n d| kr�dks�n d| kr�dkr�n n|�|� q#|�d|� �� q#d�|�S )zEscape identifier.r �-r �\r� � � �xrV �0 �9 )�- �_ r] �A �Z �a �z r� )�len�append� enumerate�ord�join)r� r� �length� start_dash�index�cr� rq rq rr �escape s$ ,&D r� c @ s. e Zd ZdZddd�Zdd d �Zddd�ZdS )�SelectorPattern�Selector pattern.r� ra r` rh rt c C s& || _ t�|tjtjB tjB �| _dS )� Initialize.N)r� �re�compile�I�X�U� re_pattern)�selfr� r` rq rq rr �__init__2 s zSelectorPattern.__init__c C s | j S )� Get name.)r� �r� rq rq rr �get_name8 s zSelectorPattern.get_name�selectorr� rg rf �Match[str] | Nonec C s | j �||�S )�Match the selector.)r� r{ )r� r� r� rf rq rq rr r{ = s zSelectorPattern.matchN)r� ra r` ra rh rt �rh ra �r� ra r� rg rf rg rh r� ��__name__� __module__� __qualname__�__doc__r� r� r{ rq rq rq rr r� / s r� c @ s. e Zd ZdZddd�Zdd d �Zddd�ZdS )�SpecialPseudoPatternr� �patterns�Ctuple[tuple[str, tuple[str, ...], str, type[SelectorPattern]], ...]rh rt c C sh i | _ |D ]}|d }|d ||d �}|d D ]}|| j |< qqd| _t�ttjtjB tjB �| _dS )r� r r� rW r N) r� � matched_namer� r� �PAT_PSEUDO_CLASS_SPECIALr� r� r� �re_pseudo_name)r� r� �pr� r` �pseudorq rq rr r� F s � z SpecialPseudoPattern.__init__ra c C s | j du rdS | j �� S )r� Nr� )r� r� r� rq rq rr r� S s z SpecialPseudoPattern.get_namer� r� rg rf r� c C sV d}| j �||�}|r)t�t|�d���}| j�|�}|r)|�|||�}|r)|| _|S )r� Nr� ) r� r{ r ry r} r� r� �getr� )r� r� r� rf r� r� r� r` rq rq rr r{ X s zSpecialPseudoPattern.matchN)r� r� rh rt r� r� r� rq rq rq rr r� C s r� c @ s< e Zd ZdZddd�Zdd d �Zddd�Zddd�ZeZdS )� _Selectorz� Intermediate selector class. This stores selector data for a compound selector as we are acquiring them. Once we are done collecting the data for a compound selector, we freeze the data in an object that can be pickled and hashed. �kwargsr rh rt c K s� |� dd�| _|� dg �| _|� dg �| _|� dg �| _|� dg �| _|� dg �| _|� dg �| _|� d d�| _|� d g �| _ |� d g �| _ |� d d �| _ |� dd�| _ dS )r� �tagN�ids�classes� attributes�nth� selectors� relations�rel_type�contains�langrf r �no_matchF) r� r� r� r� r� r� r� r� r� r� r� rf r� )r� r� rq rq rr r� q s z_Selector.__init__r� �list[_Selector]�ct.SelectorListc C s8 |r|d }|j �|dd� � t�|�� g�S t�� S )zFreeze relation.r r N)r� �extend�ct� SelectorList�freeze)r� r� �selrq rq rr �_freeze_relations� s z_Selector._freeze_relations� ct.Selector | ct.SelectorNullc C sd | j rt�� S t�| jt| j�t| j�t| j�t| j �t| j �| � | j �| j t| j�t| j�| j� S )z Freeze self.)r� r� � SelectorNull�Selectorr� �tupler� r� r� r� r� r� r� r� r� r� rf r� rq rq rr r� � s �z_Selector.freezera c C sf d| j �d| j�d| j�d| j�d| j�d| j�d| j�d| j�d | j�d | j �d | j �d | j �d �S )zString representation.z_Selector(tag=z, ids=z , classes=z , attributes=z, nth=z , selectors=z , relations=z , rel_type=z , contains=z, lang=z, flags=z , no_match=rN ) r� r� r� r� r� r� r� r� r� r� rf r� r� rq rq rr �__str__� s$ "���������z_Selector.__str__N)r� r rh rt )r� r� rh r� )rh r� r� ) r� r� r� r� r� r� r� r� �__repr__rq rq rq rr r� h s r� c @ sR e Zd ZdZede�eddeefddeefdde efd d e efd d e eff�ed e �ede �ede�ede�ede�ede�ede�ede�ede�ede�f Z dWdXd!d"�ZdYd)d*�ZdYd+d,�ZdYd-d.�ZdZd3d4�Zd[d5d6�Z d\d9d:�Z d]d?d@�Z d^dEdF�Z dYdGdH�Z dYdIdJ�Z!dYdKdL�Z"dYdMdN�Z# d_d`dPdQ�Z$dadSdT�Z%d_dbdUdV�Z&dS )crn zParse CSS selectors.� pseudo_close�pseudo_contains)rD rE rF �pseudo_nth_child)rJ rL �pseudo_nth_type)rK rM � pseudo_lang)rI � pseudo_dir)rH �pseudo_class_custom� pseudo_class�pseudo_element�amp�at_rule�id�classr� � attribute�combineNr r� ra rd �'dict[str, str | ct.SelectorList] | Nonerf rg rh rt c C s> |� dd�| _|| _| jtj@ | _|du ri | _dS || _dS )r� � r� N)r� r` rf r �DEBUG�debugrd )r� r� rd rf rq rq rr r� � s zCSSParser.__init__r� r� r� r� � has_selectorr� c C sP d}|� d�}|� d�rt�|� d��nd}|� d�r&t|� d�dd� �nd}t|� d��}d} d} d} |rD|d kr>tjnd tjB } nt�|�d krTtjtjB } d } ntj} |ru|� d ��d�rnt|� d �dd� d �} nt|� d ��} |szd} nr|�d�r�t�dt� | � | �} na|�d�r�t�dt� | � | �} nP|�d�r�t�dt� | � | �} n?|�d�r�| r�t � | �r�dnt� | �} t�d| | �} n#|�d�r�t�dt� | � | �} nt�dt� | � | �} |�d �r�d }| r�| r�t�| j �} t �||| | �}|�r t� }|j�|� t �|�� gd d�}|j�|� d }|S |j�|� d }|S ) z8Create attribute selector from the returned regex match.F�cmp�caseN�attr_ns���r� � attr_name�ir �typeTr ��"�'r rS z^%s.*rT z.*?%s$rR z.*?%s.*�~z[^\s\S]z7.*?(?:(?<=^)|(?<=[ \t\r\n\f]))%s(?=(?:[ \t\r\n\f]|$)).*rO z ^%s(?:-.*)?$z^%s$�!)r� r ry r} r� r� �DOTALL� startswithr� r� �RE_WS�searchr` r� �SelectorAttributer� r� r� r� r� r� )r� r� r� r� �inverse�opr� �ns�attr�is_type�pattern2r rf r` �sel_attr�sub_sel�not_listrq rq rr �parse_attribute_selector� s^ $ �z"CSSParser.parse_attribute_selectorc C sH |� d�rt|� d�dd� �nd}t|� d��}t�||�|_d}|S )z#Parse tag pattern from regex match.�tag_nsNr� �tag_nameT)r� r} r� � SelectorTagr� )r� r� r� r� �prefixr� rq rq rr �parse_tag_pattern s $zCSSParser.parse_tag_patternc C s� t �t|�d���}| j�|�}|du r'td|� d|�d�� �| j|�d���t |t j �sC| j|= t || j| j d�jtd�}|| j|< |j�|� d}|S ) z� 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. r� NzUndefined custom selector 'z' found at position r rj �rf T)r ry r} r� rd r� r �endr` � isinstancer� r� rn rf ro � FLG_PSEUDOr� r� )r� r� r� r� r� r� rq rq rr �parse_pseudo_class_custom' s& � �� z#CSSParser.parse_pseudo_class_custom� iselector� Iterator[tuple[str, Match[str]]]�is_html�tuple[bool, bool]c C s d}t �t|�d���}|�d�rd}|r)|tv r)| �|||||�d��}||fS |�s�|tv �r�|dkr?| jt j O _�nu|dkrO| jt j O _d}�ne|dkr]| jt j O _�nW|d krk| jt j O _�nI|d v rw|j�t� �n=|d kr�|j�t� �n1|d kr�|j�t� �n%|d kr�|j�t� �n|dkr�|j�t� �n |dkr�|j�t� �n|dkr�|j�t� n�|dkr�|j�t� n�|dkr�|j�t� n�|dkr�|j�t� n�|dkr�|j�t� n�|dkr�|j�t� n�|dk�r|j�t � n�|dk�r |j�t � n�|dk�r|j�t � n�|dk�r/|j �t � dddddt �!� �� n�|dk�rE|j �t � dddddt �!� �� no|d k�r[|j �t � dddddt �!� �� nY|d k�rq|j �t � dddddt �!� �� nC|d k�r�|j �"t � dddddt �!� �t � dddddt �!� �g� n!|d k�r�|j �"t � dddddt �!� �t � dddddt �!� �g� d}||fS |�r�|t#v �r�| �$||�d�t%t&B � d|_'d}||fS |�s�|t(v �r�d|_'d}||fS |t)v �r�t*d |� d!�| j+|�,d���t*d!|� d"�| j+|�,d���)#zParse pseudo class.Fr� �openTr r r r r )r r r r r% r r r r r r r r r r# r& r r r r$ r! r r" z!Invalid syntax for pseudo class 'r z�' was detected as a pseudo-class and is either unsupported or invalid. If the syntax was not intended to be recognized as a pseudo-class, please escape the colon.)-r ry r} r� �PSEUDO_COMPLEX�parse_pseudo_openr � PSEUDO_SIMPLErf r� �SEL_ROOT� SEL_DEFINED� SEL_SCOPE� SEL_EMPTYr� r� �CSS_LINK� CSS_CHECKED� CSS_DEFAULT�CSS_INDETERMINATE� CSS_DISABLED� CSS_ENABLED� CSS_REQUIRED� CSS_MUTED�CSS_OPEN� CSS_OPTIONAL� CSS_READ_ONLY�CSS_READ_WRITE� CSS_IN_RANGE�CSS_OUT_OF_RANGE�CSS_PLACEHOLDER_SHOWNr� � SelectorNthr� r� �PSEUDO_COMPLEX_NO_MATCH�parse_selectorsr �FLG_OPENr� �PSEUDO_SIMPLE_NO_MATCH�PSEUDO_SUPPORTEDr r` �start)r� r� r� r� r r �complex_pseudor� rq rq rr �parse_pseudo_classC s� U� " " " " �� ���� � � �z CSSParser.parse_pseudo_classc C s0 |� � }|�d�r d}nd}t�t|d ��|d< t�|�d| ��}|dkr.d}d} d } nq|d kr9d}d } d } nfttt t� |��} | � d �rQ| � d �d krQd nd} | � d�} | � d�} | � d�rg| d7 } n| rr| | dd� 7 } n| | 7 } | � d�r�| � d�d kr�d nd}| � d�r�|| � d�7 }nd}t | d�}t |d�} |d }|dkr�|� d�r�| �||�d�ttB �}nt}|dkr�|j�t�|| | dd|�� d }|S |dkr�|j�t�|| | dd |�� d }|S |d kr�|j�t�|| | d dt�� �� d }|S |d k�r|j�t�|| | d d t�� �� d }|S ) zParse `nth` pseudo.r� �_child�_typer� r� �evenrW r T�oddr �s1r� r� �a�n�1Nr� �s2�b�0� �ofrJ FrL rK rM )� groupdictr� r ry r} r r ra �RE_NTHr{ r� �endswithr rg r; r r r< �CSS_NTH_OF_S_DEFAULTr� r� r� r9 r� )r� r� r� r� r �mdict�postfixr� rF rJ �var� nth_parts�_s1rG �_s2� pseudo_sel�nth_selrq rq rr �parse_pseudo_nth� sd � � � zCSSParser.parse_pseudo_nthr� r� c C sZ t tB }|dkr |tO }n|dkr|tO }n|dv r |tO }|j�| �|||�� d}|S )z"Parse pseudo with opening bracket.rB rA )rC r@ T)r r< �FLG_NOT� FLG_RELATIVE� FLG_FORGIVEr� r� r; )r� r� r� r� r r� rf rq rq rr r$ � s zCSSParser.parse_pseudo_openr� r� r� �tuple[bool, _Selector, str]c C s� |� d��� }|s t}|tkr%||_|d j�|� dt }|�t� � n$|r3||_|d j�|� n|dd� tkrEtd|� �| j |��d| }t� }d}|||fS )�Parse combinator tokens.�relationr� rQ r Nz%The multiple combinators at position F) r� �strip� WS_COMBINATOR�COMMA_COMBINATORr� r� r� r� r r` )r� r� r� r� r� r� r� � combinatorrq rq rr �parse_has_combinator s* � z CSSParser.parse_has_combinatorr� � is_pseudo� is_forgive�tuple[bool, _Selector]c C s� |� d��� } | s t} |s3|r| tkr!td| � d|� d�| j|��| tkr2d|_|dd�= |�|� n4| tkrT|jsC|sCt � dd�|_|j � |� |�|� |dd�= n|j � |� | |_ |dd�= |�|� t� }d}||fS ) r` ra zThe combinator 'z' at position z , must have a selector before itTNrR F)r� rb rc rd r r` r� r� r� r� r r� r� r� r� ) r� r� r� r� r� r� rg rh r� re rq rq rr �parse_combinator, s8 � � zCSSParser.parse_combinatorc C sT |� d�}|�d�r|j�t|dd� �� d}|S |j�t|dd� �� d}|S )zParse HTML classes and ids.r �.r NT)r� r r� r� r} r� )r� r� r� r� r� rq rq rr �parse_class_id\ s �zCSSParser.parse_class_idc C s� t �t|�d���}|dkrt�dt� |dk}t|�d��}g }t�|�D ]%}|�d�r.q&|�d�} | � d�rBt| d d � d �} nt| �} |� | � q&|j � t � ||�� d }|S ) zParse contains.r� rD z\The pseudo class ':contains' is deprecated, ':-soup-contains' should be used moving forward.rF �values�splitr )r r r r� T)r ry r} r� �warnings�warn� FutureWarning� RE_VALUES�finditerr r� r� r� �SelectorContains) r� r� r� r� r� � contains_ownrm r� �tokenr rq rq rr �parse_pseudo_containsg s( � z CSSParser.parse_pseudo_containsc C s~ |� d�}g }t�|�D ]%}|� d�rq |� d�}|�d�r(t|dd� d�}nt|�}|�|� q |j�t�|�� d}|S )zParse pseudo language.rm rn r r r r� T) r� rr rs r r} r� r� r� � SelectorLang)r� r� r� r� rm r� rv r rq rq rr �parse_pseudo_lang� s zCSSParser.parse_pseudo_langc C s6 t �|�d��dkr tjntj}| j|O _d}|S )zParse pseudo direction.�dir�ltrT)r ry r� r� � SEL_DIR_LTR� SEL_DIR_RTLrf )r� r� r� r� r rq rq rr �parse_pseudo_dir� s zCSSParser.parse_pseudo_dirr� c C s� t � }g }d}d}g }dt } t|t@ �} t|t@ �} t|t@ �} t|t@ �} t|t@ �}t|t@ �}t|t @ �}t|t @ �}t|t @ �}t|t @ �}t|t @ �}| jr�| rZtd� | r`td� | rftd� | rltd� |rrtd� |rxtd� |r~td � |r�td � |r�td � |r�td � |r�td � | r�|�t � � �z t|�\}}|dkr�td|�d�� ���|dkr�| jtjO _d}n�|dkr�| �|||�}n�|dkr�| �|||||�\}}n�|dkr�td|�d�� ���|dkr�| �|||�}n�|dv �r| �||||�}n�|dk�r| �|||�}n�|dk�r$| � |||�}d}n�|dk�rX|�sB|�s?t d |�d�� �| j |�d���d|_ | �rHd}nut d |�d�� �| j |�d���|d k�r}| �rn| � ||||| |�\}}} nI| �!|||||| ||�\}}n:|d k�r�| �"|||�}n-|d k�r�|�r�t d!|�d�� d"�| j |�d���| �#|||�}n |d#v �r�| �$|||�}|�%d�}q�W n t&�y� Y nw | �r�|�s�t d$|� �| j |��|�r |j'�s�| �s�t�(d%d&�|_'| �r�| |_)|d' j*�|� n)|j*�+|� |d&d&�= |�|� n|�r"|�r|�s"d|_ |d&d&�= |�|� d}|�s/t d |� �| j |��|�r8tj,|d' _|�rAtj-|d' _|�rJtj.|d' _|�rStj/|d' _|�r\tj0|d' _t�1d(d)� |D �| |�S )*zParse selectors.FrQ z is_pseudo: Truez is_open: Truez is_relative: Truez is_not: Truez is_html: Truez is_default: Truez is_indeterminate: Truez is_in_range: Truez is_out_of_range: Truez is_placeholder_shown: Truez is_forgive: TrueTr� zAt-rules found at position r r� r� r� r� z!Pseudo-element found at position r� )r� r� r� r� r� z Expected a selector at position z)Unmatched pseudo-class close at position r� r� r� zTag name found at position z instead of at the start)r� r� z"Unclosed pseudo-class at position rR Nr� c S s g | ]}|� � �qS rq )r� )�.0�srq rq rr � <listcomp>R s z-CSSParser.parse_selectors.<locals>.<listcomp>)2r� rc r� r< r r] r\ �FLG_HTML� FLG_DEFAULT�FLG_INDETERMINATE� FLG_IN_RANGE�FLG_OUT_OF_RANGE�FLG_PLACEHOLDER_SHOWNr^ r� �printr� �next�NotImplementedErrorr? rf r� r( r rA rw r[ ry r~ r r` r� rf rj r r rl r � StopIterationr� r r� r� r� � SEL_DEFAULT�SEL_INDETERMINATE� SEL_IN_RANGE�SEL_OUT_OF_RANGE�SEL_PLACEHOLDER_SHOWNr� )r� r r� rf r� r� r� �closedr� r� �is_openrg � is_relative�is_notr � is_default�is_indeterminate� is_in_range�is_out_of_range�is_placeholder_shownrh r~ r� rq rq rr r; � s" �� � � � �$ � � � zCSSParser.parse_selectorsr` c c sn � t �|�}|r |�d�nd}t�|�}|r |�d�d nt|�d }| jr-td|��� ||kr�d}| jD ]2}|� ||| j �}|rh|� � }| jr\td|� d|� d��d|�d�� �� |�d�}||fV nq6|du r�|| }|dkr{d |� �}n&|d kr�d |� �}n |d kr�d |� �}n|dkr�d|� �}nd|�d|� �}t || j|��||ks1| jr�td� dS dS )zIterate selector tokens.r r z ## PARSING: NzTOKEN: 'z' --> z at position �[z)Malformed attribute selector at position rk z%Malformed class selector at position �#z"Malformed id selector at position rQ z,Malformed pseudo-class selector at position zInvalid character z position z## END PARSING)� RE_WS_BEGINr r � RE_WS_ENDr? r� r� r� � css_tokensr{ rf r� r� r r` ) r� r` r� r� r �vr� r� �msgrq rq rr � selector_iterT sF � & � � �zCSSParser.selector_iterc C s | � | �| j�||�S )zProcess selectors.)r; r� r` )r� r� rf rq rq rr ro } s zCSSParser.process_selectors)Nr )r� ra rd r� rf rg rh rt )r� r� r� r� r� r� rh r� ) r� r� r� r� r� r� r r r r� rh r! ) r� r� r� r� r� r� r r rh r� ) r� r� r� ra r� r� r r r� rg rh r� )r� r� r� r� r� r� r� r� r� ra r� rg rh r_ )r� r� r� r� r� r� r� r� r� r� rg r� rh r� r� rg rh ri )r r )r r r� rg rf rg rh r� )r` ra rh r )r� rg rf rg rh r� )'r� r� r� r� r� �PAT_PSEUDO_CLOSEr� �PAT_PSEUDO_CONTAINS�PAT_PSEUDO_NTH_CHILD�PAT_PSEUDO_NTH_TYPE�PAT_PSEUDO_LANG�PAT_PSEUDO_DIR�PAT_PSEUDO_CLASS_CUSTOM�PAT_PSEUDO_CLASS�PAT_PSEUDO_ELEMENT�PAT_AMP� PAT_AT_RULE�PAT_ID� PAT_CLASS�PAT_TAG�PAT_ATTR� PAT_COMBINEr� r� r r r rA r[ r$ rf rj rl rw ry r~ r; r� ro rq rq rq rr rn � s^ � ��� � F f A + 0 � 8)rn zhtml|*:is(a, area)[href]r z\ html|*:is(input[type=checkbox], input[type=radio])[checked], html|option[selected] z� :checked, /* This pattern must be at the end. Special logic is applied to the last selector. */ html|form html|*:is(button, input)[type="submit"] aF html|input[type="checkbox"][indeterminate], html|input[type="radio"]:is(:not([name]), [name=""]):not([checked]), html|progress:not([value]), /* This pattern must be at the end. Special logic is applied to the last selector. */ html|input[type="radio"][name]:not([name='']):not([checked]) a� html|*:is(input:not([type=hidden]), button, select, textarea, fieldset, optgroup, option, fieldset)[disabled], html|optgroup[disabled] > html|option, html|fieldset[disabled] > html|*:is(input:not([type=hidden]), button, select, textarea, fieldset), html|fieldset[disabled] > html|*:not(legend:nth-of-type(1)) html|*:is(input:not([type=hidden]), button, select, textarea, fieldset) z| html|*:is(input:not([type=hidden]), button, select, textarea, fieldset, optgroup, option, fieldset):not(:disabled) z,html|*:is(input, textarea, select)[required]z2html|*:is(input, textarea, select):not([required])aW html|input:is( :not([type]), [type=""], [type=text], [type=search], [type=url], [type=tel], [type=email], [type=password], [type=number] )[placeholder]:not([placeholder='']):is(:not([value]), [value=""]), html|textarea[placeholder]:not([placeholder='']) z*|*a html|*:is( textarea, input:is( :not([type]), [type=""], [type=text], [type=search], [type=url], [type=tel], [type=email], [type=number], [type=password], [type=date], [type=datetime-local], [type=month], [type=time], [type=week] ) ):not([readonly], :disabled), html|*:is([contenteditable=""], [contenteditable="true" i]) z! html|*:not(:read-write) z� html|input:is( [type="date"], [type="month"], [type="week"], [type="time"], [type="datetime-local"], [type="number"], [type="range"] ):is( [min], [max] ) z* html|*:is(details, dialog)[open] z( html|*:is(video, audio)[muted] ) r` ra rb rc rd re rf rg rh ri )rh rt )rd re rh rw )F)r� ra r� r� rh ra )r� ra rh ra )hr� � __future__r r� � functoolsr r� r r rl r r� r ro �typingr r r r r� r% r= r# r: �PSEUDO_SPECIALr> �NEWLINE�WS�COMMENTS�WSC� CSS_ESCAPES�CSS_STRING_ESCAPES� IDENTIFIER�NTH�VALUE�ATTRr� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� rP r� rr r r� r� rz rd rc r r\ r] r� r� r� r< r� r� r� r^ � _MAXCACHErs rv rk r} r� r� r� r� rn ro r* r+ r, r- r. r/ r0 r3 r8 rR r5 r4 r6 r7 r2 r1 rq rq rq rr �<module> sz ��$ ������������(( " %D `����� � � ��� ������� �������� �� ���� � __pycache__/pretty.cpython-310.pyc 0000644 00000007203 15030227305 0013003 0 ustar 00 o �h� � @ s� d Z ddlmZ ddlZddlmZ e�d�Ze�d�Ze�d�Z e�d�Z e�d �Z e�d �Z e�d �Z e�d �Ze�d �Ze�d�Ze�d�Ze�d�Ze�d�Ze�d�Ze�d�Zeee e e e e eeeeeeeed�Zddd�ZdS ) a� Format a pretty string of a `SoupSieve` object for easy debugging. This won't necessarily support all types and such, and definitely not support custom outputs. It is mainly geared towards our types as the `SelectorList` object is a beast to look at without some indentation and newlines. The format and various output types is fairly known (though it hasn't been tested extensively to make sure we aren't missing corners). Example: ------- ``` >>> import soupsieve as sv >>> sv.compile('this > that.class[name=value]').selectors.pretty() SelectorList( selectors=( Selector( tag=SelectorTag( name='that', prefix=None), ids=(), classes=( 'class', ), attributes=( SelectorAttribute( attribute='name', prefix='', pattern=re.compile( '^value$'), xml_type_pattern=None), ), nth=(), selectors=(), relation=SelectorList( selectors=( Selector( tag=SelectorTag( name='this', prefix=None), ids=(), classes=(), attributes=(), nth=(), selectors=(), relation=SelectorList( selectors=(), is_not=False, is_html=False), rel_type='>', contains=(), lang=(), flags=0), ), is_not=False, is_html=False), rel_type=None, contains=(), lang=(), flags=0), ), is_not=False, is_html=False) ``` � )� annotationsN)�Anyz(?i)[a-z_][_a-z\d\.]+\(z(?i)[_a-z][_a-z\d]+=z\(\)|\[\]|\{\}z\[z\{z\(z\]z\}z\)z\d+z(?i)[_a-z][_a-z\d]+z"(?:\\.|[^"\\])*"z'(?:\\.|[^'\\])*'z \s*(,)\s*z \s*(:)\s*)�class�param�empty�lstrt�dstrt�tstrt�lend�dend�tend�sqstr�sep�dsep�int�kword�dqstr�objr �return�strc C s$ t | �}d}t|�d }d}g }||kr�d}t�� D ]n\}}|�||�}|r�|} |�d�}| dv rE|d7 }|�|�d�� dd| � �� nA| dv rR|�|�d�� n4| d v rc|d8 }|�|�d�� n#| d v rw|�|�d�� dd| � �� n| d v r�|�|�d�� d�� nq||ksd �|�S ) z%Make the object output string pretty.r � N)r r r r � � � )r r r r r r )r r r )r )r � ) r �len�TOKENS�items�match�end�append�group�join) r �sel�indexr �indent�output�m�k�v�name� r+ �C/usr/local/CyberCP/lib/python3.10/site-packages/soupsieve/pretty.py�prettyl s8 �� r- )r r r r )�__doc__� __future__r �re�typingr �compile�RE_CLASS�RE_PARAM�RE_EMPTY�RE_LSTRT�RE_DSTRT�RE_TSTRT�RE_LEND�RE_DEND�RE_TEND�RE_INT�RE_KWORD�RE_DQSTR�RE_SQSTR�RE_SEP�RE_DSEPr r- r+ r+ r+ r, �<module> sH D � pretty.py 0000644 00000007701 15030227305 0006447 0 ustar 00 """ Format a pretty string of a `SoupSieve` object for easy debugging. This won't necessarily support all types and such, and definitely not support custom outputs. It is mainly geared towards our types as the `SelectorList` object is a beast to look at without some indentation and newlines. The format and various output types is fairly known (though it hasn't been tested extensively to make sure we aren't missing corners). Example: ------- ``` >>> import soupsieve as sv >>> sv.compile('this > that.class[name=value]').selectors.pretty() SelectorList( selectors=( Selector( tag=SelectorTag( name='that', prefix=None), ids=(), classes=( 'class', ), attributes=( SelectorAttribute( attribute='name', prefix='', pattern=re.compile( '^value$'), xml_type_pattern=None), ), nth=(), selectors=(), relation=SelectorList( selectors=( Selector( tag=SelectorTag( name='this', prefix=None), ids=(), classes=(), attributes=(), nth=(), selectors=(), relation=SelectorList( selectors=(), is_not=False, is_html=False), rel_type='>', contains=(), lang=(), flags=0), ), is_not=False, is_html=False), rel_type=None, contains=(), lang=(), flags=0), ), is_not=False, is_html=False) ``` """ from __future__ import annotations import re from typing import Any RE_CLASS = re.compile(r'(?i)[a-z_][_a-z\d\.]+\(') RE_PARAM = re.compile(r'(?i)[_a-z][_a-z\d]+=') RE_EMPTY = re.compile(r'\(\)|\[\]|\{\}') RE_LSTRT = re.compile(r'\[') RE_DSTRT = re.compile(r'\{') RE_TSTRT = re.compile(r'\(') RE_LEND = re.compile(r'\]') RE_DEND = re.compile(r'\}') RE_TEND = re.compile(r'\)') RE_INT = re.compile(r'\d+') RE_KWORD = re.compile(r'(?i)[_a-z][_a-z\d]+') RE_DQSTR = re.compile(r'"(?:\\.|[^"\\])*"') RE_SQSTR = re.compile(r"'(?:\\.|[^'\\])*'") RE_SEP = re.compile(r'\s*(,)\s*') RE_DSEP = re.compile(r'\s*(:)\s*') TOKENS = { 'class': RE_CLASS, 'param': RE_PARAM, 'empty': RE_EMPTY, 'lstrt': RE_LSTRT, 'dstrt': RE_DSTRT, 'tstrt': RE_TSTRT, 'lend': RE_LEND, 'dend': RE_DEND, 'tend': RE_TEND, 'sqstr': RE_SQSTR, 'sep': RE_SEP, 'dsep': RE_DSEP, 'int': RE_INT, 'kword': RE_KWORD, 'dqstr': RE_DQSTR } def pretty(obj: Any) -> str: # pragma: no cover """Make the object output string pretty.""" sel = str(obj) index = 0 end = len(sel) - 1 indent = 0 output = [] while index <= end: m = None for k, v in TOKENS.items(): m = v.match(sel, index) if m: name = k index = m.end(0) if name in ('class', 'lstrt', 'dstrt', 'tstrt'): indent += 4 output.append(f'{m.group(0)}\n{" " * indent}') elif name in ('param', 'int', 'kword', 'sqstr', 'dqstr', 'empty'): output.append(m.group(0)) elif name in ('lend', 'dend', 'tend'): indent -= 4 output.append(m.group(0)) elif name in ('sep',): output.append(f'{m.group(1)}\n{" " * indent}') elif name in ('dsep',): output.append(f'{m.group(1)} ') break return ''.join(output) py.typed 0000644 00000000000 15030227305 0006226 0 ustar 00 util.py 0000644 00000006430 15030227305 0006073 0 ustar 00 """Utility.""" from __future__ import annotations from functools import wraps, lru_cache import warnings import re from typing import Callable, Any DEBUG = 0x00001 RE_PATTERN_LINE_SPLIT = re.compile(r'(?:\r\n|(?!\r\n)[\n\r])|$') UC_A = ord('A') UC_Z = ord('Z') @lru_cache(maxsize=512) def lower(string: str) -> str: """Lower.""" new_string = [] for c in string: o = ord(c) new_string.append(chr(o + 32) if UC_A <= o <= UC_Z else c) return ''.join(new_string) class SelectorSyntaxError(Exception): """Syntax error in a CSS selector.""" def __init__(self, msg: str, pattern: str | None = None, index: int | None = None) -> None: """Initialize.""" self.line = None self.col = None self.context = None if pattern is not None and index is not None: # Format pattern to show line and column position self.context, self.line, self.col = get_pattern_context(pattern, index) msg = f'{msg}\n line {self.line}:\n{self.context}' super().__init__(msg) def deprecated(message: str, stacklevel: int = 2) -> Callable[..., Any]: # pragma: no cover """ Raise a `DeprecationWarning` when wrapped function/method is called. Usage: @deprecated("This method will be removed in version X; use Y instead.") def some_method()" pass """ def _wrapper(func: Callable[..., Any]) -> Callable[..., Any]: @wraps(func) def _deprecated_func(*args: Any, **kwargs: Any) -> Any: warnings.warn( f"'{func.__name__}' is deprecated. {message}", category=DeprecationWarning, stacklevel=stacklevel ) return func(*args, **kwargs) return _deprecated_func return _wrapper def warn_deprecated(message: str, stacklevel: int = 2) -> None: # pragma: no cover """Warn deprecated.""" warnings.warn( message, category=DeprecationWarning, stacklevel=stacklevel ) def get_pattern_context(pattern: str, index: int) -> tuple[str, int, int]: """Get the pattern context.""" last = 0 current_line = 1 col = 1 text = [] # type: list[str] line = 1 offset = None # type: int | None # Split pattern by newline and handle the text before the newline for m in RE_PATTERN_LINE_SPLIT.finditer(pattern): linetext = pattern[last:m.start(0)] if not len(m.group(0)) and not len(text): indent = '' offset = -1 col = index - last + 1 elif last <= index < m.end(0): indent = '--> ' offset = (-1 if index > m.start(0) else 0) + 3 col = index - last + 1 else: indent = ' ' offset = None if len(text): # Regardless of whether we are presented with `\r\n`, `\r`, or `\n`, # we will render the output with just `\n`. We will still log the column # correctly though. text.append('\n') text.append(f'{indent}{linetext}') if offset is not None: text.append('\n') text.append(' ' * (col + offset) + '^') line = current_line current_line += 1 last = m.end(0) return ''.join(text), line, col css_match.py 0000644 00000166572 15030227305 0007100 0 ustar 00 """CSS matcher.""" from __future__ import annotations from datetime import datetime from . import util import re from . import css_types as ct import unicodedata import bs4 from typing import Iterator, Iterable, Any, Callable, Sequence, Any, cast # noqa: F401, F811 # Empty tag pattern (whitespace okay) RE_NOT_EMPTY = re.compile('[^ \t\r\n\f]') RE_NOT_WS = re.compile('[^ \t\r\n\f]+') # Relationships REL_PARENT = ' ' REL_CLOSE_PARENT = '>' REL_SIBLING = '~' REL_CLOSE_SIBLING = '+' # Relationships for :has() (forward looking) REL_HAS_PARENT = ': ' REL_HAS_CLOSE_PARENT = ':>' REL_HAS_SIBLING = ':~' REL_HAS_CLOSE_SIBLING = ':+' NS_XHTML = 'http://www.w3.org/1999/xhtml' NS_XML = 'http://www.w3.org/XML/1998/namespace' DIR_FLAGS = ct.SEL_DIR_LTR | ct.SEL_DIR_RTL RANGES = ct.SEL_IN_RANGE | ct.SEL_OUT_OF_RANGE DIR_MAP = { 'ltr': ct.SEL_DIR_LTR, 'rtl': ct.SEL_DIR_RTL, 'auto': 0 } RE_NUM = re.compile(r"^(?P<value>-?(?:[0-9]{1,}(\.[0-9]+)?|\.[0-9]+))$") RE_TIME = re.compile(r'^(?P<hour>[0-9]{2}):(?P<minutes>[0-9]{2})$') RE_MONTH = re.compile(r'^(?P<year>[0-9]{4,})-(?P<month>[0-9]{2})$') RE_WEEK = re.compile(r'^(?P<year>[0-9]{4,})-W(?P<week>[0-9]{2})$') RE_DATE = re.compile(r'^(?P<year>[0-9]{4,})-(?P<month>[0-9]{2})-(?P<day>[0-9]{2})$') RE_DATETIME = re.compile( r'^(?P<year>[0-9]{4,})-(?P<month>[0-9]{2})-(?P<day>[0-9]{2})T(?P<hour>[0-9]{2}):(?P<minutes>[0-9]{2})$' ) RE_WILD_STRIP = re.compile(r'(?:(?:-\*-)(?:\*(?:-|$))*|-\*$)') MONTHS_30 = (4, 6, 9, 11) # April, June, September, and November FEB = 2 SHORT_MONTH = 30 LONG_MONTH = 31 FEB_MONTH = 28 FEB_LEAP_MONTH = 29 DAYS_IN_WEEK = 7 class _FakeParent: """ Fake parent class. When we have a fragment with no `BeautifulSoup` document object, we can't evaluate `nth` selectors properly. Create a temporary fake parent so we can traverse the root element as a child. """ def __init__(self, element: bs4.Tag) -> None: """Initialize.""" self.contents = [element] def __len__(self) -> int: """Length.""" return len(self.contents) class _DocumentNav: """Navigate a Beautiful Soup document.""" @classmethod def assert_valid_input(cls, tag: Any) -> None: """Check if valid input tag or document.""" # Fail on unexpected types. if not cls.is_tag(tag): raise TypeError(f"Expected a BeautifulSoup 'Tag', but instead received type {type(tag)}") @staticmethod def is_doc(obj: bs4.element.PageElement | None) -> bool: """Is `BeautifulSoup` object.""" return isinstance(obj, bs4.BeautifulSoup) @staticmethod def is_tag(obj: bs4.element.PageElement | None) -> bool: """Is tag.""" return isinstance(obj, bs4.Tag) @staticmethod def is_declaration(obj: bs4.element.PageElement | None) -> bool: # pragma: no cover """Is declaration.""" return isinstance(obj, bs4.Declaration) @staticmethod def is_cdata(obj: bs4.element.PageElement | None) -> bool: """Is CDATA.""" return isinstance(obj, bs4.CData) @staticmethod def is_processing_instruction(obj: bs4.element.PageElement | None) -> bool: # pragma: no cover """Is processing instruction.""" return isinstance(obj, bs4.ProcessingInstruction) @staticmethod def is_navigable_string(obj: bs4.element.PageElement | None) -> bool: """Is navigable string.""" return isinstance(obj, bs4.element.NavigableString) @staticmethod def is_special_string(obj: bs4.element.PageElement | None) -> bool: """Is special string.""" return isinstance(obj, (bs4.Comment, bs4.Declaration, bs4.CData, bs4.ProcessingInstruction, bs4.Doctype)) @classmethod def is_content_string(cls, obj: bs4.element.PageElement | None) -> bool: """Check if node is content string.""" return cls.is_navigable_string(obj) and not cls.is_special_string(obj) @staticmethod def create_fake_parent(el: bs4.Tag) -> _FakeParent: """Create fake parent for a given element.""" return _FakeParent(el) @staticmethod def is_xml_tree(el: bs4.Tag | None) -> bool: """Check if element (or document) is from a XML tree.""" return el is not None and bool(el._is_xml) def is_iframe(self, el: bs4.Tag | None) -> bool: """Check if element is an `iframe`.""" if el is None: # pragma: no cover return False return bool( ((el.name if self.is_xml_tree(el) else util.lower(el.name)) == 'iframe') and self.is_html_tag(el) # type: ignore[attr-defined] ) def is_root(self, el: bs4.Tag) -> bool: """ 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`. """ root = self.root and self.root is el # type: ignore[attr-defined] if not root: parent = self.get_parent(el) root = parent is not None and self.is_html and self.is_iframe(parent) # type: ignore[attr-defined] return root def get_contents(self, el: bs4.Tag | None, no_iframe: bool = False) -> Iterator[bs4.element.PageElement]: """Get contents or contents in reverse.""" if el is not None: if not no_iframe or not self.is_iframe(el): yield from el.contents def get_tag_children( self, el: bs4.Tag | None, start: int | None = None, reverse: bool = False, no_iframe: bool = False ) -> Iterator[bs4.Tag]: """Get tag children.""" return self.get_children(el, start, reverse, True, no_iframe) # type: ignore[return-value] def get_children( self, el: bs4.Tag | None, start: int | None = None, reverse: bool = False, tags: bool = False, no_iframe: bool = False ) -> Iterator[bs4.element.PageElement]: """Get children.""" if el is not None and (not no_iframe or not self.is_iframe(el)): last = len(el.contents) - 1 if start is None: index = last if reverse else 0 else: index = start end = -1 if reverse else last + 1 incr = -1 if reverse else 1 if 0 <= index <= last: while index != end: node = el.contents[index] index += incr if not tags or self.is_tag(node): yield node def get_tag_descendants( self, el: bs4.Tag | None, no_iframe: bool = False ) -> Iterator[bs4.Tag]: """Specifically get tag descendants.""" yield from self.get_descendants(el, tags=True, no_iframe=no_iframe) # type: ignore[misc] def get_descendants( self, el: bs4.Tag | None, tags: bool = False, no_iframe: bool = False ) -> Iterator[bs4.element.PageElement]: """Get descendants.""" if el is not None and (not no_iframe or not self.is_iframe(el)): next_good = None for child in el.descendants: if next_good is not None: if child is not next_good: continue next_good = None if isinstance(child, bs4.Tag): if no_iframe and self.is_iframe(child): if child.next_sibling is not None: next_good = child.next_sibling else: last_child = child # type: bs4.element.PageElement while isinstance(last_child, bs4.Tag) and last_child.contents: last_child = last_child.contents[-1] next_good = last_child.next_element yield child if next_good is None: break # Coverage isn't seeing this even though it's executed continue # pragma: no cover yield child elif not tags: yield child def get_parent(self, el: bs4.Tag | None, no_iframe: bool = False) -> bs4.Tag | None: """Get parent.""" parent = el.parent if el is not None else None if no_iframe and parent is not None and self.is_iframe(parent): parent = None return parent @staticmethod def get_tag_name(el: bs4.Tag | None) -> str | None: """Get tag.""" return el.name if el is not None else None @staticmethod def get_prefix_name(el: bs4.Tag) -> str | None: """Get prefix.""" return el.prefix @staticmethod def get_uri(el: bs4.Tag | None) -> str | None: """Get namespace `URI`.""" return el.namespace if el is not None else None @classmethod def get_next_tag(cls, el: bs4.Tag) -> bs4.Tag | None: """Get next sibling tag.""" return cls.get_next(el, tags=True) # type: ignore[return-value] @classmethod def get_next(cls, el: bs4.Tag, tags: bool = False) -> bs4.element.PageElement | None: """Get next sibling tag.""" sibling = el.next_sibling while tags and not isinstance(sibling, bs4.Tag) and sibling is not None: sibling = sibling.next_sibling if tags and not isinstance(sibling, bs4.Tag): sibling = None return sibling @classmethod def get_previous_tag(cls, el: bs4.Tag, tags: bool = True) -> bs4.Tag | None: """Get previous sibling tag.""" return cls.get_previous(el, True) # type: ignore[return-value] @classmethod def get_previous(cls, el: bs4.Tag, tags: bool = False) -> bs4.element.PageElement | None: """Get previous sibling tag.""" sibling = el.previous_sibling while tags and not isinstance(sibling, bs4.Tag) and sibling is not None: sibling = sibling.previous_sibling if tags and not isinstance(sibling, bs4.Tag): sibling = None return sibling @staticmethod def has_html_ns(el: bs4.Tag | None) -> bool: """ 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`. """ ns = getattr(el, 'namespace') if el is not None else None # noqa: B009 return bool(ns and ns == NS_XHTML) @staticmethod def split_namespace(el: bs4.Tag | None, attr_name: str) -> tuple[str | None, str | None]: """Return namespace and attribute name without the prefix.""" if el is None: # pragma: no cover return None, None return getattr(attr_name, 'namespace', None), getattr(attr_name, 'name', None) @classmethod def normalize_value(cls, value: Any) -> str | Sequence[str]: """Normalize the value to be a string or list of strings.""" # Treat `None` as empty string. if value is None: return '' # Pass through strings if (isinstance(value, str)): return value # If it's a byte string, convert it to Unicode, treating it as UTF-8. if isinstance(value, bytes): return value.decode("utf8") # BeautifulSoup supports sequences of attribute values, so make sure the children are strings. if isinstance(value, Sequence): new_value = [] for v in value: if not isinstance(v, (str, bytes)) and isinstance(v, Sequence): # This is most certainly a user error and will crash and burn later. # To keep things working, we'll do what we do with all objects, # And convert them to strings. new_value.append(str(v)) else: # Convert the child to a string new_value.append(cast(str, cls.normalize_value(v))) return new_value # Try and make anything else a string return str(value) @classmethod def get_attribute_by_name( cls, el: bs4.Tag, name: str, default: str | Sequence[str] | None = None ) -> str | Sequence[str] | None: """Get attribute by name.""" value = default if el._is_xml: try: value = cls.normalize_value(el.attrs[name]) except KeyError: pass else: for k, v in el.attrs.items(): if util.lower(k) == name: value = cls.normalize_value(v) break return value @classmethod def iter_attributes(cls, el: bs4.Tag | None) -> Iterator[tuple[str, str | Sequence[str] | None]]: """Iterate attributes.""" if el is not None: for k, v in el.attrs.items(): yield k, cls.normalize_value(v) @classmethod def get_classes(cls, el: bs4.Tag) -> Sequence[str]: """Get classes.""" classes = cls.get_attribute_by_name(el, 'class', []) if isinstance(classes, str): classes = RE_NOT_WS.findall(classes) return cast(Sequence[str], classes) def get_text(self, el: bs4.Tag, no_iframe: bool = False) -> str: """Get text.""" return ''.join( [ node for node in self.get_descendants(el, no_iframe=no_iframe) # type: ignore[misc] if self.is_content_string(node) ] ) def get_own_text(self, el: bs4.Tag, no_iframe: bool = False) -> list[str]: """Get Own Text.""" return [ node for node in self.get_contents(el, no_iframe=no_iframe) if self.is_content_string(node) # type: ignore[misc] ] class Inputs: """Class for parsing and validating input items.""" @staticmethod def validate_day(year: int, month: int, day: int) -> bool: """Validate day.""" max_days = LONG_MONTH if month == FEB: max_days = FEB_LEAP_MONTH if ((year % 4 == 0) and (year % 100 != 0)) or (year % 400 == 0) else FEB_MONTH elif month in MONTHS_30: max_days = SHORT_MONTH return 1 <= day <= max_days @staticmethod def validate_week(year: int, week: int) -> bool: """Validate week.""" max_week = datetime.strptime(f"{12}-{31}-{year}", "%m-%d-%Y").isocalendar()[1] if max_week == 1: max_week = 53 return 1 <= week <= max_week @staticmethod def validate_month(month: int) -> bool: """Validate month.""" return 1 <= month <= 12 @staticmethod def validate_year(year: int) -> bool: """Validate year.""" return 1 <= year @staticmethod def validate_hour(hour: int) -> bool: """Validate hour.""" return 0 <= hour <= 23 @staticmethod def validate_minutes(minutes: int) -> bool: """Validate minutes.""" return 0 <= minutes <= 59 @classmethod def parse_value(cls, itype: str, value: str | None) -> tuple[float, ...] | None: """Parse the input value.""" parsed = None # type: tuple[float, ...] | None if value is None: return value if itype == "date": m = RE_DATE.match(value) if m: year = int(m.group('year'), 10) month = int(m.group('month'), 10) day = int(m.group('day'), 10) if cls.validate_year(year) and cls.validate_month(month) and cls.validate_day(year, month, day): parsed = (year, month, day) elif itype == "month": m = RE_MONTH.match(value) if m: year = int(m.group('year'), 10) month = int(m.group('month'), 10) if cls.validate_year(year) and cls.validate_month(month): parsed = (year, month) elif itype == "week": m = RE_WEEK.match(value) if m: year = int(m.group('year'), 10) week = int(m.group('week'), 10) if cls.validate_year(year) and cls.validate_week(year, week): parsed = (year, week) elif itype == "time": m = RE_TIME.match(value) if m: hour = int(m.group('hour'), 10) minutes = int(m.group('minutes'), 10) if cls.validate_hour(hour) and cls.validate_minutes(minutes): parsed = (hour, minutes) elif itype == "datetime-local": m = RE_DATETIME.match(value) if m: year = int(m.group('year'), 10) month = int(m.group('month'), 10) day = int(m.group('day'), 10) hour = int(m.group('hour'), 10) minutes = int(m.group('minutes'), 10) if ( cls.validate_year(year) and cls.validate_month(month) and cls.validate_day(year, month, day) and cls.validate_hour(hour) and cls.validate_minutes(minutes) ): parsed = (year, month, day, hour, minutes) elif itype in ("number", "range"): m = RE_NUM.match(value) if m: parsed = (float(m.group('value')),) return parsed class CSSMatch(_DocumentNav): """Perform CSS matching.""" def __init__( self, selectors: ct.SelectorList, scope: bs4.Tag | None, namespaces: ct.Namespaces | None, flags: int ) -> None: """Initialize.""" self.assert_valid_input(scope) self.tag = scope self.cached_meta_lang = [] # type: list[tuple[str, str]] self.cached_default_forms = [] # type: list[tuple[bs4.Tag, bs4.Tag]] self.cached_indeterminate_forms = [] # type: list[tuple[bs4.Tag, str, bool]] self.selectors = selectors self.namespaces = {} if namespaces is None else namespaces # type: ct.Namespaces | dict[str, str] self.flags = flags self.iframe_restrict = False # Find the root element for the whole tree doc = scope parent = self.get_parent(doc) while parent: doc = parent parent = self.get_parent(doc) root = None # type: bs4.Tag | None if not self.is_doc(doc): root = doc else: for child in self.get_tag_children(doc): root = child break self.root = root self.scope = scope if scope is not doc else root self.has_html_namespace = self.has_html_ns(root) # A document can be both XML and HTML (XHTML) self.is_xml = self.is_xml_tree(doc) self.is_html = not self.is_xml or self.has_html_namespace def supports_namespaces(self) -> bool: """Check if namespaces are supported in the HTML type.""" return self.is_xml or self.has_html_namespace def get_tag_ns(self, el: bs4.Tag | None) -> str: """Get tag namespace.""" namespace = '' if el is None: # pragma: no cover return namespace if self.supports_namespaces(): ns = self.get_uri(el) if ns: namespace = ns else: namespace = NS_XHTML return namespace def is_html_tag(self, el: bs4.Tag | None) -> bool: """Check if tag is in HTML namespace.""" return self.get_tag_ns(el) == NS_XHTML def get_tag(self, el: bs4.Tag | None) -> str | None: """Get tag.""" name = self.get_tag_name(el) return util.lower(name) if name is not None and not self.is_xml else name def get_prefix(self, el: bs4.Tag) -> str | None: """Get prefix.""" prefix = self.get_prefix_name(el) return util.lower(prefix) if prefix is not None and not self.is_xml else prefix def find_bidi(self, el: bs4.Tag) -> int | None: """Get directionality from element text.""" for node in self.get_children(el): # Analyze child text nodes if self.is_tag(node): # Avoid analyzing certain elements specified in the specification. direction = DIR_MAP.get(util.lower(self.get_attribute_by_name(node, 'dir', '')), None) # type: ignore[arg-type] name = self.get_tag(node) # type: ignore[arg-type] if ( (name and name in ('bdi', 'script', 'style', 'textarea', 'iframe')) or not self.is_html_tag(node) or # type: ignore[arg-type] direction is not None ): continue # pragma: no cover # Check directionality of this node's text value = self.find_bidi(node) # type: ignore[arg-type] if value is not None: return value # Direction could not be determined continue # pragma: no cover # Skip `doctype` comments, etc. if self.is_special_string(node): continue # Analyze text nodes for directionality. for c in node: # type: ignore[attr-defined] bidi = unicodedata.bidirectional(c) if bidi in ('AL', 'R', 'L'): return ct.SEL_DIR_LTR if bidi == 'L' else ct.SEL_DIR_RTL return None def extended_language_filter(self, lang_range: str, lang_tag: str) -> bool: """Filter the language tags.""" match = True lang_range = RE_WILD_STRIP.sub('-', lang_range).lower() ranges = lang_range.split('-') subtags = lang_tag.lower().split('-') length = len(ranges) slength = len(subtags) rindex = 0 sindex = 0 r = ranges[rindex] s = subtags[sindex] # Empty specified language should match unspecified language attributes if length == 1 and slength == 1 and not r and r == s: return True # Primary tag needs to match if (r != '*' and r != s) or (r == '*' and slength == 1 and not s): match = False rindex += 1 sindex += 1 # Match until we run out of ranges while match and rindex < length: r = ranges[rindex] try: s = subtags[sindex] except IndexError: # Ran out of subtags, # but we still have ranges match = False continue # Empty range if not r: match = False continue # Matched range elif s == r: rindex += 1 # Implicit wildcard cannot match # singletons elif len(s) == 1: match = False continue # Implicitly matched, so grab next subtag sindex += 1 return match def match_attribute_name( self, el: bs4.Tag, attr: str, prefix: str | None ) -> str | Sequence[str] | None: """Match attribute name and return value if it exists.""" value = None if self.supports_namespaces(): value = None # If we have not defined namespaces, we can't very well find them, so don't bother trying. if prefix: ns = self.namespaces.get(prefix) if ns is None and prefix != '*': return None else: ns = None for k, v in self.iter_attributes(el): # Get attribute parts namespace, name = self.split_namespace(el, k) # Can't match a prefix attribute as we haven't specified one to match # Try to match it normally as a whole `p:a` as selector may be trying `p\:a`. if ns is None: if (self.is_xml and attr == k) or (not self.is_xml and util.lower(attr) == util.lower(k)): value = v break # Coverage is not finding this even though it is executed. # Adding a print statement before this (and erasing coverage) causes coverage to find the line. # Ignore the false positive message. continue # pragma: no cover # We can't match our desired prefix attribute as the attribute doesn't have a prefix if namespace is None or (ns != namespace and prefix != '*'): continue # The attribute doesn't match. if (util.lower(attr) != util.lower(name)) if not self.is_xml else (attr != name): continue value = v break else: for k, v in self.iter_attributes(el): if util.lower(attr) != util.lower(k): continue value = v break return value def match_namespace(self, el: bs4.Tag, tag: ct.SelectorTag) -> bool: """Match the namespace of the element.""" match = True namespace = self.get_tag_ns(el) default_namespace = self.namespaces.get('') tag_ns = '' if tag.prefix is None else self.namespaces.get(tag.prefix) # We must match the default namespace if one is not provided if tag.prefix is None and (default_namespace is not None and namespace != default_namespace): match = False # If we specified `|tag`, we must not have a namespace. elif (tag.prefix is not None and tag.prefix == '' and namespace): match = False # Verify prefix matches elif ( tag.prefix and tag.prefix != '*' and (tag_ns is None or namespace != tag_ns) ): match = False return match def match_attributes(self, el: bs4.Tag, attributes: tuple[ct.SelectorAttribute, ...]) -> bool: """Match attributes.""" match = True if attributes: for a in attributes: temp = self.match_attribute_name(el, a.attribute, a.prefix) pattern = a.xml_type_pattern if self.is_xml and a.xml_type_pattern else a.pattern if temp is None: match = False break value = temp if isinstance(temp, str) else ' '.join(temp) if pattern is None: continue elif pattern.match(value) is None: match = False break return match def match_tagname(self, el: bs4.Tag, tag: ct.SelectorTag) -> bool: """Match tag name.""" name = (util.lower(tag.name) if not self.is_xml and tag.name is not None else tag.name) return not ( name is not None and name not in (self.get_tag(el), '*') ) def match_tag(self, el: bs4.Tag, tag: ct.SelectorTag | None) -> bool: """Match the tag.""" match = True if tag is not None: # Verify namespace if not self.match_namespace(el, tag): match = False if not self.match_tagname(el, tag): match = False return match def match_past_relations(self, el: bs4.Tag, relation: ct.SelectorList) -> bool: """Match past relationship.""" found = False # I don't think this can ever happen, but it makes `mypy` happy if isinstance(relation[0], ct.SelectorNull): # pragma: no cover return found if relation[0].rel_type == REL_PARENT: parent = self.get_parent(el, no_iframe=self.iframe_restrict) while not found and parent: found = self.match_selectors(parent, relation) parent = self.get_parent(parent, no_iframe=self.iframe_restrict) elif relation[0].rel_type == REL_CLOSE_PARENT: parent = self.get_parent(el, no_iframe=self.iframe_restrict) if parent: found = self.match_selectors(parent, relation) elif relation[0].rel_type == REL_SIBLING: sibling = self.get_previous_tag(el) while not found and sibling: found = self.match_selectors(sibling, relation) sibling = self.get_previous_tag(sibling) elif relation[0].rel_type == REL_CLOSE_SIBLING: sibling = self.get_previous_tag(el) if sibling and self.is_tag(sibling): found = self.match_selectors(sibling, relation) return found def match_future_child(self, parent: bs4.Tag, relation: ct.SelectorList, recursive: bool = False) -> bool: """Match future child.""" match = False if recursive: children = self.get_tag_descendants # type: Callable[..., Iterator[bs4.Tag]] else: children = self.get_tag_children for child in children(parent, no_iframe=self.iframe_restrict): match = self.match_selectors(child, relation) if match: break return match def match_future_relations(self, el: bs4.Tag, relation: ct.SelectorList) -> bool: """Match future relationship.""" found = False # I don't think this can ever happen, but it makes `mypy` happy if isinstance(relation[0], ct.SelectorNull): # pragma: no cover return found if relation[0].rel_type == REL_HAS_PARENT: found = self.match_future_child(el, relation, True) elif relation[0].rel_type == REL_HAS_CLOSE_PARENT: found = self.match_future_child(el, relation) elif relation[0].rel_type == REL_HAS_SIBLING: sibling = self.get_next_tag(el) while not found and sibling: found = self.match_selectors(sibling, relation) sibling = self.get_next_tag(sibling) elif relation[0].rel_type == REL_HAS_CLOSE_SIBLING: sibling = self.get_next_tag(el) if sibling and self.is_tag(sibling): found = self.match_selectors(sibling, relation) return found def match_relations(self, el: bs4.Tag, relation: ct.SelectorList) -> bool: """Match relationship to other elements.""" found = False if isinstance(relation[0], ct.SelectorNull) or relation[0].rel_type is None: return found if relation[0].rel_type.startswith(':'): found = self.match_future_relations(el, relation) else: found = self.match_past_relations(el, relation) return found def match_id(self, el: bs4.Tag, ids: tuple[str, ...]) -> bool: """Match element's ID.""" found = True for i in ids: if i != self.get_attribute_by_name(el, 'id', ''): found = False break return found def match_classes(self, el: bs4.Tag, classes: tuple[str, ...]) -> bool: """Match element's classes.""" current_classes = self.get_classes(el) found = True for c in classes: if c not in current_classes: found = False break return found def match_root(self, el: bs4.Tag) -> bool: """Match element as root.""" is_root = self.is_root(el) if is_root: sibling = self.get_previous(el) # type: Any while is_root and sibling is not None: if ( self.is_tag(sibling) or (self.is_content_string(sibling) and sibling.strip()) or self.is_cdata(sibling) ): is_root = False else: sibling = self.get_previous(sibling) if is_root: sibling = self.get_next(el) while is_root and sibling is not None: if ( self.is_tag(sibling) or (self.is_content_string(sibling) and sibling.strip()) or self.is_cdata(sibling) ): is_root = False else: sibling = self.get_next(sibling) return is_root def match_scope(self, el: bs4.Tag) -> bool: """Match element as scope.""" return self.scope is el def match_nth_tag_type(self, el: bs4.Tag, child: bs4.Tag) -> bool: """Match tag type for `nth` matches.""" return ( (self.get_tag(child) == self.get_tag(el)) and (self.get_tag_ns(child) == self.get_tag_ns(el)) ) def match_nth(self, el: bs4.Tag, nth: tuple[ct.SelectorNth, ...]) -> bool: """Match `nth` elements.""" matched = True for n in nth: matched = False if n.selectors and not self.match_selectors(el, n.selectors): break parent = self.get_parent(el) # type: bs4.Tag | None if parent is None: parent = cast('bs4.Tag', self.create_fake_parent(el)) last = n.last last_index = len(parent) - 1 index = last_index if last else 0 relative_index = 0 a = n.a b = n.b var = n.n count = 0 count_incr = 1 factor = -1 if last else 1 idx = last_idx = a * count + b if var else a # We can only adjust bounds within a variable index if var: # Abort if our nth index is out of bounds and only getting further out of bounds as we increment. # Otherwise, increment to try to get in bounds. adjust = None while idx < 1 or idx > last_index: if idx < 0: diff_low = 0 - idx if adjust is not None and adjust == 1: break adjust = -1 count += count_incr idx = last_idx = a * count + b if var else a diff = 0 - idx if diff >= diff_low: break else: diff_high = idx - last_index if adjust is not None and adjust == -1: break adjust = 1 count += count_incr idx = last_idx = a * count + b if var else a diff = idx - last_index if diff >= diff_high: break diff_high = diff # If a < 0, our count is working backwards, so floor the index by increasing the count. # Find the count that yields the lowest, in bound value and use that. # Lastly reverse count increment so that we'll increase our index. lowest = count if a < 0: while idx >= 1: lowest = count count += count_incr idx = last_idx = a * count + b if var else a count_incr = -1 count = lowest idx = last_idx = a * count + b if var else a # Evaluate elements while our calculated nth index is still in range while 1 <= idx <= last_index + 1: child = None # type: bs4.element.PageElement | None # Evaluate while our child index is still in range. for child in self.get_children(parent, start=index, reverse=factor < 0): index += factor if not isinstance(child, bs4.Tag): continue # Handle `of S` in `nth-child` if n.selectors and not self.match_selectors(child, n.selectors): continue # Handle `of-type` if n.of_type and not self.match_nth_tag_type(el, child): continue relative_index += 1 if relative_index == idx: if child is el: matched = True else: break if child is el: break if child is el: break last_idx = idx count += count_incr if count < 0: # Count is counting down and has now ventured into invalid territory. break idx = a * count + b if var else a if last_idx == idx: break if not matched: break return matched def match_empty(self, el: bs4.Tag) -> bool: """Check if element is empty (if requested).""" is_empty = True for child in self.get_children(el): if self.is_tag(child): is_empty = False break elif self.is_content_string(child) and RE_NOT_EMPTY.search(child): # type: ignore[call-overload] is_empty = False break return is_empty def match_subselectors(self, el: bs4.Tag, selectors: tuple[ct.SelectorList, ...]) -> bool: """Match selectors.""" match = True for sel in selectors: if not self.match_selectors(el, sel): match = False return match def match_contains(self, el: bs4.Tag, contains: tuple[ct.SelectorContains, ...]) -> bool: """Match element if it contains text.""" match = True content = None # type: str | Sequence[str] | None for contain_list in contains: if content is None: if contain_list.own: content = self.get_own_text(el, no_iframe=self.is_html) else: content = self.get_text(el, no_iframe=self.is_html) found = False for text in contain_list.text: if contain_list.own: for c in content: if text in c: found = True break if found: break else: if text in content: found = True break if not found: match = False return match def match_default(self, el: bs4.Tag) -> bool: """Match default.""" match = False # Find this input's form form = None # type: bs4.Tag | None parent = self.get_parent(el, no_iframe=True) while parent and form is None: if self.get_tag(parent) == 'form' and self.is_html_tag(parent): form = parent else: parent = self.get_parent(parent, no_iframe=True) if form is not None: # Look in form cache to see if we've already located its default button found_form = False for f, t in self.cached_default_forms: if f is form: found_form = True if t is el: match = True break # We didn't have the form cached, so look for its default button if not found_form: for child in self.get_tag_descendants(form, no_iframe=True): name = self.get_tag(child) # Can't do nested forms (haven't figured out why we never hit this) if name == 'form': # pragma: no cover break if name in ('input', 'button'): v = self.get_attribute_by_name(child, 'type', '') if v and util.lower(v) == 'submit': self.cached_default_forms.append((form, child)) if el is child: match = True break return match def match_indeterminate(self, el: bs4.Tag) -> bool: """Match default.""" match = False name = cast(str, self.get_attribute_by_name(el, 'name')) def get_parent_form(el: bs4.Tag) -> bs4.Tag | None: """Find this input's form.""" form = None parent = self.get_parent(el, no_iframe=True) while form is None: if self.get_tag(parent) == 'form' and self.is_html_tag(parent): form = parent break last_parent = parent parent = self.get_parent(parent, no_iframe=True) if parent is None: form = last_parent break return form form = get_parent_form(el) # Look in form cache to see if we've already evaluated that its fellow radio buttons are indeterminate if form is not None: found_form = False for f, n, i in self.cached_indeterminate_forms: if f is form and n == name: found_form = True if i is True: match = True break # We didn't have the form cached, so validate that the radio button is indeterminate if not found_form: checked = False for child in self.get_tag_descendants(form, no_iframe=True): if child is el: continue tag_name = self.get_tag(child) if tag_name == 'input': is_radio = False check = False has_name = False for k, v in self.iter_attributes(child): if util.lower(k) == 'type' and util.lower(v) == 'radio': is_radio = True elif util.lower(k) == 'name' and v == name: has_name = True elif util.lower(k) == 'checked': check = True if is_radio and check and has_name and get_parent_form(child) is form: checked = True break if checked: break if not checked: match = True self.cached_indeterminate_forms.append((form, name, match)) return match def match_lang(self, el: bs4.Tag, langs: tuple[ct.SelectorLang, ...]) -> bool: """Match languages.""" match = False has_ns = self.supports_namespaces() root = self.root has_html_namespace = self.has_html_namespace # Walk parents looking for `lang` (HTML) or `xml:lang` XML property. parent = el # type: bs4.Tag | None found_lang = None last = None while not found_lang: has_html_ns = self.has_html_ns(parent) for k, v in self.iter_attributes(parent): attr_ns, attr = self.split_namespace(parent, k) if ( ((not has_ns or has_html_ns) and (util.lower(k) if not self.is_xml else k) == 'lang') or ( has_ns and not has_html_ns and attr_ns == NS_XML and (util.lower(attr) if not self.is_xml and attr is not None else attr) == 'lang' ) ): found_lang = v break last = parent parent = self.get_parent(parent, no_iframe=self.is_html) if parent is None: root = last has_html_namespace = self.has_html_ns(root) parent = last break # Use cached meta language. if found_lang is None and self.cached_meta_lang: for cache in self.cached_meta_lang: if root is cache[0]: found_lang = cache[1] # If we couldn't find a language, and the document is HTML, look to meta to determine language. if found_lang is None and (not self.is_xml or (has_html_namespace and root and root.name == 'html')): # Find head found = False for tag in ('html', 'head'): found = False for child in self.get_tag_children(parent, no_iframe=self.is_html): if self.get_tag(child) == tag and self.is_html_tag(child): found = True parent = child break if not found: # pragma: no cover break # Search meta tags if found and parent is not None: for child2 in parent: if isinstance(child2, bs4.Tag) and self.get_tag(child2) == 'meta' and self.is_html_tag(parent): c_lang = False content = None for k, v in self.iter_attributes(child2): if util.lower(k) == 'http-equiv' and util.lower(v) == 'content-language': c_lang = True if util.lower(k) == 'content': content = v if c_lang and content: found_lang = content self.cached_meta_lang.append((cast(str, root), cast(str, found_lang))) break if found_lang is not None: break if found_lang is None: self.cached_meta_lang.append((cast(str, root), '')) # If we determined a language, compare. if found_lang is not None: for patterns in langs: match = False for pattern in patterns: if self.extended_language_filter(pattern, cast(str, found_lang)): match = True if not match: break return match def match_dir(self, el: bs4.Tag | None, directionality: int) -> bool: """Check directionality.""" # If we have to match both left and right, we can't match either. if directionality & ct.SEL_DIR_LTR and directionality & ct.SEL_DIR_RTL: return False if el is None or not self.is_html_tag(el): return False # Element has defined direction of left to right or right to left direction = DIR_MAP.get(util.lower(self.get_attribute_by_name(el, 'dir', '')), None) if direction not in (None, 0): return direction == directionality # Element is the document element (the root) and no direction assigned, assume left to right. is_root = self.is_root(el) if is_root and direction is None: return ct.SEL_DIR_LTR == directionality # If `input[type=telephone]` and no direction is assigned, assume left to right. name = self.get_tag(el) is_input = name == 'input' is_textarea = name == 'textarea' is_bdi = name == 'bdi' itype = util.lower(self.get_attribute_by_name(el, 'type', '')) if is_input else '' if is_input and itype == 'tel' and direction is None: return ct.SEL_DIR_LTR == directionality # Auto handling for text inputs if ((is_input and itype in ('text', 'search', 'tel', 'url', 'email')) or is_textarea) and direction == 0: if is_textarea: value = ''.join(node for node in self.get_contents(el, no_iframe=True) if self.is_content_string(node)) # type: ignore[misc] else: value = cast(str, self.get_attribute_by_name(el, 'value', '')) if value: for c in value: bidi = unicodedata.bidirectional(c) if bidi in ('AL', 'R', 'L'): direction = ct.SEL_DIR_LTR if bidi == 'L' else ct.SEL_DIR_RTL return direction == directionality # Assume left to right return ct.SEL_DIR_LTR == directionality elif is_root: return ct.SEL_DIR_LTR == directionality return self.match_dir(self.get_parent(el, no_iframe=True), directionality) # Auto handling for `bdi` and other non text inputs. if (is_bdi and direction is None) or direction == 0: direction = self.find_bidi(el) if direction is not None: return direction == directionality elif is_root: return ct.SEL_DIR_LTR == directionality return self.match_dir(self.get_parent(el, no_iframe=True), directionality) # Match parents direction return self.match_dir(self.get_parent(el, no_iframe=True), directionality) def match_range(self, el: bs4.Tag, condition: int) -> bool: """ Match range. Behavior is modeled after what we see in browsers. Browsers seem to evaluate if the value is out of range, and if not, it is in range. So a missing value will not evaluate out of range; therefore, value is in range. Personally, I feel like this should evaluate as neither in or out of range. """ out_of_range = False itype = util.lower(self.get_attribute_by_name(el, 'type')) mn = Inputs.parse_value(itype, cast(str, self.get_attribute_by_name(el, 'min', None))) mx = Inputs.parse_value(itype, cast(str, self.get_attribute_by_name(el, 'max', None))) # There is no valid min or max, so we cannot evaluate a range if mn is None and mx is None: return False value = Inputs.parse_value(itype, cast(str, self.get_attribute_by_name(el, 'value', None))) if value is not None: if itype in ("date", "datetime-local", "month", "week", "number", "range"): if mn is not None and value < mn: out_of_range = True if not out_of_range and mx is not None and value > mx: out_of_range = True elif itype == "time": if mn is not None and mx is not None and mn > mx: # Time is periodic, so this is a reversed/discontinuous range if value < mn and value > mx: out_of_range = True else: if mn is not None and value < mn: out_of_range = True if not out_of_range and mx is not None and value > mx: out_of_range = True return not out_of_range if condition & ct.SEL_IN_RANGE else out_of_range def match_defined(self, el: bs4.Tag) -> bool: """ Match defined. `:defined` is related to custom elements in a browser. - If the document is XML (not XHTML), all tags will match. - Tags that are not custom (don't have a hyphen) are marked defined. - If the tag has a prefix (without or without a namespace), it will not match. This is of course requires the parser to provide us with the proper prefix and namespace info, if it doesn't, there is nothing we can do. """ name = self.get_tag(el) return ( name is not None and ( name.find('-') == -1 or name.find(':') != -1 or self.get_prefix(el) is not None ) ) def match_placeholder_shown(self, el: bs4.Tag) -> bool: """ Match placeholder shown according to HTML spec. - text area should be checked if they have content. A single newline does not count as content. """ match = False content = self.get_text(el) if content in ('', '\n'): match = True return match def match_selectors(self, el: bs4.Tag, selectors: ct.SelectorList) -> bool: """Check if element matches one of the selectors.""" match = False is_not = selectors.is_not is_html = selectors.is_html # Internal selector lists that use the HTML flag, will automatically get the `html` namespace. if is_html: namespaces = self.namespaces iframe_restrict = self.iframe_restrict self.namespaces = {'html': NS_XHTML} self.iframe_restrict = True if not is_html or self.is_html: for selector in selectors: match = is_not # We have a un-matchable situation (like `:focus` as you can focus an element in this environment) if isinstance(selector, ct.SelectorNull): continue # Verify tag matches if not self.match_tag(el, selector.tag): continue # Verify tag is defined if selector.flags & ct.SEL_DEFINED and not self.match_defined(el): continue # Verify element is root if selector.flags & ct.SEL_ROOT and not self.match_root(el): continue # Verify element is scope if selector.flags & ct.SEL_SCOPE and not self.match_scope(el): continue # Verify element has placeholder shown if selector.flags & ct.SEL_PLACEHOLDER_SHOWN and not self.match_placeholder_shown(el): continue # Verify `nth` matches if not self.match_nth(el, selector.nth): continue if selector.flags & ct.SEL_EMPTY and not self.match_empty(el): continue # Verify id matches if selector.ids and not self.match_id(el, selector.ids): continue # Verify classes match if selector.classes and not self.match_classes(el, selector.classes): continue # Verify attribute(s) match if not self.match_attributes(el, selector.attributes): continue # Verify ranges if selector.flags & RANGES and not self.match_range(el, selector.flags & RANGES): continue # Verify language patterns if selector.lang and not self.match_lang(el, selector.lang): continue # Verify pseudo selector patterns if selector.selectors and not self.match_subselectors(el, selector.selectors): continue # Verify relationship selectors if selector.relation and not self.match_relations(el, selector.relation): continue # Validate that the current default selector match corresponds to the first submit button in the form if selector.flags & ct.SEL_DEFAULT and not self.match_default(el): continue # Validate that the unset radio button is among radio buttons with the same name in a form that are # also not set. if selector.flags & ct.SEL_INDETERMINATE and not self.match_indeterminate(el): continue # Validate element directionality if selector.flags & DIR_FLAGS and not self.match_dir(el, selector.flags & DIR_FLAGS): continue # Validate that the tag contains the specified text. if selector.contains and not self.match_contains(el, selector.contains): continue match = not is_not break # Restore actual namespaces being used for external selector lists if is_html: self.namespaces = namespaces self.iframe_restrict = iframe_restrict return match def select(self, limit: int = 0) -> Iterator[bs4.Tag]: """Match all tags under the targeted tag.""" lim = None if limit < 1 else limit for child in self.get_tag_descendants(self.tag): if self.match(child): yield child if lim is not None: lim -= 1 if lim < 1: break def closest(self) -> bs4.Tag | None: """Match closest ancestor.""" current = self.tag # type: bs4.Tag | None closest = None while closest is None and current is not None: if self.match(current): closest = current else: current = self.get_parent(current) return closest def filter(self) -> list[bs4.Tag]: # noqa A001 """Filter tag's children.""" return [ tag for tag in self.get_contents(self.tag) if isinstance(tag, bs4.Tag) and self.match(tag) ] def match(self, el: bs4.Tag) -> bool: """Match.""" return not self.is_doc(el) and self.is_tag(el) and self.match_selectors(el, self.selectors) class SoupSieve(ct.Immutable): """Compiled Soup Sieve selector matching object.""" pattern: str selectors: ct.SelectorList namespaces: ct.Namespaces | None custom: dict[str, str] flags: int __slots__ = ("pattern", "selectors", "namespaces", "custom", "flags", "_hash") def __init__( self, pattern: str, selectors: ct.SelectorList, namespaces: ct.Namespaces | None, custom: ct.CustomSelectors | None, flags: int ): """Initialize.""" super().__init__( pattern=pattern, selectors=selectors, namespaces=namespaces, custom=custom, flags=flags ) def match(self, tag: bs4.Tag) -> bool: """Match.""" return CSSMatch(self.selectors, tag, self.namespaces, self.flags).match(tag) def closest(self, tag: bs4.Tag) -> bs4.Tag | None: """Match closest ancestor.""" return CSSMatch(self.selectors, tag, self.namespaces, self.flags).closest() def filter(self, iterable: Iterable[bs4.Tag]) -> list[bs4.Tag]: # noqa A001 """ Filter. `CSSMatch` can cache certain searches for tags of the same document, so if we are given a tag, all tags are from the same document, and we can take advantage of the optimization. Any other kind of iterable could have tags from different documents or detached tags, so for those, we use a new `CSSMatch` for each item in the iterable. """ if isinstance(iterable, bs4.Tag): return CSSMatch(self.selectors, iterable, self.namespaces, self.flags).filter() else: return [node for node in iterable if not CSSMatch.is_navigable_string(node) and self.match(node)] def select_one(self, tag: bs4.Tag) -> bs4.Tag | None: """Select a single tag.""" tags = self.select(tag, limit=1) return tags[0] if tags else None def select(self, tag: bs4.Tag, limit: int = 0) -> list[bs4.Tag]: """Select the specified tags.""" return list(self.iselect(tag, limit)) def iselect(self, tag: bs4.Tag, limit: int = 0) -> Iterator[bs4.Tag]: """Iterate the specified tags.""" yield from CSSMatch(self.selectors, tag, self.namespaces, self.flags).select(limit) def __repr__(self) -> str: # pragma: no cover """Representation.""" return ( f"SoupSieve(pattern={self.pattern!r}, namespaces={self.namespaces!r}, " f"custom={self.custom!r}, flags={self.flags!r})" ) __str__ = __repr__ ct.pickle_register(SoupSieve) css_parser.py 0000644 00000134167 15030227305 0007273 0 ustar 00 """CSS selector parser.""" from __future__ import annotations import re from functools import lru_cache from . import util from . import css_match as cm from . import css_types as ct from .util import SelectorSyntaxError import warnings from typing import Match, Any, Iterator, cast UNICODE_REPLACEMENT_CHAR = 0xFFFD # Simple pseudo classes that take no parameters PSEUDO_SIMPLE = { ":any-link", ":empty", ":first-child", ":first-of-type", ":in-range", ":open", ":out-of-range", ":last-child", ":last-of-type", ":link", ":only-child", ":only-of-type", ":root", ':checked', ':default', ':disabled', ':enabled', ':indeterminate', ':optional', ':placeholder-shown', ':read-only', ':read-write', ':required', ':scope', ':defined', ':muted' } # Supported, simple pseudo classes that match nothing in the Soup Sieve environment PSEUDO_SIMPLE_NO_MATCH = { ':active', ':autofill', ':buffering', ':current', ':focus', ':focus-visible', ':focus-within', ':fullscreen', ':future', ':host', ':hover', ':local-link', ':past', ':paused', ':picture-in-picture', ':playing', ':popover-open', ':seeking', ':stalled', ':target', ':target-within', ':user-invalid', ':volume-locked', ':visited' } # Complex pseudo classes that take selector lists PSEUDO_COMPLEX = { ':contains', ':-soup-contains', ':-soup-contains-own', ':has', ':is', ':matches', ':not', ':where' } PSEUDO_COMPLEX_NO_MATCH = { ':current', ':host', ':host-context' } # Complex pseudo classes that take very specific parameters and are handled special PSEUDO_SPECIAL = { ':dir', ':lang', ':nth-child', ':nth-last-child', ':nth-last-of-type', ':nth-of-type' } PSEUDO_SUPPORTED = PSEUDO_SIMPLE | PSEUDO_SIMPLE_NO_MATCH | PSEUDO_COMPLEX | PSEUDO_COMPLEX_NO_MATCH | PSEUDO_SPECIAL # Sub-patterns parts # Whitespace NEWLINE = r'(?:\r\n|(?!\r\n)[\n\f\r])' WS = fr'(?:[ \t]|{NEWLINE})' # Comments COMMENTS = r'(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/)' # Whitespace with comments included WSC = fr'(?:{WS}|{COMMENTS})' # CSS escapes CSS_ESCAPES = fr'(?:\\(?:[a-f0-9]{{1,6}}{WS}?|[^\r\n\f]|$))' CSS_STRING_ESCAPES = fr'(?:\\(?:[a-f0-9]{{1,6}}{WS}?|[^\r\n\f]|$|{NEWLINE}))' # CSS Identifier IDENTIFIER = fr''' (?:(?:-?(?:[^\x00-\x2f\x30-\x40\x5B-\x5E\x60\x7B-\x9f]|{CSS_ESCAPES})+|--) (?:[^\x00-\x2c\x2e\x2f\x3A-\x40\x5B-\x5E\x60\x7B-\x9f]|{CSS_ESCAPES})*) ''' # `nth` content NTH = fr'(?:[-+])?(?:[0-9]+n?|n)(?:(?<=n){WSC}*(?:[-+]){WSC}*(?:[0-9]+))?' # Value: quoted string or identifier VALUE = fr'''(?:"(?:\\(?:.|{NEWLINE})|[^\\"\r\n\f]+)*?"|'(?:\\(?:.|{NEWLINE})|[^\\'\r\n\f]+)*?'|{IDENTIFIER}+)''' # Attribute value comparison. `!=` is handled special as it is non-standard. ATTR = fr'(?:{WSC}*(?P<cmp>[!~^|*$]?=){WSC}*(?P<value>{VALUE})(?:{WSC}*(?P<case>[is]))?)?{WSC}*\]' # Selector patterns # IDs (`#id`) PAT_ID = fr'\#{IDENTIFIER}' # Classes (`.class`) PAT_CLASS = fr'\.{IDENTIFIER}' # Prefix:Tag (`prefix|tag`) PAT_TAG = fr'(?P<tag_ns>(?:{IDENTIFIER}|\*)?\|)?(?P<tag_name>{IDENTIFIER}|\*)' # Attributes (`[attr]`, `[attr=value]`, etc.) PAT_ATTR = fr'\[{WSC}*(?P<attr_ns>(?:{IDENTIFIER}|\*)?\|)?(?P<attr_name>{IDENTIFIER}){ATTR}' # Pseudo class (`:pseudo-class`, `:pseudo-class(`) PAT_PSEUDO_CLASS = fr'(?P<name>:{IDENTIFIER})(?P<open>\({WSC}*)?' # Pseudo class special patterns. Matches `:pseudo-class(` for special case pseudo classes. PAT_PSEUDO_CLASS_SPECIAL = fr'(?P<name>:{IDENTIFIER})(?P<open>\({WSC}*)' # Custom pseudo class (`:--custom-pseudo`) PAT_PSEUDO_CLASS_CUSTOM = fr'(?P<name>:(?=--){IDENTIFIER})' # Nesting ampersand selector. Matches `&` PAT_AMP = r'&' # Closing pseudo group (`)`) PAT_PSEUDO_CLOSE = fr'{WSC}*\)' # Pseudo element (`::pseudo-element`) PAT_PSEUDO_ELEMENT = fr':{PAT_PSEUDO_CLASS}' # At rule (`@page`, etc.) (not supported) PAT_AT_RULE = fr'@P{IDENTIFIER}' # Pseudo class `nth-child` (`:nth-child(an+b [of S]?)`, `:first-child`, etc.) PAT_PSEUDO_NTH_CHILD = fr''' (?P<pseudo_nth_child>{PAT_PSEUDO_CLASS_SPECIAL} (?P<nth_child>{NTH}|even|odd))(?:{WSC}*\)|(?P<of>{COMMENTS}*{WS}{WSC}*of{COMMENTS}*{WS}{WSC}*)) ''' # Pseudo class `nth-of-type` (`:nth-of-type(an+b)`, `:first-of-type`, etc.) PAT_PSEUDO_NTH_TYPE = fr''' (?P<pseudo_nth_type>{PAT_PSEUDO_CLASS_SPECIAL} (?P<nth_type>{NTH}|even|odd)){WSC}*\) ''' # Pseudo class language (`:lang("*-de", en)`) PAT_PSEUDO_LANG = fr'{PAT_PSEUDO_CLASS_SPECIAL}(?P<values>{VALUE}(?:{WSC}*,{WSC}*{VALUE})*){WSC}*\)' # Pseudo class direction (`:dir(ltr)`) PAT_PSEUDO_DIR = fr'{PAT_PSEUDO_CLASS_SPECIAL}(?P<dir>ltr|rtl){WSC}*\)' # Combining characters (`>`, `~`, ` `, `+`, `,`) PAT_COMBINE = fr'{WSC}*?(?P<relation>[,+>~]|{WS}(?![,+>~])){WSC}*' # Extra: Contains (`:contains(text)`) PAT_PSEUDO_CONTAINS = fr'{PAT_PSEUDO_CLASS_SPECIAL}(?P<values>{VALUE}(?:{WSC}*,{WSC}*{VALUE})*){WSC}*\)' # Regular expressions # CSS escape pattern RE_CSS_ESC = re.compile(fr'(?:(\\[a-f0-9]{{1,6}}{WSC}?)|(\\[^\r\n\f])|(\\$))', re.I) RE_CSS_STR_ESC = re.compile(fr'(?:(\\[a-f0-9]{{1,6}}{WS}?)|(\\[^\r\n\f])|(\\$)|(\\{NEWLINE}))', re.I) # Pattern to break up `nth` specifiers RE_NTH = re.compile(fr'(?P<s1>[-+])?(?P<a>[0-9]+n?|n)(?:(?<=n){WSC}*(?P<s2>[-+]){WSC}*(?P<b>[0-9]+))?', re.I) # Pattern to iterate multiple values. RE_VALUES = re.compile(fr'(?:(?P<value>{VALUE})|(?P<split>{WSC}*,{WSC}*))', re.X) # Whitespace checks RE_WS = re.compile(WS) RE_WS_BEGIN = re.compile(fr'^{WSC}*') RE_WS_END = re.compile(fr'{WSC}*$') RE_CUSTOM = re.compile(fr'^{PAT_PSEUDO_CLASS_CUSTOM}$', re.X) # Constants # List split token COMMA_COMBINATOR = ',' # Relation token for descendant WS_COMBINATOR = " " # Parse flags FLG_PSEUDO = 0x01 FLG_NOT = 0x02 FLG_RELATIVE = 0x04 FLG_DEFAULT = 0x08 FLG_HTML = 0x10 FLG_INDETERMINATE = 0x20 FLG_OPEN = 0x40 FLG_IN_RANGE = 0x80 FLG_OUT_OF_RANGE = 0x100 FLG_PLACEHOLDER_SHOWN = 0x200 FLG_FORGIVE = 0x400 # Maximum cached patterns to store _MAXCACHE = 500 @lru_cache(maxsize=_MAXCACHE) def _cached_css_compile( pattern: str, namespaces: ct.Namespaces | None, custom: ct.CustomSelectors | None, flags: int ) -> cm.SoupSieve: """Cached CSS compile.""" custom_selectors = process_custom(custom) return cm.SoupSieve( pattern, CSSParser( pattern, custom=custom_selectors, flags=flags ).process_selectors(), namespaces, custom, flags ) def _purge_cache() -> None: """Purge the cache.""" _cached_css_compile.cache_clear() def process_custom(custom: ct.CustomSelectors | None) -> dict[str, str | ct.SelectorList]: """Process custom.""" custom_selectors = {} if custom is not None: for key, value in custom.items(): name = util.lower(key) if RE_CUSTOM.match(name) is None: raise SelectorSyntaxError(f"The name '{name}' is not a valid custom pseudo-class name") if name in custom_selectors: raise KeyError(f"The custom selector '{name}' has already been registered") custom_selectors[css_unescape(name)] = value return custom_selectors def css_unescape(content: str, string: bool = False) -> str: """ Unescape CSS value. Strings allow for spanning the value on multiple strings by escaping a new line. """ def replace(m: Match[str]) -> str: """Replace with the appropriate substitute.""" if m.group(1): codepoint = int(m.group(1)[1:], 16) if codepoint == 0: codepoint = UNICODE_REPLACEMENT_CHAR value = chr(codepoint) elif m.group(2): value = m.group(2)[1:] elif m.group(3): value = '\ufffd' else: value = '' return value return (RE_CSS_ESC if not string else RE_CSS_STR_ESC).sub(replace, content) def escape(ident: str) -> str: """Escape identifier.""" string = [] length = len(ident) start_dash = length > 0 and ident[0] == '-' if length == 1 and start_dash: # Need to escape identifier that is a single `-` with no other characters string.append(f'\\{ident}') else: for index, c in enumerate(ident): codepoint = ord(c) if codepoint == 0x00: string.append('\ufffd') elif (0x01 <= codepoint <= 0x1F) or codepoint == 0x7F: string.append(f'\\{codepoint:x} ') elif (index == 0 or (start_dash and index == 1)) and (0x30 <= codepoint <= 0x39): string.append(f'\\{codepoint:x} ') elif ( codepoint in (0x2D, 0x5F) or codepoint >= 0x80 or (0x30 <= codepoint <= 0x39) or (0x30 <= codepoint <= 0x39) or (0x41 <= codepoint <= 0x5A) or (0x61 <= codepoint <= 0x7A) ): string.append(c) else: string.append(f'\\{c}') return ''.join(string) class SelectorPattern: """Selector pattern.""" def __init__(self, name: str, pattern: str) -> None: """Initialize.""" self.name = name self.re_pattern = re.compile(pattern, re.I | re.X | re.U) def get_name(self) -> str: """Get name.""" return self.name def match(self, selector: str, index: int, flags: int) -> Match[str] | None: """Match the selector.""" return self.re_pattern.match(selector, index) class SpecialPseudoPattern(SelectorPattern): """Selector pattern.""" def __init__(self, patterns: tuple[tuple[str, tuple[str, ...], str, type[SelectorPattern]], ...]) -> None: """Initialize.""" self.patterns = {} for p in patterns: name = p[0] pattern = p[3](name, p[2]) for pseudo in p[1]: self.patterns[pseudo] = pattern self.matched_name = None # type: SelectorPattern | None self.re_pseudo_name = re.compile(PAT_PSEUDO_CLASS_SPECIAL, re.I | re.X | re.U) def get_name(self) -> str: """Get name.""" return '' if self.matched_name is None else self.matched_name.get_name() def match(self, selector: str, index: int, flags: int) -> Match[str] | None: """Match the selector.""" pseudo = None m = self.re_pseudo_name.match(selector, index) if m: name = util.lower(css_unescape(m.group('name'))) pattern = self.patterns.get(name) if pattern: pseudo = pattern.match(selector, index, flags) if pseudo: self.matched_name = pattern return pseudo class _Selector: """ Intermediate selector class. This stores selector data for a compound selector as we are acquiring them. Once we are done collecting the data for a compound selector, we freeze the data in an object that can be pickled and hashed. """ def __init__(self, **kwargs: Any) -> None: """Initialize.""" self.tag = kwargs.get('tag', None) # type: ct.SelectorTag | None self.ids = kwargs.get('ids', []) # type: list[str] self.classes = kwargs.get('classes', []) # type: list[str] self.attributes = kwargs.get('attributes', []) # type: list[ct.SelectorAttribute] self.nth = kwargs.get('nth', []) # type: list[ct.SelectorNth] self.selectors = kwargs.get('selectors', []) # type: list[ct.SelectorList] self.relations = kwargs.get('relations', []) # type: list[_Selector] self.rel_type = kwargs.get('rel_type', None) # type: str | None self.contains = kwargs.get('contains', []) # type: list[ct.SelectorContains] self.lang = kwargs.get('lang', []) # type: list[ct.SelectorLang] self.flags = kwargs.get('flags', 0) # type: int self.no_match = kwargs.get('no_match', False) # type: bool def _freeze_relations(self, relations: list[_Selector]) -> ct.SelectorList: """Freeze relation.""" if relations: sel = relations[0] sel.relations.extend(relations[1:]) return ct.SelectorList([sel.freeze()]) else: return ct.SelectorList() def freeze(self) -> ct.Selector | ct.SelectorNull: """Freeze self.""" if self.no_match: return ct.SelectorNull() else: return ct.Selector( self.tag, tuple(self.ids), tuple(self.classes), tuple(self.attributes), tuple(self.nth), tuple(self.selectors), self._freeze_relations(self.relations), self.rel_type, tuple(self.contains), tuple(self.lang), self.flags ) def __str__(self) -> str: # pragma: no cover """String representation.""" return ( f'_Selector(tag={self.tag!r}, ids={self.ids!r}, classes={self.classes!r}, attributes={self.attributes!r}, ' f'nth={self.nth!r}, selectors={self.selectors!r}, relations={self.relations!r}, ' f'rel_type={self.rel_type!r}, contains={self.contains!r}, lang={self.lang!r}, flags={self.flags!r}, ' f'no_match={self.no_match!r})' ) __repr__ = __str__ class CSSParser: """Parse CSS selectors.""" css_tokens = ( SelectorPattern("pseudo_close", PAT_PSEUDO_CLOSE), SpecialPseudoPattern( ( ( "pseudo_contains", (':contains', ':-soup-contains', ':-soup-contains-own'), PAT_PSEUDO_CONTAINS, SelectorPattern ), ("pseudo_nth_child", (':nth-child', ':nth-last-child'), PAT_PSEUDO_NTH_CHILD, SelectorPattern), ("pseudo_nth_type", (':nth-of-type', ':nth-last-of-type'), PAT_PSEUDO_NTH_TYPE, SelectorPattern), ("pseudo_lang", (':lang',), PAT_PSEUDO_LANG, SelectorPattern), ("pseudo_dir", (':dir',), PAT_PSEUDO_DIR, SelectorPattern) ) ), SelectorPattern("pseudo_class_custom", PAT_PSEUDO_CLASS_CUSTOM), SelectorPattern("pseudo_class", PAT_PSEUDO_CLASS), SelectorPattern("pseudo_element", PAT_PSEUDO_ELEMENT), SelectorPattern("amp", PAT_AMP), SelectorPattern("at_rule", PAT_AT_RULE), SelectorPattern("id", PAT_ID), SelectorPattern("class", PAT_CLASS), SelectorPattern("tag", PAT_TAG), SelectorPattern("attribute", PAT_ATTR), SelectorPattern("combine", PAT_COMBINE) ) def __init__( self, selector: str, custom: dict[str, str | ct.SelectorList] | None = None, flags: int = 0 ) -> None: """Initialize.""" self.pattern = selector.replace('\x00', '\ufffd') self.flags = flags self.debug = self.flags & util.DEBUG self.custom = {} if custom is None else custom def parse_attribute_selector(self, sel: _Selector, m: Match[str], has_selector: bool) -> bool: """Create attribute selector from the returned regex match.""" inverse = False op = m.group('cmp') case = util.lower(m.group('case')) if m.group('case') else None ns = css_unescape(m.group('attr_ns')[:-1]) if m.group('attr_ns') else '' attr = css_unescape(m.group('attr_name')) is_type = False pattern2 = None value = '' if case: flags = (re.I if case == 'i' else 0) | re.DOTALL elif util.lower(attr) == 'type': flags = re.I | re.DOTALL is_type = True else: flags = re.DOTALL if op: if m.group('value').startswith(('"', "'")): value = css_unescape(m.group('value')[1:-1], True) else: value = css_unescape(m.group('value')) if not op: # Attribute name pattern = None elif op.startswith('^'): # Value start with pattern = re.compile(r'^%s.*' % re.escape(value), flags) elif op.startswith('$'): # Value ends with pattern = re.compile(r'.*?%s$' % re.escape(value), flags) elif op.startswith('*'): # Value contains pattern = re.compile(r'.*?%s.*' % re.escape(value), flags) elif op.startswith('~'): # Value contains word within space separated list # `~=` should match nothing if it is empty or contains whitespace, # so if either of these cases is present, use `[^\s\S]` which cannot be matched. value = r'[^\s\S]' if not value or RE_WS.search(value) else re.escape(value) pattern = re.compile(r'.*?(?:(?<=^)|(?<=[ \t\r\n\f]))%s(?=(?:[ \t\r\n\f]|$)).*' % value, flags) elif op.startswith('|'): # Value starts with word in dash separated list pattern = re.compile(r'^%s(?:-.*)?$' % re.escape(value), flags) else: # Value matches pattern = re.compile(r'^%s$' % re.escape(value), flags) if op.startswith('!'): # Equivalent to `:not([attr=value])` inverse = True if is_type and pattern: pattern2 = re.compile(pattern.pattern) # Append the attribute selector sel_attr = ct.SelectorAttribute(attr, ns, pattern, pattern2) if inverse: # If we are using `!=`, we need to nest the pattern under a `:not()`. sub_sel = _Selector() sub_sel.attributes.append(sel_attr) not_list = ct.SelectorList([sub_sel.freeze()], True, False) sel.selectors.append(not_list) else: sel.attributes.append(sel_attr) has_selector = True return has_selector def parse_tag_pattern(self, sel: _Selector, m: Match[str], has_selector: bool) -> bool: """Parse tag pattern from regex match.""" prefix = css_unescape(m.group('tag_ns')[:-1]) if m.group('tag_ns') else None tag = css_unescape(m.group('tag_name')) sel.tag = ct.SelectorTag(tag, prefix) has_selector = True return has_selector def parse_pseudo_class_custom(self, sel: _Selector, m: Match[str], has_selector: bool) -> bool: """ 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. """ pseudo = util.lower(css_unescape(m.group('name'))) selector = self.custom.get(pseudo) if selector is None: raise SelectorSyntaxError( f"Undefined custom selector '{pseudo}' found at position {m.end(0)}", self.pattern, m.end(0) ) if not isinstance(selector, ct.SelectorList): del self.custom[pseudo] selector = CSSParser( selector, custom=self.custom, flags=self.flags ).process_selectors(flags=FLG_PSEUDO) self.custom[pseudo] = selector sel.selectors.append(selector) has_selector = True return has_selector def parse_pseudo_class( self, sel: _Selector, m: Match[str], has_selector: bool, iselector: Iterator[tuple[str, Match[str]]], is_html: bool ) -> tuple[bool, bool]: """Parse pseudo class.""" complex_pseudo = False pseudo = util.lower(css_unescape(m.group('name'))) if m.group('open'): complex_pseudo = True if complex_pseudo and pseudo in PSEUDO_COMPLEX: has_selector = self.parse_pseudo_open(sel, pseudo, has_selector, iselector, m.end(0)) elif not complex_pseudo and pseudo in PSEUDO_SIMPLE: if pseudo == ':root': sel.flags |= ct.SEL_ROOT elif pseudo == ':defined': sel.flags |= ct.SEL_DEFINED is_html = True elif pseudo == ':scope': sel.flags |= ct.SEL_SCOPE elif pseudo == ':empty': sel.flags |= ct.SEL_EMPTY elif pseudo in (':link', ':any-link'): sel.selectors.append(CSS_LINK) elif pseudo == ':checked': sel.selectors.append(CSS_CHECKED) elif pseudo == ':default': sel.selectors.append(CSS_DEFAULT) elif pseudo == ':indeterminate': sel.selectors.append(CSS_INDETERMINATE) elif pseudo == ":disabled": sel.selectors.append(CSS_DISABLED) elif pseudo == ":enabled": sel.selectors.append(CSS_ENABLED) elif pseudo == ":required": sel.selectors.append(CSS_REQUIRED) elif pseudo == ":muted": sel.selectors.append(CSS_MUTED) elif pseudo == ":open": sel.selectors.append(CSS_OPEN) elif pseudo == ":optional": sel.selectors.append(CSS_OPTIONAL) elif pseudo == ":read-only": sel.selectors.append(CSS_READ_ONLY) elif pseudo == ":read-write": sel.selectors.append(CSS_READ_WRITE) elif pseudo == ":in-range": sel.selectors.append(CSS_IN_RANGE) elif pseudo == ":out-of-range": sel.selectors.append(CSS_OUT_OF_RANGE) elif pseudo == ":placeholder-shown": sel.selectors.append(CSS_PLACEHOLDER_SHOWN) elif pseudo == ':first-child': sel.nth.append(ct.SelectorNth(1, False, 0, False, False, ct.SelectorList())) elif pseudo == ':last-child': sel.nth.append(ct.SelectorNth(1, False, 0, False, True, ct.SelectorList())) elif pseudo == ':first-of-type': sel.nth.append(ct.SelectorNth(1, False, 0, True, False, ct.SelectorList())) elif pseudo == ':last-of-type': sel.nth.append(ct.SelectorNth(1, False, 0, True, True, ct.SelectorList())) elif pseudo == ':only-child': sel.nth.extend( [ ct.SelectorNth(1, False, 0, False, False, ct.SelectorList()), ct.SelectorNth(1, False, 0, False, True, ct.SelectorList()) ] ) elif pseudo == ':only-of-type': sel.nth.extend( [ ct.SelectorNth(1, False, 0, True, False, ct.SelectorList()), ct.SelectorNth(1, False, 0, True, True, ct.SelectorList()) ] ) has_selector = True elif complex_pseudo and pseudo in PSEUDO_COMPLEX_NO_MATCH: self.parse_selectors(iselector, m.end(0), FLG_PSEUDO | FLG_OPEN) sel.no_match = True has_selector = True elif not complex_pseudo and pseudo in PSEUDO_SIMPLE_NO_MATCH: sel.no_match = True has_selector = True elif pseudo in PSEUDO_SUPPORTED: raise SelectorSyntaxError( f"Invalid syntax for pseudo class '{pseudo}'", self.pattern, m.start(0) ) else: raise SelectorSyntaxError( f"'{pseudo}' was detected as a pseudo-class and is either unsupported or invalid. " "If the syntax was not intended to be recognized as a pseudo-class, please escape the colon.", self.pattern, m.start(0) ) return has_selector, is_html def parse_pseudo_nth( self, sel: _Selector, m: Match[str], has_selector: bool, iselector: Iterator[tuple[str, Match[str]]] ) -> bool: """Parse `nth` pseudo.""" mdict = m.groupdict() if mdict.get('pseudo_nth_child'): postfix = '_child' else: postfix = '_type' mdict['name'] = util.lower(css_unescape(mdict['name'])) content = util.lower(mdict.get('nth' + postfix)) if content == 'even': # 2n s1 = 2 s2 = 0 var = True elif content == 'odd': # 2n+1 s1 = 2 s2 = 1 var = True else: nth_parts = cast(Match[str], RE_NTH.match(content)) _s1 = '-' if nth_parts.group('s1') and nth_parts.group('s1') == '-' else '' a = nth_parts.group('a') var = a.endswith('n') if a.startswith('n'): _s1 += '1' elif var: _s1 += a[:-1] else: _s1 += a _s2 = '-' if nth_parts.group('s2') and nth_parts.group('s2') == '-' else '' if nth_parts.group('b'): _s2 += nth_parts.group('b') else: _s2 = '0' s1 = int(_s1, 10) s2 = int(_s2, 10) pseudo_sel = mdict['name'] if postfix == '_child': if m.group('of'): # Parse the rest of `of S`. nth_sel = self.parse_selectors(iselector, m.end(0), FLG_PSEUDO | FLG_OPEN) else: # Use default `*|*` for `of S`. nth_sel = CSS_NTH_OF_S_DEFAULT if pseudo_sel == ':nth-child': sel.nth.append(ct.SelectorNth(s1, var, s2, False, False, nth_sel)) elif pseudo_sel == ':nth-last-child': sel.nth.append(ct.SelectorNth(s1, var, s2, False, True, nth_sel)) else: if pseudo_sel == ':nth-of-type': sel.nth.append(ct.SelectorNth(s1, var, s2, True, False, ct.SelectorList())) elif pseudo_sel == ':nth-last-of-type': sel.nth.append(ct.SelectorNth(s1, var, s2, True, True, ct.SelectorList())) has_selector = True return has_selector def parse_pseudo_open( self, sel: _Selector, name: str, has_selector: bool, iselector: Iterator[tuple[str, Match[str]]], index: int ) -> bool: """Parse pseudo with opening bracket.""" flags = FLG_PSEUDO | FLG_OPEN if name == ':not': flags |= FLG_NOT elif name == ':has': flags |= FLG_RELATIVE elif name in (':where', ':is'): flags |= FLG_FORGIVE sel.selectors.append(self.parse_selectors(iselector, index, flags)) has_selector = True return has_selector def parse_has_combinator( self, sel: _Selector, m: Match[str], has_selector: bool, selectors: list[_Selector], rel_type: str, index: int ) -> tuple[bool, _Selector, str]: """Parse combinator tokens.""" combinator = m.group('relation').strip() if not combinator: combinator = WS_COMBINATOR if combinator == COMMA_COMBINATOR: sel.rel_type = rel_type selectors[-1].relations.append(sel) rel_type = ":" + WS_COMBINATOR selectors.append(_Selector()) else: if has_selector: # End the current selector and associate the leading combinator with this selector. sel.rel_type = rel_type selectors[-1].relations.append(sel) elif rel_type[1:] != WS_COMBINATOR: # It's impossible to have two whitespace combinators after each other as the patterns # will gobble up trailing whitespace. It is also impossible to have a whitespace # combinator after any other kind for the same reason. But we could have # multiple non-whitespace combinators. So if the current combinator is not a whitespace, # then we've hit the multiple combinator case, so we should fail. raise SelectorSyntaxError( f'The multiple combinators at position {index}', self.pattern, index ) # Set the leading combinator for the next selector. rel_type = ':' + combinator sel = _Selector() has_selector = False return has_selector, sel, rel_type def parse_combinator( self, sel: _Selector, m: Match[str], has_selector: bool, selectors: list[_Selector], relations: list[_Selector], is_pseudo: bool, is_forgive: bool, index: int ) -> tuple[bool, _Selector]: """Parse combinator tokens.""" combinator = m.group('relation').strip() if not combinator: combinator = WS_COMBINATOR if not has_selector: if not is_forgive or combinator != COMMA_COMBINATOR: raise SelectorSyntaxError( f"The combinator '{combinator}' at position {index}, must have a selector before it", self.pattern, index ) # If we are in a forgiving pseudo class, just make the selector a "no match" if combinator == COMMA_COMBINATOR: sel.no_match = True del relations[:] selectors.append(sel) else: if combinator == COMMA_COMBINATOR: if not sel.tag and not is_pseudo: # Implied `*` sel.tag = ct.SelectorTag('*', None) sel.relations.extend(relations) selectors.append(sel) del relations[:] else: sel.relations.extend(relations) sel.rel_type = combinator del relations[:] relations.append(sel) sel = _Selector() has_selector = False return has_selector, sel def parse_class_id(self, sel: _Selector, m: Match[str], has_selector: bool) -> bool: """Parse HTML classes and ids.""" selector = m.group(0) if selector.startswith('.'): sel.classes.append(css_unescape(selector[1:])) else: sel.ids.append(css_unescape(selector[1:])) has_selector = True return has_selector def parse_pseudo_contains(self, sel: _Selector, m: Match[str], has_selector: bool) -> bool: """Parse contains.""" pseudo = util.lower(css_unescape(m.group('name'))) if pseudo == ":contains": warnings.warn( # noqa: B028 "The pseudo class ':contains' is deprecated, ':-soup-contains' should be used moving forward.", FutureWarning ) contains_own = pseudo == ":-soup-contains-own" values = css_unescape(m.group('values')) patterns = [] for token in RE_VALUES.finditer(values): if token.group('split'): continue value = token.group('value') if value.startswith(("'", '"')): value = css_unescape(value[1:-1], True) else: value = css_unescape(value) patterns.append(value) sel.contains.append(ct.SelectorContains(patterns, contains_own)) has_selector = True return has_selector def parse_pseudo_lang(self, sel: _Selector, m: Match[str], has_selector: bool) -> bool: """Parse pseudo language.""" values = m.group('values') patterns = [] for token in RE_VALUES.finditer(values): if token.group('split'): continue value = token.group('value') if value.startswith(('"', "'")): value = css_unescape(value[1:-1], True) else: value = css_unescape(value) patterns.append(value) sel.lang.append(ct.SelectorLang(patterns)) has_selector = True return has_selector def parse_pseudo_dir(self, sel: _Selector, m: Match[str], has_selector: bool) -> bool: """Parse pseudo direction.""" value = ct.SEL_DIR_LTR if util.lower(m.group('dir')) == 'ltr' else ct.SEL_DIR_RTL sel.flags |= value has_selector = True return has_selector def parse_selectors( self, iselector: Iterator[tuple[str, Match[str]]], index: int = 0, flags: int = 0 ) -> ct.SelectorList: """Parse selectors.""" # Initialize important variables sel = _Selector() selectors = [] has_selector = False closed = False relations = [] # type: list[_Selector] rel_type = ":" + WS_COMBINATOR # Setup various flags is_open = bool(flags & FLG_OPEN) is_pseudo = bool(flags & FLG_PSEUDO) is_relative = bool(flags & FLG_RELATIVE) is_not = bool(flags & FLG_NOT) is_html = bool(flags & FLG_HTML) is_default = bool(flags & FLG_DEFAULT) is_indeterminate = bool(flags & FLG_INDETERMINATE) is_in_range = bool(flags & FLG_IN_RANGE) is_out_of_range = bool(flags & FLG_OUT_OF_RANGE) is_placeholder_shown = bool(flags & FLG_PLACEHOLDER_SHOWN) is_forgive = bool(flags & FLG_FORGIVE) # Print out useful debug stuff if self.debug: # pragma: no cover if is_pseudo: print(' is_pseudo: True') if is_open: print(' is_open: True') if is_relative: print(' is_relative: True') if is_not: print(' is_not: True') if is_html: print(' is_html: True') if is_default: print(' is_default: True') if is_indeterminate: print(' is_indeterminate: True') if is_in_range: print(' is_in_range: True') if is_out_of_range: print(' is_out_of_range: True') if is_placeholder_shown: print(' is_placeholder_shown: True') if is_forgive: print(' is_forgive: True') # The algorithm for relative selectors require an initial selector in the selector list if is_relative: selectors.append(_Selector()) try: while True: key, m = next(iselector) # Handle parts if key == "at_rule": raise NotImplementedError(f"At-rules found at position {m.start(0)}") elif key == "amp": sel.flags |= ct.SEL_SCOPE has_selector = True elif key == 'pseudo_class_custom': has_selector = self.parse_pseudo_class_custom(sel, m, has_selector) elif key == 'pseudo_class': has_selector, is_html = self.parse_pseudo_class(sel, m, has_selector, iselector, is_html) elif key == 'pseudo_element': raise NotImplementedError(f"Pseudo-element found at position {m.start(0)}") elif key == 'pseudo_contains': has_selector = self.parse_pseudo_contains(sel, m, has_selector) elif key in ('pseudo_nth_type', 'pseudo_nth_child'): has_selector = self.parse_pseudo_nth(sel, m, has_selector, iselector) elif key == 'pseudo_lang': has_selector = self.parse_pseudo_lang(sel, m, has_selector) elif key == 'pseudo_dir': has_selector = self.parse_pseudo_dir(sel, m, has_selector) # Currently only supports HTML is_html = True elif key == 'pseudo_close': if not has_selector: if not is_forgive: raise SelectorSyntaxError( f"Expected a selector at position {m.start(0)}", self.pattern, m.start(0) ) sel.no_match = True if is_open: closed = True break else: raise SelectorSyntaxError( f"Unmatched pseudo-class close at position {m.start(0)}", self.pattern, m.start(0) ) elif key == 'combine': if is_relative: has_selector, sel, rel_type = self.parse_has_combinator( sel, m, has_selector, selectors, rel_type, index ) else: has_selector, sel = self.parse_combinator( sel, m, has_selector, selectors, relations, is_pseudo, is_forgive, index ) elif key == 'attribute': has_selector = self.parse_attribute_selector(sel, m, has_selector) elif key == 'tag': if has_selector: raise SelectorSyntaxError( f"Tag name found at position {m.start(0)} instead of at the start", self.pattern, m.start(0) ) has_selector = self.parse_tag_pattern(sel, m, has_selector) elif key in ('class', 'id'): has_selector = self.parse_class_id(sel, m, has_selector) index = m.end(0) except StopIteration: pass # Handle selectors that are not closed if is_open and not closed: raise SelectorSyntaxError( f"Unclosed pseudo-class at position {index}", self.pattern, index ) # Cleanup completed selector piece if has_selector: if not sel.tag and not is_pseudo: # Implied `*` sel.tag = ct.SelectorTag('*', None) if is_relative: sel.rel_type = rel_type selectors[-1].relations.append(sel) else: sel.relations.extend(relations) del relations[:] selectors.append(sel) # Forgive empty slots in pseudo-classes that have lists (and are forgiving) elif is_forgive and (not selectors or not relations): # Handle normal pseudo-classes with empty slots like `:is()` etc. sel.no_match = True del relations[:] selectors.append(sel) has_selector = True if not has_selector: # We will always need to finish a selector when `:has()` is used as it leads with combining. # May apply to others as well. raise SelectorSyntaxError( f'Expected a selector at position {index}', self.pattern, index ) # Some patterns require additional logic, such as default. We try to make these the # last pattern, and append the appropriate flag to that selector which communicates # to the matcher what additional logic is required. if is_default: selectors[-1].flags = ct.SEL_DEFAULT if is_indeterminate: selectors[-1].flags = ct.SEL_INDETERMINATE if is_in_range: selectors[-1].flags = ct.SEL_IN_RANGE if is_out_of_range: selectors[-1].flags = ct.SEL_OUT_OF_RANGE if is_placeholder_shown: selectors[-1].flags = ct.SEL_PLACEHOLDER_SHOWN # Return selector list return ct.SelectorList([s.freeze() for s in selectors], is_not, is_html) def selector_iter(self, pattern: str) -> Iterator[tuple[str, Match[str]]]: """Iterate selector tokens.""" # Ignore whitespace and comments at start and end of pattern m = RE_WS_BEGIN.search(pattern) index = m.end(0) if m else 0 m = RE_WS_END.search(pattern) end = (m.start(0) - 1) if m else (len(pattern) - 1) if self.debug: # pragma: no cover print(f'## PARSING: {pattern!r}') while index <= end: m = None for v in self.css_tokens: m = v.match(pattern, index, self.flags) if m: name = v.get_name() if self.debug: # pragma: no cover print(f"TOKEN: '{name}' --> {m.group(0)!r} at position {m.start(0)}") index = m.end(0) yield name, m break if m is None: c = pattern[index] # If the character represents the start of one of the known selector types, # throw an exception mentioning that the known selector type is in error; # otherwise, report the invalid character. if c == '[': msg = f"Malformed attribute selector at position {index}" elif c == '.': msg = f"Malformed class selector at position {index}" elif c == '#': msg = f"Malformed id selector at position {index}" elif c == ':': msg = f"Malformed pseudo-class selector at position {index}" else: msg = f"Invalid character {c!r} position {index}" raise SelectorSyntaxError(msg, self.pattern, index) if self.debug: # pragma: no cover print('## END PARSING') def process_selectors(self, index: int = 0, flags: int = 0) -> ct.SelectorList: """Process selectors.""" return self.parse_selectors(self.selector_iter(self.pattern), index, flags) # Precompile CSS selector lists for pseudo-classes (additional logic may be required beyond the pattern) # A few patterns are order dependent as they use patterns previous compiled. # CSS pattern for `:link` and `:any-link` CSS_LINK = CSSParser( 'html|*:is(a, area)[href]' ).process_selectors(flags=FLG_PSEUDO | FLG_HTML) # CSS pattern for `:checked` CSS_CHECKED = CSSParser( ''' html|*:is(input[type=checkbox], input[type=radio])[checked], html|option[selected] ''' ).process_selectors(flags=FLG_PSEUDO | FLG_HTML) # CSS pattern for `:default` (must compile CSS_CHECKED first) CSS_DEFAULT = CSSParser( ''' :checked, /* This pattern must be at the end. Special logic is applied to the last selector. */ html|form html|*:is(button, input)[type="submit"] ''' ).process_selectors(flags=FLG_PSEUDO | FLG_HTML | FLG_DEFAULT) # CSS pattern for `:indeterminate` CSS_INDETERMINATE = CSSParser( ''' html|input[type="checkbox"][indeterminate], html|input[type="radio"]:is(:not([name]), [name=""]):not([checked]), html|progress:not([value]), /* This pattern must be at the end. Special logic is applied to the last selector. */ html|input[type="radio"][name]:not([name='']):not([checked]) ''' ).process_selectors(flags=FLG_PSEUDO | FLG_HTML | FLG_INDETERMINATE) # CSS pattern for `:disabled` CSS_DISABLED = CSSParser( ''' html|*:is(input:not([type=hidden]), button, select, textarea, fieldset, optgroup, option, fieldset)[disabled], html|optgroup[disabled] > html|option, html|fieldset[disabled] > html|*:is(input:not([type=hidden]), button, select, textarea, fieldset), html|fieldset[disabled] > html|*:not(legend:nth-of-type(1)) html|*:is(input:not([type=hidden]), button, select, textarea, fieldset) ''' ).process_selectors(flags=FLG_PSEUDO | FLG_HTML) # CSS pattern for `:enabled` CSS_ENABLED = CSSParser( ''' html|*:is(input:not([type=hidden]), button, select, textarea, fieldset, optgroup, option, fieldset):not(:disabled) ''' ).process_selectors(flags=FLG_PSEUDO | FLG_HTML) # CSS pattern for `:required` CSS_REQUIRED = CSSParser( 'html|*:is(input, textarea, select)[required]' ).process_selectors(flags=FLG_PSEUDO | FLG_HTML) # CSS pattern for `:optional` CSS_OPTIONAL = CSSParser( 'html|*:is(input, textarea, select):not([required])' ).process_selectors(flags=FLG_PSEUDO | FLG_HTML) # CSS pattern for `:placeholder-shown` CSS_PLACEHOLDER_SHOWN = CSSParser( ''' html|input:is( :not([type]), [type=""], [type=text], [type=search], [type=url], [type=tel], [type=email], [type=password], [type=number] )[placeholder]:not([placeholder='']):is(:not([value]), [value=""]), html|textarea[placeholder]:not([placeholder='']) ''' ).process_selectors(flags=FLG_PSEUDO | FLG_HTML | FLG_PLACEHOLDER_SHOWN) # CSS pattern default for `:nth-child` "of S" feature CSS_NTH_OF_S_DEFAULT = CSSParser( '*|*' ).process_selectors(flags=FLG_PSEUDO) # CSS pattern for `:read-write` (CSS_DISABLED must be compiled first) CSS_READ_WRITE = CSSParser( ''' html|*:is( textarea, input:is( :not([type]), [type=""], [type=text], [type=search], [type=url], [type=tel], [type=email], [type=number], [type=password], [type=date], [type=datetime-local], [type=month], [type=time], [type=week] ) ):not([readonly], :disabled), html|*:is([contenteditable=""], [contenteditable="true" i]) ''' ).process_selectors(flags=FLG_PSEUDO | FLG_HTML) # CSS pattern for `:read-only` CSS_READ_ONLY = CSSParser( ''' html|*:not(:read-write) ''' ).process_selectors(flags=FLG_PSEUDO | FLG_HTML) # CSS pattern for `:in-range` CSS_IN_RANGE = CSSParser( ''' html|input:is( [type="date"], [type="month"], [type="week"], [type="time"], [type="datetime-local"], [type="number"], [type="range"] ):is( [min], [max] ) ''' ).process_selectors(flags=FLG_PSEUDO | FLG_IN_RANGE | FLG_HTML) # CSS pattern for `:out-of-range` CSS_OUT_OF_RANGE = CSSParser( ''' html|input:is( [type="date"], [type="month"], [type="week"], [type="time"], [type="datetime-local"], [type="number"], [type="range"] ):is( [min], [max] ) ''' ).process_selectors(flags=FLG_PSEUDO | FLG_OUT_OF_RANGE | FLG_HTML) # CSS pattern for :open CSS_OPEN = CSSParser( ''' html|*:is(details, dialog)[open] ''' ).process_selectors(flags=FLG_PSEUDO | FLG_HTML) # CSS pattern for :muted CSS_MUTED = CSSParser( ''' html|*:is(video, audio)[muted] ''' ).process_selectors(flags=FLG_PSEUDO | FLG_HTML) __init__.py 0000644 00000010745 15030227305 0006661 0 ustar 00 """ Soup Sieve. A CSS selector filter for BeautifulSoup4. MIT License Copyright (c) 2018 Isaac Muse Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. """ from __future__ import annotations from .__meta__ import __version__, __version_info__ # noqa: F401 from . import css_parser as cp from . import css_match as cm from . import css_types as ct from .util import DEBUG, SelectorSyntaxError # noqa: F401 import bs4 from typing import Any, Iterator, Iterable __all__ = ( 'DEBUG', 'SelectorSyntaxError', 'SoupSieve', 'closest', 'compile', 'filter', 'iselect', 'match', 'select', 'select_one' ) SoupSieve = cm.SoupSieve def compile( # noqa: A001 pattern: str, namespaces: dict[str, str] | None = None, flags: int = 0, *, custom: dict[str, str] | None = None, **kwargs: Any ) -> cm.SoupSieve: """Compile CSS pattern.""" if isinstance(pattern, SoupSieve): if flags: raise ValueError("Cannot process 'flags' argument on a compiled selector list") elif namespaces is not None: raise ValueError("Cannot process 'namespaces' argument on a compiled selector list") elif custom is not None: raise ValueError("Cannot process 'custom' argument on a compiled selector list") return pattern return cp._cached_css_compile( pattern, ct.Namespaces(namespaces) if namespaces is not None else namespaces, ct.CustomSelectors(custom) if custom is not None else custom, flags ) def purge() -> None: """Purge cached patterns.""" cp._purge_cache() def closest( select: str, tag: bs4.Tag, namespaces: dict[str, str] | None = None, flags: int = 0, *, custom: dict[str, str] | None = None, **kwargs: Any ) -> bs4.Tag | None: """Match closest ancestor.""" return compile(select, namespaces, flags, **kwargs).closest(tag) def match( select: str, tag: bs4.Tag, namespaces: dict[str, str] | None = None, flags: int = 0, *, custom: dict[str, str] | None = None, **kwargs: Any ) -> bool: """Match node.""" return compile(select, namespaces, flags, **kwargs).match(tag) def filter( # noqa: A001 select: str, iterable: Iterable[bs4.Tag], namespaces: dict[str, str] | None = None, flags: int = 0, *, custom: dict[str, str] | None = None, **kwargs: Any ) -> list[bs4.Tag]: """Filter list of nodes.""" return compile(select, namespaces, flags, **kwargs).filter(iterable) def select_one( select: str, tag: bs4.Tag, namespaces: dict[str, str] | None = None, flags: int = 0, *, custom: dict[str, str] | None = None, **kwargs: Any ) -> bs4.Tag | None: """Select a single tag.""" return compile(select, namespaces, flags, **kwargs).select_one(tag) def select( select: str, tag: bs4.Tag, namespaces: dict[str, str] | None = None, limit: int = 0, flags: int = 0, *, custom: dict[str, str] | None = None, **kwargs: Any ) -> list[bs4.Tag]: """Select the specified tags.""" return compile(select, namespaces, flags, **kwargs).select(tag, limit) def iselect( select: str, tag: bs4.Tag, namespaces: dict[str, str] | None = None, limit: int = 0, flags: int = 0, *, custom: dict[str, str] | None = None, **kwargs: Any ) -> Iterator[bs4.Tag]: """Iterate the specified tags.""" yield from compile(select, namespaces, flags, **kwargs).iselect(tag, limit) def escape(ident: str) -> str: """Escape identifier.""" return cp.escape(ident)
| ver. 1.4 |
Github
|
.
| PHP 8.2.28 | Generation time: 0.02 |
proxy
|
phpinfo
|
Settings