maps4fs 2.9.34__py3-none-any.whl → 2.9.36__py3-none-any.whl

maps4fs/generator/component/background.py

@@ -823,6 +823,10 @@ class Background(MeshComponent, ImageComponent):
 
         if self.map.background_settings.flatten_water:
             try:
+                # Check if there are any water pixels (255) in the water resources image.
+                if not np.any(water_resources_image == 255):
+                    self.logger.warning("No water pixels found in water resources image.")
+                    return
                 mask = water_resources_image == 255
                 flatten_to = int(np.mean(dem_image[mask]) - subtract_by)  # type: ignore
                 self.flatten_water_to = flatten_to  # type: ignore
@@ -862,13 +866,14 @@ class Background(MeshComponent, ImageComponent):
         """
         self.logger.debug("Starting line-based water generation...")
         water_polygons = self.get_infolayer_data(Parameters.BACKGROUND, Parameters.WATER)
-        self.logger.debug(
-            "Found %s water polygons in background info layer.", len(water_polygons)  # type: ignore
-        )
         if not water_polygons:
             self.logger.warning("No water polygons found in background info layer.")
             return
 
+        self.logger.debug(
+            "Found %s water polygons in background info layer.", len(water_polygons)  # type: ignore
+        )
+
         polygons: list[shapely.Polygon] = []
         for polygon_points in water_polygons:
             if not polygon_points or len(polygon_points) < 2:

maps4fs/generator/component/building.py

@@ -14,8 +14,9 @@ from maps4fs.generator.settings import Parameters
 from maps4fs.generator.utils import get_region_by_coordinates
 
 BUILDINGS_STARTING_NODE_ID = 10000
-TOLERANCE_FACTOR = 0.3  # 30% size tolerance
 DEFAULT_HEIGHT = 200
+AUTO_REGION = "auto"
+ALL_REGIONS = "all"
 
 
 AREA_TYPES = {
@@ -45,16 +46,25 @@ class BuildingEntry(NamedTuple):
 class BuildingEntryCollection:
     """Collection of building entries with efficient lookup capabilities."""
 
-    def __init__(self, building_entries: list[BuildingEntry], region: str):
+    def __init__(
+        self, building_entries: list[BuildingEntry], region: str, ignore_region: bool = False
+    ):
         """Initialize the collection with a list of building entries for a specific region.
 
         Arguments:
             building_entries (list[BuildingEntry]): List of building entries to manage
             region (str): The region for this collection (filters entries to this region only)
+            ignore_region (bool): If True, ignore region filtering and use all entries
         """
         self.region = region
-        # Filter entries to only include the specified region
-        self.entries = [entry for entry in building_entries if region in entry.regions]
+        self.ignore_region = ignore_region
+
+        # Filter entries based on ignore_region flag
+        if ignore_region:
+            self.entries = building_entries  # Use all entries regardless of region
+        else:
+            self.entries = [entry for entry in building_entries if region in entry.regions]
+
         # Create indices for faster lookup
         self._create_indices()
 
@@ -77,7 +87,7 @@ class BuildingEntryCollection:
         tolerance: float = 0.3,
     ) -> BuildingEntry | None:
         """Find the best matching building entry based on criteria.
-        All entries are already filtered by region during initialization.
+        Entries are filtered by region during initialization unless ignore_region is True.
 
         Arguments:
             category (str): Required building category
