simplestmaps 1.5.0__tar.gz → 1.7.0__tar.gz

simplestmaps-1.7.0/PKG-INFO

@@ -0,0 +1,61 @@
+Metadata-Version: 2.1
+Name: simplestmaps
+Version: 1.7.0
+Summary: Super simple on-liner maps in python.
+Home-page: http://github.com/fisadev/simplestmaps
+Author: Juan Pedro Fisanotti
+Author-email: fisadev@gmail.com
+License: MIT
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# Simplest Maps
+
+Super simple on-liner maps in python.
+
+# Installation
+
+`pip3 install simplestmaps`
+
+# Usage
+
+This lib aims to be super simple to use. For instance, to draw a markers and an area, you could do something like this:
+
+```python
+from simplestmaps import draw_map, area, marker
+
+draw_map(
+    marker(-31.2526, -61.4917, popup="my hometown"),
+    area([(-31.2741, -61.5105), (-31.2872, -61.5137), (-31.2895, -61.5003), (-31.2764, -61.4973)], color="green", popup="our airfield"),
+)
+```
+
+![example map](./docs/readme_example1.png)
+
+It can even do more advanced stuff, like plotting the contents of a geojson file (points, areas, lines):
+
+```python
+from simplestmaps import draw_map, geojson
+
+draw_map(
+    geojson("./docs/readme_example.geojson"),
+)
+```
+
+![example map](./docs/readme_example2.png)
+
+SimplestMaps can plot markers, dots, labels (text), custom html, lines, areas and geojsons, and all of that can be combined in every map.
+
+And every element plotted into the map is also customizable (colors, fonts, sizes, popups, etc).
+
+# More demos and docs
+
+Here are a good set of examples that showcase (and document) all of the supported features:
+
+## [Take a look at everything that's possible with so little code!](https://simplestmaps.fisadev.com/)

{simplestmaps-1.5.0 → simplestmaps-1.7.0}/README.md

@@ -19,7 +19,7 @@ draw_map(
 )
 ```
 
-![example map](./readme_example1.png)
+![example map](./docs/readme_example1.png)
 
 It can even do more advanced stuff, like plotting the contents of a geojson file (points, areas, lines):
 
@@ -27,11 +27,11 @@ It can even do more advanced stuff, like plotting the contents of a geojson file
 from simplestmaps import draw_map, geojson
 
 draw_map(
-    geojson("./readme_example.geojson"),
+    geojson("./docs/readme_example.geojson"),
 )
 ```
 
-![example map](./readme_example2.png)
+![example map](./docs/readme_example2.png)
 
 SimplestMaps can plot markers, dots, labels (text), custom html, lines, areas and geojsons, and all of that can be combined in every map.
 
@@ -41,4 +41,4 @@ And every element plotted into the map is also customizable (colors, fonts, size
 
 Here are a good set of examples that showcase (and document) all of the supported features:
 
-## [Take a look at everything that's possible with so little code!](https://nbviewer.org/github/fisadev/simplestmaps/blob/59c84384463eb31eb827e2ec42cb40f2f502ff58/demo_and_docs.ipynb)
+## [Take a look at everything that's possible with so little code!](https://simplestmaps.fisadev.com/)

{simplestmaps-1.5.0 → simplestmaps-1.7.0}/setup.py

@@ -3,7 +3,7 @@ from setuptools import setup
 
 setup(
     name="simplestmaps",
-    version="1.5.0",
+    version="1.7.0",
     description="Super simple on-liner maps in python.",
     long_description=open("README.md").read(),
     long_description_content_type="text/markdown",

simplestmaps-1.7.0/simplestmaps.egg-info/PKG-INFO

@@ -0,0 +1,61 @@
+Metadata-Version: 2.1
+Name: simplestmaps
+Version: 1.7.0
+Summary: Super simple on-liner maps in python.
+Home-page: http://github.com/fisadev/simplestmaps
+Author: Juan Pedro Fisanotti
+Author-email: fisadev@gmail.com
+License: MIT
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# Simplest Maps
+
+Super simple on-liner maps in python.
+
+# Installation
+
+`pip3 install simplestmaps`
+
+# Usage
+
+This lib aims to be super simple to use. For instance, to draw a markers and an area, you could do something like this:
+
+```python
+from simplestmaps import draw_map, area, marker
+
+draw_map(
+    marker(-31.2526, -61.4917, popup="my hometown"),
+    area([(-31.2741, -61.5105), (-31.2872, -61.5137), (-31.2895, -61.5003), (-31.2764, -61.4973)], color="green", popup="our airfield"),
+)
+```
+
+![example map](./docs/readme_example1.png)
+
+It can even do more advanced stuff, like plotting the contents of a geojson file (points, areas, lines):
+
+```python
+from simplestmaps import draw_map, geojson
+
+draw_map(
+    geojson("./docs/readme_example.geojson"),
+)
+```
+
+![example map](./docs/readme_example2.png)
+
+SimplestMaps can plot markers, dots, labels (text), custom html, lines, areas and geojsons, and all of that can be combined in every map.
+
+And every element plotted into the map is also customizable (colors, fonts, sizes, popups, etc).
+
+# More demos and docs
+
+Here are a good set of examples that showcase (and document) all of the supported features:
+
+## [Take a look at everything that's possible with so little code!](https://simplestmaps.fisadev.com/)

{simplestmaps-1.5.0 → simplestmaps-1.7.0}/simplestmaps.py

@@ -24,20 +24,25 @@ def all_numbers(sequence):
     )
 
 
-def to_points(source):
+def to_points(source, inverted_tuples=False):
     """
     Convert any possible thing to lat lon points and/or sequences of points.
+    Optionally reverse lat,lon values (used when converting points from lists of coordinates in
+    geojsons).
     """
     while source.__class__ in converters:
         # a custom type for which we have a converter registered, use it before trying to extract
         # points from it
         source = converters[source.__class__](source)
 
-    if isinstance(source, GeneratorType):
+    if isinstance(source, Point):
+        # don't re-convert things that are already points
+        return source
+    elif isinstance(source, GeneratorType):
         # traverse the generator and build a tuple with its components, that we can inspect and
         # parse (so we can do things like decide how to parse it based on its length and the types
         # of its items)
-        return to_points(tuple(source))
+        return to_points(tuple(source), inverted_tuples=inverted_tuples)
     elif hasattr(source, "lat") and hasattr(source, "lon"):
         # a few known classes that have lat long attributes
         lat, lon = source.lat, source.lon
@@ -49,18 +54,25 @@ def to_points(source):
         # a few known classes that have latitude_deg longitude_deg attributes, like the
         # locations from the orbit-predictor lib
         lat, lon = source.latitude_deg, source.longitude_deg
+    elif source.__class__.__name__ == "Position" and hasattr(source, "position_llh"):
+        # a known class from the orbit-predictor lib, which has ECEF coordinates but can easily
+        # produce lat, lon, height coords
+        lat, lon, _ = source.position_llh
     elif isinstance(source, (tuple, list)):
         if len(source) == 1:
             # a sequence with a single object inside, so extract a point from it as if we just got
             # that object alone
-            return to_points(source[0])
+            return to_points(source[0], inverted_tuples=inverted_tuples)
         elif len(source) in (2, 3) and all_numbers(source):
             # a sequence of 2 or 3 numbers, these must be coordinates, finally!
-            lat, lon = source[:2]
+            if inverted_tuples:
+                lon, lat = source[:2]
+            else:
+                lat, lon = source[:2]
         else:
             # a sequence that doesn't look like coordinates but maybe a collection of points, try
             # to extract all of them into a list
-            return [to_points(item) for item in source]
+            return [to_points(item, inverted_tuples=inverted_tuples) for item in source]
     else:
         raise ValueError(
             f"Can't guess the latitude and longitude from this object: {repr(source)}"
@@ -278,27 +290,21 @@ def geojson(path_or_data, points_as=marker, lines_as=line, areas_as=area):
             # a collection of features, extract them individually
             for feature in geojson_data["features"]:
                 yield from geojson(feature["geometry"], points_as, lines_as, areas_as)
-
         elif geojson_type == "Point":
-            # geojson uses lon,lat instead of lat,lon
-            raw_coords = geojson_data["coordinates"]
-            yield points_as(raw_coords[1], raw_coords[0])
-
+            yield points_as(
+                extract_single_points(to_points(geojson_data["coordinates"],
+                                                inverted_tuples=True))
+            )
         elif geojson_type == "LineString":
-            # geojson uses lon,lat instead of lat,lon
-            raw_coords_sequence = geojson_data["coordinates"]
             yield lines_as(
-                (raw_coords[1], raw_coords[0])
-                for raw_coords in raw_coords_sequence
+                extract_points_sequences(to_points(geojson_data["coordinates"],
+                                                   inverted_tuples=True))
+            )
+        elif geojson_type in ("Polygon", "MultiPolygon"):
+            yield areas_as(
+                extract_points_sequences(to_points(geojson_data["coordinates"],
+                                                   inverted_tuples=True))
             )
-
-        elif geojson_type == "Polygon":
-            # geojson uses lon,lat instead of lat,lon. And polygons have lists of lists of coords
-            for raw_coords_sequence in geojson_data["coordinates"]:
-                yield areas_as(
-                    (raw_coords[1], raw_coords[0])
-                    for raw_coords in raw_coords_sequence
-                )
 
 
 def draw_map(*things, center=(0, 0), zoom=1.5, tiles="cartodbpositron"):

simplestmaps-1.5.0/PKG-INFO

@@ -1,61 +0,0 @@
-Metadata-Version: 2.1
-Name: simplestmaps
-Version: 1.5.0
-Summary: Super simple on-liner maps in python.
-Home-page: http://github.com/fisadev/simplestmaps
-Author: Juan Pedro Fisanotti
-Author-email: fisadev@gmail.com
-License: MIT
-Description: # Simplest Maps
-        
-        Super simple on-liner maps in python.
-        
-        # Installation
-        
-        `pip3 install simplestmaps`
-        
-        # Usage
-        
-        This lib aims to be super simple to use. For instance, to draw a markers and an area, you could do something like this:
-        
-        ```python
-        from simplestmaps import draw_map, area, marker
-        
-        draw_map(
-            marker(-31.2526, -61.4917, popup="my hometown"),
-            area([(-31.2741, -61.5105), (-31.2872, -61.5137), (-31.2895, -61.5003), (-31.2764, -61.4973)], color="green", popup="our airfield"),
-        )
-        ```
-        
-        ![example map](./readme_example1.png)
-        
-        It can even do more advanced stuff, like plotting the contents of a geojson file (points, areas, lines):
-        
-        ```python
-        from simplestmaps import draw_map, geojson
-        
-        draw_map(
-            geojson("./readme_example.geojson"),
-        )
-        ```
-        
-        ![example map](./readme_example2.png)
-        
-        SimplestMaps can plot markers, dots, labels (text), custom html, lines, areas and geojsons, and all of that can be combined in every map.
-        
-        And every element plotted into the map is also customizable (colors, fonts, sizes, popups, etc).
-        
-        # More demos and docs
-        
-        Here are a good set of examples that showcase (and document) all of the supported features:
-        
-        ## [Take a look at everything that's possible with so little code!](https://nbviewer.org/github/fisadev/simplestmaps/blob/59c84384463eb31eb827e2ec42cb40f2f502ff58/demo_and_docs.ipynb)
-        
-Platform: UNKNOWN
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Natural Language :: English
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3
-Description-Content-Type: text/markdown

simplestmaps-1.5.0/simplestmaps.egg-info/PKG-INFO

@@ -1,61 +0,0 @@
-Metadata-Version: 2.1
-Name: simplestmaps
-Version: 1.5.0
-Summary: Super simple on-liner maps in python.
-Home-page: http://github.com/fisadev/simplestmaps
-Author: Juan Pedro Fisanotti
-Author-email: fisadev@gmail.com
-License: MIT
-Description: # Simplest Maps
-        
-        Super simple on-liner maps in python.
-        
-        # Installation
-        
-        `pip3 install simplestmaps`
-        
-        # Usage
-        
-        This lib aims to be super simple to use. For instance, to draw a markers and an area, you could do something like this:
-        
-        ```python
-        from simplestmaps import draw_map, area, marker
-        
-        draw_map(
-            marker(-31.2526, -61.4917, popup="my hometown"),
-            area([(-31.2741, -61.5105), (-31.2872, -61.5137), (-31.2895, -61.5003), (-31.2764, -61.4973)], color="green", popup="our airfield"),
-        )
-        ```
-        
-        ![example map](./readme_example1.png)
-        
-        It can even do more advanced stuff, like plotting the contents of a geojson file (points, areas, lines):
-        
-        ```python
-        from simplestmaps import draw_map, geojson
-        
-        draw_map(
-            geojson("./readme_example.geojson"),
-        )
-        ```
-        
-        ![example map](./readme_example2.png)
-        
-        SimplestMaps can plot markers, dots, labels (text), custom html, lines, areas and geojsons, and all of that can be combined in every map.
-        
-        And every element plotted into the map is also customizable (colors, fonts, sizes, popups, etc).
-        
-        # More demos and docs
-        
-        Here are a good set of examples that showcase (and document) all of the supported features:
-        
-        ## [Take a look at everything that's possible with so little code!](https://nbviewer.org/github/fisadev/simplestmaps/blob/59c84384463eb31eb827e2ec42cb40f2f502ff58/demo_and_docs.ipynb)
-        
-Platform: UNKNOWN
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Natural Language :: English
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3
-Description-Content-Type: text/markdown