automatic import of python-geopipopeneuler20.03

1 files changed, 348 insertions, 0 deletions

diff --git a/python-geopip.spec b/python-geopip.spec
new file mode 100644
index 0000000..0dd9c22
--- /dev/null
+++ b/python-geopip.spec
@@ -0,0 +1,348 @@
+%global _empty_manifest_terminate_build 0
+Name:		python-geopip
+Version:	1.1
+Release:	1
+Summary:	Reverse geocode a lng/lat coordinate within a geojson FeatureCollection.
+License:	MIT
+URL:		https://github.com/tammoippen/geopip
+Source0:	https://mirrors.nju.edu.cn/pypi/web/packages/f8/68/6915c368d8ca24f1b8e91b3184241fc9a6379ff0fd39f9b949ed5a835037/geopip-1.1.tar.gz
+BuildArch:	noarch
+
+
+%description
+|Build Status| |Coverage Status| |Tested CPython Versions| |Tested PyPy
+Versions| |PyPi version| |PyPi license|
+Reverse geocode a lng/lat coordinate within a geojson
+``FeatureCollection`` and return information about the containing
+country (polygon).
+Basically, you can use any
+`geojson <https://tools.ietf.org/html/rfc7946>`__ file (top level is a
+``FeatureCollection``) for reverse coding - set the environment variable
+``REVERSE_GEOCODE_DATA`` to the geojson file. Only ``Polygon`` and
+``MultiPolygon`` features will be used! If a point is found to be in a
+feature, the ``properties`` of that feature will be returned.
+In other words, provide a geojson with postcode boundaries, and you can
+query for the postcode in which a coordinate is. Provide timezone
+boundaries and you can find the timezone for a coordinate. Be creative
+The default shape data (contained within the package) is from
+`thematicmapping <http://thematicmapping.org/downloads/world_borders.php>`__
+(the simple shapes). It contains polygons representing one country with
+the following meta-data (``properties``):
+    FIPS      String(2)         FIPS 10-4 Country Code
+    ISO2      String(2)         ISO 3166-1 Alpha-2 Country Code
+    ISO3      String(3)         ISO 3166-1 Alpha-3 Country Code
+    UN        Short Integer(3)  ISO 3166-1 Numeric-3 Country Code
+    NAME      String(50)        Name of country/area
+    AREA      Long Integer(7)   Land area, FAO Statistics (2002)
+    POP2005   Double(10,0)      Population, World Population Prospects (2005)
+    REGION    Short Integer(3)  Macro geographical (continental region), UN Statistics
+    SUBREGION Short Integer(3)  Geographical sub-region, UN Statistics
+    LON       FLOAT (7,3)       Longitude
+    LAT       FLOAT (6,3)       Latitude
+Hence, you can use this package as an *offline reverse geocoder on the
+country level* (by default):
+    In [1]: import geopip
+    In [2]: geopip.search(lng=4.910248, lat=50.850981)
+    Out[2]:
+    {'AREA': 0,
+     'FIPS': 'BE',
+     'ISO2': 'BE',
+     'ISO3': 'BEL',
+     'LAT': 50.643,
+     'LON': 4.664,
+     'NAME': 'Belgium',
+     'POP2005': 10398049,
+     'REGION': 150,
+     'SUBREGION': 155,
+     'UN': 56}
+**NOTE**: Since the polygons for each country are quite simple, reverse
+geocoding at the borders of two countrys is **not** exact. Use polygons
+with higher resolution for these use cases (see `Data <#data>`__).
+The ``shapely`` package will be used, if installed. Otherwise, a pure
+python implementation will be used (on the basis of `winding
+numbers <https://en.wikipedia.org/wiki/Winding_number>`__). See
+`here <https://www.toptal.com/python/computational-geometry-in-python-from-theory-to-implementation>`__,
+`here <http://geomalgorithms.com/a03-_inclusion.html>`__ and
+`here <http://www.dgp.toronto.edu/~mac/e-stuff/point_in_polygon.py>`__
+for more informations and example implementations. Espacially for larger
+features, the shapely implementation might give performance improvements
+(default shape data and 2.6 GHz Intel Core i7, python3.6.2, cythonized
+version of
+`geohash-hilbert <https://github.com/tammoippen/geohash-hilbert>`__):
+*Pure*:
+    In [1]: import geopip
+    In [2]: geopip._geopip.p_in_polygon?
+    Signature: geopip._geopip.p_in_polygon(p, shp)
+    Docstring:
+    Test, whether point `p` is in shape `shp`.
+    Use the pure python implementation for this.
+    Parameters:
+        p: Tuple[float, float]  Point (lng, lat) in WGS84.
+        shp: Dict[str, Any]     Prepared shape dictionary from `geopip._pure.prepare()`.
+    Returns:
+        boolean: True, if p in shp, False otherwise
+    File:      ~/repositories/geopip/geopip/_pure.py
+    Type:      function
+    In [3]: %timeit geopip.search(4.910248, 50.850981)
+    25.6 µs ± 390 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
+*Shapely*:
+    In [1]: import geopip
+    In [2]: geopip_geopip.p_in_polygon?
+    Signature: geopip._geopip.p_in_polygon(p, shp)
+    Docstring:
+    Test, whether point `p` is in shape `shp`.
+    Use the shapely implementation for this.
+    Parameters:
+        p: Tuple[float, float]  Point (lng, lat) in WGS84.
+        shp: Dict[str, Any]     Prepared shape dictionary from `geopip._shapely.prepare()`.
+    Returns:
+        boolean: True, if p in shp, False otherwise
+    File:      ~/repositories/geopip/geopip/_shapely.py
+    Type:      function
+    In [3]: %timeit geopip.search(4.910248, 50.850981)
+    50 µs ± 601 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
+For simple geojsons, the pure python implementation is faster, but on
+more complex polygons, the shapely implementation will win.
+
+%package -n python3-geopip
+Summary:	Reverse geocode a lng/lat coordinate within a geojson FeatureCollection.
+Provides:	python-geopip
+BuildRequires:	python3-devel
+BuildRequires:	python3-setuptools
+BuildRequires:	python3-pip
+%description -n python3-geopip
+|Build Status| |Coverage Status| |Tested CPython Versions| |Tested PyPy
+Versions| |PyPi version| |PyPi license|
+Reverse geocode a lng/lat coordinate within a geojson
+``FeatureCollection`` and return information about the containing
+country (polygon).
+Basically, you can use any
+`geojson <https://tools.ietf.org/html/rfc7946>`__ file (top level is a
+``FeatureCollection``) for reverse coding - set the environment variable
+``REVERSE_GEOCODE_DATA`` to the geojson file. Only ``Polygon`` and
+``MultiPolygon`` features will be used! If a point is found to be in a
+feature, the ``properties`` of that feature will be returned.
+In other words, provide a geojson with postcode boundaries, and you can
+query for the postcode in which a coordinate is. Provide timezone
+boundaries and you can find the timezone for a coordinate. Be creative
+The default shape data (contained within the package) is from
+`thematicmapping <http://thematicmapping.org/downloads/world_borders.php>`__
+(the simple shapes). It contains polygons representing one country with
+the following meta-data (``properties``):
+    FIPS      String(2)         FIPS 10-4 Country Code
+    ISO2      String(2)         ISO 3166-1 Alpha-2 Country Code
+    ISO3      String(3)         ISO 3166-1 Alpha-3 Country Code
+    UN        Short Integer(3)  ISO 3166-1 Numeric-3 Country Code
+    NAME      String(50)        Name of country/area
+    AREA      Long Integer(7)   Land area, FAO Statistics (2002)
+    POP2005   Double(10,0)      Population, World Population Prospects (2005)
+    REGION    Short Integer(3)  Macro geographical (continental region), UN Statistics
+    SUBREGION Short Integer(3)  Geographical sub-region, UN Statistics
+    LON       FLOAT (7,3)       Longitude
+    LAT       FLOAT (6,3)       Latitude
+Hence, you can use this package as an *offline reverse geocoder on the
+country level* (by default):
+    In [1]: import geopip
+    In [2]: geopip.search(lng=4.910248, lat=50.850981)
+    Out[2]:
+    {'AREA': 0,
+     'FIPS': 'BE',
+     'ISO2': 'BE',
+     'ISO3': 'BEL',
+     'LAT': 50.643,
+     'LON': 4.664,
+     'NAME': 'Belgium',
+     'POP2005': 10398049,
+     'REGION': 150,
+     'SUBREGION': 155,
+     'UN': 56}
+**NOTE**: Since the polygons for each country are quite simple, reverse
+geocoding at the borders of two countrys is **not** exact. Use polygons
+with higher resolution for these use cases (see `Data <#data>`__).
+The ``shapely`` package will be used, if installed. Otherwise, a pure
+python implementation will be used (on the basis of `winding
+numbers <https://en.wikipedia.org/wiki/Winding_number>`__). See
+`here <https://www.toptal.com/python/computational-geometry-in-python-from-theory-to-implementation>`__,
+`here <http://geomalgorithms.com/a03-_inclusion.html>`__ and
+`here <http://www.dgp.toronto.edu/~mac/e-stuff/point_in_polygon.py>`__
+for more informations and example implementations. Espacially for larger
+features, the shapely implementation might give performance improvements
+(default shape data and 2.6 GHz Intel Core i7, python3.6.2, cythonized
+version of
+`geohash-hilbert <https://github.com/tammoippen/geohash-hilbert>`__):
+*Pure*:
+    In [1]: import geopip
+    In [2]: geopip._geopip.p_in_polygon?
+    Signature: geopip._geopip.p_in_polygon(p, shp)
+    Docstring:
+    Test, whether point `p` is in shape `shp`.
+    Use the pure python implementation for this.
+    Parameters:
+        p: Tuple[float, float]  Point (lng, lat) in WGS84.
+        shp: Dict[str, Any]     Prepared shape dictionary from `geopip._pure.prepare()`.
+    Returns:
+        boolean: True, if p in shp, False otherwise
+    File:      ~/repositories/geopip/geopip/_pure.py
+    Type:      function
+    In [3]: %timeit geopip.search(4.910248, 50.850981)
+    25.6 µs ± 390 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
+*Shapely*:
+    In [1]: import geopip
+    In [2]: geopip_geopip.p_in_polygon?
+    Signature: geopip._geopip.p_in_polygon(p, shp)
+    Docstring:
+    Test, whether point `p` is in shape `shp`.
+    Use the shapely implementation for this.
+    Parameters:
+        p: Tuple[float, float]  Point (lng, lat) in WGS84.
+        shp: Dict[str, Any]     Prepared shape dictionary from `geopip._shapely.prepare()`.
+    Returns:
+        boolean: True, if p in shp, False otherwise
+    File:      ~/repositories/geopip/geopip/_shapely.py
+    Type:      function
+    In [3]: %timeit geopip.search(4.910248, 50.850981)
+    50 µs ± 601 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
+For simple geojsons, the pure python implementation is faster, but on
+more complex polygons, the shapely implementation will win.
+
+%package help
+Summary:	Development documents and examples for geopip
+Provides:	python3-geopip-doc
+%description help
+|Build Status| |Coverage Status| |Tested CPython Versions| |Tested PyPy
+Versions| |PyPi version| |PyPi license|
+Reverse geocode a lng/lat coordinate within a geojson
+``FeatureCollection`` and return information about the containing
+country (polygon).
+Basically, you can use any
+`geojson <https://tools.ietf.org/html/rfc7946>`__ file (top level is a
+``FeatureCollection``) for reverse coding - set the environment variable
+``REVERSE_GEOCODE_DATA`` to the geojson file. Only ``Polygon`` and
+``MultiPolygon`` features will be used! If a point is found to be in a
+feature, the ``properties`` of that feature will be returned.
+In other words, provide a geojson with postcode boundaries, and you can
+query for the postcode in which a coordinate is. Provide timezone
+boundaries and you can find the timezone for a coordinate. Be creative
+The default shape data (contained within the package) is from
+`thematicmapping <http://thematicmapping.org/downloads/world_borders.php>`__
+(the simple shapes). It contains polygons representing one country with
+the following meta-data (``properties``):
+    FIPS      String(2)         FIPS 10-4 Country Code
+    ISO2      String(2)         ISO 3166-1 Alpha-2 Country Code
+    ISO3      String(3)         ISO 3166-1 Alpha-3 Country Code
+    UN        Short Integer(3)  ISO 3166-1 Numeric-3 Country Code
+    NAME      String(50)        Name of country/area
+    AREA      Long Integer(7)   Land area, FAO Statistics (2002)
+    POP2005   Double(10,0)      Population, World Population Prospects (2005)
+    REGION    Short Integer(3)  Macro geographical (continental region), UN Statistics
+    SUBREGION Short Integer(3)  Geographical sub-region, UN Statistics
+    LON       FLOAT (7,3)       Longitude
+    LAT       FLOAT (6,3)       Latitude
+Hence, you can use this package as an *offline reverse geocoder on the
+country level* (by default):
+    In [1]: import geopip
+    In [2]: geopip.search(lng=4.910248, lat=50.850981)
+    Out[2]:
+    {'AREA': 0,
+     'FIPS': 'BE',
+     'ISO2': 'BE',
+     'ISO3': 'BEL',
+     'LAT': 50.643,
+     'LON': 4.664,
+     'NAME': 'Belgium',
+     'POP2005': 10398049,
+     'REGION': 150,
+     'SUBREGION': 155,
+     'UN': 56}
+**NOTE**: Since the polygons for each country are quite simple, reverse
+geocoding at the borders of two countrys is **not** exact. Use polygons
+with higher resolution for these use cases (see `Data <#data>`__).
+The ``shapely`` package will be used, if installed. Otherwise, a pure
+python implementation will be used (on the basis of `winding
+numbers <https://en.wikipedia.org/wiki/Winding_number>`__). See
+`here <https://www.toptal.com/python/computational-geometry-in-python-from-theory-to-implementation>`__,
+`here <http://geomalgorithms.com/a03-_inclusion.html>`__ and
+`here <http://www.dgp.toronto.edu/~mac/e-stuff/point_in_polygon.py>`__
+for more informations and example implementations. Espacially for larger
+features, the shapely implementation might give performance improvements
+(default shape data and 2.6 GHz Intel Core i7, python3.6.2, cythonized
+version of
+`geohash-hilbert <https://github.com/tammoippen/geohash-hilbert>`__):
+*Pure*:
+    In [1]: import geopip
+    In [2]: geopip._geopip.p_in_polygon?
+    Signature: geopip._geopip.p_in_polygon(p, shp)
+    Docstring:
+    Test, whether point `p` is in shape `shp`.
+    Use the pure python implementation for this.
+    Parameters:
+        p: Tuple[float, float]  Point (lng, lat) in WGS84.
+        shp: Dict[str, Any]     Prepared shape dictionary from `geopip._pure.prepare()`.
+    Returns:
+        boolean: True, if p in shp, False otherwise
+    File:      ~/repositories/geopip/geopip/_pure.py
+    Type:      function
+    In [3]: %timeit geopip.search(4.910248, 50.850981)
+    25.6 µs ± 390 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
+*Shapely*:
+    In [1]: import geopip
+    In [2]: geopip_geopip.p_in_polygon?
+    Signature: geopip._geopip.p_in_polygon(p, shp)
+    Docstring:
+    Test, whether point `p` is in shape `shp`.
+    Use the shapely implementation for this.
+    Parameters:
+        p: Tuple[float, float]  Point (lng, lat) in WGS84.
+        shp: Dict[str, Any]     Prepared shape dictionary from `geopip._shapely.prepare()`.
+    Returns:
+        boolean: True, if p in shp, False otherwise
+    File:      ~/repositories/geopip/geopip/_shapely.py
+    Type:      function
+    In [3]: %timeit geopip.search(4.910248, 50.850981)
+    50 µs ± 601 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
+For simple geojsons, the pure python implementation is faster, but on
+more complex polygons, the shapely implementation will win.
+
+%prep
+%autosetup -n geopip-1.1
+
+%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-geopip -f filelist.lst
+%dir %{python3_sitelib}/*
+
+%files help -f doclist.lst
+%{_docdir}/*
+
+%changelog
+* Fri May 05 2023 Python_Bot <Python_Bot@openeuler.org> - 1.1-1
+- Package Spec generated