factorio-draftsman 3.0.0__tar.gz → 3.0.1__tar.gz

{factorio_draftsman-3.0.0 → factorio_draftsman-3.0.1}/MANIFEST.in

@@ -1,9 +1,9 @@
-global-include *.pkl
-global-exclude *.zip
-
-exclude draftsman/factorio-mods/mod-settings.dat
-exclude draftsman/factorio-mods/mod-list.json
-include draftsman/factorio-mods/.gitignore
-
-recursive-include draftsman/factorio-data/* *
+global-include *.pkl
+global-exclude *.zip
+
+exclude draftsman/factorio-mods/mod-settings.dat
+exclude draftsman/factorio-mods/mod-list.json
+include draftsman/factorio-mods/.gitignore
+
+recursive-include draftsman/factorio-data/* *
 include draftsman/compatibility/*

{factorio_draftsman-3.0.0/factorio_draftsman.egg-info → factorio_draftsman-3.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: factorio-draftsman
-Version: 3.0.0
+Version: 3.0.1
 Summary: A complete, well-tested, and up-to-date module to manipulate Factorio blueprint strings. Compatible with mods.
 Author: redruin01
 License: MIT License
@@ -31,10 +31,6 @@ Project-URL: Issues, https://github.com/redruin1/factorio-draftsman/issues
 Project-URL: Changelog, https://github.com/redruin1/factorio-draftsman/blob/main/changelog.md
 Keywords: factorio,blueprint,string
 Classifier: Development Status :: 4 - Beta
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
@@ -43,7 +39,7 @@ Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: End Users/Desktop
 Classifier: Operating System :: OS Independent
 Classifier: License :: OSI Approved :: MIT License
-Requires-Python: >=3.8
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: attrs>=25.3.0
@@ -274,6 +270,7 @@ Available recipes:
     test            # Run test suite against {current Factorio version, all Python versions}
     test-all        # Run test suite against {all Factorio versions, latest Python version} (LONG)
     report-coverage # Combine all coverage files and create HTML report
+    benchmark       # Run benchmark tests and save profiles for this Draftsman version
 ```
 
 Note that testing currently is only guaranteed to pass with a vanilla [environment](https://factorio-draftsman.readthedocs.io/en/latest/concepts/environment.html).

{factorio_draftsman-3.0.0 → factorio_draftsman-3.0.1}/README.md

@@ -216,6 +216,7 @@ Available recipes:
     test            # Run test suite against {current Factorio version, all Python versions}
     test-all        # Run test suite against {all Factorio versions, latest Python version} (LONG)
     report-coverage # Combine all coverage files and create HTML report
+    benchmark       # Run benchmark tests and save profiles for this Draftsman version
 ```
 
 Note that testing currently is only guaranteed to pass with a vanilla [environment](https://factorio-draftsman.readthedocs.io/en/latest/concepts/environment.html).

factorio_draftsman-3.0.1/draftsman/_version.py

@@ -0,0 +1,4 @@
+# _version.py
+
+__version__ = "3.0.1"
+__version_info__ = (3, 0, 1)

{factorio_draftsman-3.0.0 → factorio_draftsman-3.0.1}/draftsman/blueprintable.py

@@ -76,6 +76,7 @@ def get_blueprintable_from_JSON(blueprintable_JSON: dict) -> Blueprintable:
         ``"deconstruction_planner"``, ``"upgrade_planner"``, nor
         ``"blueprint_book"``, and thus it's type cannot be deduced.
     """
+    blueprintable_type: type[Blueprintable]
     if "blueprint" in blueprintable_JSON:
         blueprintable_type = Blueprint
     elif "deconstruction_planner" in blueprintable_JSON:
@@ -92,7 +93,9 @@ def get_blueprintable_from_JSON(blueprintable_JSON: dict) -> Blueprintable:
         )
     # Try and get the version from the dictionary, falling back to current
     # environment configuration if not found
-    root_item = blueprintable_type.root_item.fget(blueprintable_type)
+    # TODO: could maybe fix mypy annotation here by making `root_item` a raw
+    # attribute, but that seems worse
+    root_item = blueprintable_type.root_item.fget(blueprintable_type)  # type: ignore
     if "version" in blueprintable_JSON[root_item]:
         version = decode_version(blueprintable_JSON[root_item]["version"])
     else:

{factorio_draftsman-3.0.0 → factorio_draftsman-3.0.1}/draftsman/classes/blueprint.py

@@ -211,7 +211,7 @@ class Blueprint(Transformable, Collection, Blueprintable):
         result += self.tiles.validate(mode=mode)
         # TODO: self.schedules.validate(mode=mode)
 
-        for class_validator in type(self).__attrs_class_validators__:
+        for class_validator in type(self).__attrs_class_validators__:  # type: ignore
             class_validator(self, mode=mode)  # TODO: pass in error/warning list
 
         return result
@@ -397,7 +397,7 @@ draftsman_converters.get_version((1, 0)).add_hook_fns(
         ): fields.position_relative_to_grid.name,
         ("blueprint", "entities"): (  # Custom structure function
             fields.entities,
-            lambda value, _, inst: EntityList(
+            lambda value, _, inst, args: EntityList(
                 inst,
                 [
                     converter.structure(
@@ -417,7 +417,7 @@ draftsman_converters.get_version((1, 0)).add_hook_fns(
             ),
         ),
         ("blueprint", "tiles"): fields.tiles.name,
-        # None: fields.wires.name,
+        ("blueprint", "wires"): fields.wires.name,  # *Possibly* imported
         ("blueprint", "schedules"): fields.schedules.name,
         # None: fields.stock_connections.name,
     },
@@ -436,7 +436,7 @@ draftsman_converters.get_version((1, 0)).add_hook_fns(
         ): fields.position_relative_to_grid.name,
         ("blueprint", "entities"): fields.entities.name,
         ("blueprint", "tiles"): fields.tiles.name,
-        # None: fields.wires.name,
+        # None: fields.wires.name, # Not exported (if I have anything to say about it)
         ("blueprint", "schedules"): fields.schedules.name,
         # None: fields.stock_connections.name,
     },
@@ -486,7 +486,14 @@ def structure_blueprint_1_0_factory(t: type):
 
         blueprint_dict = d["blueprint"]
 
-        wires = blueprint_dict["wires"] = []
+        # For crazy ass reasons, "wires" might *actually* be populated on a 1.0
+        # versioned blueprint (If the blueprint "version" key is straight up
+        # wrong)
+        # So try to grab it and use it if it exists, otherwise initialize it to
+        # an empty list
+        if "wires" not in blueprint_dict:  # pragma: no coverage
+            blueprint_dict["wires"] = []
+        wires = blueprint_dict["wires"]
         if "entities" in blueprint_dict:
             for entity in blueprint_dict["entities"]:
 
@@ -602,7 +609,7 @@ draftsman_converters.get_version((2, 0)).add_hook_fns(
         ): fields.position_relative_to_grid.name,
         ("blueprint", "entities"): (  # Custom structure function
             fields.entities,
-            lambda value, _, inst: EntityList(
+            lambda value, _, inst, args: EntityList(
                 inst,
                 [
                     converter.structure(

{factorio_draftsman-3.0.0 → factorio_draftsman-3.0.1}/draftsman/classes/blueprint_book.py

@@ -20,7 +20,7 @@ from draftsman.validators import instance_of
 import attrs
 import cattrs
 from collections.abc import MutableSequence
-from typing import Any, Literal, Union
+from typing import Any, Iterable, Literal, Sequence, overload
 
 
 class BlueprintableList(MutableSequence):
@@ -30,7 +30,7 @@ class BlueprintableList(MutableSequence):
 
     def __init__(
         self,
-        initlist: list[Union[dict, Blueprintable]] = [],
+        initlist: Sequence[dict | Blueprintable] = [],
     ):
         from draftsman.blueprintable import get_blueprintable_from_JSON  # FIXME: cursed
 
@@ -47,17 +47,27 @@ class BlueprintableList(MutableSequence):
 
         self.data.insert(idx, value)
 
-    def __getitem__(
-        self, idx: Union[int, slice]
-    ) -> Union[Blueprintable, MutableSequence[Blueprintable]]:
+    @overload
+    def __getitem__(self, idx: int) -> Blueprintable: ...
+    @overload
+    def __getitem__(self, idx: slice) -> list[Blueprintable]: ...
+    def __getitem__(self, idx):
         return self.data[idx]
 
-    def __setitem__(self, idx: Union[int, slice], value: Blueprintable) -> None:
-        self.check_blueprintable(value)
-
-        self.data[idx] = value
+    @overload
+    def __setitem__(self, idx: int, value: Blueprintable) -> None: ...
+    @overload
+    def __setitem__(self, idx: slice, value: Iterable[Blueprintable]) -> None: ...
+    def __setitem__(self, idx, value):
+        if isinstance(idx, slice):
+            for v in value:
+                self.check_blueprintable(v)
+            self.data[idx] = [v for v in value]
+        else:
+            self.check_blueprintable(value)
+            self.data[idx] = value
 
-    def __delitem__(self, idx: Union[int, slice]) -> None:
+    def __delitem__(self, idx: int | slice) -> None:
         del self.data[idx]
 
     def __len__(self) -> int:

{factorio_draftsman-3.0.0 → factorio_draftsman-3.0.1}/draftsman/classes/blueprintable.py

@@ -77,6 +77,11 @@ class Blueprintable(Exportable, metaclass=ABCMeta):
         # Try and get the version from the dictionary, falling back to current
         # environment configuration if not found
         if "version" in json_dict[root_item]:
+            # However, "version" is simply the version of the game that the
+            # blueprint was originally created in, and is not necessarily kept
+            # up-to-date and as such may be straight up wrong.
+            # This means our importing methods need to be robust to the case
+            # where the blueprint string lies to us about it's contents
             version = decode_version(json_dict[root_item]["version"])
         else:
             version = mods.versions.get("base", DEFAULT_FACTORIO_VERSION)
@@ -254,7 +259,7 @@ class Blueprintable(Exportable, metaclass=ABCMeta):
 
         This attribute is imported/exported from blueprint strings.
 
-    The version of Factorio the Blueprint was created in/intended for.
+    The version of Factorio the Blueprint was created in.
 
     The Blueprint ``version`` is a 64-bit integer, which is a bitwise-OR
     of four 16-bit numbers. You can interpret this number more clearly by

{factorio_draftsman-3.0.0 → factorio_draftsman-3.0.1}/draftsman/classes/deconstruction_planner.py

@@ -219,7 +219,11 @@ class DeconstructionPlanner(Blueprintable):
             new_entry = EntityFilter(
                 index=index, name=name, quality=quality, comparator=comparator
             )
-            bisect.insort(self.entity_filters, new_entry, key=lambda e: e.index)
+            bisect.insort(
+                self.entity_filters,
+                new_entry,
+                key=lambda e: 0 if e.index is None else e.index,
+            )
 
     def set_tile_filter(
         self, index: int, name: str  # TODO: should be uint64  # TODO: should be TileID
@@ -248,7 +252,11 @@ class DeconstructionPlanner(Blueprintable):
         if found_index is None:
             # Otherwise its unique; add to list
             new_entry = TileFilter(index=index, name=name)
-            bisect.insort(self.tile_filters, new_entry, key=lambda e: e.index)
+            bisect.insort(
+                self.tile_filters,
+                new_entry,
+                key=lambda e: 0 if e.index is None else e.index,
+            )
 
 
 draftsman_converters.add_hook_fns(

{factorio_draftsman-3.0.0 → factorio_draftsman-3.0.1}/draftsman/classes/entity.py

@@ -156,7 +156,7 @@ class Entity(EntityLike, Exportable):
     def __attrs_post_init__(self):
         # We gave incorrect defaults for `position` and `tile_position` so that
         # we can deduce which ones were specified in init
-        # (For example`position` can be `None` at this point, even though it's
+        # (For example `position` can be `None` at this point, even though it's
         # type annotated as always being a Vector instance. We wouldn't have to
         # do this if attrs supported kwargs here, but it doesn't, so.)
 
@@ -259,7 +259,7 @@ class Entity(EntityLike, Exportable):
     # =========================================================================
 
     @property
-    def collision_mask(self) -> set:
+    def collision_mask(self) -> set[str]:
         """
         The set of all collision layers that this Entity collides with,
         specified as strings. Equivalent to Factorio's ``data.raw`` entry.
@@ -1021,7 +1021,7 @@ draftsman_converters.get_version((1, 0)).add_hook_fns(
         "entity_number": None,
         "name": (
             fields.name,
-            lambda input, _, inst: migrate_name(
+            lambda input, _, inst, args: migrate_name(
                 input,
                 source_version=(1, 0),
                 dest_version=mods.versions.get("base", DEFAULT_FACTORIO_VERSION),
@@ -1032,7 +1032,7 @@ draftsman_converters.get_version((1, 0)).add_hook_fns(
         # None: fields.quality.name,
         "items": (
             _export_fields.item_requests,
-            lambda input_dict, _, inst: [
+            lambda input_dict, _, inst, args: [
                 {
                     "id": {"name": k, "quality": "normal"},
                     "items": {
@@ -1060,7 +1060,7 @@ draftsman_converters.get_version((1, 0)).add_hook_fns(
     lambda fields, converter: {
         "name": (
             fields.name,
-            lambda inst: migrate_name(
+            lambda inst: migrate_name(  # TODO
                 inst.name,
                 source_version=mods.versions.get("base", DEFAULT_FACTORIO_VERSION),
                 dest_version=(1, 0),
@@ -1090,7 +1090,7 @@ draftsman_converters.get_version((2, 0)).add_hook_fns(
         "entity_number": None,
         "name": (
             fields.name,
-            lambda input, _, inst: migrate_name(
+            lambda input, _, inst, args: migrate_name(
                 input,
                 source_version=(2, 0),
                 dest_version=mods.versions.get("base", DEFAULT_FACTORIO_VERSION),

{factorio_draftsman-3.0.0 → factorio_draftsman-3.0.1}/draftsman/classes/exportable.py

@@ -375,35 +375,58 @@ def make_exportable_structure_factory_func(
         def structure_hook(input_dict: dict, _: type):
             inst = cls.__new__(cls)
 
+            # print(input_dict)
+
             init_args = {}
-            for dict_loc, attr_name in structure_dict.items():
-                if attr_name is None:
-                    try_pop_location(input_dict, dict_loc)
+            for source_loc, dest_loc in structure_dict.items():
+                # If the destination is None, that's us telling the structure
+                # function to ignore that particular entry
+                if dest_loc is None:
+                    try_pop_location(input_dict, source_loc)
                     continue
 
-                if isinstance(attr_name, tuple):
-                    attr = attr_name[0]
-                    custom_handler = attr_name[1]
+                # print(source_loc, dest_loc)
+
+                if isinstance(dest_loc, dict):
+                    custom_handler = dest_loc.get("handler", None)
+                    attr = dest_loc["attr"]
+                    attr_name = dest_loc["name"]
+                    attr_type = dest_loc["type"]
+                elif isinstance(dest_loc, tuple):
+                    attr = dest_loc[0]
+                    custom_handler = dest_loc[1]
                     attr_name = attr.alias if attr.alias != attr.name else attr.name
+                    attr_type = attr.type
                 else:
-                    attr = getattr(class_attrs, attr_name)
+                    attr = getattr(class_attrs, dest_loc)
                     custom_handler = None
                     attr_name = attr.alias if attr.alias != attr.name else attr.name
+                    attr_type = attr.type
+
+                # print(attr)
+                # print(attr_name)
+                # print(attr_type)
+                # print(custom_handler)
 
-                value = try_pop_location(input_dict, dict_loc)
+                value = try_pop_location(input_dict, source_loc)
+                # No value means nothing to do
                 if value is None:
                     continue
 
+                # Grab the appropriate structure handler
                 handler = (
                     custom_handler
-                    if custom_handler
-                    else find_structure_handler(attr, attr.type, converter)
+                    if custom_handler is not None
+                    else find_structure_handler(attr, attr_type, converter)
                 )
+                # print(handler)
                 try:
                     if custom_handler:
-                        init_args[attr_name] = handler(value, attr.type, inst)
+                        init_args[attr_name] = handler(
+                            value, attr_type, inst, init_args
+                        )
                     else:
-                        init_args[attr_name] = handler(value, attr.type)
+                        init_args[attr_name] = handler(value, attr_type)
                 except Exception as e:
                     raise DataFormatError(e)
 

{factorio_draftsman-3.0.0 → factorio_draftsman-3.0.1}/draftsman/classes/group.py

@@ -6,6 +6,7 @@ from draftsman.classes.blueprint import (
 )
 from draftsman.classes.collection import Collection
 from draftsman.classes.collision_set import CollisionSet
+from draftsman.classes.entity import Entity
 from draftsman.classes.entity_like import EntityLike
 from draftsman.classes.entity_list import EntityList
 from draftsman.classes.exportable import Exportable, ValidationMode, ValidationResult
@@ -241,16 +242,15 @@ class Group(
 
     # =========================================================================
 
-    # TODO: delete this or fix this
-    collision_mask: dict = attrs.field(
-        factory=lambda: {"layers": set()},
-        converter=lambda v: {"layers": set()} if v is None else v,
-        validator=instance_of(dict),
+    collision_mask: set[str] = attrs.field(
+        factory=set,
+        converter=lambda v: set() if v is None else v,
+        validator=instance_of(set),
         kw_only=True,
     )
     """
-    The set of all collision layers that this Entity collides with,
-    specified as strings. Defaults to an empty ``set``.
+    The set of all collision layers that this group collides with, specified as 
+    strings. Defaults to an empty ``set``.
     """
 
     # =========================================================================
@@ -264,7 +264,7 @@ class Group(
 
     # =========================================================================
 
-    def get(self) -> list[EntityLike]:
+    def get(self) -> list[Entity]:
         """
         Gets all the child-most ``Entity`` instances in this ``Group`` and
         returns them as a "flattened" 1-dimensional list. Offsets all of their
@@ -285,7 +285,7 @@ class Group(
     def get_dimensions(self) -> tuple[int, int]:
         return aabb_to_dimensions(self.get_world_bounding_box())
 
-    def mergable_with(self, other: "Group") -> bool:
+    def mergable_with(self, other: EntityLike) -> bool:
         # For now, we assume that Groups themselves are not mergable
         # Note that the entities *inside* groups are perfectly mergable; the
         # only case where this is important is when two identical groups are
@@ -293,7 +293,7 @@ class Group(
         # will exist, one of which will be empty
         return False
 
-    def merge(self, other: "Group"):
+    def merge(self, other: EntityLike):
         # For now, we assume that Groups themselves are not mergable
         return  # Do nothing
 
@@ -328,7 +328,7 @@ draftsman_converters.get_version((1, 0)).add_hook_fns(
         ("blueprint", "position-relative-to-grid"): None,
         ("blueprint", "entities"): (  # Custom structure function
             fields.entities,
-            lambda value, _, inst: EntityList(
+            lambda value, _, inst, args: EntityList(
                 inst,
                 [
                     converter.structure(elem, get_entity_class(elem.get("name", None)))
@@ -377,7 +377,7 @@ draftsman_converters.get_version((2, 0)).add_hook_fns(
         ("blueprint", "position-relative-to-grid"): None,
         ("blueprint", "entities"): (  # Custom structure function
             fields.entities,
-            lambda value, _, inst: EntityList(
+            lambda value, _, inst, args: EntityList(
                 inst,
                 [
                     converter.structure(elem, get_entity_class(elem.get("name", None)))

{factorio_draftsman-3.0.0 → factorio_draftsman-3.0.1}/draftsman/classes/mixins/request_filters.py

@@ -139,7 +139,7 @@ draftsman_converters.get_version((1, 0)).add_hook_fns(
         # None: fields.requests_enabled.name,
         "request_filters": (
             _export_fields.sections,
-            lambda input_dict, _, inst: [
+            lambda input_dict, _, inst, args: [
                 ManualSection(
                     index=0, filters=converter.structure(input_dict, list[SignalFilter])
                 )
@@ -153,7 +153,11 @@ draftsman_converters.get_version((1, 0)).add_hook_fns(
         "request_filters": (
             _export_fields.sections,
             lambda inst: (
-                converter.unstructure(inst.sections[0].filters)
+                # Have to copy from ManualSection
+                [
+                    converter.unstructure(value)
+                    for _, value in sorted(inst.sections[0].filters.items())
+                ]
                 if len(inst.sections) > 0
                 else []
             ),

{factorio_draftsman-3.0.0 → factorio_draftsman-3.0.1}/draftsman/classes/spatial_data_structure.py

@@ -57,7 +57,7 @@ class SpatialDataStructure(metaclass=abc.ABCMeta):
         pass
 
     @abc.abstractmethod
-    def get_all_entities(self) -> list[SpatialLike]:  # pragma: no coverage
+    def get_all(self) -> list[SpatialLike]:  # pragma: no coverage
         """
         Get all the entities in the hash map. Iterates over every cell and
         returns the contents sequentially. Useful if you want to get all the

{factorio_draftsman-3.0.0 → factorio_draftsman-3.0.1}/draftsman/classes/spatial_hashmap.py

@@ -27,7 +27,7 @@ class SpatialHashMap(SpatialDataStructure):
     Accellerates spatial queries of :py:class:`~.Collection`.
     """
 
-    def __init__(self, cell_size: int = 8) -> None:
+    def __init__(self, cell_size: int = 4) -> None:
         """
         Create a new :py:class:`.SpatialHashMap`.
 
@@ -97,8 +97,10 @@ class SpatialHashMap(SpatialDataStructure):
             # StraightRails and CurvedRails cannot collide with each other
             # UNLESS they are the same type, face the same direction, and
             # exist at the exact same place
-            if isinstance(item, (StraightRail, LegacyCurvedRail)) and isinstance(
-                overlapping_item, (StraightRail, LegacyCurvedRail)
+            if isinstance(
+                item, (StraightRail, LegacyStraightRail, LegacyCurvedRail)
+            ) and isinstance(
+                overlapping_item, (StraightRail, LegacyStraightRail, LegacyCurvedRail)
             ):
                 identical = (
                     item.name == overlapping_item.name
@@ -125,19 +127,33 @@ class SpatialHashMap(SpatialDataStructure):
             overlapping_collision_set = overlapping_item.get_world_collision_set()
             if item_collision_set.overlaps(overlapping_collision_set):
                 warnings.warn(
-                    "Added object '{}' ({}) at {} intersects '{}' ({}) at {}".format(
+                    "Added object\n"
+                    "\t'{}' ({}) at {}{}\n"
+                    "intersects\n"
+                    "\t'{}' ({}) at {}{}".format(
                         item.name,
                         type(item).__name__,
                         item.global_position,
+                        (
+                            " facing {}".format(repr(item.direction))
+                            if hasattr(item, "rotatable") and item.rotatable
+                            else ""
+                        ),
                         overlapping_item.name,
                         type(overlapping_item).__name__,
                         overlapping_item.global_position,
+                        (
+                            " facing {}".format(repr(overlapping_item.direction))
+                            if hasattr(overlapping_item, "rotatable")
+                            and overlapping_item.rotatable
+                            else ""
+                        ),
                     ),
                     OverlappingObjectsWarning,
                     stacklevel=2,
                 )
 
-    def get_all_entities(self) -> list[SpatialLike]:
+    def get_all(self) -> list[SpatialLike]:
         items = []
         for cell_coord in self.map:
             for item in self.map[cell_coord]: