maps4fs 2.2.7__py3-none-any.whl → 2.2.72__py3-none-any.whl

maps4fs/__init__.py

@@ -6,4 +6,5 @@ import maps4fs.generator.component as component
 import maps4fs.generator.settings as settings
 from maps4fs.generator.game import Game
 from maps4fs.generator.map import Map
+from maps4fs.generator.settings import GenerationSettings, MainSettings
 from maps4fs.logger import Logger

maps4fs/generator/component/background.py

@@ -586,7 +586,7 @@ class Background(MeshComponent, ImageComponent):
                 continue
 
             # Make Polygon a little bit bigger to hide under the terrain when creating water planes.
-            polygon = polygon.buffer(Parameters.WATER_ADD_WIDTH, resolution=4)
+            polygon = polygon.buffer(Parameters.WATER_ADD_WIDTH, quad_segs=4)
 
             polygons.append(polygon)
 

maps4fs/generator/component/dem.py

@@ -7,9 +7,6 @@ import cv2
 import numpy as np
 from pydtmdl import DTMProvider
 
-# import rasterio  # type: ignore
-from pympler import asizeof  # type: ignore
-
 import maps4fs.generator.config as mfscfg
 from maps4fs.generator.component.base.component_image import ImageComponent
 
@@ -297,9 +294,6 @@ class DEM(ImageComponent):
         """
         resampled_data = cv2.resize(data, self.output_resolution, interpolation=cv2.INTER_LINEAR)
 
-        size_of_resampled_data = asizeof.asizeof(resampled_data) / 1024 / 1024
-        self.logger.debug("Size of resampled data: %s MB.", size_of_resampled_data)
-
         return resampled_data
 
     def rotate_dem(self) -> None:

maps4fs/generator/component/grle.py

@@ -472,7 +472,7 @@ class GRLE(ImageComponent, XMLComponent):
             for a, r in zip(random_angles, random_radii)
         ]
         polygon = Polygon(points)
-        buffered_polygon = polygon.buffer(rounding_radius, resolution=16)
+        buffered_polygon = polygon.buffer(rounding_radius, quad_segs=16)
         rounded_polygon = list(buffered_polygon.exterior.coords)
         if not rounded_polygon:
             return None

maps4fs/generator/config.py

@@ -3,6 +3,7 @@
 import os
 import shutil
 import subprocess
+import tempfile
 
 from osmnx import settings as ox_settings
 
@@ -10,34 +11,94 @@ from maps4fs.logger import Logger
 
 logger = Logger()
 
-DEFAULT_TEMPLATES_DIR = os.path.join(os.getcwd(), "data")
-MFS_TEMPLATES_DIR = os.getenv("MFS_TEMPLATES_DIRECTORY")
-if MFS_TEMPLATES_DIR is None:
-    logger.info("MFS_TEMPLATES_DIRECTORY is not set. Using default templates directory.")
-    MFS_TEMPLATES_DIR = DEFAULT_TEMPLATES_DIR
-else:
-    logger.info("MFS_TEMPLATES_DIRECTORY is set to: %s", MFS_TEMPLATES_DIR)
-    if not os.path.isdir(MFS_TEMPLATES_DIR):
-        logger.info("Templates directory %s does not exist. Creating it.", MFS_TEMPLATES_DIR)
-        os.makedirs(MFS_TEMPLATES_DIR, exist_ok=True)
-
-    # Check if there any files (directory is empty).
-    if not os.listdir(MFS_TEMPLATES_DIR):
-        logger.info("Templates directory %s is empty. Copying default files.", MFS_TEMPLATES_DIR)
-        for item in os.listdir(DEFAULT_TEMPLATES_DIR):
-            s = os.path.join(DEFAULT_TEMPLATES_DIR, item)
-            d = os.path.join(MFS_TEMPLATES_DIR, item)
-            if os.path.isdir(s):
-                shutil.copytree(s, d, False, None)
+MFS_TEMPLATES_DIR = os.path.join(os.getcwd(), "data")
+
+
+def ensure_templates():
+    """Ensure templates directory exists and is populated with data.
+
+    If MFS_TEMPLATES_DIR is empty or doesn't exist, clone the maps4fsdata
+    repository and run the preparation script to populate it.
+    """
+
+    # Check if templates directory exists and has content
+    if os.path.exists(MFS_TEMPLATES_DIR) and os.listdir(MFS_TEMPLATES_DIR):
+        logger.info("Templates directory already exists and contains data: %s", MFS_TEMPLATES_DIR)
+        return
+
+    logger.info("Templates directory is empty or missing, preparing data...")
+
+    # Create templates directory if it doesn't exist
+    os.makedirs(MFS_TEMPLATES_DIR, exist_ok=True)
+
+    try:
+        with tempfile.TemporaryDirectory() as temp_dir:
+            clone_dir = os.path.join(temp_dir, "maps4fsdata")
+
+            logger.info("Cloning maps4fsdata repository to temporary directory...")
+            # Clone the repository with depth 1 (shallow clone)
+            subprocess.run(
+                [
+                    "git",
+                    "clone",
+                    "--depth",
+                    "1",
+                    "https://github.com/iwatkot/maps4fsdata.git",
+                    clone_dir,
+                ],
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+
+            # Make the preparation script executable
+            prep_script = os.path.join(clone_dir, "prepare_data.sh")
+            if os.path.exists(prep_script):
+                os.chmod(prep_script, 0o755)
+
+                logger.info("Running data preparation script...")
+                # Run the preparation script from the cloned directory
+                subprocess.run(
+                    ["./prepare_data.sh"], cwd=clone_dir, check=True, capture_output=True, text=True
+                )
+
+                # Copy the generated data directory to templates directory
+                data_src = os.path.join(clone_dir, "data")
+                if os.path.exists(data_src):
+                    logger.info(
+                        "Copying prepared data to templates directory: %s", MFS_TEMPLATES_DIR
+                    )
+                    # Copy all files from data directory to MFS_TEMPLATES_DIR
+                    for item in os.listdir(data_src):
+                        src_path = os.path.join(data_src, item)
+                        dst_path = os.path.join(MFS_TEMPLATES_DIR, item)
+                        if os.path.isdir(src_path):
+                            shutil.copytree(src_path, dst_path, dirs_exist_ok=True)
+                        else:
+                            shutil.copy2(src_path, dst_path)
+                    logger.info("Templates data prepared successfully")
+                else:
+                    logger.error("Data directory not found after running preparation script")
+                    raise FileNotFoundError(
+                        "Data preparation script did not create expected data directory"
+                    )
             else:
-                shutil.copy2(s, d)
-        logger.info("Default files copied to %s.", MFS_TEMPLATES_DIR)
-    else:
-        logger.warning(
-            "Templates directory %s is not empty. Will not copy default files. "
-            "Ensure that the directory contains the necessary template files.",
-            MFS_TEMPLATES_DIR,
-        )
+                logger.error("Preparation script not found: %s", prep_script)
+                raise FileNotFoundError("prepare_data.sh not found in cloned repository")
+
+    except subprocess.CalledProcessError as e:
+        logger.error("Failed to prepare templates data: %s", str(e))
+        if e.stdout:
+            logger.error("Script stdout: %s", e.stdout)
+        if e.stderr:
+            logger.error("Script stderr: %s", e.stderr)
+        raise
+    except Exception as e:
+        logger.error("Error preparing templates: %s", str(e))
+        raise
+
+
+ensure_templates()
 
 MFS_ROOT_DIR = os.getenv("MFS_ROOT_DIRECTORY", os.path.join(os.getcwd(), "mfsrootdir"))
 MFS_CACHE_DIR = os.path.join(MFS_ROOT_DIR, "cache")

maps4fs/generator/map.py

@@ -5,30 +5,16 @@ from __future__ import annotations
 import json
 import os
 import shutil
-from datetime import datetime
 from typing import Any, Generator
-from xml.etree import ElementTree as ET
 
-import osmnx as ox
-from geopy.geocoders import Nominatim
-from osmnx._errors import InsufficientResponseError
 from pydtmdl import DTMProvider
 from pydtmdl.base.dtm import DTMProviderSettings
 
 import maps4fs.generator.config as mfscfg
+import maps4fs.generator.utils as mfsutils
 from maps4fs.generator.component import Background, Component, Layer, Texture
-from maps4fs.generator.game import FS25, Game
-from maps4fs.generator.settings import (
-    BackgroundSettings,
-    DEMSettings,
-    GenerationSettings,
-    GRLESettings,
-    I3DSettings,
-    MainSettings,
-    SatelliteSettings,
-    SharedSettings,
-    TextureSettings,
-)
+from maps4fs.generator.game import Game
+from maps4fs.generator.settings import GenerationSettings, MainSettings, SharedSettings
 from maps4fs.generator.statistics import send_advanced_settings, send_main_settings
 from maps4fs.logger import Logger
 
@@ -55,174 +41,98 @@ class Map:
         map_directory: str | None = None,
         logger: Any = None,
         custom_osm: str | None = None,
-        dem_settings: DEMSettings = DEMSettings(),
-        background_settings: BackgroundSettings = BackgroundSettings(),
-        grle_settings: GRLESettings = GRLESettings(),
-        i3d_settings: I3DSettings = I3DSettings(),
-        texture_settings: TextureSettings = TextureSettings(),
-        satellite_settings: SatelliteSettings = SatelliteSettings(),
+        generation_settings: GenerationSettings = GenerationSettings(),
         **kwargs,
     ):
-        if not logger:
-            logger = Logger()
-        self.logger = logger
-        self.size = size
-
-        if rotation:
-            rotation_multiplier = 1.5
-        else:
-            rotation_multiplier = 1
-
-        self.rotation = rotation
-        self.rotated_size = int(size * rotation_multiplier)
-        self.output_size = kwargs.get("output_size", None)
-        self.size_scale = 1.0
-        if self.output_size:
-            self.size_scale = self.output_size / self.size
 
+        # region main properties
         self.game = game
         self.dtm_provider = dtm_provider
         self.dtm_provider_settings = dtm_provider_settings
-        self.components: list[Component] = []
         self.coordinates = coordinates
         self.map_directory = map_directory or self.suggest_map_directory(
             coordinates=coordinates, game_code=game.code  # type: ignore
         )
+        self.rotation = rotation
+        self.kwargs = kwargs
+        # endregion
 
-        main_settings = MainSettings.from_json(
-            {
-                "game": game.code,  # type: ignore
-                "latitude": coordinates[0],
-                "longitude": coordinates[1],
-                "country": self.get_country_by_coordinates(),
-                "size": size,
-                "output_size": self.output_size,
-                "rotation": rotation,
-                "dtm_provider": dtm_provider.name(),
-                "custom_osm": bool(custom_osm),
-                "is_public": kwargs.get("is_public", False),
-                "api_request": kwargs.get("api_request", False),
-                "date": datetime.now().strftime("%Y-%m-%d"),
-                "time": datetime.now().strftime("%H:%M:%S"),
-                "version": mfscfg.PACKAGE_VERSION,
-                "completed": False,
-                "error": None,
-            }
-        )
-        main_settings_json = main_settings.to_json()
-
-        try:
-            send_main_settings(main_settings_json)
-        except Exception as e:
-            self.logger.error("Error sending main settings: %s", e)
-
-        self.main_settings_path = os.path.join(self.map_directory, "main_settings.json")
-        with open(self.main_settings_path, "w", encoding="utf-8") as file:
-            json.dump(main_settings_json, file, indent=4)
-
-        log_entry = ""
-        log_entry += f"Map instance created for Game: {game.code}. "
-        log_entry += f"Coordinates: {coordinates}. Size: {size}. Rotation: {rotation}. "
-        if self.output_size:
-            log_entry += f"Output size: {self.output_size}. Scaling: {self.size_scale}. "
-        log_entry += f"DTM provider is {dtm_provider.name()}. "
+        # region size properties
+        self.size = size
+        rotation_multiplier = 1.5 if rotation else 1
+        self.rotated_size = int(size * rotation_multiplier)
+        self.output_size = kwargs.get("output_size", None)
+        self.size_scale = 1.0 if not self.output_size else self.output_size / size
+        # endregion
 
+        # region custom OSM properties
         self.custom_osm = custom_osm
-        log_entry += f"Custom OSM file: {custom_osm}. "
+        if custom_osm and not os.path.isfile(custom_osm):
+            raise FileNotFoundError(f"Custom OSM file {custom_osm} does not exist.")
+        mfsutils.check_and_fix_osm(self.custom_osm, save_directory=self.map_directory)
+        # endregion
 
-        if self.custom_osm:
-            osm_is_valid = check_osm_file(self.custom_osm)
-            if not osm_is_valid:
-                self.logger.warning(
-                    "Custom OSM file %s is not valid. Attempting to fix it.", custom_osm
-                )
-                fixed, fixed_errors = fix_osm_file(self.custom_osm)
-                if not fixed:
-                    raise ValueError(
-                        f"Custom OSM file {custom_osm} is not valid and cannot be fixed."
-                    )
-                self.logger.info(
-                    "Custom OSM file %s fixed. Fixed errors: %d", custom_osm, fixed_errors
-                )
-
-        # Make a copy of a custom osm file to the map directory, so it will be
-        # included in the output archive.
-        if custom_osm:
-            copy_path = os.path.join(self.map_directory, "custom_osm.osm")
-            shutil.copyfile(custom_osm, copy_path)
-            self.logger.debug("Custom OSM file copied to %s", copy_path)
-
-        self.dem_settings = dem_settings
-        log_entry += f"DEM settings: {dem_settings}. "
-        if self.dem_settings.water_depth > 0:
-            # Make sure that the plateau value is >= water_depth
-            self.dem_settings.plateau = max(
-                self.dem_settings.plateau, self.dem_settings.water_depth
-            )
+        # region main settings
+        main_settings = MainSettings.from_map(self)
+        main_settings_json = main_settings.to_json()
+        self.main_settings_path = os.path.join(self.map_directory, "main_settings.json")
+        self._update_main_settings(main_settings_json)
+        # endregion
 
-        self.background_settings = background_settings
-        log_entry += f"Background settings: {background_settings}. "
-        self.grle_settings = grle_settings
-        log_entry += f"GRLE settings: {grle_settings}. "
-        self.i3d_settings = i3d_settings
-        log_entry += f"I3D settings: {i3d_settings}. "
-        self.texture_settings = texture_settings
-        log_entry += f"Texture settings: {texture_settings}. "
-        self.satellite_settings = satellite_settings
-
-        self.logger.info(log_entry)
-        os.makedirs(self.map_directory, exist_ok=True)
-        self.logger.debug("Map directory created: %s", self.map_directory)
+        # region generation settings
+        self.dem_settings = generation_settings.dem_settings
+        self.background_settings = generation_settings.background_settings
+        self.grle_settings = generation_settings.grle_settings
+        self.i3d_settings = generation_settings.i3d_settings
+        self.texture_settings = generation_settings.texture_settings
+        self.satellite_settings = generation_settings.satellite_settings
+        self.process_settings()
 
-        settings_json = GenerationSettings(
-            dem_settings=dem_settings,
-            background_settings=background_settings,
-            grle_settings=grle_settings,
-            i3d_settings=i3d_settings,
-            texture_settings=texture_settings,
-            satellite_settings=satellite_settings,
-        ).to_json()
+        self.logger = logger if logger else Logger()
+        generation_settings_json = generation_settings.to_json()
 
         try:
-            send_advanced_settings(settings_json)
+            send_main_settings(main_settings_json)
+            send_advanced_settings(generation_settings_json)
+            self.logger.info("Settings sent successfully.")
         except Exception as e:
-            self.logger.error("Error sending advanced settings: %s", e)
-
-        save_path = os.path.join(self.map_directory, "generation_settings.json")
-
-        with open(save_path, "w", encoding="utf-8") as file:
-            json.dump(settings_json, file, indent=4)
-
-        self.shared_settings = SharedSettings()
+            self.logger.warning("Error sending settings: %s", e)
+        # endregion
 
+        # region JSON data saving
+        os.makedirs(self.map_directory, exist_ok=True)
         self.texture_custom_schema = kwargs.get("texture_custom_schema", None)
-        if self.texture_custom_schema:
-            save_path = os.path.join(self.map_directory, "texture_custom_schema.json")
-            with open(save_path, "w", encoding="utf-8") as file:
-                json.dump(self.texture_custom_schema, file, indent=4)
-            self.logger.debug("Texture custom schema saved to %s", save_path)
-
         self.tree_custom_schema = kwargs.get("tree_custom_schema", None)
-        if self.tree_custom_schema:
-            save_path = os.path.join(self.map_directory, "tree_custom_schema.json")
-            with open(save_path, "w", encoding="utf-8") as file:
-                json.dump(self.tree_custom_schema, file, indent=4)
-            self.logger.debug("Tree custom schema saved to %s", save_path)
 
-        self.custom_background_path = kwargs.get("custom_background_path", None)
-        if self.custom_background_path:
-            save_path = os.path.join(self.map_directory, "custom_background.png")
-            shutil.copyfile(self.custom_background_path, save_path)
+        json_data = {
+            "generation_settings.json": generation_settings_json,
+            "texture_custom_schema.json": self.texture_custom_schema,
+            "tree_custom_schema.json": self.tree_custom_schema,
+        }
+
+        for filename, data in json_data.items():
+            mfsutils.dump_json(filename, self.map_directory, data)
+        # endregion
 
+        # region prepare map working directory
         try:
             shutil.unpack_archive(game.template_path, self.map_directory)
             self.logger.debug("Map template unpacked to %s", self.map_directory)
         except Exception as e:
             raise RuntimeError(f"Can not unpack map template due to error: {e}") from e
+        # endregion
 
-        self.logger.debug(
-            "MFS_DATA_DIR: %s. MFS_CACHE_DIR %s", mfscfg.MFS_DATA_DIR, mfscfg.MFS_CACHE_DIR
-        )
+        self.shared_settings = SharedSettings()
+        self.components: list[Component] = []
+        self.custom_background_path = kwargs.get("custom_background_path", None)
+
+    def process_settings(self) -> None:
+        """Checks the settings by predefined rules and updates them accordingly."""
+        if self.dem_settings.water_depth > 0:
+            # Make sure that the plateau value is >= water_depth
+            self.dem_settings.plateau = max(
+                self.dem_settings.plateau, self.dem_settings.water_depth
+            )
 
     @staticmethod
     def suggest_map_directory(coordinates: tuple[float, float], game_code: str) -> str:
@@ -241,30 +151,9 @@ class Map:
             str: Directory name.
         """
         lat, lon = coordinates