@@ -88,7 +98,7 @@ class BuildingEntryCollection:
         Returns:
             BuildingEntry | None: Best matching entry or None if no suitable match found
         """
-        # Start with buildings of the required category (already filtered by region)
+        # Start with buildings of the required category (filtered by region unless ignore_region is True)
         candidates = self.by_category.get(category, [])
         if not candidates:
             return None
@@ -107,6 +117,91 @@ class BuildingEntryCollection:
         scored_candidates.sort(key=lambda x: x[0], reverse=True)
         return scored_candidates[0][1]
 
+    def find_best_match_with_orientation(
+        self,
+        category: str,
+        width: float | None = None,
+        depth: float | None = None,
+        tolerance: float = 0.3,
+    ) -> tuple[BuildingEntry | None, bool]:
+        """Find the best matching building entry and determine if rotation is needed.
+
+        Arguments:
+            category (str): Required building category
+            width (float | None): Desired width (optional)
+            depth (float | None): Desired depth (optional)
+            tolerance (float): Size tolerance factor (0.3 = 30% tolerance)
+
+        Returns:
+            tuple[BuildingEntry | None, bool]: Best matching entry and whether it needs 90° rotation
+        """
+        # Start with buildings of the required category
+        candidates = self.by_category.get(category, [])
+        if not candidates:
+            return None, False
+
+        # Score each candidate and track orientation
+        scored_candidates = []
+        for entry in candidates:
+            score, needs_rotation = self._calculate_match_score_with_orientation(
+                entry, category, width, depth, tolerance
+            )
+            if score > 0:  # Only consider viable matches
+                scored_candidates.append((score, entry, needs_rotation))
+
+        if not scored_candidates:
+            return None, False
+
+        # Return the highest scoring match with its orientation info
+        scored_candidates.sort(key=lambda x: x[0], reverse=True)
+        _, best_entry, needs_rotation = scored_candidates[0]
+        return best_entry, needs_rotation
+
+    def _calculate_match_score_with_orientation(
+        self,
+        entry: BuildingEntry,
+        category: str,
+        width: float | None,
+        depth: float | None,
+        tolerance: float,
+    ) -> tuple[float, bool]:
+        """Calculate a match score and determine orientation for a building entry.
+
+        Returns:
+            tuple[float, bool]: Match score and whether 90° rotation is needed
+        """
+        score = 0.0
+
+        # Category match (required) - base score
+        if category in entry.categories:
+            score = 100.0
+        else:
+            return 0.0, False  # Category mismatch = no match
+
+        # Size matching (if dimensions are provided)
+        if width is not None and depth is not None:
+            # Calculate how well the dimensions match (considering both orientations)
+            size_score1 = self._calculate_size_match(
+                entry.width, entry.depth, width, depth, tolerance
+            )
+            size_score2 = self._calculate_size_match(
+                entry.width, entry.depth, depth, width, tolerance
+            )
+
+            # Determine which orientation is better
+            if size_score1 >= size_score2:
+                # Original orientation is better
+                if size_score1 > 0:
+                    score += size_score1 * 80.0
+                    return score, False
+                return 0.0, False
+            if size_score2 > 0:
+                score += size_score2 * 80.0
+                return score, True
+            return 0.0, False
+
+        return score, False
+
     def _calculate_match_score(
         self,
         entry: BuildingEntry,
@@ -116,7 +211,7 @@ class BuildingEntryCollection:
         tolerance: float,
     ) -> float:
         """Calculate a match score for a building entry.
-        Region is already matched during initialization.
+        Region is matched during initialization unless ignore_region is True.
 
         Returns:
             float: Match score (higher is better, 0 means no match)
@@ -175,11 +270,11 @@ class BuildingEntryCollection:
         return (width_ratio + depth_ratio) / 2.0
 
     def get_available_categories(self) -> list[str]:
-        """Get list of available building categories for this region."""
+        """Get list of available building categories for this collection."""
         return list(self.by_category.keys())
 
     def filter_by_category(self, category: str) -> list[BuildingEntry]:
-        """Get all buildings of a specific category (already filtered by region)."""
+        """Get all buildings of a specific category (filtered by region unless ignore_region is True)."""
         return self.by_category.get(category, [])
 
 
@@ -310,17 +405,40 @@ class Building(I3d):
             building = BuildingEntry(**building_entry)
             building_entries.append(building)
 
-        region = get_region_by_coordinates(self.coordinates)
+        ignore_region = False
+        region = ""
 
-        self.buildings_collection = BuildingEntryCollection(building_entries, region)
-        self.logger.info(
-            "Buildings collection created with %d buildings for region '%s'.",
-            len(self.buildings_collection.entries),
-            region,
-        )
+        if self.map.building_settings.region == AUTO_REGION:
+            region = get_region_by_coordinates(self.coordinates)
+        elif self.map.building_settings.region == ALL_REGIONS:
+            ignore_region = True
+            region = "all"  # Set a default region name for logging
+        else:
+            region = self.map.building_settings.region
+
+        self.buildings_collection = BuildingEntryCollection(building_entries, region, ignore_region)
+
+        if ignore_region:
+            self.logger.info(
+                "Buildings collection created with %d buildings ignoring region restrictions.",
+                len(self.buildings_collection.entries),
+            )
+        else:
+            self.logger.info(
+                "Buildings collection created with %d buildings for region '%s'.",
+                len(self.buildings_collection.entries),
+                region,
+            )
 
