itemadapter

The ItemAdapter class is a wrapper for data container objects, providing a common interface to handle objects of different types in an uniform manner, regardless of their underlying implementation.

Currently supported types are:

• scrapy.item.Item
• dict
• dataclass-based classes
• attrs-based classes
• pydantic-based classes

Additionally, interaction with arbitrary types is supported, by implementing a pre-defined interface (see extending itemadapter).

Requirements

• Python 3.6+
• scrapy: optional, needed to interact with scrapy items
• dataclasses (stdlib in Python 3.7+, or its backport in Python 3.6): optional, needed to interact with dataclass-based items
• attrs: optional, needed to interact with attrs-based items
• pydantic: optional, needed to interact with pydantic-based items

Installation

itemadapter is available on PyPI, it can be installed with pip:

pip install itemadapter

License

itemadapter is distributed under a BSD-3 license.

Basic usage

The following is a simple example using a dataclass object. Consider the following type definition:

>>> from dataclasses import dataclass
>>> from itemadapter import ItemAdapter, is_item
>>> @dataclass
... class InventoryItem:
...     name: str
...     price: float
...     stock: int
>>>

The ItemAdapter object can be treated much like a dictionary:

>>> obj = InventoryItem(name='foo', price=20.5, stock=10)
>>> is_item(obj)
True
>>> adapter = ItemAdapter(obj)
>>> len(adapter)
3
>>> adapter["name"]
'foo'
>>> adapter.get("price")
20.5
>>>

The wrapped object is modified in-place:

>>> adapter["name"] = "bar"
>>> adapter.update({"price": 12.7, "stock": 9})
>>> adapter.item
InventoryItem(name='bar', price=12.7, stock=9)
>>> adapter.item is obj
True
>>>

Converting to dict

The ItemAdapter class provides the asdict method, which converts nested items recursively. Consider the following example:

>>> from dataclasses import dataclass
>>> from itemadapter import ItemAdapter
>>> @dataclass
... class Price:
...     value: int
...     currency: str
>>> @dataclass
... class Product:
...     name: str
...     price: Price
>>>

>>> item = Product("Stuff", Price(42, "UYU"))
>>> adapter = ItemAdapter(item)
>>> adapter.asdict()
{'name': 'Stuff', 'price': {'value': 42, 'currency': 'UYU'}}
>>>

Note that just passing an adapter object to the dict built-in also works, but it doesn't traverse the object recursively converting nested items:

>>> dict(adapter)
{'name': 'Stuff', 'price': Price(value=42, currency='UYU')}
>>>

API reference

Built-in adapters

The following adapters are included by default:

• itemadapter.adapter.ScrapyItemAdapter: handles Scrapy items
• itemadapter.adapter.DictAdapter: handles Python dictionaries
• itemadapter.adapter.DataclassAdapter: handles dataclass objects
• itemadapter.adapter.AttrsAdapter: handles attrs objects
• itemadapter.adapter.PydanticAdapter: handles pydantic objects

class itemadapter.adapter.ItemAdapter(item: Any)

This is the main entrypoint for the package. Tipically, user code wraps an item using this class, and proceeds to handle it with the provided interface. ItemAdapter implements the MutableMapping interface, providing a dict-like API to manipulate data for the object it wraps (which is modified in-place).

Attributes

class attribute ADAPTER_CLASSES: collections.deque

Stores the currently registered adapter classes. Being a collections.deque, it supports efficient addition/deletion of adapters classes to both ends.

The order in which the adapters are registered is important. When an ItemAdapter object is created for a specific item, the registered adapters are traversed in order and the first adapter class to return True for the is_item class method is used for all subsequent operations. The default order is the one defined in the built-in adapters section.

See the section on extending itemadapter for additional information.

Methods

class method is_item(item: Any) -> bool

Return True if any of the registed adapters can handle the item (i.e. if any of them returns True for its is_item method with item as argument), False otherwise.

get_field_meta(field_name: str) -> MappingProxyType

