[FEAT] Allow processing of multiple countries via CLI (#190)

* Allow input of multiple countries

* move get_tiles_of_wanted_map into base class

* unify xy processing with country processing

- XYGeofabrik class takes raw into in _init_ method
- get_xy_coordinates_from_input therefore moved to geofabrik.py
- unittests adopted to new way of calling XYGeofabrik class

* fix some pylint findings

* Bump version to v4.0.0a1

* clarify -co and -xy cli arguments

* Bump version to v4.0.0a2

* Bump version to v4.0.0a4

* enhance calc_border_countries if -nbc is given

* Bump version to v4.0.0a6

* Bump version to v4.0.0a9

* calc_country_name for multiple countries

Author: treee111

.vscode/launch.json

@@ -238,6 +238,36 @@
                 "100"
             ]
         },
+        {
+            "name": "country: liechtenstein & suisse",
+            "type": "python",
+            "request": "launch",
+            "module": "wahoomc",
+            "console": "integratedTerminal",
+            "args": [
+                "cli",
+                "-co",
+                "liechtenstein,switzerland",
+                "-c",
+                "-md",
+                "100"
+            ]
+        },
+        {
+            "name": "country: malta & liechtenstein",
+            "type": "python",
+            "request": "launch",
+            "module": "wahoomc",
+            "console": "integratedTerminal",
+            "args": [
+                "cli",
+                "-co",
+                "malta,liechtenstein",
+                "-c",
+                "-md",
+                "100"
+            ]
+        },
         {
             "name": "co: france",
             "type": "python",

setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = wahoomc
-version = 4.0.0a0
+version = 4.0.0a9
 author = Benjamin Kreuscher
 author_email = benni.kreuscher@gmail.com
 description = Create maps for your Wahoo bike computer based on latest OSM maps 

tests/test_geofabrik.py

@@ -4,11 +4,11 @@
 import os
 # import sys
 import unittest
-from shapely.geometry import shape # pylint: disable=import-error
+from shapely.geometry import shape  # pylint: disable=import-error
 
 # import custom python packages
 from wahoomc.geofabrik import CountryGeofabrik, XYGeofabrik
-from wahoomc.geofabrik import calc_bounding_box_tiles
+from wahoomc.geofabrik import calc_bounding_box_tiles, get_xy_coordinates_from_input
 from wahoomc.downloader import Downloader
 from wahoomc import constants
 from wahoomc.geofabrik_json import GeofabrikJson
@@ -73,8 +73,7 @@ def test_tiles_via_geofabrik_malta_xy(self):
         item_0 = [{'x': 138, 'y': 100, 'left': 14.0625, 'top': 36.59788913307021, 'right': 15.46875, 'bottom': 35.4606699514953, 'countries': [
             'italy', 'malta'], 'urls': ['https://download.geofabrik.de/europe/italy-latest.osm.pbf', 'https://download.geofabrik.de/europe/malta-latest.osm.pbf']}]
 
-        geofabrik_tiles = calc_tiles_via_geofabrik_json_xy(
-            [{'x': 138, 'y': 100}])
+        geofabrik_tiles = calc_tiles_via_geofabrik_json_xy('138/100')
 
         self.assertEqual(item_0, geofabrik_tiles)
 
@@ -97,8 +96,7 @@ def test_tiles_via_geofabrik_xy(self):
                      'https://download.geofabrik.de/europe/germany-latest.osm.pbf']
         }]
 
-        geofabrik_tiles = calc_tiles_via_geofabrik_json_xy(
-            [{"x": 133, "y": 88}])
+        geofabrik_tiles = calc_tiles_via_geofabrik_json_xy('133/88')
 
         self.assertEqual(geofabrik_tiles_exp, geofabrik_tiles)
 
@@ -152,11 +150,50 @@ def test_bbox_and_shape_xy(self):
         bbox_tiles = calc_bounding_box_tiles(bbox)
         self.assertEqual(bbox_tiles_exp, bbox_tiles)
 
-        o_geofabrik = XYGeofabrik([{'x': 138, 'y': 100}])
+        o_geofabrik = XYGeofabrik('138/100')
         wanted_region_string = str(o_geofabrik.compose_shape(bbox_tiles))
 
         self.assertEqual(wanted_region_exp, wanted_region_string)
 
