grab.base

Module Contents

Classes

BaseRequest
BaseExtension	Abstract base class for generic types.
BaseClient	Abstract base class for generic types.
BaseTransport	Abstract base class for generic types.

class grab.base.BaseRequest

init_keys: set[str]

__repr__() → str

Return repr(self).

classmethod create_from_mapping(mapping: collections.abc.Mapping[str, Any]) → RequestT

class grab.base.BaseExtension

Bases: Generic[RequestT, ResponseT]

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as:

class Mapping(Generic[KT, VT]):
    def __getitem__(self, key: KT) -> VT:
        ...
    # Etc.

This class can then be used as follows:

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
    try:
        return mapping[key]
    except KeyError:
        return default

ext_handlers: collections.abc.Mapping[str, collections.abc.Callable[Ellipsis, Any]]

registry: collections.abc.MutableMapping[str, tuple[type[BaseClient[RequestT, ResponseT]], BaseExtension[RequestT, ResponseT]]]

__slots__ = ('owners',)

__set_name__(owner: type[BaseClient[RequestT, ResponseT]], attr: str) → None

abstract reset() → None

classmethod get_extensions(obj: BaseClient[RequestT, ResponseT]) → collections.abc.Sequence[tuple[str, BaseExtension[RequestT, ResponseT]]]

class grab.base.BaseClient(transport: None | BaseTransport[RequestT, ResponseT] | type[BaseTransport[RequestT, ResponseT]] = None)

Bases: Generic[RequestT, ResponseT]

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as:

class Mapping(Generic[KT, VT]):
    def __getitem__(self, key: KT) -> VT:
        ...
    # Etc.

This class can then be used as follows:

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
    try:
        return mapping[key]
    except KeyError:
        return default

abstract property request_class: type[RequestT]

abstract property default_transport_class: type[BaseTransport[RequestT, ResponseT]]

__slots__ = ('transport', 'ext_handlers')

transport: BaseTransport[RequestT, ResponseT]

ext_handlers: collections.abc.Mapping[str, list[collections.abc.Callable[Ellipsis, Any]]]

abstract process_request_result(req: RequestT) → ResponseT

request(req: None | RequestT = None, **request_kwargs: Any) → ResponseT

clone() → T

class grab.base.BaseTransport

Bases: Generic[RequestT, ResponseT]

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as:

class Mapping(Generic[KT, VT]):
    def __getitem__(self, key: KT) -> VT:
        ...
    # Etc.

This class can then be used as follows:

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
    try:
        return mapping[key]
    except KeyError:
        return default

__slots__ = ()

abstract reset() → None

abstract prepare_response(req: RequestT, *, document_class: type[ResponseT]) → ResponseT

abstract wrap_transport_error() → collections.abc.Generator[None, None, None]

abstract request(req: RequestT) → None

classmethod resolve_entity(entity: None | BaseTransport[RequestT, ResponseT] | type[BaseTransport[RequestT, ResponseT]], default: type[BaseTransport[RequestT, ResponseT]]) → BaseTransport[RequestT, ResponseT]