How to use the vdirsyncer.sync.status.ItemMetadata function in vdirsyncer

for href, etag in self.storage.list():
            storage_nonempty = True
            ident, meta = self.status.get_by_href(href)

            if meta is None or meta.href != href or meta.etag != etag:
                # Either the item is completely new, or updated
                # In both cases we should prefetch
                prefetch.append(href)
            else:
                # Metadata is completely identical
                _store_props(ident, meta)

        # Prefetch items
        for href, item, etag in (self.storage.get_multi(prefetch)
                                 if prefetch else ()):
            _store_props(item.ident, ItemMetadata(
                href=href,
                hash=item.hash,
                etag=etag
            ))
            self.set_item_cache(item.ident, item)

        return storage_nonempty

def _get_by_href_impl(self, href, default=(None, None), side=None):
        res = self._c.execute(
            'SELECT ident, hash_{side} AS hash, etag_{side} AS etag '
            'FROM status WHERE href_{side}=?'.format(side=side),
            (href,)).fetchone()
        if not res:
            return default
        return res['ident'], ItemMetadata(
            href=href,
            hash=res['hash'],
            etag=res['etag'],
        )

def _run_impl(self, a, b):

        if self.dest.storage.read_only:
            href = etag = None
        else:
            sync_logger.info('Copying (uploading) item {} to {}'
                             .format(self.ident, self.dest.storage))
            href, etag = self.dest.storage.upload(self.item)
            assert href is not None

        self.dest.status.insert_ident(self.ident, ItemMetadata(
            href=href,
            hash=self.item.hash,
            etag=etag
        ))

def load_legacy_status(self, status):
        with self.transaction():
            for ident, metadata in status.items():
                if len(metadata) == 4:
                    href_a, etag_a, href_b, etag_b = metadata
                    props_a = ItemMetadata(href=href_a, hash='UNDEFINED',
                                           etag=etag_a)
                    props_b = ItemMetadata(href=href_b, hash='UNDEFINED',
                                           etag=etag_b)
                else:
                    a, b = metadata
                    a.setdefault('hash', 'UNDEFINED')
                    b.setdefault('hash', 'UNDEFINED')
                    props_a = ItemMetadata(**a)
                    props_b = ItemMetadata(**b)

                self.insert_ident_a(ident, props_a)
                self.insert_ident_b(ident, props_b)

def insert_ident_a(self, ident, a_props):
        # FIXME: Super inefficient
        old_props = self.get_new_a(ident)
        if old_props is not None:
            raise IdentAlreadyExists(old_href=old_props.href,
                                     new_href=a_props.href)
        b_props = self.get_new_b(ident) or ItemMetadata()
        self._c.execute(
            'INSERT OR REPLACE INTO new_status '
            'VALUES(?, ?, ?, ?, ?, ?, ?)',
            (ident, a_props.href, b_props.href, a_props.hash, b_props.hash,
             a_props.etag, b_props.etag)
        )

def insert_ident_b(self, ident, b_props):
        # FIXME: Super inefficient
        old_props = self.get_new_b(ident)
        if old_props is not None:
            raise IdentAlreadyExists(old_href=old_props.href,
                                     new_href=b_props.href)
        a_props = self.get_new_a(ident) or ItemMetadata()
        self._c.execute(
            'INSERT OR REPLACE INTO new_status '
            'VALUES(?, ?, ?, ?, ?, ?, ?)',
            (ident, a_props.href, b_props.href, a_props.hash, b_props.hash,
             a_props.etag, b_props.etag)
        )

res = self._c.execute('SELECT href_{side} AS href,'
                              '       hash_{side} AS hash,'
                              '       etag_{side} AS etag '
                              'FROM {table} WHERE ident=?'
                              .format(side=side, table=table),
                              (ident,)).fetchone()
        if res is None:
            return None

        if res['hash'] is None:  # FIXME: Implement as constraint in db
            assert res['href'] is None
            assert res['etag'] is None
            return None

        res = dict(res)
        return ItemMetadata(**res)

def _run_impl(self, a, b):
        if self.dest.storage.read_only:
            meta = ItemMetadata(hash=self.item.hash)
        else:
            sync_logger.info('Copying (updating) item {} to {}'
                             .format(self.ident, self.dest.storage))
            meta = self.dest.status.get_new(self.ident)
            meta.etag = \
                self.dest.storage.update(meta.href, self.item, meta.etag)

        self.dest.status.update_ident(self.ident, meta)

def load_legacy_status(self, status):
        with self.transaction():
            for ident, metadata in status.items():
                if len(metadata) == 4:
                    href_a, etag_a, href_b, etag_b = metadata
                    props_a = ItemMetadata(href=href_a, hash='UNDEFINED',
                                           etag=etag_a)
                    props_b = ItemMetadata(href=href_b, hash='UNDEFINED',
                                           etag=etag_b)
                else:
                    a, b = metadata
                    a.setdefault('hash', 'UNDEFINED')
                    b.setdefault('hash', 'UNDEFINED')
                    props_a = ItemMetadata(**a)
                    props_b = ItemMetadata(**b)

                self.insert_ident_a(ident, props_a)
                self.insert_ident_b(ident, props_b)