+    def test_splitting_of_single_xy_coordinate(self):
+        """
+        use static json files in the repo to calculate relevant tiles
+        """
+
+        xy_tuple = get_xy_coordinates_from_input("133/88")
+        self.assertEqual(xy_tuple, [{"x": 133, "y": 88}])
+
+        xy_tuple = get_xy_coordinates_from_input("11/92")
+        self.assertEqual(xy_tuple, [{"x": 11, "y": 92}])
+
+        xy_tuple = get_xy_coordinates_from_input("138/100")
+        self.assertEqual(xy_tuple, [{"x": 138, "y": 100}])
+
+    def test_splitting_of_multiple_xy_coordinate(self):
+        """
+        use static json files in the repo to calculate relevant tiles
+        """
+
+        xy_tuple = get_xy_coordinates_from_input("133/88,138/100")
+        expected_result = [{"x": 133, "y": 88}, {"x": 138, "y": 100}]
+
+        self.assertEqual(xy_tuple, expected_result)
+
+    # def test_get_tile_via_xy_coordinate_error(self):
+    #     """
+    #     use static json files in the repo to calculate a not-existing tile.
+
+    #     does not error out due to new Geofabrik Json processing. Nevertheless, the tile is not existing
+    #     only +/- 180 -/+90: https://epsg.io/4326
+    #     """
+
+    #     o_geofabrik = XYGeofabrik([{"x": 200, "y": 1}])
+
+    #     # tiles =
+
+    #     with self.assertRaises(TileNotFoundError):
+    #         o_geofabrik.get_tiles_of_wanted_map()
+
 
 if __name__ == '__main__':
     unittest.main()

tests/test_osm_maps.py

@@ -8,7 +8,6 @@
 # import custom python packages
 from wahoomc.osm_maps_functions import CountryOsmData, XYOsmData
 from wahoomc.osm_maps_functions import OsmMaps
-from wahoomc.osm_maps_functions import get_xy_coordinates_from_input
 # from wahoomc.osm_maps_functions import TileNotFoundError
 from wahoomc.input import InputData
 from wahoomc import file_directory_functions as fd_fct
@@ -40,6 +39,13 @@ def test_calc_border_countries_input_country(self):
         self.process_and_check_border_countries(
             'germany', True, expected_result, 'country')
 
+        # germany,malta
+        expected_result = {'czech-republic': {}, 'germany': {}, 'austria': {}, 'liechtenstein': {},
+                           'switzerland': {}, 'italy': {}, 'netherlands': {}, 'belgium': {},
+                           'luxembourg': {}, 'france': {}, 'poland': {}, 'denmark': {}, 'sweden': {}, 'malta': {}}
+        self.process_and_check_border_countries(
+            'germany,malta', True, expected_result, 'country')
+
     def test_calc_border_countries_input_xy_coordinates_1tile(self):
         """
         Test initialized border countries
@@ -78,7 +84,15 @@ def test_calc_without_border_countries_input_country(self):
         self.process_and_check_border_countries(
             'china', False, {'china': {}}, 'country')
 
-    def test_calc_without_border_countries__xy_coordinates_1tile(self):
+        # malta,liechtenstein
+        self.process_and_check_border_countries(
+            'malta,liechtenstein', False, {'malta': {}, 'liechtenstein': {}}, 'country')
+
+        # malta,tunisia
+        self.process_and_check_border_countries(
+            'malta,tunisia', False, {'malta': {}, 'tunisia': {}}, 'country')
+
+    def test_calc_without_border_countries_xy_coordinates_1tile(self):
         """
         Test initialized countries without border countries
         - of one tile
@@ -89,7 +103,7 @@ def test_calc_without_border_countries__xy_coordinates_1tile(self):
         self.process_and_check_border_countries(
             "133/88", False, expected_result, 'xy_coordinate')
 
-    def test_calc_without_border_countries__xy_coordinates_2tiles(self):
+    def test_calc_without_border_countries_xy_coordinates_2tiles(self):
         """
         Test initialized countries without border countries
         - of two tiles
@@ -146,45 +160,6 @@ def test_input_country_malta(self):
         result = o_osm_data.country_name
         self.assertEqual(result, 'malta')
 
-    def test_splitting_of_single_xy_coordinate(self):
-        """
-        use static json files in the repo to calculate relevant tiles
-        """
-
-        xy_tuple = get_xy_coordinates_from_input("133/88")
-        self.assertEqual(xy_tuple, [{"x": 133, "y": 88}])
-
-        xy_tuple = get_xy_coordinates_from_input("11/92")
-        self.assertEqual(xy_tuple, [{"x": 11, "y": 92}])
-
-        xy_tuple = get_xy_coordinates_from_input("138/100")
-        self.assertEqual(xy_tuple, [{"x": 138, "y": 100}])
-
-    def test_splitting_of_multiple_xy_coordinate(self):
-        """
-        use static json files in the repo to calculate relevant tiles
-        """
-
-        xy_tuple = get_xy_coordinates_from_input("133/88,138/100")
-        expected_result = [{"x": 133, "y": 88}, {"x": 138, "y": 100}]
-
-        self.assertEqual(xy_tuple, expected_result)
-
-    # def test_get_tile_via_xy_coordinate_error(self):
-    #     """
-    #     use static json files in the repo to calculate a not-existing tile.
-
-    #     does not error out due to new Geofabrik Json processing. Nevertheless, the tile is not existing
-    #     only +/- 180 -/+90: https://epsg.io/4326
-    #     """
-
-    #     o_geofabrik = XYGeofabrik([{"x": 200, "y": 1}])
-
-    #     # tiles =
-
-    #     with self.assertRaises(TileNotFoundError):
-    #         o_geofabrik.get_tiles_of_wanted_map()
-
     def test_encoding_open_sea_osm(self):
         """
         use static json files in the repo to calculate relevant tile