path: root/python-ballpark.spec

%global _empty_manifest_terminate_build 0
Name:		python-ballpark
Version:	1.4.0
Release:	1
Summary:	Better human-readable numbers.
License:	ISC
URL:		https://github.com/debrouwere/python-ballpark/
Source0:	https://mirrors.nju.edu.cn/pypi/web/packages/8f/5b/e259db671525c63202885c2cad5fc90cf095a65149a2ad3a7586fa73180f/ballpark-1.4.0.tar.gz
BuildArch:	noarch


%description
When people think of human-readable numbers, they think of rounding to
two decimal places and adding a thousands separator. 12,214.17 is
already quite an improvement over 12214.16666667. But standard formats
for human-readable numbers still have various flaws:
-  even with a thousands separator, at a glance you might easily mistake
   a billion for a trillion
-  even when rounding, an amount like 12,214.17 dollars is a lot of
   number noise for communicating 12.2K
-  scientific notation leads to exponents like ``1.22e4`` which are hard
   to interpret because we're used to working with thousands, millions
   and billions – orders of magnitudes that are multiples of three
-  when comparing multiple measurements of the same underlying variable,
   like the yearly sales numbers for 2010-2015, it's annoying to have
   some numbers in thousands and other numbers in millions – you want
   consistency so that digits in the same position are of the same
   magnitude
``python-ballpark`` introduces *business notation*, an offshoot of
`engineering
notation <https://en.wikipedia.org/wiki/Engineering_notation>`__, for
producing better human-readable numbers.
Install with ``pip install ballpark`` or ``pip3 install ballpark``.
What it looks like
~~~~~~~~~~~~~~~~~~
+---------------------+-----------------------+-----------------+-----------------+
| numbers             | rounded               | engineering     | **business      |
|                     |                       | notation        | notation**      |
+=====================+=======================+=================+=================+
| 11234.22,           | 11,234.22,            | 11.2E+3,        | 11K, 233K,      |
| 233000.55,          | 233,000.55,           | 233E+3, 1.18E+6 | 1,180K          |
| 1175125.2           | 1,175,125.2           |                 |                 |
+---------------------+-----------------------+-----------------+-----------------+
| 111, 1111.23,       | 111, 1,111.23,        | 111, 1.11E+3,   | 0.11K, 1.11K,   |
| 1175125.234         | 1,175,125.23          | 1.18E+6         | 1,180.00K       |
+---------------------+-----------------------+-----------------+-----------------+
How to use it
~~~~~~~~~~~~~
    >>> from ballpark import human, scientific, engineering, business, ballpark
    >>> business([11234.22, 233000.55, 1175125.2])
    ['11K', '233K', '1,180K']
    >>>
    >>> # business notation is also aliased as `ballpark`
    >>> ballpark([11234.22, 233000.55, 1175125.2])
    ['11K', '233K', '1,180K']
    >>>
    >>> # or use the shortcut functions
    >>> from ballpark import H, S, E, B
    >>> B([11234.22, 233000.55, 1175125.2])
    ['11K', '233K', '1,180K']
    >>>
    >>> # all notations accept single numbers too, but then we can't guarantee
    >>> # that all numbers will have the same prefix (kilo, mega etc.)
    >>> [B(value) for value in [11234.22, 233000.55, 1175125.2]]
    ['11.2K', '233K', '1.18M']
How it works
~~~~~~~~~~~~
    business(values, precision=3, prefix=True, prefixes=SI, statistic=median)
-  **precision:** the amount of significant digits. When necessary,
   ``business`` will round beyond the decimal sign as well: in the
   example above, ``1175125.2`` was turned into ``1,180K`` rather than
   ``1,175K`` to retain only 3 significant digits.
-  **prefix:** whether to use SI prefixes like m (milli), K (kilo) and
   so on instead of scientific exponents like E+03.
-  **prefixes:** a mapping of orders of magnitude to prefixes, e.g.
   ``{-3: 'm', 3: 'K'}``, allowing you to customize the prefixes, for
   example using B for billion instead of T for tera.
-  **statistic:** a function to produce the reference number. The
   reference number determines the order of magnitude and precision for
   the entire group of numbers, so that for example when the reference
   number is 23.3K, smaller numbers like 1.1K won't gain a decimal place
   and larger numbers like 1,180K won't jump an order of magnitude to
   1.18M. The median often works well, but if you want more precision
   for small outliers, try ``ballpark.statistics.Q1`` or even Python's
   builtin ``min``.