-        latr = Map.coordinate_to_string(lat)
-        lonr = Map.coordinate_to_string(lon)
-        return f"{Map.get_timestamp()}_{game_code}_{latr}_{lonr}".lower()
-
-    @staticmethod
-    def get_timestamp() -> str:
-        """Get current underscore-separated timestamp.
-
-        Returns:
-            str: Current timestamp.
-        """
-        return datetime.now().strftime("%Y%m%d_%H%M%S")
-
-    @staticmethod
-    def coordinate_to_string(coordinate: float) -> str:
-        """Convert coordinate to string with 3 decimal places.
-
-        Arguments:
-            coordinate (float): Coordinate value.
-
-        Returns:
-            str: Coordinate as string.
-        """
-        return f"{coordinate:.3f}".replace(".", "_")
+        latr = mfsutils.coordinate_to_string(lat)
+        lonr = mfsutils.coordinate_to_string(lon)
+        return f"{mfsutils.get_timestamp()}_{game_code}_{latr}_{lonr}".lower()
 
     @property
     def texture_schema(self) -> list[dict[str, Any]] | None:
@@ -332,14 +221,19 @@ class Map:
 
     def _update_main_settings(self, data: dict[str, Any]) -> None:
         """Update main settings with provided data.
+        If the main settings file exists, it will be updated with the new data.
+        If it does not exist, a new file will be created.
 
         Arguments:
             data (dict[str, Any]): Data to update main settings.
         """