Return a types.MappingProxyType object, which is a read-only mapping with metadata about the given field. If the item class does not support field metadata, or there is no metadata for the given field, an empty object is returned.

The returned value is taken from the following sources, depending on the item type:

• scrapy.item.Field for scrapy.item.Items
• dataclasses.field.metadata for dataclass-based items
• attr.Attribute.metadata for attrs-based items
• pydantic.fields.FieldInfo for pydantic-based items

field_names() -> collections.abc.KeysView

Return a keys view with the names of all the defined fields for the item.

asdict() -> dict

Return a dict object with the contents of the adapter. This works slightly different than calling dict(adapter), because it's applied recursively to nested items (if there are any).

function itemadapter.utils.is_item(obj: Any) -> bool

Return True if the given object belongs to (at least) one of the supported types, False otherwise. This is an alias for itemadapter.adapter.ItemAdapter.is_item.

function itemadapter.utils.get_field_meta_from_class(item_class: type, field_name: str) -> types.MappingProxyType

Given an item class and a field name, return a MappingProxyType object, which is a read-only mapping with metadata about the given field. If the item class does not support field metadata, or there is no metadata for the given field, an empty object is returned.

Metadata support

scrapy.item.Item, dataclass, attrs, and pydantic objects allow the definition of arbitrary field metadata. This can be accessed through a MappingProxyType object, which can be retrieved from an item instance with the itemadapter.adapter.ItemAdapter.get_field_meta method, or from an item class with the itemadapter.utils.get_field_meta_from_class function. The definition procedure depends on the underlying type.

scrapy.item.Item objects

>>> from scrapy.item import Item, Field
>>> from itemadapter import ItemAdapter
>>> class InventoryItem(Item):
...     name = Field(serializer=str)
...     value = Field(serializer=int, limit=100)
...
>>> adapter = ItemAdapter(InventoryItem(name="foo", value=10))
>>> adapter.get_field_meta("name")
mappingproxy({'serializer': <class 'str'>})
>>> adapter.get_field_meta("value")
mappingproxy({'serializer': <class 'int'>, 'limit': 100})
>>>

dataclass objects

>>> from dataclasses import dataclass, field
>>> @dataclass
... class InventoryItem:
...     name: str = field(metadata={"serializer": str})
...     value: int = field(metadata={"serializer": int, "limit": 100})
...
>>> adapter = ItemAdapter(InventoryItem(name="foo", value=10))
>>> adapter.get_field_meta("name")
mappingproxy({'serializer': <class 'str'>})
>>> adapter.get_field_meta("value")
mappingproxy({'serializer': <class 'int'>, 'limit': 100})
>>>

attrs objects

>>> import attr
>>> @attr.s
... class InventoryItem:
...     name = attr.ib(metadata={"serializer": str})
...     value = attr.ib(metadata={"serializer": int, "limit": 100})
...
>>> adapter = ItemAdapter(InventoryItem(name="foo", value=10))
>>> adapter.get_field_meta("name")
mappingproxy({'serializer': <class 'str'>})
>>> adapter.get_field_meta("value")
mappingproxy({'serializer': <class 'int'>, 'limit': 100})
>>>

pydantic objects

>>> from pydantic import BaseModel, Field
>>> class InventoryItem(BaseModel):
...     name: str = Field(serializer=str)
...     value: int = Field(serializer=int, limit=100)
...
>>> adapter = ItemAdapter(InventoryItem(name="foo", value=10))
>>> adapter.get_field_meta("name")
mappingproxy({'serializer': <class 'str'>})
>>> adapter.get_field_meta("value")
mappingproxy({'serializer': <class 'int'>, 'limit': 100})
>>>

Extending itemadapter

This package allows to handle arbitrary item classes, by implementing an adapter interface:

class itemadapter.adapter.AdapterInterface(item: Any)

