diff options
Diffstat (limited to 'python-numcompress.spec')
| -rw-r--r-- | python-numcompress.spec | 415 |
1 files changed, 415 insertions, 0 deletions
diff --git a/python-numcompress.spec b/python-numcompress.spec new file mode 100644 index 0000000..0fbfde8 --- /dev/null +++ b/python-numcompress.spec @@ -0,0 +1,415 @@ +%global _empty_manifest_terminate_build 0 +Name: python-numcompress +Version: 0.1.2 +Release: 1 +Summary: Python package to convert numerical series & numpy arrays into compressed strings +License: MIT +URL: https://github.com/amit1rrr/numcompress +Source0: https://mirrors.nju.edu.cn/pypi/web/packages/5c/76/4fec4fc7534dc96fdb220a1aeccbc034c733eddd4dd6f0445b52f21c65d1/numcompress-0.1.2.tar.gz +BuildArch: noarch + +Requires: python3-numpy + +%description +[](https://badge.fury.io/py/numcompress) [](https://travis-ci.org/amit1rrr/numcompress) [](https://coveralls.io/github/amit1rrr/numcompress) + +# numcompress +Simple way to compress and decompress numerical series & numpy arrays. +- Easily gets you above 80% compression ratio +- You can specify the precision you need for floating points (up to 10 decimal points) +- Useful to store or transmit stock prices, monitoring data & other time series data in compressed string format + +Compression algorithm is based on [google encoded polyline format](https://developers.google.com/maps/documentation/utilities/polylinealgorithm). I modified it to preserve arbitrary precision and apply it to any numerical series. The work is motivated by usefulness of [time aware polyline](https://www.hypertrack.com/blog/2016/09/01/the-missing-dimension-in-geospatial-data-formats/) built by [Arjun Attam](https://github.com/arjun27) at [HyperTrack](https://github.com/hypertrack/time-aware-polyline-py). +After building this I came across [arrays](https://docs.python.org/3/library/array.html) that are much efficient than lists in terms memory footprint. You might consider using that over numcompress if you don't care about conversion to string for transmitting or storing purpose. + +# Installation +``` +pip install numcompress +``` + +# Usage +```python +from numcompress import compress, decompress + +# Integers +>>> compress([14578, 12759, 13525]) +'B_twxZnv_nB_bwm@' + +>>> decompress('B_twxZnv_nB_bwm@') +[14578.0, 12759.0, 13525.0] +``` + +```python +# Floats - lossless compression +# precision argument specifies how many decimal points to preserve, defaults to 3 +>>> compress([145.7834, 127.5989, 135.2569], precision=4) +'Csi~wAhdbJgqtC' + +>>> decompress('Csi~wAhdbJgqtC') +[145.7834, 127.5989, 135.2569] +``` +```python +# Floats - lossy compression +>>> compress([145.7834, 127.5989, 135.2569], precision=2) +'Acn[rpB{n@' + +>>> decompress('Acn[rpB{n@') +[145.78, 127.6, 135.26] +``` +```python +# compressing and decompressing numpy arrays +>>> from numcompress import compress_ndarray, decompress_ndarray +>>> import numpy as np + +>>> series = np.random.randint(1, 100, 25).reshape(5, 5) +>>> compressed_series = compress_ndarray(series) +>>> decompressed_series = decompress_ndarray(compressed_series) + +>>> series +array([[29, 95, 10, 48, 20], + [60, 98, 73, 96, 71], + [95, 59, 8, 6, 17], + [ 5, 12, 69, 65, 52], + [84, 6, 83, 20, 50]]) + +>>> compressed_series +'5*5,Bosw@_|_Cn_eD_fiA~tu@_cmA_fiAnyo@o|k@nyo@_{m@~heAnrbB~{BonT~lVotLoinB~xFnkX_o}@~iwCokuCn`zB_ry@' + +>>> decompressed_series +array([[29., 95., 10., 48., 20.], + [60., 98., 73., 96., 71.], + [95., 59., 8., 6., 17.], + [ 5., 12., 69., 65., 52.], + [84., 6., 83., 20., 50.]]) + +>>> (series == decompressed_series).all() +True +``` + + +# Compression Ratio + +| Test | # of Numbers | Compression ratio | +| ------------- |-------------- |---------------------------| +| [Integers](https://github.com/amit1rrr/numcompress/blob/master/test/test_numcompress.py#L29) | 10k | **91.14%** | +| [Floats](https://github.com/amit1rrr/numcompress/blob/master/test/test_numcompress.py#L49) | 10k | **81.35%** | + +You can run the test suite with -s switch to see the compression ratio. You can even modify the tests to see what kind of compression ratio you will get for your own input. +``` +pytest -s +``` + +Here's a quick example showing compression ratio: + +```python +>>> series = random.sample(range(1, 100000), 50000) # generate 50k random numbers between 1 and 100k +>>> text = compress(series) # apply compression + +>>> original_size = sum(sys.getsizeof(i) for i in series) +>>> original_size +1200000 + +>>> compressed_size = sys.getsizeof(text) +>>> compressed_size +284092 + +>>> compression_ratio = ((original_size - compressed_size) * 100.0) / original_size +>>> compression_ratio +76.32566666666666 +``` + +We get ~76% compression for 50k random numbers between 1 & 100k. This ratio increases for real world numerical series as the difference between consecutive numbers tends to be lower. Think of stock prices, monitoring & other time series data. + + +# Contribute +If you see any problem, open an issue or send a pull request. You can write to [me](https://blog.amirathi.com/about/) at [amit.juschill@gmail.com](mailto:amit.juschill@gmail.com) + + + + +%package -n python3-numcompress +Summary: Python package to convert numerical series & numpy arrays into compressed strings +Provides: python-numcompress +BuildRequires: python3-devel +BuildRequires: python3-setuptools +BuildRequires: python3-pip +%description -n python3-numcompress +[](https://badge.fury.io/py/numcompress) [](https://travis-ci.org/amit1rrr/numcompress) [](https://coveralls.io/github/amit1rrr/numcompress) + +# numcompress +Simple way to compress and decompress numerical series & numpy arrays. +- Easily gets you above 80% compression ratio +- You can specify the precision you need for floating points (up to 10 decimal points) +- Useful to store or transmit stock prices, monitoring data & other time series data in compressed string format + +Compression algorithm is based on [google encoded polyline format](https://developers.google.com/maps/documentation/utilities/polylinealgorithm). I modified it to preserve arbitrary precision and apply it to any numerical series. The work is motivated by usefulness of [time aware polyline](https://www.hypertrack.com/blog/2016/09/01/the-missing-dimension-in-geospatial-data-formats/) built by [Arjun Attam](https://github.com/arjun27) at [HyperTrack](https://github.com/hypertrack/time-aware-polyline-py). +After building this I came across [arrays](https://docs.python.org/3/library/array.html) that are much efficient than lists in terms memory footprint. You might consider using that over numcompress if you don't care about conversion to string for transmitting or storing purpose. + +# Installation +``` +pip install numcompress +``` + +# Usage +```python +from numcompress import compress, decompress + +# Integers +>>> compress([14578, 12759, 13525]) +'B_twxZnv_nB_bwm@' + +>>> decompress('B_twxZnv_nB_bwm@') +[14578.0, 12759.0, 13525.0] +``` + +```python +# Floats - lossless compression +# precision argument specifies how many decimal points to preserve, defaults to 3 +>>> compress([145.7834, 127.5989, 135.2569], precision=4) +'Csi~wAhdbJgqtC' + +>>> decompress('Csi~wAhdbJgqtC') +[145.7834, 127.5989, 135.2569] +``` +```python +# Floats - lossy compression +>>> compress([145.7834, 127.5989, 135.2569], precision=2) +'Acn[rpB{n@' + +>>> decompress('Acn[rpB{n@') +[145.78, 127.6, 135.26] +``` +```python +# compressing and decompressing numpy arrays +>>> from numcompress import compress_ndarray, decompress_ndarray +>>> import numpy as np + +>>> series = np.random.randint(1, 100, 25).reshape(5, 5) +>>> compressed_series = compress_ndarray(series) +>>> decompressed_series = decompress_ndarray(compressed_series) + +>>> series +array([[29, 95, 10, 48, 20], + [60, 98, 73, 96, 71], + [95, 59, 8, 6, 17], + [ 5, 12, 69, 65, 52], + [84, 6, 83, 20, 50]]) + +>>> compressed_series +'5*5,Bosw@_|_Cn_eD_fiA~tu@_cmA_fiAnyo@o|k@nyo@_{m@~heAnrbB~{BonT~lVotLoinB~xFnkX_o}@~iwCokuCn`zB_ry@' + +>>> decompressed_series +array([[29., 95., 10., 48., 20.], + [60., 98., 73., 96., 71.], + [95., 59., 8., 6., 17.], + [ 5., 12., 69., 65., 52.], + [84., 6., 83., 20., 50.]]) + +>>> (series == decompressed_series).all() +True +``` + + +# Compression Ratio + +| Test | # of Numbers | Compression ratio | +| ------------- |-------------- |---------------------------| +| [Integers](https://github.com/amit1rrr/numcompress/blob/master/test/test_numcompress.py#L29) | 10k | **91.14%** | +| [Floats](https://github.com/amit1rrr/numcompress/blob/master/test/test_numcompress.py#L49) | 10k | **81.35%** | + +You can run the test suite with -s switch to see the compression ratio. You can even modify the tests to see what kind of compression ratio you will get for your own input. +``` +pytest -s +``` + +Here's a quick example showing compression ratio: + +```python +>>> series = random.sample(range(1, 100000), 50000) # generate 50k random numbers between 1 and 100k +>>> text = compress(series) # apply compression + +>>> original_size = sum(sys.getsizeof(i) for i in series) +>>> original_size +1200000 + +>>> compressed_size = sys.getsizeof(text) +>>> compressed_size +284092 + +>>> compression_ratio = ((original_size - compressed_size) * 100.0) / original_size +>>> compression_ratio +76.32566666666666 +``` + +We get ~76% compression for 50k random numbers between 1 & 100k. This ratio increases for real world numerical series as the difference between consecutive numbers tends to be lower. Think of stock prices, monitoring & other time series data. + + +# Contribute +If you see any problem, open an issue or send a pull request. You can write to [me](https://blog.amirathi.com/about/) at [amit.juschill@gmail.com](mailto:amit.juschill@gmail.com) + + + + +%package help +Summary: Development documents and examples for numcompress +Provides: python3-numcompress-doc +%description help +[](https://badge.fury.io/py/numcompress) [](https://travis-ci.org/amit1rrr/numcompress) [](https://coveralls.io/github/amit1rrr/numcompress) + +# numcompress +Simple way to compress and decompress numerical series & numpy arrays. +- Easily gets you above 80% compression ratio +- You can specify the precision you need for floating points (up to 10 decimal points) +- Useful to store or transmit stock prices, monitoring data & other time series data in compressed string format + +Compression algorithm is based on [google encoded polyline format](https://developers.google.com/maps/documentation/utilities/polylinealgorithm). I modified it to preserve arbitrary precision and apply it to any numerical series. The work is motivated by usefulness of [time aware polyline](https://www.hypertrack.com/blog/2016/09/01/the-missing-dimension-in-geospatial-data-formats/) built by [Arjun Attam](https://github.com/arjun27) at [HyperTrack](https://github.com/hypertrack/time-aware-polyline-py). +After building this I came across [arrays](https://docs.python.org/3/library/array.html) that are much efficient than lists in terms memory footprint. You might consider using that over numcompress if you don't care about conversion to string for transmitting or storing purpose. + +# Installation +``` +pip install numcompress +``` + +# Usage +```python +from numcompress import compress, decompress + +# Integers +>>> compress([14578, 12759, 13525]) +'B_twxZnv_nB_bwm@' + +>>> decompress('B_twxZnv_nB_bwm@') +[14578.0, 12759.0, 13525.0] +``` + +```python +# Floats - lossless compression +# precision argument specifies how many decimal points to preserve, defaults to 3 +>>> compress([145.7834, 127.5989, 135.2569], precision=4) +'Csi~wAhdbJgqtC' + +>>> decompress('Csi~wAhdbJgqtC') +[145.7834, 127.5989, 135.2569] +``` +```python +# Floats - lossy compression +>>> compress([145.7834, 127.5989, 135.2569], precision=2) +'Acn[rpB{n@' + +>>> decompress('Acn[rpB{n@') +[145.78, 127.6, 135.26] +``` +```python +# compressing and decompressing numpy arrays +>>> from numcompress import compress_ndarray, decompress_ndarray +>>> import numpy as np + +>>> series = np.random.randint(1, 100, 25).reshape(5, 5) +>>> compressed_series = compress_ndarray(series) +>>> decompressed_series = decompress_ndarray(compressed_series) + +>>> series +array([[29, 95, 10, 48, 20], + [60, 98, 73, 96, 71], + [95, 59, 8, 6, 17], + [ 5, 12, 69, 65, 52], + [84, 6, 83, 20, 50]]) + +>>> compressed_series +'5*5,Bosw@_|_Cn_eD_fiA~tu@_cmA_fiAnyo@o|k@nyo@_{m@~heAnrbB~{BonT~lVotLoinB~xFnkX_o}@~iwCokuCn`zB_ry@' + +>>> decompressed_series +array([[29., 95., 10., 48., 20.], + [60., 98., 73., 96., 71.], + [95., 59., 8., 6., 17.], + [ 5., 12., 69., 65., 52.], + [84., 6., 83., 20., 50.]]) + +>>> (series == decompressed_series).all() +True +``` + + +# Compression Ratio + +| Test | # of Numbers | Compression ratio | +| ------------- |-------------- |---------------------------| +| [Integers](https://github.com/amit1rrr/numcompress/blob/master/test/test_numcompress.py#L29) | 10k | **91.14%** | +| [Floats](https://github.com/amit1rrr/numcompress/blob/master/test/test_numcompress.py#L49) | 10k | **81.35%** | + +You can run the test suite with -s switch to see the compression ratio. You can even modify the tests to see what kind of compression ratio you will get for your own input. +``` +pytest -s +``` + +Here's a quick example showing compression ratio: + +```python +>>> series = random.sample(range(1, 100000), 50000) # generate 50k random numbers between 1 and 100k +>>> text = compress(series) # apply compression + +>>> original_size = sum(sys.getsizeof(i) for i in series) +>>> original_size +1200000 + +>>> compressed_size = sys.getsizeof(text) +>>> compressed_size +284092 + +>>> compression_ratio = ((original_size - compressed_size) * 100.0) / original_size +>>> compression_ratio +76.32566666666666 +``` + +We get ~76% compression for 50k random numbers between 1 & 100k. This ratio increases for real world numerical series as the difference between consecutive numbers tends to be lower. Think of stock prices, monitoring & other time series data. + + +# Contribute +If you see any problem, open an issue or send a pull request. You can write to [me](https://blog.amirathi.com/about/) at [amit.juschill@gmail.com](mailto:amit.juschill@gmail.com) + + + + +%prep +%autosetup -n numcompress-0.1.2 + +%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-numcompress -f filelist.lst +%dir %{python3_sitelib}/* + +%files help -f doclist.lst +%{_docdir}/* + +%changelog +* Wed May 31 2023 Python_Bot <Python_Bot@openeuler.org> - 0.1.2-1 +- Package Spec generated |