-        with open(self.main_settings_path, "r", encoding="utf-8") as file:
-            main_settings_json = json.load(file)
+        if os.path.exists(self.main_settings_path):
+            with open(self.main_settings_path, "r", encoding="utf-8") as file:
+                main_settings_json = json.load(file)
 
-        main_settings_json.update(data)
+            main_settings_json.update(data)
+        else:
+            main_settings_json = data
 
         with open(self.main_settings_path, "w", encoding="utf-8") as file:
             json.dump(main_settings_json, file, indent=4)
@@ -452,79 +346,3 @@ class Map:
             except Exception as e:
                 self.logger.debug("Error removing map directory %s: %s", self.map_directory, e)
         return archive_path
-
-    def get_country_by_coordinates(self) -> str:
-        """Get country name by coordinates.
-
-        Returns:
-            str: Country name.
-        """
-        try:
-            geolocator = Nominatim(user_agent="maps4fs")
-            location = geolocator.reverse(self.coordinates, language="en")
-            if location and "country" in location.raw["address"]:
-                return location.raw["address"]["country"]
-        except Exception as e:
-            self.logger.error("Error getting country name by coordinates: %s", e)
-            return "Unknown"
-        return "Unknown"
-
-
-def check_osm_file(file_path: str) -> bool:
-    """Tries to read the OSM file using OSMnx and returns True if the file is valid,
-    False otherwise.
-
-    Arguments:
-        file_path (str): Path to the OSM file.
-
-    Returns:
-        bool: True if the file is valid, False otherwise.
-    """
-    with open(FS25().texture_schema, encoding="utf-8") as f:
-        schema = json.load(f)
-
-    tags = []
-    for element in schema:
-        element_tags = element.get("tags")
-        if element_tags:
-            tags.append(element_tags)
-
-    for tag in tags:
-        try:
-            ox.features_from_xml(file_path, tags=tag)
-        except InsufficientResponseError:
-            continue
-        except Exception:  # pylint: disable=W0718
-            return False
-    return True
-
-
-def fix_osm_file(input_file_path: str, output_file_path: str | None = None) -> tuple[bool, int]:
-    """Fixes the OSM file by removing all the <relation> nodes and all the nodes with
-    action='delete'.
-
-    Arguments:
-        input_file_path (str): Path to the input OSM file.
-        output_file_path (str | None): Path to the output OSM file. If None, the input file
-            will be overwritten.
-
-    Returns:
-        tuple[bool, int]: A tuple containing the result of the check_osm_file function
-            and the number of fixed errors.
-    """
-    broken_entries = ["relation", ".//*[@action='delete']"]
-    output_file_path = output_file_path or input_file_path
-
-    tree = ET.parse(input_file_path)
-    root = tree.getroot()
-
-    fixed_errors = 0
-    for entry in broken_entries:
-        for element in root.findall(entry):
-            root.remove(element)
-            fixed_errors += 1
-
-    tree.write(output_file_path)  # type: ignore
-    result = check_osm_file(output_file_path)  # type: ignore
-
-    return result, fixed_errors

