"""
Scrapy Item
See documentation in docs/topics/item.rst
"""
from abc import ABCMeta
from collections.abc import MutableMapping
from copy import deepcopy
from pprint import pformat
from warnings import warn
from scrapy.utils.deprecate import ScrapyDeprecationWarning
from scrapy.utils.trackref import object_ref
[docs]class BaseItem(object_ref):
"""Base class for item types that do not subclass any other :ref:`supported
item type <item-types>`.
:class:`BaseItem` instances may be :ref:`tracked <topics-leaks-trackrefs>`
to debug memory leaks.
Note that, while :func:`~scrapy.utils.item.is_item_like` returns ``True``
for any instance of a :class:`BaseItem` subclass,
:class:`~scrapy.utils.item.ItemAdapter` may not work as expected with your
custom item objects, specially if they do not implement the same API as one
of the ref:`supported item type <item-types>`.
"""
pass
[docs]class Field(dict):
"""Container of field metadata"""
class DictItem(MutableMapping, BaseItem):
fields = {}
def __new__(cls, *args, **kwargs):
if issubclass(cls, DictItem) and not issubclass(cls, Item):
warn('scrapy.item.DictItem is deprecated, please use '
'scrapy.item.Item instead',
ScrapyDeprecationWarning, stacklevel=2)
return super(DictItem, cls).__new__(cls, *args, **kwargs)
def __init__(self, *args, **kwargs):
self._values = {}
if args or kwargs: # avoid creating dict for most common case
for k, v in dict(*args, **kwargs).items():
self[k] = v
def __getitem__(self, key):
return self._values[key]
def __setitem__(self, key, value):
if key in self.fields:
self._values[key] = value
else:
raise KeyError("%s does not support field: %s" %
(self.__class__.__name__, key))
def __delitem__(self, key):
del self._values[key]
def __getattr__(self, name):
if name in self.fields:
raise AttributeError("Use item[%r] to get field value" % name)
raise AttributeError(name)
def __setattr__(self, name, value):
if not name.startswith('_'):
raise AttributeError("Use item[%r] = %r to set field value" %
(name, value))
super(DictItem, self).__setattr__(name, value)
def __len__(self):
return len(self._values)
def __iter__(self):
return iter(self._values)
__hash__ = BaseItem.__hash__
def keys(self):
return self._values.keys()
def __repr__(self):
return pformat(dict(self))
def copy(self):
return self.__class__(self)
def deepcopy(self):
"""Return a :func:`~copy.deepcopy` of this item.
"""
return deepcopy(self)
[docs]class Item(DictItem, metaclass=ItemMeta):
pass