-    # pylint: disable=too-many-return-statements
     def process(self) -> None:
+        """Process and place buildings on the map."""
+        try:
+            self.add_buildings()
+        except Exception as e:
+            self.logger.warning("An error occurred during buildings processing: %s", e)
+
+    # pylint: disable=too-many-return-statements
+    def add_buildings(self) -> None:
         """Process and place buildings on the map based on the buildings map image and schema."""
         if not hasattr(self, "buildings_map_path") or not os.path.isfile(self.buildings_map_path):
             self.logger.warning(
@@ -376,7 +494,7 @@ class Building(I3d):
         file_id_counter = BUILDINGS_STARTING_NODE_ID
         node_id_counter = BUILDINGS_STARTING_NODE_ID + 1000
 
-        not_resized_dem = self.get_not_resized_dem(with_foundations=True)
+        not_resized_dem = self.get_not_resized_dem_with_foundations(allow_fallback=True)
         if not_resized_dem is None:
             self.logger.warning("Not resized DEM not found.")
             return
@@ -414,17 +532,21 @@ class Building(I3d):
                 rotation_angle,
             )
 
-            # 3. Find the best matching building from the collection (region already filtered)
-            best_match = self.buildings_collection.find_best_match(
+            # 3. Find the best matching building from the collection and determine orientation
+            best_match, needs_rotation = self.buildings_collection.find_best_match_with_orientation(
                 category=category,
                 width=width,
                 depth=depth,
-                tolerance=TOLERANCE_FACTOR,
+                tolerance=self.map.building_settings.tolerance_factor,
             )
 
             if best_match:
                 self.logger.debug(
-                    f"Best building match: {best_match.name} ({best_match.width}x{best_match.depth})"
+                    "Best building match: %s: %d x %d, needs_rotation: %s",
+                    best_match.name,
+                    best_match.width,
+                    best_match.depth,
+                    needs_rotation,
                 )
 
                 # Get world coordinates
@@ -470,11 +592,21 @@ class Building(I3d):
                 else:
                     file_id = used_building_files[best_match.file]
 
+                # Adjust rotation if the building needs to be rotated 90 degrees
+                final_rotation = rotation_angle
+                if needs_rotation:
+                    final_rotation = (rotation_angle + 90.0) % 360.0
+                    self.logger.debug(
+                        "Building needs 90° rotation: original=%.1f°, final=%.1f°",
+                        rotation_angle,
+                        final_rotation,
+                    )
+
                 # Create building instance in the buildings group
                 building_node = ET.SubElement(buildings_group, "ReferenceNode")
                 building_node.set("name", f"{best_match.name}_{node_id_counter}")
                 building_node.set("translation", f"{x_center:.3f} {z:.3f} {y_center:.3f}")
-                building_node.set("rotation", f"0 {rotation_angle:.3f} 0")
+                building_node.set("rotation", f"0 {final_rotation:.3f} 0")
                 # building_node.set(
                 #     "scale", f"{scale_width:.4f} 1.0 {scale_depth:.4f}"
                 # )
@@ -485,7 +617,11 @@ class Building(I3d):
 
             else:
                 self.logger.debug(
-                    f"No suitable building found for category '{category}' with dimensions {width:.2f}x{depth:.2f}"
+                    "No suitable building found for category '%s' with dimensions %.2fx%.2f",
+                    category,
+                    width,
+                    depth,
+                    needs_rotation,
                 )
                 continue
 

maps4fs/generator/component/i3d.py

@@ -712,7 +712,7 @@ class I3d(XMLComponent, ImageComponent):
             else background_component.not_resized_path
         )
 
