%global _empty_manifest_terminate_build 0
Name:		python-json2table
Version:	1.1.5
Release:	1
Summary:	Convert JSON to an HTML table
License:	MIT
URL:		https://github.com/latture/json2table
Source0:	https://mirrors.nju.edu.cn/pypi/web/packages/fe/f6/05039bd75d6ec8a07135bf97d6d11e92ab51e2939cd065bb6f7d0be46de5/json2table-1.1.5.tar.gz
BuildArch:	noarch


%description
|Build Status| |Coverage Status|
This is a simple Python package that allows a JSON object to be converted to HTML. It provides a ``convert`` function that accepts a ``dict`` instance and returns a string of converted HTML. For example, the simple JSON object ``{"key" : "value"}`` can be converted to HTML via:
    >>> from json2table import convert
    >>> json_object = {"key" : "value"}
    >>> build_direction = "LEFT_TO_RIGHT"
    >>> table_attributes = {"style" : "width:100%"}
    >>> html = convert(json_object, build_direction=build_direction, table_attributes=table_attributes)
    >>> print(html)
    '<table style="width:100%"><tr><th>key</th><td>value</td></tr></table>'
The resulting table will resemble
+---------+-------+
| **key** | value |
+---------+-------+
More complex parsing is also possible. If a list of ``dict``'s provides the same list of keys, the generated HTML with gather items by key and display them in the same column.
    {"menu": {
      "id": "file",
      "value": "File",
        "menuitem": [
          {"value": "New", "onclick": "CreateNewDoc()"},
          {"value": "Open", "onclick": "OpenDoc()"},
          {"value": "Close", "onclick": "CloseDoc()"}
        ]
      }
    }
Output:
+----------+--------------+----------------+-----------+
| **menu** | **menuitem** | **onclick**    | **value** |
+          +              +----------------+-----------+
|          |              | CreateNewDoc() | New       |
+          +              +----------------+-----------+
|          |              | OpenDoc()      | Open      |
+          +              +----------------+-----------+
|          |              | CloseDoc()     | Close     |
+          +--------------+----------------+-----------+
|          | **id**       | file                       |
+          +--------------+----------------+-----------+
|          | **value**    | File                       |
+----------+--------------+----------------+-----------+
It might, however, be more readable if we were able to build the table from top-to-bottom instead of the default left-to-right. Changing the ``build_direction`` to ``"TOP_TO_BOTTOM"`` yields:
+----------------+-----------+-------+-----------+
| **menu**                                       |
+----------------+-----------+-------+-----------+
| **menuitem**               | **id**| **value** |
+----------------+-----------+-------+-----------+
| **onclick**    | **value** |  file |   File    |
+----------------+-----------+       +           +
| CreateNewDoc() | New       |       |           | 
+----------------+-----------+       +           +
| OpenDoc()      | Open      |       |           |
+----------------+-----------+       +           +
| CloseDoc()     | Close     |       |           |
+----------------+-----------+-------+-----------+
Table attributes are added via the ``table_attributes`` parameter. This parameter should be a ``dict`` of ``(key, value)`` pairs to apply to the table in the form ``key="value"``. If in our simple example before we additionally wanted to apply a class attribute of ``"table table-striped"`` we would use the following:
    >>> table_attributes = {"style" : "width:100%", "class" : "table table-striped"}
and convert just as before:
    >>> html = convert(json_object, build_direction=build_direction, table_attributes=table_attributes)

%package -n python3-json2table
Summary:	Convert JSON to an HTML table
Provides:	python-json2table
BuildRequires:	python3-devel
BuildRequires:	python3-setuptools
BuildRequires:	python3-pip
%description -n python3-json2table
|Build Status| |Coverage Status|
This is a simple Python package that allows a JSON object to be converted to HTML. It provides a ``convert`` function that accepts a ``dict`` instance and returns a string of converted HTML. For example, the simple JSON object ``{"key" : "value"}`` can be converted to HTML via:
    >>> from json2table import convert
    >>> json_object = {"key" : "value"}
    >>> build_direction = "LEFT_TO_RIGHT"
    >>> table_attributes = {"style" : "width:100%"}
    >>> html = convert(json_object, build_direction=build_direction, table_attributes=table_attributes)
    >>> print(html)
    '<table style="width:100%"><tr><th>key</th><td>value</td></tr></table>'
The resulting table will resemble
+---------+-------+
| **key** | value |
+---------+-------+
More complex parsing is also possible. If a list of ``dict``'s provides the same list of keys, the generated HTML with gather items by key and display them in the same column.
    {"menu": {
      "id": "file",
      "value": "File",
        "menuitem": [
          {"value": "New", "onclick": "CreateNewDoc()"},
          {"value": "Open", "onclick": "OpenDoc()"},
          {"value": "Close", "onclick": "CloseDoc()"}
        ]
      }
    }
Output:
+----------+--------------+----------------+-----------+
| **menu** | **menuitem** | **onclick**    | **value** |
+          +              +----------------+-----------+
|          |              | CreateNewDoc() | New       |
+          +              +----------------+-----------+
|          |              | OpenDoc()      | Open      |
+          +              +----------------+-----------+
|          |              | CloseDoc()     | Close     |
+          +--------------+----------------+-----------+
|          | **id**       | file                       |
+          +--------------+----------------+-----------+
|          | **value**    | File                       |
+----------+--------------+----------------+-----------+
It might, however, be more readable if we were able to build the table from top-to-bottom instead of the default left-to-right. Changing the ``build_direction`` to ``"TOP_TO_BOTTOM"`` yields:
+----------------+-----------+-------+-----------+
| **menu**                                       |
+----------------+-----------+-------+-----------+
| **menuitem**               | **id**| **value** |
+----------------+-----------+-------+-----------+
| **onclick**    | **value** |  file |   File    |
+----------------+-----------+       +           +
| CreateNewDoc() | New       |       |           | 
+----------------+-----------+       +           +
| OpenDoc()      | Open      |       |           |
+----------------+-----------+       +           +
| CloseDoc()     | Close     |       |           |
+----------------+-----------+-------+-----------+
Table attributes are added via the ``table_attributes`` parameter. This parameter should be a ``dict`` of ``(key, value)`` pairs to apply to the table in the form ``key="value"``. If in our simple example before we additionally wanted to apply a class attribute of ``"table table-striped"`` we would use the following:
    >>> table_attributes = {"style" : "width:100%", "class" : "table table-striped"}
and convert just as before:
    >>> html = convert(json_object, build_direction=build_direction, table_attributes=table_attributes)

%package help
Summary:	Development documents and examples for json2table
Provides:	python3-json2table-doc
%description help
|Build Status| |Coverage Status|
This is a simple Python package that allows a JSON object to be converted to HTML. It provides a ``convert`` function that accepts a ``dict`` instance and returns a string of converted HTML. For example, the simple JSON object ``{"key" : "value"}`` can be converted to HTML via:
    >>> from json2table import convert
    >>> json_object = {"key" : "value"}
    >>> build_direction = "LEFT_TO_RIGHT"
    >>> table_attributes = {"style" : "width:100%"}
    >>> html = convert(json_object, build_direction=build_direction, table_attributes=table_attributes)
    >>> print(html)
    '<table style="width:100%"><tr><th>key</th><td>value</td></tr></table>'
The resulting table will resemble
+---------+-------+
| **key** | value |
+---------+-------+
More complex parsing is also possible. If a list of ``dict``'s provides the same list of keys, the generated HTML with gather items by key and display them in the same column.
    {"menu": {
      "id": "file",
      "value": "File",
        "menuitem": [
          {"value": "New", "onclick": "CreateNewDoc()"},
          {"value": "Open", "onclick": "OpenDoc()"},
          {"value": "Close", "onclick": "CloseDoc()"}
        ]
      }
    }
Output:
+----------+--------------+----------------+-----------+
| **menu** | **menuitem** | **onclick**    | **value** |
+          +              +----------------+-----------+
|          |              | CreateNewDoc() | New       |
+          +              +----------------+-----------+
|          |              | OpenDoc()      | Open      |
+          +              +----------------+-----------+
|          |              | CloseDoc()     | Close     |
+          +--------------+----------------+-----------+
|          | **id**       | file                       |
+          +--------------+----------------+-----------+
|          | **value**    | File                       |
+----------+--------------+----------------+-----------+
It might, however, be more readable if we were able to build the table from top-to-bottom instead of the default left-to-right. Changing the ``build_direction`` to ``"TOP_TO_BOTTOM"`` yields:
+----------------+-----------+-------+-----------+
| **menu**                                       |
+----------------+-----------+-------+-----------+
| **menuitem**               | **id**| **value** |
+----------------+-----------+-------+-----------+
| **onclick**    | **value** |  file |   File    |
+----------------+-----------+       +           +
| CreateNewDoc() | New       |       |           | 
+----------------+-----------+       +           +
| OpenDoc()      | Open      |       |           |
+----------------+-----------+       +           +
| CloseDoc()     | Close     |       |           |
+----------------+-----------+-------+-----------+
Table attributes are added via the ``table_attributes`` parameter. This parameter should be a ``dict`` of ``(key, value)`` pairs to apply to the table in the form ``key="value"``. If in our simple example before we additionally wanted to apply a class attribute of ``"table table-striped"`` we would use the following:
    >>> table_attributes = {"style" : "width:100%", "class" : "table table-striped"}
and convert just as before:
    >>> html = convert(json_object, build_direction=build_direction, table_attributes=table_attributes)

%prep
%autosetup -n json2table-1.1.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-json2table -f filelist.lst
%dir %{python3_sitelib}/*

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

%changelog
* Thu Mar 09 2023 Python_Bot <Python_Bot@openeuler.org> - 1.1.5-1
- Package Spec generated