automatic import of python-items

3 files changed, 180 insertions, 0 deletions

diff --git a/.gitignore b/.gitignore
index e69de29..7b45798 100644
--- a/.gitignore
+++ b/.gitignore
@@ -0,0 +1 @@
+/items-0.6.5.tar.gz
diff --git a/python-items.spec b/python-items.spec
new file mode 100644
index 0000000..c1af229
--- /dev/null
+++ b/python-items.spec
@@ -0,0 +1,178 @@
+%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
+* Mon May 15 2023 Python_Bot <Python_Bot@openeuler.org> - 0.6.5-1
+- Package Spec generated
diff --git a/sources b/sources
new file mode 100644
index 0000000..13cf485
--- /dev/null
+++ b/sources
@@ -0,0 +1 @@
+5b2a2c26929ded028a5183981723a3c6  items-0.6.5.tar.gz