%package -n python3-ballpark
Summary:	Better human-readable numbers.
Provides:	python-ballpark
BuildRequires:	python3-devel
BuildRequires:	python3-setuptools
BuildRequires:	python3-pip
%description -n python3-ballpark
When people think of human-readable numbers, they think of rounding to
two decimal places and adding a thousands separator. 12,214.17 is
already quite an improvement over 12214.16666667. But standard formats
for human-readable numbers still have various flaws:
-  even with a thousands separator, at a glance you might easily mistake
   a billion for a trillion
-  even when rounding, an amount like 12,214.17 dollars is a lot of
   number noise for communicating 12.2K
-  scientific notation leads to exponents like ``1.22e4`` which are hard
   to interpret because we're used to working with thousands, millions
   and billions – orders of magnitudes that are multiples of three
-  when comparing multiple measurements of the same underlying variable,
   like the yearly sales numbers for 2010-2015, it's annoying to have
   some numbers in thousands and other numbers in millions – you want
   consistency so that digits in the same position are of the same
   magnitude
``python-ballpark`` introduces *business notation*, an offshoot of
`engineering
notation <https://en.wikipedia.org/wiki/Engineering_notation>`__, for
producing better human-readable numbers.
Install with ``pip install ballpark`` or ``pip3 install ballpark``.
What it looks like
~~~~~~~~~~~~~~~~~~
+---------------------+-----------------------+-----------------+-----------------+
| numbers             | rounded               | engineering     | **business      |
|                     |                       | notation        | notation**      |
+=====================+=======================+=================+=================+
| 11234.22,           | 11,234.22,            | 11.2E+3,        | 11K, 233K,      |
| 233000.55,          | 233,000.55,           | 233E+3, 1.18E+6 | 1,180K          |
| 1175125.2           | 1,175,125.2           |                 |                 |
+---------------------+-----------------------+-----------------+-----------------+
| 111, 1111.23,       | 111, 1,111.23,        | 111, 1.11E+3,   | 0.11K, 1.11K,   |
| 1175125.234         | 1,175,125.23          | 1.18E+6         | 1,180.00K       |
+---------------------+-----------------------+-----------------+-----------------+
How to use it
~~~~~~~~~~~~~
    >>> from ballpark import human, scientific, engineering, business, ballpark
    >>> business([11234.22, 233000.55, 1175125.2])
    ['11K', '233K', '1,180K']
    >>>
    >>> # business notation is also aliased as `ballpark`
    >>> ballpark([11234.22, 233000.55, 1175125.2])
    ['11K', '233K', '1,180K']
    >>>
    >>> # or use the shortcut functions
    >>> from ballpark import H, S, E, B
    >>> B([11234.22, 233000.55, 1175125.2])
    ['11K', '233K', '1,180K']
    >>>
    >>> # all notations accept single numbers too, but then we can't guarantee
    >>> # that all numbers will have the same prefix (kilo, mega etc.)
    >>> [B(value) for value in [11234.22, 233000.55, 1175125.2]]
    ['11.2K', '233K', '1.18M']
How it works
~~~~~~~~~~~~
    business(values, precision=3, prefix=True, prefixes=SI, statistic=median)
-  **precision:** the amount of significant digits. When necessary,
   ``business`` will round beyond the decimal sign as well: in the
   example above, ``1175125.2`` was turned into ``1,180K`` rather than
   ``1,175K`` to retain only 3 significant digits.
-  **prefix:** whether to use SI prefixes like m (milli), K (kilo) and
   so on instead of scientific exponents like E+03.
-  **prefixes:** a mapping of orders of magnitude to prefixes, e.g.
   ``{-3: 'm', 3: 'K'}``, allowing you to customize the prefixes, for
   example using B for billion instead of T for tera.
-  **statistic:** a function to produce the reference number. The
   reference number determines the order of magnitude and precision for
   the entire group of numbers, so that for example when the reference
   number is 23.3K, smaller numbers like 1.1K won't gain a decimal place
   and larger numbers like 1,180K won't jump an order of magnitude to
   1.18M. The median often works well, but if you want more precision
   for small outliers, try ``ballpark.statistics.Q1`` or even Python's
   builtin ``min``.