maps4fs/generator/settings.py

@@ -3,10 +3,16 @@
 from __future__ import annotations
 
 import re
-from typing import Any, NamedTuple
+from datetime import datetime
+from typing import TYPE_CHECKING, Any, NamedTuple
 
 from pydantic import BaseModel, ConfigDict
 
+import maps4fs.generator.config as mfscfg
+
+if TYPE_CHECKING:
+    from maps4fs.generator.map import Map
+
 
 class Parameters:
     """Simple class to store string constants for parameters."""
@@ -79,7 +85,7 @@ class SettingsModel(BaseModel):
 
     @classmethod
     def all_settings_from_json(
-        cls, data: dict, flattening: bool = True
+        cls, data: dict, flattening: bool = True, from_snake: bool = False, safe: bool = False
     ) -> dict[str, SettingsModel]:
         """Create settings instances from JSON data.
 
@@ -87,13 +93,19 @@ class SettingsModel(BaseModel):
             data (dict): JSON data.
             flattening (bool): if set to True will flattet iterables to use the first element
                 of it.
+            from_snake (bool): if set to True will convert snake_case keys to camelCase.
 
         Returns:
             dict[str, Type[SettingsModel]]: Dictionary with settings instances.
         """
         settings = {}
         for subclass in cls.__subclasses__():
