automatic import of python-haversine

1 files changed, 507 insertions, 0 deletions

diff --git a/python-haversine.spec b/python-haversine.spec
new file mode 100644
index 0000000..77f8c65
--- /dev/null
+++ b/python-haversine.spec
@@ -0,0 +1,507 @@
+%global _empty_manifest_terminate_build 0
+Name:		python-haversine
+Version:	2.8.0
+Release:	1
+Summary:	Calculate the distance between 2 points on Earth.
+License:	MIT
+URL:		https://github.com/mapado/haversine
+Source0:	https://mirrors.nju.edu.cn/pypi/web/packages/b9/6b/0a774af6a2eea772aa99e5fbc7af7711eba02ff0dee3e71838c1b5926ef5/haversine-2.8.0.tar.gz
+BuildArch:	noarch
+
+
+%description
+# Haversine
+
+Calculate the distance (in various units) between two points on Earth using their latitude and longitude.
+
+## Installation
+
+```sh
+pip install haversine
+```
+
+## Usage
+
+### Calculate the distance between Lyon and Paris
+
+```python
+from haversine import haversine, Unit
+
+lyon = (45.7597, 4.8422) # (lat, lon)
+paris = (48.8567, 2.3508)
+
+haversine(lyon, paris)
+>> 392.2172595594006  # in kilometers
+
+haversine(lyon, paris, unit=Unit.MILES)
+>> 243.71250609539814  # in miles
+
+# you can also use the string abbreviation for units:
+haversine(lyon, paris, unit='mi')
+>> 243.71250609539814  # in miles
+
+haversine(lyon, paris, unit=Unit.NAUTICAL_MILES)
+>> 211.78037755311516  # in nautical miles
+```
+
+The lat/lon values need to be provided in degrees of the ranges [-90,90] (lat) and [-180,180] (lon).
+If values are outside their ranges, an error will be raised. This can be avoided by automatic normalization via the `normalize` parameter.
+
+The `haversine.Unit` enum contains all supported units:
+
+```python
+import haversine
+
+print(tuple(haversine.Unit))
+```
+
+outputs
+
+```text
+(<Unit.KILOMETERS: 'km'>, <Unit.METERS: 'm'>, <Unit.MILES: 'mi'>,
+ <Unit.NAUTICAL_MILES: 'nmi'>, <Unit.FEET: 'ft'>, <Unit.INCHES: 'in'>,
+ <Unit.RADIANS: 'rad'>, <Unit.DEGREES: 'deg'>)
+```
+
+#### Note for radians and degrees
+
+The radian and degrees returns the [great circle distance](https://en.wikipedia.org/wiki/Great-circle_distance) between two points on a sphere.
+
+Notes:
+
+- on a unit-sphere the angular distance in radians equals the distance between the two points on the sphere (definition of radians)
+- When using "degree", this angle is just converted from radians to degrees
+
+### Inverse Haversine Formula
+
+Calculates a point from a given vector (distance and direction) and start point.
+Currently explicitly supports both cardinal (north, east, south, west) and intercardinal (northeast, southeast, southwest, northwest) directions.
+But also allows for explicit angles expressed in Radians.
+
+## Example: Finding arbitary point from Paris
+
+```python
+from haversine import inverse_haversine, Direction
+from math import pi
+paris = (48.8567, 2.3508) # (lat, lon)
+# Finding 32 km west of Paris
+inverse_haversine(paris, 32, Direction.WEST)
+# returns tuple (48.85587279023947, 1.9134085092836945)
+# Finding 32 km southwest of Paris
+inverse_haversine(paris, 32, pi * 1.25)
+# returns tuple (48.65279552300661, 2.0427666779658806)
+# Finding 50 miles north of Paris
+inverse_haversine(paris, 50, Direction.NORTH, unit=Unit.MILES)
+# returns tuple (49.58035791599536, 2.3508)
+# Finding 10 nautical miles south of Paris
+inverse_haversine(paris, 10, Direction.SOUTH, unit=Unit.NAUTICAL_MILES)
+# returns tuple (48.690145868497645, 2.3508)
+```
+
+### Performance optimisation for distances between all points in two vectors
+
+You will need to install [numpy](https://pypi.org/project/numpy/) in order to gain performance with vectors.
+For optimal performance, you can turn off coordinate checking by adding `check=False` and install the optional packages [numba](https://pypi.org/project/numba/) and [icc_rt](https://pypi.org/project/icc_rt/).
+
+You can then do this:
+
+```python
+from haversine import haversine_vector, Unit
+
+lyon = (45.7597, 4.8422) # (lat, lon)
+paris = (48.8567, 2.3508)
+new_york = (40.7033962, -74.2351462)
+
+haversine_vector([lyon, lyon], [paris, new_york], Unit.KILOMETERS)
+
+>> array([ 392.21725956, 6163.43638211])
+```
+
+It is generally slower to use `haversine_vector` to get distance between two points, but can be really fast to compare distances between two vectors.
+
+### Combine matrix
+
+You can generate a matrix of all combinations between coordinates in different vectors by setting `comb` parameter as True.
+
+```python
+from haversine import haversine_vector, Unit
+
+lyon = (45.7597, 4.8422) # (lat, lon)
+london = (51.509865, -0.118092)
+paris = (48.8567, 2.3508)
+new_york = (40.7033962, -74.2351462)
+
+haversine_vector([lyon, london], [paris, new_york], Unit.KILOMETERS, comb=True)
+
+>> array([[ 392.21725956,  343.37455271],
+ 	  [6163.43638211, 5586.48447423]])
+```
+
+The output array from the example above returns the following table:
+
+|        |       Paris       |       New York       |
+| ------ | :---------------: | :------------------: |
+| Lyon   |  Lyon <\-> Paris  |  Lyon <\-> New York  |
+| London | London <\-> Paris | London <\-> New York |
+
+By definition, if you have a vector _a_ with _n_ elements, and a vector _b_ with _m_ elements. The result matrix _M_ would be $n x m$ and a element M\[i,j\] from the matrix would be the distance between the ith coordinate from vector _a_ and jth coordinate with vector _b_.
+
+## Contributing
+
+Clone the project.
+
+Install [pipenv](https://github.com/pypa/pipenv).
+
+Run `pipenv install --dev`
+
+Launch test with `pipenv run pytest`
+
+
+%package -n python3-haversine
+Summary:	Calculate the distance between 2 points on Earth.
+Provides:	python-haversine
+BuildRequires:	python3-devel
+BuildRequires:	python3-setuptools
+BuildRequires:	python3-pip
+%description -n python3-haversine
+# Haversine
+
+Calculate the distance (in various units) between two points on Earth using their latitude and longitude.
+
+## Installation
+
+```sh
+pip install haversine
+```
+
+## Usage
+
+### Calculate the distance between Lyon and Paris
+
+```python
+from haversine import haversine, Unit
+
+lyon = (45.7597, 4.8422) # (lat, lon)
+paris = (48.8567, 2.3508)
+
+haversine(lyon, paris)
+>> 392.2172595594006  # in kilometers
+
+haversine(lyon, paris, unit=Unit.MILES)
+>> 243.71250609539814  # in miles
+
+# you can also use the string abbreviation for units:
+haversine(lyon, paris, unit='mi')
+>> 243.71250609539814  # in miles
+
+haversine(lyon, paris, unit=Unit.NAUTICAL_MILES)
+>> 211.78037755311516  # in nautical miles
+```
+
+The lat/lon values need to be provided in degrees of the ranges [-90,90] (lat) and [-180,180] (lon).
+If values are outside their ranges, an error will be raised. This can be avoided by automatic normalization via the `normalize` parameter.
+
+The `haversine.Unit` enum contains all supported units:
+
+```python
+import haversine
+
+print(tuple(haversine.Unit))
+```
+
+outputs
+
+```text
+(<Unit.KILOMETERS: 'km'>, <Unit.METERS: 'm'>, <Unit.MILES: 'mi'>,
+ <Unit.NAUTICAL_MILES: 'nmi'>, <Unit.FEET: 'ft'>, <Unit.INCHES: 'in'>,
+ <Unit.RADIANS: 'rad'>, <Unit.DEGREES: 'deg'>)
+```
+
+#### Note for radians and degrees
+
+The radian and degrees returns the [great circle distance](https://en.wikipedia.org/wiki/Great-circle_distance) between two points on a sphere.
+
+Notes:
+
+- on a unit-sphere the angular distance in radians equals the distance between the two points on the sphere (definition of radians)
+- When using "degree", this angle is just converted from radians to degrees
+
+### Inverse Haversine Formula
+
+Calculates a point from a given vector (distance and direction) and start point.
+Currently explicitly supports both cardinal (north, east, south, west) and intercardinal (northeast, southeast, southwest, northwest) directions.
+But also allows for explicit angles expressed in Radians.
+
+## Example: Finding arbitary point from Paris
+
+```python
+from haversine import inverse_haversine, Direction
+from math import pi
+paris = (48.8567, 2.3508) # (lat, lon)
+# Finding 32 km west of Paris
+inverse_haversine(paris, 32, Direction.WEST)
+# returns tuple (48.85587279023947, 1.9134085092836945)
+# Finding 32 km southwest of Paris
+inverse_haversine(paris, 32, pi * 1.25)
+# returns tuple (48.65279552300661, 2.0427666779658806)
+# Finding 50 miles north of Paris
+inverse_haversine(paris, 50, Direction.NORTH, unit=Unit.MILES)
+# returns tuple (49.58035791599536, 2.3508)
+# Finding 10 nautical miles south of Paris
+inverse_haversine(paris, 10, Direction.SOUTH, unit=Unit.NAUTICAL_MILES)
+# returns tuple (48.690145868497645, 2.3508)
+```
+
+### Performance optimisation for distances between all points in two vectors
+
+You will need to install [numpy](https://pypi.org/project/numpy/) in order to gain performance with vectors.
+For optimal performance, you can turn off coordinate checking by adding `check=False` and install the optional packages [numba](https://pypi.org/project/numba/) and [icc_rt](https://pypi.org/project/icc_rt/).
+
+You can then do this:
+
+```python
+from haversine import haversine_vector, Unit
+
+lyon = (45.7597, 4.8422) # (lat, lon)
+paris = (48.8567, 2.3508)
+new_york = (40.7033962, -74.2351462)
+
+haversine_vector([lyon, lyon], [paris, new_york], Unit.KILOMETERS)
+
+>> array([ 392.21725956, 6163.43638211])
+```
+
+It is generally slower to use `haversine_vector` to get distance between two points, but can be really fast to compare distances between two vectors.
+
+### Combine matrix
+
+You can generate a matrix of all combinations between coordinates in different vectors by setting `comb` parameter as True.
+
+```python
+from haversine import haversine_vector, Unit
+
+lyon = (45.7597, 4.8422) # (lat, lon)
+london = (51.509865, -0.118092)
+paris = (48.8567, 2.3508)
+new_york = (40.7033962, -74.2351462)
+
+haversine_vector([lyon, london], [paris, new_york], Unit.KILOMETERS, comb=True)
+
+>> array([[ 392.21725956,  343.37455271],
+ 	  [6163.43638211, 5586.48447423]])
+```
+
+The output array from the example above returns the following table:
+
+|        |       Paris       |       New York       |
+| ------ | :---------------: | :------------------: |
+| Lyon   |  Lyon <\-> Paris  |  Lyon <\-> New York  |
+| London | London <\-> Paris | London <\-> New York |
+
+By definition, if you have a vector _a_ with _n_ elements, and a vector _b_ with _m_ elements. The result matrix _M_ would be $n x m$ and a element M\[i,j\] from the matrix would be the distance between the ith coordinate from vector _a_ and jth coordinate with vector _b_.
+
+## Contributing
+
+Clone the project.
+
+Install [pipenv](https://github.com/pypa/pipenv).
+
+Run `pipenv install --dev`
+
+Launch test with `pipenv run pytest`
+
+
+%package help
+Summary:	Development documents and examples for haversine
+Provides:	python3-haversine-doc
+%description help
+# Haversine
+
+Calculate the distance (in various units) between two points on Earth using their latitude and longitude.
+
+## Installation
+
+```sh
+pip install haversine
+```
+
+## Usage
+
+### Calculate the distance between Lyon and Paris
+
+```python
+from haversine import haversine, Unit
+
+lyon = (45.7597, 4.8422) # (lat, lon)
+paris = (48.8567, 2.3508)
+
+haversine(lyon, paris)
+>> 392.2172595594006  # in kilometers
+
+haversine(lyon, paris, unit=Unit.MILES)
+>> 243.71250609539814  # in miles
+
+# you can also use the string abbreviation for units:
+haversine(lyon, paris, unit='mi')
+>> 243.71250609539814  # in miles
+
+haversine(lyon, paris, unit=Unit.NAUTICAL_MILES)
+>> 211.78037755311516  # in nautical miles
+```
+
+The lat/lon values need to be provided in degrees of the ranges [-90,90] (lat) and [-180,180] (lon).
+If values are outside their ranges, an error will be raised. This can be avoided by automatic normalization via the `normalize` parameter.
+
+The `haversine.Unit` enum contains all supported units:
+
+```python
+import haversine
+
+print(tuple(haversine.Unit))
+```
+
+outputs
+
+```text
+(<Unit.KILOMETERS: 'km'>, <Unit.METERS: 'm'>, <Unit.MILES: 'mi'>,
+ <Unit.NAUTICAL_MILES: 'nmi'>, <Unit.FEET: 'ft'>, <Unit.INCHES: 'in'>,
+ <Unit.RADIANS: 'rad'>, <Unit.DEGREES: 'deg'>)
+```
+
+#### Note for radians and degrees
+
+The radian and degrees returns the [great circle distance](https://en.wikipedia.org/wiki/Great-circle_distance) between two points on a sphere.
+
+Notes:
+
+- on a unit-sphere the angular distance in radians equals the distance between the two points on the sphere (definition of radians)
+- When using "degree", this angle is just converted from radians to degrees
+
+### Inverse Haversine Formula
+
+Calculates a point from a given vector (distance and direction) and start point.
+Currently explicitly supports both cardinal (north, east, south, west) and intercardinal (northeast, southeast, southwest, northwest) directions.
+But also allows for explicit angles expressed in Radians.
+
+## Example: Finding arbitary point from Paris
+
+```python
+from haversine import inverse_haversine, Direction
+from math import pi
+paris = (48.8567, 2.3508) # (lat, lon)
+# Finding 32 km west of Paris
+inverse_haversine(paris, 32, Direction.WEST)
+# returns tuple (48.85587279023947, 1.9134085092836945)
+# Finding 32 km southwest of Paris
+inverse_haversine(paris, 32, pi * 1.25)
+# returns tuple (48.65279552300661, 2.0427666779658806)
+# Finding 50 miles north of Paris
+inverse_haversine(paris, 50, Direction.NORTH, unit=Unit.MILES)
+# returns tuple (49.58035791599536, 2.3508)
+# Finding 10 nautical miles south of Paris
+inverse_haversine(paris, 10, Direction.SOUTH, unit=Unit.NAUTICAL_MILES)
+# returns tuple (48.690145868497645, 2.3508)
+```
+
+### Performance optimisation for distances between all points in two vectors
+
+You will need to install [numpy](https://pypi.org/project/numpy/) in order to gain performance with vectors.
+For optimal performance, you can turn off coordinate checking by adding `check=False` and install the optional packages [numba](https://pypi.org/project/numba/) and [icc_rt](https://pypi.org/project/icc_rt/).
+
+You can then do this:
+
+```python
+from haversine import haversine_vector, Unit
+
+lyon = (45.7597, 4.8422) # (lat, lon)
+paris = (48.8567, 2.3508)
+new_york = (40.7033962, -74.2351462)
+
+haversine_vector([lyon, lyon], [paris, new_york], Unit.KILOMETERS)
+
+>> array([ 392.21725956, 6163.43638211])
+```
+
+It is generally slower to use `haversine_vector` to get distance between two points, but can be really fast to compare distances between two vectors.
+
+### Combine matrix
+
+You can generate a matrix of all combinations between coordinates in different vectors by setting `comb` parameter as True.
+
+```python
+from haversine import haversine_vector, Unit
+
+lyon = (45.7597, 4.8422) # (lat, lon)
+london = (51.509865, -0.118092)
+paris = (48.8567, 2.3508)
+new_york = (40.7033962, -74.2351462)
+
+haversine_vector([lyon, london], [paris, new_york], Unit.KILOMETERS, comb=True)
+
+>> array([[ 392.21725956,  343.37455271],
+ 	  [6163.43638211, 5586.48447423]])
+```
+
+The output array from the example above returns the following table:
+
+|        |       Paris       |       New York       |
+| ------ | :---------------: | :------------------: |
+| Lyon   |  Lyon <\-> Paris  |  Lyon <\-> New York  |
+| London | London <\-> Paris | London <\-> New York |
+
+By definition, if you have a vector _a_ with _n_ elements, and a vector _b_ with _m_ elements. The result matrix _M_ would be $n x m$ and a element M\[i,j\] from the matrix would be the distance between the ith coordinate from vector _a_ and jth coordinate with vector _b_.
+
+## Contributing
+
+Clone the project.
+
+Install [pipenv](https://github.com/pypa/pipenv).
+
+Run `pipenv install --dev`
+
+Launch test with `pipenv run pytest`
+
+
+%prep
+%autosetup -n haversine-2.8.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-haversine -f filelist.lst
+%dir %{python3_sitelib}/*
+
+%files help -f doclist.lst
+%{_docdir}/*
+
+%changelog
+* Mon Apr 10 2023 Python_Bot <Python_Bot@openeuler.org> - 2.8.0-1
+- Package Spec generated