maps4fs 2.9.38__tar.gz → 2.9.41__tar.gz

{maps4fs-2.9.38 → maps4fs-2.9.41}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maps4fs
-Version: 2.9.38
+Version: 2.9.41
 Summary: Generate map templates for Farming Simulator from real places.
 Author-email: iwatkot <iwatkot@gmail.com>
 License-Expression: CC-BY-NC-4.0
@@ -94,11 +94,10 @@ Dynamic: license-file
 📦 **Giants Editor Ready** - Import and start building immediately<br>
 
 🗺️ **Advanced Customization** - [Custom OSM maps](https://maps4fs.gitbook.io/docs/advanced-topics/custom_osm) and elevation data<br>
-🔌 **API Integration** - Generate maps programmatically via [API](https://github.com/iwatkot/maps4fsapi)<br>
 📚 **Complete Documentation** - [Detailed guides](https://maps4fs.gitbook.io/docs) and video tutorials<br>
 
 <p align="center">
-<img src="https://github.com/iwatkot/maps4fs/releases/download/2.9.34/mfsg.gif"><br>
+<img src="https://github.com/iwatkot/maps4fs/releases/download/2.9.40/mfsg2.gif"><br>
 <i>Example of map generated with Maps4FS with no manual edits.</i>
 </p>
 

{maps4fs-2.9.38 → maps4fs-2.9.41}/README.md

@@ -64,11 +64,10 @@
 📦 **Giants Editor Ready** - Import and start building immediately<br>
 
 🗺️ **Advanced Customization** - [Custom OSM maps](https://maps4fs.gitbook.io/docs/advanced-topics/custom_osm) and elevation data<br>
-🔌 **API Integration** - Generate maps programmatically via [API](https://github.com/iwatkot/maps4fsapi)<br>
 📚 **Complete Documentation** - [Detailed guides](https://maps4fs.gitbook.io/docs) and video tutorials<br>
 
 <p align="center">
-<img src="https://github.com/iwatkot/maps4fs/releases/download/2.9.34/mfsg.gif"><br>
+<img src="https://github.com/iwatkot/maps4fs/releases/download/2.9.40/mfsg2.gif"><br>
 <i>Example of map generated with Maps4FS with no manual edits.</i>
 </p>
 

{maps4fs-2.9.38 → maps4fs-2.9.41}/maps4fs/__init__.py

@@ -6,5 +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.monitor import Logger
 from maps4fs.generator.settings import GenerationSettings, MainSettings
-from maps4fs.logger import Logger

{maps4fs-2.9.38 → maps4fs-2.9.41}/maps4fs/generator/component/building.py

@@ -2,7 +2,7 @@
 
 import json
 import os
-from typing import NamedTuple
+from typing import Any, NamedTuple
 from xml.etree import ElementTree as ET
 
 import cv2
@@ -320,6 +320,7 @@ class Building(I3d):
 
     def preprocess(self) -> None:
         """Preprocess and prepare buildings schema and buildings map image."""
+        self.info: dict[str, Any] = {}
         try:
             buildings_schema_path = self.game.buildings_schema
         except ValueError as e:
@@ -350,7 +351,7 @@ class Building(I3d):
         else:
             self.buildings_schema = custom_buildings_schema
 
-        self.logger.info(
+        self.logger.debug(
             "Buildings schema loaded successfully with %d objects.", len(self.buildings_schema)
         )
 
@@ -398,7 +399,7 @@ class Building(I3d):
 
         # Save the buildings map image
         cv2.imwrite(self.buildings_map_path, buildings_map_image)
-        self.logger.info("Building categories map saved to: %s", self.buildings_map_path)
+        self.logger.debug("Building categories map saved to: %s", self.buildings_map_path)
 
         building_entries = []
         for building_entry in self.buildings_schema:
@@ -418,13 +419,17 @@ class Building(I3d):
 
         self.buildings_collection = BuildingEntryCollection(building_entries, region, ignore_region)
 
+        self.info["building_region"] = region
+        self.info["ignore_building_region"] = ignore_region
+        self.info["total_buildings_in_schema"] = len(self.buildings_collection.entries)
+
         if ignore_region:
-            self.logger.info(
+            self.logger.debug(
                 "Buildings collection created with %d buildings ignoring region restrictions.",
                 len(self.buildings_collection.entries),
             )
         else:
-            self.logger.info(
+            self.logger.debug(
                 "Buildings collection created with %d buildings for region '%s'.",
                 len(self.buildings_collection.entries),
                 region,
@@ -465,7 +470,7 @@ class Building(I3d):
             self.logger.warning("Buildings data not found in textures info layer.")
             return
 
-        self.logger.info("Found %d building entries to process.", len(buildings))
+        self.logger.debug("Found %d building entries to process.", len(buildings))
 
         # Initialize tracking for XML modifications
         tree = self.get_tree()
@@ -537,7 +542,7 @@ class Building(I3d):
                 category=category,
                 width=width,
                 depth=depth,
-                tolerance=self.map.building_settings.tolerance_factor,
+                tolerance=self.map.building_settings.tolerance_factor / 100,
             )
 
             if best_match:
@@ -626,11 +631,14 @@ class Building(I3d):
                 continue
 
         added_buildings_count = node_id_counter - (BUILDINGS_STARTING_NODE_ID + 1000)
-        self.logger.info("Total buildings placed: %d of %d", added_buildings_count, len(buildings))
+        self.logger.debug("Total buildings placed: %d of %d", added_buildings_count, len(buildings))
+
+        self.info["total_buildings_placed"] = added_buildings_count
+        self.info["total_buildings_attempted"] = len(buildings)
 
         # Save the modified XML tree
         self.save_tree(tree)
-        self.logger.info("Buildings placement completed and saved to map.i3d")
+        self.logger.debug("Buildings placement completed and saved to map.i3d")
 
     def _get_polygon_dimensions_and_rotation(
         self, polygon_points: np.ndarray
@@ -702,5 +710,10 @@ class Building(I3d):
         scene_node.append(buildings_group)
         return buildings_group
 
-    def info_sequence(self) -> dict[str, dict[str, str | float | int]]:
-        return {}
+    def info_sequence(self) -> dict[str, Any]:
+        """Return information about the building processing as a dictionary.
+
+        Returns:
+            dict[str, Any]: Information about building processing.
+        """
+        return self.info

{maps4fs-2.9.38 → maps4fs-2.9.41}/maps4fs/generator/component/config.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import os
+from typing import Any
 
 import cv2
 import numpy as np
@@ -40,6 +41,7 @@ class Config(XMLComponent, ImageComponent):
 
     def preprocess(self) -> None:
         """Gets the path to the map XML file and saves it to the instance variable."""
+        self.info: dict[str, Any] = {}
         self.xml_path = self.game.map_xml_path(self.map_directory)
         self.fog_parameters: dict[str, int] = {}
 
@@ -106,6 +108,8 @@ class Config(XMLComponent, ImageComponent):
         if self.fog_parameters:
             data["Fog"] = self.fog_parameters  # type: ignore
 
+        data.update(self.info)
+
         return data  # type: ignore
 
     def qgis_sequence(self) -> None:
@@ -360,6 +364,7 @@ class Config(XMLComponent, ImageComponent):
             return
 
         country_name = mfsutils.get_country_by_coordinates(self.map.coordinates).lower()
+        self.info["license_plate_country_name"] = country_name
         if country_name not in self.supported_countries:
             self.logger.warning(
                 "License plates processing is not supported for country: %s.", country_name
@@ -369,8 +374,10 @@ class Config(XMLComponent, ImageComponent):
         # Get license plate country code and EU format.
         country_code = self.supported_countries[country_name]
         eu_format = country_code in self.eu_countries
+        self.info["license_plate_country_code"] = country_code
+        self.info["license_plate_eu_format"] = eu_format
 
-        self.logger.info(
+        self.logger.debug(
             "Updating license plates for country: %s, EU format: %s",
             country_name,
             eu_format,
@@ -402,7 +409,7 @@ class Config(XMLComponent, ImageComponent):
                 COUNTRY_CODE_BOTTOM,
             )
 
-            self.logger.info("License plates updated successfully")
+            self.logger.debug("License plates updated successfully")
         except Exception as e:
             self.logger.error("Failed to update license plates: %s", e)
             return
@@ -484,12 +491,17 @@ class Config(XMLComponent, ImageComponent):
         # 1. Update license plate prefix to ensure max 3 letters, uppercase.
         license_plate_prefix = license_plate_prefix.upper()[:3]
 
-        # 2. Position X values for the letters.
+        # 2. Pad the prefix to exactly 3 characters with spaces if needed.
+        license_plate_prefix = license_plate_prefix.ljust(3)
+        self.info["license_plate_prefix"] = license_plate_prefix
+
+        # 3. Position X values for the letters.
         pos_x_values = ["-0.1712", "-0.1172", "-0.0632"]  # ? DO WE REALLY NEED THEM?
 
-        # 3. Update only the first 3 values (prefix letters), leave others intact.
-        # Find and update nodes 0|0, 0|1, 0|2 specifically.
-        for i, letter in enumerate(license_plate_prefix):
+        # 4. Update all 3 positions (0|0, 0|1, 0|2) to ensure proper formatting.
+        # Always process exactly 3 positions, padding with spaces as needed.
+        for i in range(3):
+            letter = license_plate_prefix[i]  # This will be a space if padding was applied
             target_node = f"0|{i}"
             # Find existing value with this node ID.
             existing_value = None

{maps4fs-2.9.38 → maps4fs-2.9.41}/maps4fs/generator/component/road.py

@@ -3,7 +3,7 @@
 import os
 import shutil
 from collections import defaultdict
-from typing import NamedTuple
+from typing import Any, NamedTuple
 
 import numpy as np
 import shapely
@@ -42,6 +42,7 @@ class Road(I3d, MeshComponent):
 
     def preprocess(self) -> None:
         """Preprocess the road data before generation."""
+        self.info: dict[str, Any] = {}
 
     def process(self):
         """Process and generate roads for the map."""
@@ -63,8 +64,13 @@ class Road(I3d, MeshComponent):
             if road_texture:
                 roads_by_texture[road_texture].append(road_info)
 
+        self.info["road_textures"] = list(roads_by_texture.keys())
+        self.info["total_OSM_roads"] = len(road_infos)
+
+        fitted_roads_count = 0
+        patches_created_count = 0
         for texture, roads_polylines in roads_by_texture.items():
-            self.logger.info("Processing roads with texture: %s", texture)
+            self.logger.debug("Processing roads with texture: %s", texture)
 
             # The texture name is represents the name of texture file without extension
             # for easy reference if the texture uses various extensions.
@@ -106,9 +112,10 @@ class Road(I3d, MeshComponent):
 
                 road_entries.append(RoadEntry(linestring=linestring, width=width))
 
-            self.logger.info("Total found for mesh generation: %d", len(road_entries))
+            self.logger.debug("Total found for mesh generation: %d", len(road_entries))
 
             if road_entries:
+                fitted_roads_count += len(road_entries)
                 # 1. Apply smart interpolation to make linestrings smoother,
                 # but carefully, ensuring that points are not too close to each other.
                 # Otherwise it may lead to artifacts in the mesh.
@@ -123,9 +130,13 @@ class Road(I3d, MeshComponent):
                 patches_road_entries: list[RoadEntry] = self.get_patches_linestrings(
                     split_road_entries
                 )
+                patches_created_count += len(patches_road_entries)
                 split_road_entries.extend(patches_road_entries)
                 self.generate_road_mesh(split_road_entries, texture)
 
+        self.info["total_fitted_roads"] = fitted_roads_count
+        self.info["total_patches_created"] = patches_created_count
+
     def smart_interpolation(self, road_entries: list[RoadEntry]) -> list[RoadEntry]:
         """Apply smart interpolation to road linestrings.
         Making sure that result polylines do not have points too close to each other.
@@ -214,7 +225,7 @@ class Road(I3d, MeshComponent):
                 )
                 interpolated_entries.append(RoadEntry(linestring, width, z_offset))
 
-        self.logger.info(
+        self.logger.debug(
             "Smart interpolation complete. Processed %d roads.", len(interpolated_entries)
         )
         return interpolated_entries
@@ -249,7 +260,7 @@ class Road(I3d, MeshComponent):
             num_segments = int(np.ceil(road_length / max_road_length))
             segment_length = road_length / num_segments
 
-            self.logger.info(
+            self.logger.debug(
                 "Splitting road (%.2fm) into %d segments of ~%.2fm each",
                 road_length,
                 num_segments,
@@ -276,7 +287,7 @@ class Road(I3d, MeshComponent):
                 except Exception as e:
                     self.logger.warning("Failed to split road segment %d: %s", i, e)
 
-        self.logger.info(
+        self.logger.debug(
             "Road splitting complete: %d roads -> %d segments",
             len(road_entries),
             len(split_entries),
@@ -376,7 +387,7 @@ class Road(I3d, MeshComponent):
                             self.logger.debug("Failed to create patch linestring: %s", e)
                             continue
 
-        self.logger.info("Generated %d patch segments for T-junctions", len(patches))
+        self.logger.debug("Generated %d patch segments for T-junctions", len(patches))
         return patches
 
     def find_texture_file(self, templates_directory: str, texture_base_name: str) -> str:
@@ -419,7 +430,7 @@ class Road(I3d, MeshComponent):
         )
 
         shutil.copyfile(texture_path, dst_texture_path)
-        self.logger.info("Texture copied to %s", dst_texture_path)
+        self.logger.debug("Texture copied to %s", dst_texture_path)
 
         obj_output_path = os.path.join(road_mesh_directory, f"roads_{texture}.obj")
         mtl_output_path = os.path.join(road_mesh_directory, f"roads_{texture}.mtl")
@@ -483,7 +494,7 @@ class Road(I3d, MeshComponent):
         texture_tile_size = 10.0  # meters - how many meters before texture repeats
 
         patches_count = sum(1 for entry in road_entries if entry.z_offset > 0)
-        self.logger.info(
+        self.logger.debug(
             "Creating mesh for %d roads (%d patches with z-offset)",
             len(road_entries),
             patches_count,
@@ -607,7 +618,7 @@ class Road(I3d, MeshComponent):
             mtl_file.write("illum 2\n")  # Illumination model
             mtl_file.write(f"map_Kd {texture_filename}\n")  # Diffuse texture map
 
-        self.logger.info("MTL file written to %s", mtl_output_path)
+        self.logger.debug("MTL file written to %s", mtl_output_path)
 
         # Write OBJ file
         with open(obj_output_path, "w", encoding="utf-8") as obj_file:
@@ -636,13 +647,17 @@ class Road(I3d, MeshComponent):
                     f"{face[2] + 1}/{face[2] + 1}\n"
                 )
 
-        self.logger.info(
+        self.logger.debug(
             "OBJ file written to %s with %d vertices and %d faces",
             obj_output_path,
             len(vertices),
             len(faces),
         )
 
-    def info_sequence(self):
-        """Returns information about the component."""
-        return {}
+    def info_sequence(self) -> dict[str, Any]:
+        """Returns information about the road processing as a dictionary.
+
+        Returns:
+            dict[str, Any]: Information about road processing.
+        """
+        return self.info

{maps4fs-2.9.38 → maps4fs-2.9.41}/maps4fs/generator/component/texture.py

@@ -846,7 +846,7 @@ class Texture(ImageComponent):
             else:
                 objects = ox.features_from_bbox(bbox=self.new_bbox, tags=tags)
         except Exception as e:
-            self.logger.warning("Error fetching objects for tags: %s. Error: %s.", tags, e)
+            self.logger.debug("Error fetching objects for tags: %s. Error: %s.", tags, e)
             return None
 
         return objects

{maps4fs-2.9.38 → maps4fs-2.9.41}/maps4fs/generator/config.py

@@ -7,11 +7,11 @@ import tempfile
 
 from osmnx import settings as ox_settings
 
-from maps4fs.logger import Logger
+from maps4fs.generator.monitor import Logger
 
 TQDM_DISABLE = os.getenv("TQDM_DISABLE", "0") == "1"
 
-logger = Logger()
+logger = Logger(name="MAPS4FS.CONFIG")
 
 MFS_TEMPLATES_DIR = os.path.join(os.getcwd(), "templates")
 

{maps4fs-2.9.38 → maps4fs-2.9.41}/maps4fs/generator/map.py

@@ -15,14 +15,13 @@ import maps4fs.generator.config as mfscfg
 import maps4fs.generator.utils as mfsutils
 from maps4fs.generator.component import Background, Component, Layer, Satellite, Texture
 from maps4fs.generator.game import Game
-from maps4fs.generator.monitor import PerformanceMonitor, performance_session
+from maps4fs.generator.monitor import Logger, PerformanceMonitor, performance_session
 from maps4fs.generator.settings import GenerationSettings, MainSettings, SharedSettings
 from maps4fs.generator.statistics import (
     send_advanced_settings,
     send_main_settings,
     send_performance_report,
 )
-from maps4fs.logger import Logger
 
 
 class Map:
@@ -222,66 +221,90 @@ class Map:
             )
             generation_start = perf_counter()
 
-            for game_component in self.game.components:
-                component = game_component(
-                    self.game,
-                    self,
+            try:
+                for game_component in self.game.components:
+                    component = game_component(
+                        self.game,
+                        self,
+                        self.coordinates,
+                        self.size,
+                        self.rotated_size,
+                        self.rotation,
+                        self.map_directory,
+                        self.logger,
+                        texture_custom_schema=self.texture_custom_schema,  # type: ignore
+                        tree_custom_schema=self.tree_custom_schema,  # type: ignore
+                    )
+                    self.components.append(component)
+
+                    yield component.__class__.__name__
+
+                    try:
+                        component_start = perf_counter()
+                        component.process()
+                        component_finish = perf_counter()
+                        self.logger.info(
+                            "Component %s processed in %.2f seconds.",
+                            component.__class__.__name__,
+                            component_finish - component_start,
+                        )
+                        component.commit_generation_info()
+                    except Exception as e:
+                        self.logger.error(
+                            "Error processing or committing generation info for component %s: %s",
+                            component.__class__.__name__,
+                            e,
+                        )
+                        self._update_main_settings({"error": str(e)})
+                        raise e
+
+                generation_finish = perf_counter()
+                self.logger.info(
+                    "Map generation completed in %.2f seconds.",
+                    generation_finish - generation_start,
+                )
+
+                self._update_main_settings({"completed": True})
+
+                self.logger.info(
+                    "Map generation completed. Game code: %s. Coordinates: %s, size: %s. Rotation: %s.",
+                    self.game.code,
                     self.coordinates,
                     self.size,
-                    self.rotated_size,
                     self.rotation,
-                    self.map_directory,
-                    self.logger,
-                    texture_custom_schema=self.texture_custom_schema,  # type: ignore
-                    tree_custom_schema=self.tree_custom_schema,  # type: ignore
                 )
-                self.components.append(component)
-
-                yield component.__class__.__name__
-
-                try:
-                    component_start = perf_counter()
-                    component.process()
-                    component_finish = perf_counter()
-                    self.logger.info(
-                        "Component %s processed in %.2f seconds.",
-                        component.__class__.__name__,
-                        component_finish - component_start,
-                    )
-                    component.commit_generation_info()
-                except Exception as e:
-                    self.logger.error(
-                        "Error processing or committing generation info for component %s: %s",
-                        component.__class__.__name__,
-                        e,
-                    )
-                    self._update_main_settings({"error": str(e)})
-                    raise e
 
-            generation_finish = perf_counter()
-            self.logger.info(
-                "Map generation completed in %.2f seconds.",
-                generation_finish - generation_start,
-            )
+            finally:
+                self._save_metrics(session_id)
 
-            self._update_main_settings({"completed": True})
+    def _save_metrics(self, session_id: str) -> None:
+        """Save logs and performance metrics to JSON files.
 
-            self.logger.info(
-                "Map generation completed. Game code: %s. Coordinates: %s, size: %s. Rotation: %s.",
-                self.game.code,
-                self.coordinates,
-                self.size,
-                self.rotation,
-            )
+        Arguments:
+            session_id (str): Session ID.
+        """
+        try:
+            logs_json = self.logger.group_by_level(session_id)
+            if logs_json:
+                logs_filename = "generation_logs.json"
+                with open(
+                    os.path.join(self.map_directory, logs_filename), "w", encoding="utf-8"
+                ) as file:
+                    json.dump(logs_json, file, indent=4)
+        except Exception as e:
+            self.logger.error("Error saving logs to JSON: %s", e)
 
-        session_json = PerformanceMonitor().get_session_json(session_id)
-        if session_json:
-            report_filename = "performance_report.json"
-            with open(
-                os.path.join(self.map_directory, report_filename), "w", encoding="utf-8"
-            ) as file:
-                json.dump(session_json, file, indent=4)
-            send_performance_report(session_json)
+        try:
+            session_json = PerformanceMonitor().pop_session_json(session_id)
+            if session_json:
+                report_filename = "performance_report.json"
+                with open(
+                    os.path.join(self.map_directory, report_filename), "w", encoding="utf-8"
+                ) as file:
+                    json.dump(session_json, file, indent=4)
+                send_performance_report(session_json)
+        except Exception as e:
+            self.logger.error("Error saving performance report to JSON: %s", e)
 
     def _update_main_settings(self, data: dict[str, Any]) -> None:
         """Update main settings with provided data.

maps4fs-2.9.41/maps4fs/generator/monitor.py

@@ -0,0 +1,217 @@
+"""Module for performance monitoring during map generation."""
+
+import functools
+import logging
+import os
+import sys
+import threading
+import uuid
+from collections import defaultdict
+from contextlib import contextmanager
+from datetime import datetime
+from time import perf_counter
+from typing import Callable, Generator, Literal
+
+from maps4fs.generator.utils import Singleton
+
+_local = threading.local()
+MFS_LOG_LEVEL = "MFS_LOG_LEVEL"
+SUPPORTED_LOG_LEVELS = {
+    10: "DEBUG",
+    20: "INFO",
+    30: "WARNING",
+    40: "ERROR",
+}
+
+
+class Logger(logging.Logger):
+    """Handles logging to stdout with timestamps and session tracking."""
+
+    def __init__(
+        self,
+        name: str = "MAPS4FS",
+        level: Literal["DEBUG", "INFO", "WARNING", "ERROR"] = "INFO",
+        **kwargs,
+    ):
+        log_level = os.getenv(MFS_LOG_LEVEL, level)
+        if log_level not in SUPPORTED_LOG_LEVELS.values():
+            log_level = "INFO"
+        super().__init__(name)
+        self.setLevel(level)
+
+        # Standard stdout handler
+        self.stdout_handler = logging.StreamHandler(sys.stdout)
+        formatter = "%(name)s | %(levelname)s | %(asctime)s | %(message)s"
+        self.fmt = formatter
+        self.stdout_handler.setFormatter(logging.Formatter(formatter))
+        self.addHandler(self.stdout_handler)
+
+        # Session storage - simple dict of lists
+        self.session_logs: dict[str, list[dict[str, str]]] = defaultdict(list)
+
+    def _capture_to_session(self, level: int, msg, args):
+        """Capture log to session storage regardless of logger level."""
+        try:
+            session_id = get_current_session()
+            if session_id:
+                timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S,%f")[:-3]
+                formatted_msg = msg % args if args else str(msg)
+                level_name = SUPPORTED_LOG_LEVELS.get(level, "INFO")
+                log_entry = {"level": level_name, "timestamp": timestamp, "message": formatted_msg}
+                self.session_logs[session_id].append(log_entry)
+        except Exception:
+            pass
+
+    def debug(self, msg, *args, **kwargs):
+        """Override debug to always capture in session storage."""
+        self._capture_to_session(logging.DEBUG, msg, args)
+        super().debug(msg, *args, **kwargs)
+
+    def info(self, msg, *args, **kwargs):
+        """Override info to always capture in session storage."""
+        self._capture_to_session(logging.INFO, msg, args)
+        super().info(msg, *args, **kwargs)
+
+    def warning(self, msg, *args, **kwargs):
+        """Override warning to always capture in session storage."""
+        self._capture_to_session(logging.WARNING, msg, args)
+        super().warning(msg, *args, **kwargs)
+
+    def error(self, msg, *args, **kwargs):
+        """Override error to always capture in session storage."""
+        self._capture_to_session(logging.ERROR, msg, args)
+        super().error(msg, *args, **kwargs)
+
+    def pop_session_logs(self, session_id: str) -> list[dict[str, str]]:
+        """Pop logs for a specific session.
+
+        Arguments:
+            session_id (str): The session ID.
+
+        Returns:
+            list[dict[str, str]]: List of log entries for the session.
+        """
+        return self.session_logs.pop(session_id, [])
+
+    def group_by_level(self, session_id: str) -> dict[str, list[dict[str, str]]]:
+        """Group logs by level for a specific session.
+
+        Arguments:
+            session_id (str): The session ID.
+
+        Returns:
+            dict[str, list[dict[str, str]]]: Logs grouped by level.
+        """
+        session_logs = self.pop_session_logs(session_id)
+        grouped_logs: dict[str, list[dict[str, str]]] = defaultdict(list)
+        for log in session_logs:
+            level = log.get("level")
+            if level:
+                grouped_logs[level].append(log)
+
+        return grouped_logs
+
+
+logger = Logger(name="MAPS4FS_MONITOR")
+
+
+def get_current_session() -> str | None:
+    """Get the current session name from thread-local storage."""
+    return getattr(_local, "current_session", None)
+
+
+@contextmanager
+def performance_session(session_id: str | None = None) -> Generator[str, None, None]:
+    """Context manager for performance monitoring session.
+
+    Arguments:
+        session_id (str, optional): Custom session ID. If None, generates UUID.
+    """
+    if session_id is None:
+        session_id = str(uuid.uuid4())
+
+    _local.current_session = session_id
+
+    try:
+        yield session_id
+    finally:
+        _local.current_session = None
+
+
+class PerformanceMonitor(metaclass=Singleton):
+    """Singleton class for monitoring performance metrics."""
+
+    def __init__(self) -> None:
+        self.sessions: dict[str, dict[str, dict[str, float]]] = defaultdict(
+            lambda: defaultdict(lambda: defaultdict(float))
+        )
+
+    def add_record(self, session: str, component: str, function: str, time_taken: float) -> None:
+        """Add a performance record.
+
+        Arguments:
+            session (str): The session name.
+            component (str): The component/class name.
+            function (str): The function/method name.
+            time_taken (float): Time taken in seconds.
+        """
+        self.sessions[session][component][function] += time_taken
+
+    def pop_session_json(self, session: str) -> dict[str, dict[str, float]]:
+        """Pop performance data for a session in JSON-serializable format.
+
+        Arguments:
+            session (str): The session name.
+
+        Returns:
+            dict[str, dict[str, float]]: Performance data.
+        """
+        return self.sessions.pop(session, {})
+
+
+def monitor_performance(func: Callable) -> Callable:
+    """Decorator to monitor performance of methods/functions.
+
+    Arguments:
+        func (callable) -- The function to be monitored.
+
+    Returns:
+        callable -- The wrapped function with performance monitoring.
+    """
+
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        if args and hasattr(args[0], "__class__"):
+            class_name = args[0].__class__.__name__
+        elif args and hasattr(args[0], "__name__"):
+            class_name = args[0].__name__
+        elif "." in func.__qualname__:
+            class_name = func.__qualname__.split(".")[0]
+        else:
+            class_name = None
+
+        function_name = func.__name__
+
+        start = perf_counter()
+        result = func(*args, **kwargs)
+        end = perf_counter()
+        time_taken = round(end - start, 5)
+
+        session_name = get_current_session()
+
+        try:
+            if session_name and time_taken > 0.001 and class_name:
+                PerformanceMonitor().add_record(session_name, class_name, function_name, time_taken)
+                logger.debug(
+                    "[PERFORMANCE] %s | %s | %s | %s",
+                    session_name,
+                    class_name,
+                    function_name,
+                    time_taken,
+                )
+        except Exception:
+            pass
+
+        return result
+
+    return wrapper

{maps4fs-2.9.38 → maps4fs-2.9.41}/maps4fs/generator/settings.py

@@ -285,13 +285,13 @@ class BuildingSettings(SettingsModel):
     Attributes:
         generate_buildings (bool): generate buildings on the map.
         region (Literal["auto", "all", "EU", "US"]): region for the buildings.
-        tolerance_factor (float): tolerance factor representing allowed dimension difference
+        tolerance_factor (int): tolerance factor representing allowed dimension difference
             between OSM building footprint and the building model footprint.
     """
 
     generate_buildings: bool = True
     region: Literal["auto", "all", "EU", "US"] = "auto"
-    tolerance_factor: float = 0.3
+    tolerance_factor: int = 30
 
 
 class GenerationSettings(BaseModel):

{maps4fs-2.9.38 → maps4fs-2.9.41}/maps4fs/generator/statistics.py

@@ -6,9 +6,9 @@ from typing import Any
 
 import requests
 
-from maps4fs.logger import Logger
+from maps4fs.generator.monitor import Logger
 
-logger = Logger()
+logger = Logger(name="MAPS4FS.STATISTICS")
 
 try:
     from dotenv import load_dotenv

{maps4fs-2.9.38 → maps4fs-2.9.41}/maps4fs/logger.py

@@ -1,5 +1,6 @@
 """This module contains the Logger class for logging to the file and stdout."""
 
+import inspect
 import logging
 import sys
 from typing import Literal
@@ -16,6 +17,21 @@ class Logger(logging.Logger):
         to_stdout: bool = True,
         **kwargs,
     ):
+        print(
+            "The maps4fs.logger.Logger class is deprecated and will be removed in future versions. "
+            "Switch to maps4fs.generator.monitoring.Logger instead.",
+        )
+
+        # Show detailed information from where the instantiation is happening.
+        frame = inspect.currentframe()
+        if frame is not None:
+            caller_frame = frame.f_back
+            if caller_frame is not None:
+                info = inspect.getframeinfo(caller_frame)
+                print(
+                    f"Logger instantiated from file: {info.filename}, line: {info.lineno}, function: {info.function}"
+                )
+
         super().__init__(kwargs.pop("name", LOGGER_NAME))
         self.setLevel(level)
         self.stdout_handler = logging.StreamHandler(sys.stdout)

{maps4fs-2.9.38 → maps4fs-2.9.41}/maps4fs.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maps4fs
-Version: 2.9.38
+Version: 2.9.41
 Summary: Generate map templates for Farming Simulator from real places.
 Author-email: iwatkot <iwatkot@gmail.com>
 License-Expression: CC-BY-NC-4.0
@@ -94,11 +94,10 @@ Dynamic: license-file
 📦 **Giants Editor Ready** - Import and start building immediately<br>
 
 🗺️ **Advanced Customization** - [Custom OSM maps](https://maps4fs.gitbook.io/docs/advanced-topics/custom_osm) and elevation data<br>
-🔌 **API Integration** - Generate maps programmatically via [API](https://github.com/iwatkot/maps4fsapi)<br>
 📚 **Complete Documentation** - [Detailed guides](https://maps4fs.gitbook.io/docs) and video tutorials<br>
 
 <p align="center">
-<img src="https://github.com/iwatkot/maps4fs/releases/download/2.9.34/mfsg.gif"><br>
+<img src="https://github.com/iwatkot/maps4fs/releases/download/2.9.40/mfsg2.gif"><br>
 <i>Example of map generated with Maps4FS with no manual edits.</i>
 </p>
 

{maps4fs-2.9.38 → maps4fs-2.9.41}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "maps4fs"
-version = "2.9.38"
+version = "2.9.41"
 description = "Generate map templates for Farming Simulator from real places."
 authors = [{name = "iwatkot", email = "iwatkot@gmail.com"}]
 readme = "README.md"

maps4fs-2.9.38/maps4fs/generator/monitor.py

@@ -1,118 +0,0 @@
-"""Module for performance monitoring during map generation."""
-
-import functools
-import threading
-import uuid
-from collections import defaultdict
-from contextlib import contextmanager
-from time import perf_counter
-from typing import Callable, Generator
-
-from maps4fs.generator.utils import Singleton
-from maps4fs.logger import Logger
-
-logger = Logger(name="MAPS4FS_MONITOR")
-
-_local = threading.local()
-
-
-def get_current_session() -> str | None:
-    """Get the current session name from thread-local storage."""
-    return getattr(_local, "current_session", None)
-
-
-@contextmanager
-def performance_session(session_id: str | None = None) -> Generator[str, None, None]:
-    """Context manager for performance monitoring session.
-
-    Arguments:
-        session_id (str, optional): Custom session ID. If None, generates UUID.
-    """
-    if session_id is None:
-        session_id = str(uuid.uuid4())
-
-    _local.current_session = session_id
-
-    try:
-        yield session_id
-    finally:
-        _local.current_session = None
-
-
-class PerformanceMonitor(metaclass=Singleton):
-    """Singleton class for monitoring performance metrics."""
-
-    def __init__(self) -> None:
-        self.sessions: dict[str, dict[str, dict[str, float]]] = defaultdict(
-            lambda: defaultdict(lambda: defaultdict(float))
-        )
-
-    def add_record(self, session: str, component: str, function: str, time_taken: float) -> None:
-        """Add a performance record.
-
-        Arguments:
-            session (str): The session name.
-            component (str): The component/class name.
-            function (str): The function/method name.
-            time_taken (float): Time taken in seconds.
-        """
-        self.sessions[session][component][function] += time_taken
-
-    def get_session_json(self, session: str) -> dict[str, dict[str, float]]:
-        """Get performance data for a session in JSON-serializable format.
-
-        Arguments:
-            session (str): The session name.
-
-        Returns:
-            dict[str, dict[str, float]]: Performance data.
-        """
-        return self.sessions.get(session, {})
-
-
-def monitor_performance(func: Callable) -> Callable:
-    """Decorator to monitor performance of methods/functions.
-
-    Arguments:
-        func (callable) -- The function to be monitored.
-
-    Returns:
-        callable -- The wrapped function with performance monitoring.
-    """
-
-    @functools.wraps(func)
-    def wrapper(*args, **kwargs):
-        if args and hasattr(args[0], "__class__"):
-            class_name = args[0].__class__.__name__
-        elif args and hasattr(args[0], "__name__"):
-            class_name = args[0].__name__
-        elif "." in func.__qualname__:
-            class_name = func.__qualname__.split(".")[0]
-        else:
-            class_name = None
-
-        function_name = func.__name__
-
-        start = perf_counter()
-        result = func(*args, **kwargs)
-        end = perf_counter()
-        time_taken = round(end - start, 5)
-
-        session_name = get_current_session()
-
-        try:
-            if session_name and time_taken > 0.001 and class_name:
-                PerformanceMonitor().add_record(session_name, class_name, function_name, time_taken)
-                logger.debug(
-                    "[PERFORMANCE] %s | %s | %s | %s",
-                    session_name,
-                    class_name,
-                    function_name,
-                    time_taken,
-                )
-        except Exception:
-            pass
-
-        return result
-
-    return wrapper