-        if not dem_path:
+        if not dem_path or not os.path.isfile(dem_path):
             self.logger.warning("Not resized DEM path not found.")
             return None
 
@@ -720,6 +720,28 @@ class I3d(XMLComponent, ImageComponent):
 
         return not_resized_dem
 
+    def get_not_resized_dem_with_foundations(
+        self, allow_fallback: bool = False
+    ) -> np.ndarray | None:
+        """Gets the not resized DEM with foundations. If the DEM with foundations is not found
+        and allow_fallback is True, the method returns the not resized DEM without foundations.
+
+        Arguments:
+            allow_fallback (bool, optional): Whether to allow fallback to DEM without
+                foundations. Defaults to False.
+
+        Returns:
+            np.ndarray | None: The not resized DEM image or None if the image could not be read.
+        """
+        dem_with_foundations = self.get_not_resized_dem(with_foundations=True)
+
+        if dem_with_foundations is not None:
+            return dem_with_foundations
+        self.logger.warning("Not resized DEM with foundations not found.")
+        if allow_fallback:
+            return self.get_not_resized_dem(with_foundations=False)
+        return None
+
     def info_sequence(self) -> dict[str, dict[str, str | float | int]]:
         """Returns information about the component.
 

maps4fs/generator/component/texture.py

@@ -814,7 +814,7 @@ class Texture(ImageComponent):
         is_fieds = info_layer == "fields"
 
         ox_settings.use_cache = self.map.texture_settings.use_cache
-        ox_settings.requests_timeout = 30
+        ox_settings.requests_timeout = 10
 
         objects = self.fetch_osm_data(tags)
         if objects is None or objects.empty:
@@ -845,7 +845,7 @@ class Texture(ImageComponent):
             else:
                 objects = ox.features_from_bbox(bbox=self.new_bbox, tags=tags)
         except Exception as e:
-            self.logger.debug("Error fetching objects for tags: %s. Error: %s.", tags, e)
+            self.logger.warning("Error fetching objects for tags: %s. Error: %s.", tags, e)
             return None
 
         return objects

maps4fs/generator/config.py

@@ -205,8 +205,31 @@ SAT_CACHE_DIR = os.path.join(MFS_CACHE_DIR, "sat")
 
 osmnx_cache = os.path.join(MFS_CACHE_DIR, "osmnx")
 osmnx_data = os.path.join(MFS_CACHE_DIR, "odata")
-os.makedirs(osmnx_cache, exist_ok=True)
-os.makedirs(osmnx_data, exist_ok=True)
+
+CACHE_DIRS = [DTM_CACHE_DIR, SAT_CACHE_DIR, osmnx_cache, osmnx_data]
+
+
+def create_cache_dirs() -> None:
+    """Create cache directories if they do not exist."""
+    logger.info("Ensuring cache directories exist...")
+    for cache_dir in CACHE_DIRS:
+        os.makedirs(cache_dir, exist_ok=True)
+        logger.debug("Cache directory ensured: %s", cache_dir)
+    logger.info("All cache directories are ready.")
+
+
+def clean_cache() -> None:
+    """Clean all cache directories by removing and recreating them."""
+    logger.info("Cleaning cache directories...")
+    for cache_dir in CACHE_DIRS:
+        if os.path.exists(cache_dir):
+            shutil.rmtree(cache_dir)
+            logger.debug("Removed cache directory: %s", cache_dir)
+    create_cache_dirs()
+    logger.info("Cache directories cleaned and recreated.")
+
+
+create_cache_dirs()
 
 
 ox_settings.cache_folder = osmnx_cache

maps4fs/generator/map.py

@@ -105,6 +105,7 @@ class Map:
         self.i3d_settings = generation_settings.i3d_settings
         self.texture_settings = generation_settings.texture_settings
         self.satellite_settings = generation_settings.satellite_settings
+        self.building_settings = generation_settings.building_settings
         self.process_settings()
 
         self.logger = logger if logger else Logger()

maps4fs/generator/settings.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import re
 from datetime import datetime
-from typing import TYPE_CHECKING, Any, NamedTuple
+from typing import TYPE_CHECKING, Any, Literal, NamedTuple
 
 from pydantic import BaseModel, ConfigDict
 
@@ -279,6 +279,21 @@ class SatelliteSettings(SettingsModel):
     zoom_level: int = 16
 
 
+class BuildingSettings(SettingsModel):
+    """Represents the advanced settings for building component.
+
+    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
+            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
+
+
 class GenerationSettings(BaseModel):
     """Represents the settings for the map generation process."""
 