-            subclass_data = data[subclass.__name__]
+            if from_snake:
+                subclass_key = subclass.__name__.replace("Settings", "_settings").lower()
+            else:
+                subclass_key = subclass.__name__
+
+            subclass_data = data.get(subclass_key, {}) if safe else data[subclass_key]
             if flattening:
                 for key, value in subclass_data.items():
                     if isinstance(value, (list, tuple)):
@@ -257,12 +269,12 @@ class SatelliteSettings(SettingsModel):
 class GenerationSettings(BaseModel):
     """Represents the settings for the map generation process."""
 
-    dem_settings: DEMSettings
-    background_settings: BackgroundSettings
-    grle_settings: GRLESettings
-    i3d_settings: I3DSettings
-    texture_settings: TextureSettings
-    satellite_settings: SatelliteSettings
+    dem_settings: DEMSettings = DEMSettings()
+    background_settings: BackgroundSettings = BackgroundSettings()
+    grle_settings: GRLESettings = GRLESettings()
+    i3d_settings: I3DSettings = I3DSettings()
+    texture_settings: TextureSettings = TextureSettings()
+    satellite_settings: SatelliteSettings = SatelliteSettings()
 
     def to_json(self) -> dict[str, Any]:
         """Convert the GenerationSettings instance to JSON format.
@@ -280,23 +292,23 @@ class GenerationSettings(BaseModel):
         }
 
     @classmethod
-    def from_json(cls, data: dict[str, Any]) -> GenerationSettings:
+    def from_json(
+        cls, data: dict[str, Any], from_snake: bool = False, safe: bool = False
+    ) -> GenerationSettings:
         """Create a GenerationSettings instance from JSON data.
 
         Arguments:
             data (dict[str, Any]): JSON data.