Abstract Base Class for adapters. An adapter that handles a specific type of item must inherit from this class and implement the abstract methods defined on it. AdapterInterface inherits from collections.abc.MutableMapping, so all methods from the MutableMapping class must be implemented as well.

• class method is_item(cls, item: Any) -> bool

  Return True if the adapter can handle the given item, False otherwise. Abstract (mandatory).

• method get_field_meta(self, field_name: str) -> types.MappingProxyType

  Return metadata for the given field name, if available. By default, this method returns an empty MappingProxyType object. Please supply your own method definition if you want to handle field metadata based on custom logic. See the section on metadata support for additional information.

• method field_names(self) -> collections.abc.KeysView:

  Return a dynamic view of the item's field names. By default, this method returns the result of calling keys() on the current adapter, i.e., its return value depends on the implementation of the methods from the MutableMapping interface (more specifically, it depends on the return value of __iter__).

  You might want to override this method if you want a way to get all fields for an item, whether or not they are populated. For instance, Scrapy uses this method to define column names when exporting items to CSV.

Registering an adapter

Add your custom adapter class to the itemadapter.adapter.ItemAdapter.ADAPTER_CLASSES class attribute in order to handle custom item classes:

Example

>>> from itemadapter.adapter import ItemAdapter
>>> from tests.test_interface import BaseFakeItemAdapter, FakeItemClass
>>>
>>> ItemAdapter.ADAPTER_CLASSES.appendleft(BaseFakeItemAdapter)
>>> item = FakeItemClass()
>>> adapter = ItemAdapter(item)
>>> adapter
<ItemAdapter for FakeItemClass()>
>>>

More examples

scrapy.item.Item objects

>>> from scrapy.item import Item, Field
>>> from itemadapter import ItemAdapter
>>> class InventoryItem(Item):
...     name = Field()
...     price = Field()
...
>>> item = InventoryItem(name="foo", price=10)
>>> adapter = ItemAdapter(item)
>>> adapter.item is item
True
>>> adapter["name"]
'foo'
>>> adapter["name"] = "bar"
>>> adapter["price"] = 5
>>> item
{'name': 'bar', 'price': 5}
>>>

dict

>>> from itemadapter import ItemAdapter
>>> item = dict(name="foo", price=10)
>>> adapter = ItemAdapter(item)
>>> adapter.item is item
True
>>> adapter["name"]
'foo'
>>> adapter["name"] = "bar"
>>> adapter["price"] = 5
>>> item
{'name': 'bar', 'price': 5}
>>>

dataclass objects

>>> from dataclasses import dataclass
>>> from itemadapter import ItemAdapter
>>> @dataclass
... class InventoryItem:
...     name: str
...     price: int
...
>>> item = InventoryItem(name="foo", price=10)
>>> adapter = ItemAdapter(item)
>>> adapter.item is item
True
>>> adapter["name"]
'foo'
>>> adapter["name"] = "bar"
>>> adapter["price"] = 5
>>> item
InventoryItem(name='bar', price=5)
>>>

attrs objects

>>> import attr
>>> from itemadapter import ItemAdapter
>>> @attr.s
... class InventoryItem:
...     name = attr.ib()
...     price = attr.ib()
...
>>> item = InventoryItem(name="foo", price=10)
>>> adapter = ItemAdapter(item)
>>> adapter.item is item
True
>>> adapter["name"]
'foo'
>>> adapter["name"] = "bar"
>>> adapter["price"] = 5
>>> item
InventoryItem(name='bar', price=5)
>>>

pydantic objects

>>> from pydantic import BaseModel
>>> from itemadapter import ItemAdapter
>>> class InventoryItem(BaseModel):
...     name: str
...     price: int
...
>>> item = InventoryItem(name="foo", price=10)
>>> adapter = ItemAdapter(item)
>>> adapter.item is item
True
>>> adapter["name"]
'foo'
>>> adapter["name"] = "bar"
>>> adapter["price"] = 5
>>> item
InventoryItem(name='bar', price=5)
>>>

Changelog

See the full changelog