%global _empty_manifest_terminate_build 0
Name:		python-items
Version:	0.6.5
Release:	1
Summary:	Attribute accessible dicts and collections thereof
License:	Apache License 2.0
URL:		https://bitbucket.org/jeunice/items
Source0:	https://mirrors.nju.edu.cn/pypi/web/packages/ef/ee/cd1171db6e0168b4b26678617eb5b3a1fc4b1dfa6ef365fcb60a1799e364/items-0.6.5.tar.gz
BuildArch:	noarch

Requires:	python3-nulltype

%description
``items`` therefore provides ``Item``, a convenient attribute-accessible ``dict`` subclass,
plus helper functions.
``itemize``, for example, helps iterate through a sequence of dictionaries, as often found
in JSON processing: Each record is handed back as an ``Item`` rather than a Python
``dict``.
A typical progression would be from:
    for item in data:
        item_name = item['name']
        # ...
        print(item_name)
to
    from items import itemize
    for item in itemize(data):
        # ...
        print(item.name)
To process a sequence wholesale, returning a ``list``:
    from items import itemize_all
    itemize_all(data)
If you're iterating over a sequence of tuples (or lists) rather than
dictionaries, you can still use ``itemize`` by providing the field names
you wnat assigned.
    parser = ...
    for item in itemize(parser, fields='prefix token value'):
        if item.prefix is None and item.token == 'start_array':
Here each result returned by ``parser`` (typically a Python generator)
is converted from a tuple (or list) into an ``Item``.  Now you have several values
conveniently packaged in a name-accessible way without having to create
a separate ``namedtuple`` for this result type, and without any need for
tuple positional indexing.
You can even do this for a scalar sequence:
    for item in itemize('aeiou', fields='vowel'):
        item.value = 20 if item.vowel == 'e' else 15
Beyond graceful handling of single-valued sequences, this example demonstrates
the mutability of each ``Item``. ``namedtuples`` are grand as return types,
but they cannot be easily extended or annotated by subsequent processing...a
common requirement for many algorithms.

%package -n python3-items
Summary:	Attribute accessible dicts and collections thereof
Provides:	python-items
BuildRequires:	python3-devel
BuildRequires:	python3-setuptools
BuildRequires:	python3-pip
%description -n python3-items
``items`` therefore provides ``Item``, a convenient attribute-accessible ``dict`` subclass,
plus helper functions.
``itemize``, for example, helps iterate through a sequence of dictionaries, as often found
in JSON processing: Each record is handed back as an ``Item`` rather than a Python
``dict``.
A typical progression would be from:
    for item in data:
        item_name = item['name']
        # ...
        print(item_name)
to
    from items import itemize
    for item in itemize(data):
        # ...
        print(item.name)
To process a sequence wholesale, returning a ``list``:
    from items import itemize_all
    itemize_all(data)
If you're iterating over a sequence of tuples (or lists) rather than
dictionaries, you can still use ``itemize`` by providing the field names
you wnat assigned.
    parser = ...
    for item in itemize(parser, fields='prefix token value'):
        if item.prefix is None and item.token == 'start_array':
Here each result returned by ``parser`` (typically a Python generator)
is converted from a tuple (or list) into an ``Item``.  Now you have several values
conveniently packaged in a name-accessible way without having to create
a separate ``namedtuple`` for this result type, and without any need for
tuple positional indexing.
You can even do this for a scalar sequence:
    for item in itemize('aeiou', fields='vowel'):
        item.value = 20 if item.vowel == 'e' else 15
Beyond graceful handling of single-valued sequences, this example demonstrates
the mutability of each ``Item``. ``namedtuples`` are grand as return types,
but they cannot be easily extended or annotated by subsequent processing...a
common requirement for many algorithms.

%package help
Summary:	Development documents and examples for items
Provides:	python3-items-doc
%description help
``items`` therefore provides ``Item``, a convenient attribute-accessible ``dict`` subclass,
plus helper functions.
``itemize``, for example, helps iterate through a sequence of dictionaries, as often found
in JSON processing: Each record is handed back as an ``Item`` rather than a Python
``dict``.
A typical progression would be from:
    for item in data:
        item_name = item['name']
        # ...
        print(item_name)
to
    from items import itemize
    for item in itemize(data):
        # ...
        print(item.name)
To process a sequence wholesale, returning a ``list``:
    from items import itemize_all
    itemize_all(data)
If you're iterating over a sequence of tuples (or lists) rather than
dictionaries, you can still use ``itemize`` by providing the field names
you wnat assigned.
    parser = ...
    for item in itemize(parser, fields='prefix token value'):
        if item.prefix is None and item.token == 'start_array':
Here each result returned by ``parser`` (typically a Python generator)
is converted from a tuple (or list) into an ``Item``.  Now you have several values
conveniently packaged in a name-accessible way without having to create
a separate ``namedtuple`` for this result type, and without any need for
tuple positional indexing.
You can even do this for a scalar sequence:
    for item in itemize('aeiou', fields='vowel'):
        item.value = 20 if item.vowel == 'e' else 15
Beyond graceful handling of single-valued sequences, this example demonstrates
the mutability of each ``Item``. ``namedtuples`` are grand as return types,
but they cannot be easily extended or annotated by subsequent processing...a
common requirement for many algorithms.

%prep
%autosetup -n items-0.6.5

%build
%py3_build

%install
%py3_install
install -d -m755 %{buildroot}/%{_pkgdocdir}
if [ -d doc ]; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi
if [ -d docs ]; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi
if [ -d example ]; then cp -arf example %{buildroot}/%{_pkgdocdir}; fi
if [ -d examples ]; then cp -arf examples %{buildroot}/%{_pkgdocdir}; fi
pushd %{buildroot}
if [ -d usr/lib ]; then
	find usr/lib -type f -printf "/%h/%f\n" >> filelist.lst
fi
if [ -d usr/lib64 ]; then
	find usr/lib64 -type f -printf "/%h/%f\n" >> filelist.lst
fi
if [ -d usr/bin ]; then
	find usr/bin -type f -printf "/%h/%f\n" >> filelist.lst
fi
if [ -d usr/sbin ]; then
	find usr/sbin -type f -printf "/%h/%f\n" >> filelist.lst
fi
touch doclist.lst
if [ -d usr/share/man ]; then
	find usr/share/man -type f -printf "/%h/%f.gz\n" >> doclist.lst
fi
popd
mv %{buildroot}/filelist.lst .
mv %{buildroot}/doclist.lst .

%files -n python3-items -f filelist.lst
%dir %{python3_sitelib}/*

%files help -f doclist.lst
%{_docdir}/*

%changelog
* Tue May 30 2023 Python_Bot <Python_Bot@openeuler.org> - 0.6.5-1
- Package Spec generated