File: utils.py

package info (click to toggle)
python-itemadapter 0.2.0-1~bpo10%2B1
  • links: PTS, VCS
  • area: main
  • in suites: buster-backports
  • size: 184 kB
  • sloc: python: 844; sh: 8; makefile: 4
file content (114 lines) | stat: -rw-r--r-- 3,733 bytes parent folder | download | duplicates (2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
from types import MappingProxyType
from typing import Any


def _get_scrapy_item_classes() -> tuple:
    try:
        import scrapy
    except ImportError:
        return ()
    else:
        try:
            _base_item_cls = getattr(scrapy.item, "_BaseItem", scrapy.item.BaseItem)  # deprecated
            return (scrapy.item.Item, _base_item_cls)
        except AttributeError:
            return (scrapy.item.Item,)


def _is_dataclass(obj: Any) -> bool:
    try:
        import dataclasses
    except ImportError:
        return False
    return dataclasses.is_dataclass(obj)


def _is_attrs_class(obj: Any) -> bool:
    try:
        import attr
    except ImportError:
        return False
    return attr.has(obj)


def is_dataclass_instance(obj: Any) -> bool:
    """
    Return True if the given object is a dataclass object, False otherwise.

    In py36, this function returns False if the "dataclasses" backport is not available.

    Taken from https://docs.python.org/3/library/dataclasses.html#dataclasses.is_dataclass.
    """
    return _is_dataclass(obj) and not isinstance(obj, type)


def is_attrs_instance(obj: Any) -> bool:
    """
    Return True if the given object is a attrs-based object, False otherwise.
    """
    return _is_attrs_class(obj) and not isinstance(obj, type)


def is_scrapy_item(obj: Any) -> bool:
    """
    Return True if the given object is a Scrapy item, False otherwise.
    """
    try:
        import scrapy
    except ImportError:
        return False
    if isinstance(obj, scrapy.item.Item):
        return True
    try:
        # handle deprecated BaseItem
        BaseItem = getattr(scrapy.item, "_BaseItem", scrapy.item.BaseItem)
        return isinstance(obj, BaseItem)
    except AttributeError:
        return False


def is_item(obj: Any) -> bool:
    """
    Return True if the given object belongs to one of the supported types, False otherwise.

    Alias for ItemAdapter.is_item
    """
    from itemadapter.adapter import ItemAdapter

    return ItemAdapter.is_item(obj)


def get_field_meta_from_class(item_class: type, field_name: str) -> MappingProxyType:
    """
    Return a read-only mapping with metadata for the given field name, within the given item class.
    If there is no metadata for the field, or the item class does not support field metadata,
    an empty object is returned.

    Field metadata is taken from different sources, depending on the item type:
    * scrapy.item.Item: corresponding scrapy.item.Field object
    * dataclass items: "metadata" attribute for the corresponding field
    * attrs items: "metadata" attribute for the corresponding field

    The returned value is an instance of types.MappingProxyType, i.e. a dynamic read-only view
    of the original mapping, which gets automatically updated if the original mapping changes.
    """
    if issubclass(item_class, _get_scrapy_item_classes()):
        return MappingProxyType(item_class.fields[field_name])  # type: ignore
    elif _is_dataclass(item_class):
        from dataclasses import fields

        for field in fields(item_class):
            if field.name == field_name:
                return field.metadata  # type: ignore
        raise KeyError("%s does not support field: %s" % (item_class.__name__, field_name))
    elif _is_attrs_class(item_class):
        from attr import fields_dict

        try:
            return fields_dict(item_class)[field_name].metadata  # type: ignore
        except KeyError:
            raise KeyError("%s does not support field: %s" % (item_class.__name__, field_name))
    elif issubclass(item_class, dict):
        return MappingProxyType({})
    else:
        raise TypeError("%s is not a valid item class" % (item_class,))