%package help
Summary:	Development documents and examples for ballpark
Provides:	python3-ballpark-doc
%description help
When people think of human-readable numbers, they think of rounding to
two decimal places and adding a thousands separator. 12,214.17 is
already quite an improvement over 12214.16666667. But standard formats
for human-readable numbers still have various flaws:
-  even with a thousands separator, at a glance you might easily mistake
   a billion for a trillion
-  even when rounding, an amount like 12,214.17 dollars is a lot of
   number noise for communicating 12.2K
-  scientific notation leads to exponents like ``1.22e4`` which are hard
   to interpret because we're used to working with thousands, millions
   and billions – orders of magnitudes that are multiples of three
-  when comparing multiple measurements of the same underlying variable,
   like the yearly sales numbers for 2010-2015, it's annoying to have
   some numbers in thousands and other numbers in millions – you want
   consistency so that digits in the same position are of the same
   magnitude
``python-ballpark`` introduces *business notation*, an offshoot of
`engineering
notation <https://en.wikipedia.org/wiki/Engineering_notation>`__, for
producing better human-readable numbers.
Install with ``pip install ballpark`` or ``pip3 install ballpark``.
What it looks like
~~~~~~~~~~~~~~~~~~
+---------------------+-----------------------+-----------------+-----------------+
| numbers             | rounded               | engineering     | **business      |
|                     |                       | notation        | notation**      |
+=====================+=======================+=================+=================+
| 11234.22,           | 11,234.22,            | 11.2E+3,        | 11K, 233K,      |
| 233000.55,          | 233,000.55,           | 233E+3, 1.18E+6 | 1,180K          |
| 1175125.2           | 1,175,125.2           |                 |                 |
+---------------------+-----------------------+-----------------+-----------------+
| 111, 1111.23,       | 111, 1,111.23,        | 111, 1.11E+3,   | 0.11K, 1.11K,   |
| 1175125.234         | 1,175,125.23          | 1.18E+6         | 1,180.00K       |
+---------------------+-----------------------+-----------------+-----------------+
How to use it
~~~~~~~~~~~~~
    >>> from ballpark import human, scientific, engineering, business, ballpark
    >>> business([11234.22, 233000.55, 1175125.2])
    ['11K', '233K', '1,180K']
    >>>
    >>> # business notation is also aliased as `ballpark`
    >>> ballpark([11234.22, 233000.55, 1175125.2])
    ['11K', '233K', '1,180K']
    >>>
    >>> # or use the shortcut functions
    >>> from ballpark import H, S, E, B
    >>> B([11234.22, 233000.55, 1175125.2])
    ['11K', '233K', '1,180K']
    >>>
    >>> # all notations accept single numbers too, but then we can't guarantee
    >>> # that all numbers will have the same prefix (kilo, mega etc.)
    >>> [B(value) for value in [11234.22, 233000.55, 1175125.2]]
    ['11.2K', '233K', '1.18M']
How it works
~~~~~~~~~~~~
    business(values, precision=3, prefix=True, prefixes=SI, statistic=median)
-  **precision:** the amount of significant digits. When necessary,
   ``business`` will round beyond the decimal sign as well: in the
   example above, ``1175125.2`` was turned into ``1,180K`` rather than
   ``1,175K`` to retain only 3 significant digits.
-  **prefix:** whether to use SI prefixes like m (milli), K (kilo) and
   so on instead of scientific exponents like E+03.
-  **prefixes:** a mapping of orders of magnitude to prefixes, e.g.
   ``{-3: 'm', 3: 'K'}``, allowing you to customize the prefixes, for
   example using B for billion instead of T for tera.
-  **statistic:** a function to produce the reference number. The
   reference number determines the order of magnitude and precision for
   the entire group of numbers, so that for example when the reference
   number is 23.3K, smaller numbers like 1.1K won't gain a decimal place
   and larger numbers like 1,180K won't jump an order of magnitude to
   1.18M. The median often works well, but if you want more precision
   for small outliers, try ``ballpark.statistics.Q1`` or even Python's
   builtin ``min``.

%prep
%autosetup -n ballpark-1.4.0

%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-ballpark -f filelist.lst
%dir %{python3_sitelib}/*

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

%changelog
* Fri May 05 2023 Python_Bot <Python_Bot@openeuler.org> - 1.4.0-1
- Package Spec generated