+            from_snake (bool): if set to True will convert snake_case keys to camelCase.
+            safe (bool): if set to True will ignore unknown keys.
 
         Returns:
             GenerationSettings: Instance of GenerationSettings.
         """
-        return cls(
-            dem_settings=DEMSettings(**data["DEMSettings"]),
-            background_settings=BackgroundSettings(**data["BackgroundSettings"]),
-            grle_settings=GRLESettings(**data["GRLESettings"]),
-            i3d_settings=I3DSettings(**data["I3DSettings"]),
-            texture_settings=TextureSettings(**data["TextureSettings"]),
-            satellite_settings=SatelliteSettings(**data["SatelliteSettings"]),
+        all_settings = SettingsModel.all_settings_from_json(
+            data, flattening=False, from_snake=from_snake, safe=safe
         )
+        return cls(**all_settings)  # type: ignore
 
 
 class MainSettings(NamedTuple):
@@ -355,3 +367,34 @@ class MainSettings(NamedTuple):
             "completed": self.completed,
             "error": self.error,
         }
+
+    @classmethod
+    def from_map(cls, map: Map) -> MainSettings:
+        """Create a MainSettings instance from a Map instance.
+
+        Arguments:
+            map (Map): Instance of Map.
+
+        Returns:
+            MainSettings: Instance of MainSettings.
+        """
+        from maps4fs.generator.utils import get_country_by_coordinates
+
+        return cls(
+            game=map.game.code,  # type: ignore
+            latitude=map.coordinates[0],
+            longitude=map.coordinates[1],
+            country=get_country_by_coordinates(map.coordinates),
+            size=map.size,
+            output_size=map.output_size,
+            rotation=map.rotation,
+            dtm_provider=map.dtm_provider.name(),
+            custom_osm=bool(map.custom_osm),
+            is_public=map.kwargs.get("is_public", False),
+            api_request=map.kwargs.get("api_request", False),
+            date=datetime.now().strftime("%Y-%m-%d"),
+            time=datetime.now().strftime("%H:%M:%S"),
+            version=mfscfg.PACKAGE_VERSION,
+            completed=False,
+            error=None,
+        )

maps4fs/generator/statistics.py

@@ -1,6 +1,7 @@
 """Module for sending settings to the statistics server."""
 
 import os
+import threading
 from typing import Any
 
 import requests
@@ -24,27 +25,31 @@ if not API_TOKEN:
     logger.debug("API_TOKEN not set in environment")
 
 
-def post(endpoint: str, data: dict[str, Any]) -> dict[str, Any] | None:
-    """Make a POST request to the statistics server.
+def post(endpoint: str, data: dict[str, Any]) -> None:
+    """Make a POST request to the statistics server in a separate thread.
 
     Arguments:
         endpoint (str): The endpoint to send the request to.
         data (dict[str, Any]): The data to send.
-
-    Returns:
-        dict[str, Any]: The response from the server.
     """
-    if not STATS_HOST or not API_TOKEN:
-        logger.info("STATS_HOST or API_TOKEN not set in environment, can't send settings.")
-        return None
 
-    headers = {"Authorization": f"Bearer {API_TOKEN}", "Content-Type": "application/json"}
-    response = requests.post(endpoint, headers=headers, json=data, timeout=10)
-    if response.status_code != 200:
-        logger.error("Failed to send settings: %s", response.text)
-        return None
-    logger.info("Settings sent successfully")
-    return response.json()
+    def _post_thread():
+        try:
+            if not STATS_HOST or not API_TOKEN:
+                logger.debug("STATS_HOST or API_TOKEN not set in environment, can't send settings.")
+                return
+
+            headers = {"Authorization": f"Bearer {API_TOKEN}", "Content-Type": "application/json"}
+            response = requests.post(endpoint, headers=headers, json=data, timeout=10)
+            if response.status_code != 200:
+                logger.warning("Failed to send settings: %s", response.text)
+                return
+            logger.debug("Settings sent successfully")
+        except Exception as e:
+            logger.warning("Error while trying to send settings: %s", e)
+
+    thread = threading.Thread(target=_post_thread, daemon=True)
+    thread.start()
 
 
 def send_main_settings(data: dict[str, Any]) -> None:
@@ -65,21 +70,3 @@ def send_advanced_settings(data: dict[str, Any]) -> None:
     """
     endpoint = f"{STATS_HOST}/receive_advanced_settings"
     post(endpoint, data)
-
-
-def get_main_settings(fields: list[str], limit: int | None = None) -> list[dict[str, Any]] | None:
-    """Get main settings from the statistics server.
-
-    Arguments:
-        fields (list[str]): The fields to get.
-        limit (int | None): The maximum number of settings to get.
-
-    Returns:
-        list[dict[str, Any]]: The settings from the server.
-    """
-    endpoint = f"{STATS_HOST}/get_main_settings"
-    data = {"fields": fields, "limit": limit}
-    result = post(endpoint, data)
-    if not result:
-        return None
-    return result.get("settings")

maps4fs/generator/utils.py

@@ -0,0 +1,160 @@
+"""This module contains utility functions for working with maps4fs."""
+
+import json
+import os
+import shutil
+from datetime import datetime
+from typing import Any
+from xml.etree import ElementTree as ET
+
+import osmnx as ox
+from geopy.geocoders import Nominatim
+from osmnx._errors import InsufficientResponseError
+
+
+def check_osm_file(file_path: str) -> bool:
+    """Tries to read the OSM file using OSMnx and returns True if the file is valid,
+    False otherwise.
+
+    Arguments:
+        file_path (str): Path to the OSM file.
+
+    Returns:
+        bool: True if the file is valid, False otherwise.
+    """
+    from maps4fs.generator.game import FS25
+
+    with open(FS25().texture_schema, encoding="utf-8") as f:
+        schema = json.load(f)
+
+    tags = []
+    for element in schema:
+        element_tags = element.get("tags")
+        if element_tags:
+            tags.append(element_tags)
+
+    for tag in tags:
+        try:
+            ox.features_from_xml(file_path, tags=tag)
+        except InsufficientResponseError:
+            continue
+        except Exception:  # pylint: disable=W0718
+            return False
+    return True
+
+
+def fix_osm_file(input_file_path: str, output_file_path: str | None = None) -> tuple[bool, int]:
+    """Fixes the OSM file by removing all the <relation> nodes and all the nodes with
+    action='delete'.
+
+    Arguments:
+        input_file_path (str): Path to the input OSM file.
+        output_file_path (str | None): Path to the output OSM file. If None, the input file
+            will be overwritten.
+
+    Returns:
+        tuple[bool, int]: A tuple containing the result of the check_osm_file function
+            and the number of fixed errors.
+    """
+    broken_entries = ["relation", ".//*[@action='delete']"]
+    output_file_path = output_file_path or input_file_path
+
+    tree = ET.parse(input_file_path)
+    root = tree.getroot()
+
+    fixed_errors = 0
+    for entry in broken_entries:
+        for element in root.findall(entry):
+            root.remove(element)
+            fixed_errors += 1
+
+    tree.write(output_file_path)  # type: ignore
+    result = check_osm_file(output_file_path)  # type: ignore
+
+    return result, fixed_errors
+
+
+def check_and_fix_osm(
+    custom_osm: str | None, save_directory: str | None = None, output_name: str = "custom_osm.osm"
+) -> None:
+    """Check and fix custom OSM file if necessary.
+
+    Arguments:
+        custom_osm (str | None): Path to the custom OSM file.
+        save_directory (str | None): Directory to save the fixed OSM file.
+        output_name (str): Name of the output OSM file.
+
+    Raises:
+        FileNotFoundError: If the custom OSM file does not exist.
+        ValueError: If the custom OSM file is not valid and cannot be fixed.
+    """
+    if not custom_osm:
+        return None
+    if not os.path.isfile(custom_osm):
+        raise FileNotFoundError(f"Custom OSM file {custom_osm} does not exist.")
+
+    osm_is_valid = check_osm_file(custom_osm)
+    if not osm_is_valid:
+        fixed, _ = fix_osm_file(custom_osm)
+        if not fixed:
+            raise ValueError(f"Custom OSM file {custom_osm} is not valid and cannot be fixed.")
+
+    if save_directory:
+        output_path = os.path.join(save_directory, output_name)
+        shutil.copyfile(custom_osm, output_path)
+
+    return None
+
+
+def get_country_by_coordinates(coordinates: tuple[float, float]) -> str:
+    """Get country name by coordinates.
+
+    Returns:
+        str: Country name.
+    """
+    try:
+        geolocator = Nominatim(user_agent="maps4fs")
+        location = geolocator.reverse(coordinates, language="en")
+        if location and "country" in location.raw["address"]:
+            return location.raw["address"]["country"]
+    except Exception:
+        return "Unknown"
+    return "Unknown"
+
+
+def get_timestamp() -> str:
+    """Get current underscore-separated timestamp.
+
+    Returns:
+        str: Current timestamp.
+    """
+    return datetime.now().strftime("%Y%m%d_%H%M%S")
+
+
+def coordinate_to_string(coordinate: float) -> str:
+    """Convert coordinate to string with 3 decimal places.
+
+    Arguments:
+        coordinate (float): Coordinate value.
+
+    Returns:
+        str: Coordinate as string.
+    """
+    return f"{coordinate:.3f}".replace(".", "_")
+
+
+def dump_json(filename: str, directory: str, data: dict[Any, Any] | Any | None) -> None:
+    """Dump data to a JSON file.
+
+    Arguments:
+        filename (str): Name of the JSON file.
+        directory (str): Directory to save the JSON file.
+        data (dict[Any, Any] | Any | None): Data to dump.
+    """
+    if not data:
+        return
+    if not isinstance(data, (dict, list)):
+        raise TypeError("Data must be a dictionary or a list.")
+    save_path = os.path.join(directory, filename)
+    with open(save_path, "w", encoding="utf-8") as file:
+        json.dump(data, file, indent=4)

{maps4fs-2.2.7.dist-info → maps4fs-2.2.72.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maps4fs
-Version: 2.2.7
+Version: 2.2.72
 Summary: Generate map templates for Farming Simulator from real places.
 Author-email: iwatkot <iwatkot@gmail.com>
 License: Apache License 2.0
@@ -18,15 +18,13 @@ Requires-Dist: osmnx>=2.0.0
 Requires-Dist: rasterio
 Requires-Dist: geopy
 Requires-Dist: trimesh
-Requires-Dist: imageio
-Requires-Dist: tifffile
-Requires-Dist: pympler
 Requires-Dist: pydantic
 Requires-Dist: pygmdl
 Requires-Dist: owslib
 Requires-Dist: tqdm
 Requires-Dist: scipy
 Requires-Dist: pydtmdl
+Requires-Dist: manifold3d
 Dynamic: license-file
 
 ⚠️ Learn more about the 2.0 changes in the [migration guide](docs/migration.md).  

{maps4fs-2.2.7.dist-info → maps4fs-2.2.72.dist-info}/RECORD

@@ -1,17 +1,18 @@
-maps4fs/__init__.py,sha256=Fy521EmVAWnhu6OvOInc97yrtJotFzcV0YfRB2b9O4s,314
+maps4fs/__init__.py,sha256=5ixsCA5vgcIV0OrF9EJBm91Mmc_KfMiDRM-QyifMAvo,386
 maps4fs/logger.py,sha256=6sem0aFKQqtVjQ_yNu9iGcc-hqzLQUhfxco05K6nqow,763
 maps4fs/generator/__init__.py,sha256=zZMLEkGzb4z0xql650gOtGSvcgX58DnJ2yN3vC2daRk,43
-maps4fs/generator/config.py,sha256=H63HqgpZG6M2wt2DnS-m44cDPiy_hd3qJubX8WZz5Ys,3185
+maps4fs/generator/config.py,sha256=vJ5Qff3V8C6I2VVyksz8XcwtLST9gtvSqOBhqBoMZT8,5489
 maps4fs/generator/game.py,sha256=nf6iuYNA5NJc-ir_WOgkw-MdJVgetVHeEtxbWJYt3Vo,14462
-maps4fs/generator/map.py,sha256=ATTRrsxvwao3kW1M-AGeFpyJGG3h-LuTDZjC5v1MDMY,19073
+maps4fs/generator/map.py,sha256=5at6Dlk1nk2dGr46rjjuQvq4hUNpbvchIoc8ahrKNag,12723
 maps4fs/generator/qgis.py,sha256=Es8hLuqN_KH8lDfnJE6He2rWYbAKJ3RGPn-o87S6CPI,6116
-maps4fs/generator/settings.py,sha256=NukAt1s4CS0HEWmUcBPc8OiqkWqjts3AvvkX0APZKes,11385
-maps4fs/generator/statistics.py,sha256=aynS3zbAtiwnU_YLKHPTiiaKW98_suvQUhy1SGBA6mc,2448
+maps4fs/generator/settings.py,sha256=LX1Y4_8cisiel2fMvoRuxMypJlmysEHenM4SZ5oqw5o,13052
+maps4fs/generator/statistics.py,sha256=Dp1-NS-DWv0l0UdmhOoXeQs_N-Hs7svYUnmziSW5Z9I,2098
+maps4fs/generator/utils.py,sha256=ugdQ8C22NeiZLIlldLoEKCc7ioOefz4W-8qF2eOy9qU,4834
 maps4fs/generator/component/__init__.py,sha256=s01yVVVi8R2xxNvflu2D6wTd9I_g73AMM2x7vAC7GX4,490
-maps4fs/generator/component/background.py,sha256=-GNA6zdQmfu7Oi4Cny0uhxlgl39VbvhEGhl4wKdh0ew,34533
+maps4fs/generator/component/background.py,sha256=rUDTPduNCD7KKt_eoVWN4XVSVgjwGSoLNPbZOzpGx7E,34532
 maps4fs/generator/component/config.py,sha256=uL76h9UwyhZKZmbxz0mBmWtEPN6qYay4epTEqqtej60,8601
-maps4fs/generator/component/dem.py,sha256=mtsdTIcEHmR9mW1LMcCaX4F2OCch9BM_WXHkvJby9ZY,11930
-maps4fs/generator/component/grle.py,sha256=3BKGlR0q0t0NvmqeT81WieS6MIc_UlMQjIDDZiqTiws,27243
+maps4fs/generator/component/dem.py,sha256=FPqcXmFQg5MPaGuy4g5kxzvY1wbhozeCf-aNMCj5eaU,11687
+maps4fs/generator/component/grle.py,sha256=0PC1K829wjD4y4d9qfIbnU29ebjflIPBbwIZx8FXwc8,27242
 maps4fs/generator/component/i3d.py,sha256=RvpiW9skkZ6McyahC-AeIdPuSQjpXiFs1l0xOioJAu4,26638
 maps4fs/generator/component/layer.py,sha256=bdy1XGOODyPqYUM3b_wEY2H9Piz-AaHsCDecl-qRHiM,6627
 maps4fs/generator/component/satellite.py,sha256=9nKwL8zQ-BB6WFMx2m8zduFn6RaxSNv6Vtpge1-QMYE,5052
@@ -21,8 +22,8 @@ maps4fs/generator/component/base/component.py,sha256=lf0V9CLUXMg88Nm2yI3rP5taVYY
 maps4fs/generator/component/base/component_image.py,sha256=WTGC6v1KuS5sLNCC95Z48nCspvATKKNOuhTNYzTWXr4,8315
 maps4fs/generator/component/base/component_mesh.py,sha256=3hC-qDT8Vde6SmRMqs9USAkrF-gL2dDTYW71ATpxUS4,9130
 maps4fs/generator/component/base/component_xml.py,sha256=MT-VhU2dEckLFxAgmxg6V3gnv11di_94Qq6atfpOLdc,5342
-maps4fs-2.2.7.dist-info/licenses/LICENSE.md,sha256=pTKD_oUexcn-yccFCTrMeLkZy0ifLRa-VNcDLqLZaIw,10749
-maps4fs-2.2.7.dist-info/METADATA,sha256=LwFe89_T2zXKstBCRBmLPFMi63cd-E3Bomwi_7VNvd8,46314
-maps4fs-2.2.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-maps4fs-2.2.7.dist-info/top_level.txt,sha256=Ue9DSRlejRQRCaJueB0uLcKrWwsEq9zezfv5dI5mV1M,8
-maps4fs-2.2.7.dist-info/RECORD,,
+maps4fs-2.2.72.dist-info/licenses/LICENSE.md,sha256=pTKD_oUexcn-yccFCTrMeLkZy0ifLRa-VNcDLqLZaIw,10749
+maps4fs-2.2.72.dist-info/METADATA,sha256=Rps1HNin3PYU98Oo_olUxMx2STbIlWCmODd6kwaToxs,46271
+maps4fs-2.2.72.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+maps4fs-2.2.72.dist-info/top_level.txt,sha256=Ue9DSRlejRQRCaJueB0uLcKrWwsEq9zezfv5dI5mV1M,8
+maps4fs-2.2.72.dist-info/RECORD,,