@@ -288,6 +303,7 @@ class GenerationSettings(BaseModel):
     i3d_settings: I3DSettings = I3DSettings()
     texture_settings: TextureSettings = TextureSettings()
     satellite_settings: SatelliteSettings = SatelliteSettings()
+    building_settings: BuildingSettings = BuildingSettings()
 
     def to_json(self) -> dict[str, Any]:
         """Convert the GenerationSettings instance to JSON format.
@@ -302,6 +318,7 @@ class GenerationSettings(BaseModel):
             "I3DSettings": self.i3d_settings.model_dump(),
             "TextureSettings": self.texture_settings.model_dump(),
             "SatelliteSettings": self.satellite_settings.model_dump(),
+            "BuildingSettings": self.building_settings.model_dump(),
         }
 
     @classmethod

{maps4fs-2.9.34.dist-info → maps4fs-2.9.36.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maps4fs
-Version: 2.9.34
+Version: 2.9.36
 Summary: Generate map templates for Farming Simulator from real places.
 Author-email: iwatkot <iwatkot@gmail.com>
 License: GNU Affero General Public License v3.0

{maps4fs-2.9.34.dist-info → maps4fs-2.9.36.dist-info}/RECORD

@@ -1,31 +1,31 @@
 maps4fs/__init__.py,sha256=5ixsCA5vgcIV0OrF9EJBm91Mmc_KfMiDRM-QyifMAvo,386
 maps4fs/logger.py,sha256=aZAa9glzgvH6ySVDLelSPTwHfWZtpGK5YBl-ufNUsPg,801
 maps4fs/generator/__init__.py,sha256=zZMLEkGzb4z0xql650gOtGSvcgX58DnJ2yN3vC2daRk,43
-maps4fs/generator/config.py,sha256=gLYch5ZTmuJ4Bo9EKzwutZVpOHsTVlY90gSFLkzegmk,9035
+maps4fs/generator/config.py,sha256=o_zRT8Nauy1djELsC867yD7GTs1fwz1OtZ2jE4w_7Ts,9797
 maps4fs/generator/game.py,sha256=bflRv0lxJ9-wkRvauh0k0RzIgF7zVWguygqQLcC7U-s,18457
-maps4fs/generator/map.py,sha256=9F3PaoK63sbhNONvHN46k62-ZFMBQy5qvu9T193gwWs,16045
+maps4fs/generator/map.py,sha256=kkyMETKteFhnWRgmcR8gjdNBQy4roQzcdlFw1nE5chE,16116
 maps4fs/generator/monitor.py,sha256=Yrc7rClpmJK53SRzrOYZNBlwJmb5l6TkW-laFbyBEno,3524
 maps4fs/generator/qgis.py,sha256=Es8hLuqN_KH8lDfnJE6He2rWYbAKJ3RGPn-o87S6CPI,6116
-maps4fs/generator/settings.py,sha256=_QJL4ikQYLFOIB1zWqXjYvyLfoh3cr2RYb2IzsunMJg,13405
+maps4fs/generator/settings.py,sha256=jrrIILNRtIpj7hpLrQqLTIagTY8tdJlLZDEN1M4n3Yc,14116
 maps4fs/generator/statistics.py,sha256=ol0MTiehcCbQFfyYA7cKU-M4_cjiLCktnGbid4GYABU,2641
 maps4fs/generator/utils.py,sha256=qaHmS5I30OhDwd213bbctlplQQlX-qkHugyszXGmh0U,5587
 maps4fs/generator/component/__init__.py,sha256=s01yVVVi8R2xxNvflu2D6wTd9I_g73AMM2x7vAC7GX4,490
-maps4fs/generator/component/background.py,sha256=c2bjK3DkQXvA6Gtb_hUM9m-7fIVgp2BxJp09c4ZY3_A,49434
-maps4fs/generator/component/building.py,sha256=Ru3AAFMPN2X_ePwM3Yoe-KDkuJySRERpvvvSxU1lJvc,22233
+maps4fs/generator/component/background.py,sha256=KYtbnIqflrqiTzsibWh7atDWTeV1GgvLD0ZG463WshM,49704
+maps4fs/generator/component/building.py,sha256=VoLjj6mDT-4kVfwxXP-lD0r4vJVYszyWZtciVFwdkIk,27402
 maps4fs/generator/component/config.py,sha256=tI2RQaGIqBgJIi9KjYfMZZ8AWg_YVUm6KKsBHGV241g,31285
 maps4fs/generator/component/dem.py,sha256=vMVJtU2jAS-2lfB9JsqodZsrUvY1h5xr3Dh5qk6txwk,11895
 maps4fs/generator/component/grle.py,sha256=FAcGmG7yq0icOElRoO4QMsVisZMsNrLhfNSWvGKnOHg,29899
-maps4fs/generator/component/i3d.py,sha256=qB18jQWfWjlTiaZ4fHd16vv359hN2YHRLzGTZuJnbbU,27166
+maps4fs/generator/component/i3d.py,sha256=UM1js6bJx9_deftSvij1qjTiDypY8zvyhcXa5oXkfbk,28143
 maps4fs/generator/component/layer.py,sha256=-MHnIXyJ7Xth9wOcjJCX-XkXBIYYv23lRRGbQ0XlHdU,7602
 maps4fs/generator/component/satellite.py,sha256=1bPqd8JqAPqU0tEI9m-iuljMW9hXqlaCIxvq7kdpMY0,5219
-maps4fs/generator/component/texture.py,sha256=pmX8KE96dJAwzhnOe_ed-1In6sOLXs8-qdJ0aPc-ePM,38526
+maps4fs/generator/component/texture.py,sha256=XocNWPH1BHBcvTOJgpx8RU_tB-Mi1Kefp_lgOVIkEzY,38528
 maps4fs/generator/component/base/__init__.py,sha256=zZMLEkGzb4z0xql650gOtGSvcgX58DnJ2yN3vC2daRk,43
 maps4fs/generator/component/base/component.py,sha256=-7H3donrH19f0_rivNyI3fgLsiZkntXfGywEx4tOnM4,23924
 maps4fs/generator/component/base/component_image.py,sha256=GXFkEFARNRkWkDiGSjvU4WX6f_8s6R1t2ZYqZflv1jk,9626
 maps4fs/generator/component/base/component_mesh.py,sha256=2wGe_-wAZVRljMKzzVJ8jdzIETWg7LjxGj8A3inH5eI,25550
 maps4fs/generator/component/base/component_xml.py,sha256=MT-VhU2dEckLFxAgmxg6V3gnv11di_94Qq6atfpOLdc,5342
-maps4fs-2.9.34.dist-info/licenses/LICENSE.md,sha256=Ptw8AkqJ60c4tRts6yuqGP_8B0dxwOGmJsp6YJ8dKqM,34328
-maps4fs-2.9.34.dist-info/METADATA,sha256=N8RjSki41ECPZSKqYO5R97NgpGKcpeonB6SyWKI_m8c,10213
-maps4fs-2.9.34.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-maps4fs-2.9.34.dist-info/top_level.txt,sha256=Ue9DSRlejRQRCaJueB0uLcKrWwsEq9zezfv5dI5mV1M,8
-maps4fs-2.9.34.dist-info/RECORD,,
+maps4fs-2.9.36.dist-info/licenses/LICENSE.md,sha256=Ptw8AkqJ60c4tRts6yuqGP_8B0dxwOGmJsp6YJ8dKqM,34328
+maps4fs-2.9.36.dist-info/METADATA,sha256=-Fi5m_KZ584IkyeFCJnx89a1yFNq0VIPZEe6Wv3lKSQ,10213
+maps4fs-2.9.36.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+maps4fs-2.9.36.dist-info/top_level.txt,sha256=Ue9DSRlejRQRCaJueB0uLcKrWwsEq9zezfv5dI5mV1M,8
+maps4fs-2.9.36.dist-info/RECORD,,