factorio-draftsman 3.1.1__tar.gz → 3.2.0__tar.gz

{factorio_draftsman-3.1.1/factorio_draftsman.egg-info → factorio_draftsman-3.2.0}/PKG-INFO

@@ -1,30 +1,9 @@
 Metadata-Version: 2.4
 Name: factorio-draftsman
-Version: 3.1.1
+Version: 3.2.0
 Summary: A complete, well-tested, and up-to-date module to manipulate Factorio blueprint strings. Compatible with mods.
 Author: redruin01
-License: MIT License
-        
-        Copyright (c) 2023 redruin1
-        
-        Permission is hereby granted, free of charge, to any person obtaining a copy
-        of this software and associated documentation files (the "Software"), to deal
-        in the Software without restriction, including without limitation the rights
-        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-        copies of the Software, and to permit persons to whom the Software is
-        furnished to do so, subject to the following conditions:
-        
-        The above copyright notice and this permission notice shall be included in all
-        copies or substantial portions of the Software.
-        
-        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-        SOFTWARE.
-        
+License-Expression: MIT
 Project-URL: Homepage, https://github.com/redruin1/factorio-draftsman
 Project-URL: Documentation, https://factorio-draftsman.readthedocs.io/en/latest/index.html
 Project-URL: Issues, https://github.com/redruin1/factorio-draftsman/issues
@@ -38,11 +17,10 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: End Users/Desktop
 Classifier: Operating System :: OS Independent
-Classifier: License :: OSI Approved :: MIT License
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: attrs>=25.3.0
+Requires-Dist: attrs>=25.4.0
 Requires-Dist: cattrs>=24.1.3
 Requires-Dist: lupa>=2.0
 Requires-Dist: GitPython>=3.1.43

factorio_draftsman-3.2.0/draftsman/_version.py

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

{factorio_draftsman-3.1.1 → factorio_draftsman-3.2.0}/draftsman/classes/entity.py

@@ -31,7 +31,6 @@ from draftsman.utils import (
 )
 from draftsman.validators import conditional, instance_of, one_of
 from draftsman.warning import (
-    GridAlignmentWarning,
     UnknownEntityWarning,
     UnknownKeywordWarning,
 )
@@ -40,7 +39,6 @@ from draftsman.data import mods
 from draftsman.data.planets import get_surface_properties
 
 import attrs
-import math
 import pprint
 from typing import Any, Optional
 import warnings
@@ -536,7 +534,7 @@ class Entity(EntityLike, Exportable):
         )
 
         # Check of grid-alignment warnings after the positions have been updated
-        attr.validator(self, attr, value)
+        # attr.validator(self, attr, value)
 
         return res
 
@@ -564,21 +562,51 @@ class Entity(EntityLike, Exportable):
         <handbook.blueprints.forbidden_entity_attributes>`
     """
 
-    @position.validator
-    @conditional(ValidationMode.MINIMUM)
-    def _position_validator(self, _: attrs.Attribute, value: Vector):
-        if self.double_grid_aligned:
-            if self.tile_position.x % 2 == 1 or self.tile_position.y % 2 == 1:
-                cast_position = Vector(
-                    math.floor(self.tile_position.x / 2) * 2,
-                    math.floor(self.tile_position.y / 2) * 2,
-                )
-                msg = (
-                    "Double-grid aligned entity is not placed along chunk grid; "
-                    "entity's tile position will be cast from {} to {} when "
-                    "imported".format(self.tile_position, cast_position)
-                )
-                warnings.warn(GridAlignmentWarning(msg))
+    # This validator has always been a pain in the ass; I'm going to remove it
+    # for now as it needs a rethink, as it is incredibly contextual and does not
+    # play well with some of the hacky behaviors I've needed to use when working
+    # with attrs
+
+    # @position.validator
+    # @conditional(ValidationMode.MINIMUM)
+    # def _position_validator(self, _: attrs.Attribute, value: Vector):
+    #     if self.double_grid_aligned:
+    #         # If a double grid aligned entity lies on an odd coordinate, they're
+    #         # in the wrong spot
+    #         incorrect_offset = 1
+    #         # ... except for the case of 2.0 diagonal straight rails, which now
+    #         # lie on odd coordinates
+    #         # TODO: needs to be versioned...
+    #         if self.type == "straight-rail":
+    #             if self.direction in (
+    #                 Direction.NORTHEAST,
+    #                 Direction.SOUTHEAST,
+    #                 Direction.SOUTHWEST,
+    #                 Direction.NORTHWEST,
+    #             ):
+    #                 incorrect_offset = 0
+    #         print(incorrect_offset)
+    #         print(self.position)
+    #         print(self.tile_position)
+    #         print(self.tile_position.x % 2)
+
+    #         if (
+    #             self.tile_position.x % 2 == incorrect_offset
+    #             or self.tile_position.y % 2 == incorrect_offset
+    #         ):
+    #             print("wtf")
+    #             cast_position = Vector(
+    #                 math.floor(self.tile_position.x / 2) * 2,
+    #                 math.floor(self.tile_position.y / 2) * 2,
+    #             )
+    #             msg = (
+    #                 "Double-grid aligned entity ({}) is not placed along chunk grid; "
+    #                 "entity's tile position will be cast from {} to {} when "
+    #                 "imported".format(
+    #                     repr(self.name), self.tile_position, cast_position
+    #                 )
+    #             )
+    #             warnings.warn(GridAlignmentWarning(msg))
 
     # =========================================================================
 

{factorio_draftsman-3.1.1 → factorio_draftsman-3.2.0}/draftsman/classes/mixins/directional.py

@@ -47,34 +47,20 @@ class DirectionalMixin(Exportable):
         :py:class:`~.OrientationMixin`
     """
 
-    def __attrs_pre_init__(self, name=attrs.NOTHING, first_call=None, **kwargs):
-        # Make sure this is the first time calling pre-init (bugfix until attrs
-        # is patched)
-        if not first_call:
-            return
-
-        # Call parent pre-init
-        # super().__attrs_pre_init__()
-        # name = kwargs.get("name", get_first(self.similar_entities))
+    def __attrs_pre_init__(self, name=attrs.NOTHING, *args, **kwargs):
+        # Other attributes might need to know what entity we're dealing with,
+        # even prior to __init__
         name = name if name is not attrs.NOTHING else get_first(self.similar_entities)
         object.__setattr__(self, "name", name)
 
         # We generate collision sets on an as-needed basis for each unique
         # entity that is instantiated
-        # Automatically generate a set of rotated collision sets for every
-        # orientation
         try:
             _rotated_collision_sets[name]
         except KeyError:
-            static_collision_set = entities.collision_sets.get(name, None)
-            _rotated_collision_sets[name] = {}
-            for i in self.valid_directions:
-                if self.collision_set_rotated and static_collision_set is not None:
-                    rotated_collision_set = static_collision_set.rotate(i)
-                else:
-                    rotated_collision_set = static_collision_set
-
-                _rotated_collision_sets[name][i] = rotated_collision_set
+            # We encapsulate it in a function, since certain collision sets are
+            # hardcoded by the game and we need to account for that
+            _rotated_collision_sets[name] = self._specify_collision_sets()
 
         # The default position function uses `tile_width`/`tile_height`, which
         # use `collision_set`, which for rotatable entities is derived from the
@@ -236,6 +222,23 @@ class DirectionalMixin(Exportable):
         base_mergable = super().mergable_with(other)
         return base_mergable and self.direction == other.direction
 
+    def _specify_collision_sets(self) -> dict:
+        """
+        What values the rotated collision sets for this entity should be.
+        Isolated into it's own function for certain entities whose collision
+        boxes are hardcoded.
+        """
+        result = {}
+        static_collision_set = entities.collision_sets.get(self.name, None)
+        for dir in self.valid_directions:
+            if self.collision_set_rotated and static_collision_set is not None:
+                rotated_collision_set = static_collision_set.rotate(dir)
+            else:
+                rotated_collision_set = static_collision_set
+
+            result[dir] = rotated_collision_set
+        return result
+
 
 draftsman_converters.add_hook_fns(
     DirectionalMixin,

{factorio_draftsman-3.1.1 → factorio_draftsman-3.2.0}/draftsman/classes/mixins/orientation.py

@@ -19,12 +19,10 @@ class OrientationMixin(Exportable):
     Used in trains and wagons to specify their direction.
     """
 
-    def __attrs_pre_init__(self, name=attrs.NOTHING, *args, first_call=None, **kwargs):
-        if not first_call:
-            return
-
+    def __attrs_pre_init__(self, name=attrs.NOTHING, *args, **kwargs):
         name = name if name is not attrs.NOTHING else get_first(self.similar_entities)
         object.__setattr__(self, "name", name)
+
         object.__setattr__(
             self, "orientation", kwargs.get("orientation", Orientation.NORTH)
         )

{factorio_draftsman-3.1.1 → factorio_draftsman-3.2.0}/draftsman/classes/schedule.py

@@ -21,7 +21,7 @@ from draftsman.data import mods
 
 import attrs
 import copy
-from typing import Literal, Optional, Union
+from typing import ClassVar, Literal, Optional, Union
 
 
 # TODO: Right now, everything is just lumped into one WaitCondition class, which means
@@ -292,6 +292,65 @@ draftsman_converters.register_unstructure_hook_factory(
 )
 
 
+@attrs.define
+class ScheduleStop(Exportable):
+    station: str = attrs.field(validator=instance_of(str))
+    """
+    The name of the station or planet that this train or space platform
+    should stop at.
+    """
+    wait_conditions: WaitConditions = attrs.field(
+        factory=WaitConditions,
+        converter=WaitConditions,
+        validator=instance_of(WaitConditions),
+    )
+    """
+    A list of :py:class:`.WaitCondition` objects to evaluate at this
+    particular stop.
+    """
+    allows_unloading: Optional[bool] = attrs.field(
+        default=True, validator=instance_of(Optional[bool])
+    )
+    """
+    Whether or not this stop permits this space platform to fulfill any
+    requests at the planet it's stopped above. Only applies to space
+    platform schedules.
+    """
+
+
+@attrs.define
+class ScheduleInterrupt(Exportable):
+    name: str = attrs.field(validator=instance_of(str))
+    """
+    The name of this particular interrupt.
+    """
+    conditions: WaitConditions = attrs.field(
+        factory=WaitConditions,
+        converter=WaitConditions,
+        validator=instance_of(WaitConditions),
+    )
+    """
+    The set of conditions that need to pass in order for this interrupt
+    to be triggered.
+    """
+    targets: list[ScheduleStop] = attrs.field(
+        factory=list,
+        # TODO: converter
+        validator=instance_of(list[ScheduleStop]),
+    )
+    """
+    The target schedule that the interrupt should execute if it's 
+    triggered.
+    """
+    inside_interrupt: bool = attrs.field(
+        default=False,
+    )
+    """
+    Whether or not this interrupt can be triggered midway through an 
+    already executing interrupt.
+    """
+
+
 @attrs.define
 class Schedule(Exportable):
     """
@@ -301,62 +360,66 @@ class Schedule(Exportable):
     interrupts.
     """
 
-    @attrs.define
-    class Stop(Exportable):
-        station: str = attrs.field(validator=instance_of(str))
-        """
-        The name of the station or planet that this train or space platform
-        should stop at.
-        """
-        wait_conditions: WaitConditions = attrs.field(
-            factory=WaitConditions,
-            converter=WaitConditions,
-            validator=instance_of(WaitConditions),
-        )
-        """
-        A list of :py:class:`.WaitCondition` objects to evaluate at this
-        particular stop.
-        """
-        allows_unloading: Optional[bool] = attrs.field(
-            default=True, validator=instance_of(Optional[bool])
-        )
-        """
-        Whether or not this stop permits this space platform to fulfill any
-        requests at the planet it's stopped above. Only applies to space
-        platform schedules.
-        """
-
-    @attrs.define
-    class Interrupt(Exportable):
-        name: str = attrs.field(validator=instance_of(str))
-        """
-        The name of this particular interrupt.
-        """
-        conditions: WaitConditions = attrs.field(
-            factory=WaitConditions,
-            converter=WaitConditions,
-            validator=instance_of(WaitConditions),
-        )
-        """
-        The set of conditions that need to pass in order for this interrupt
-        to be triggered.
-        """
-        targets: list["Schedule.Stop"] = attrs.field(
-            factory=list,
-            # TODO: converter
-            validator=instance_of(list["Schedule.Stop"]),
-        )
-        """
-        The target schedule that the interrupt should execute if it's 
-        triggered.
-        """
-        inside_interrupt: bool = attrs.field(
-            default=False,
-        )
-        """
-        Whether or not this interrupt can be triggered midway through an 
-        already executing interrupt.
-        """
+    Stop: ClassVar = ScheduleStop
+
+    # @attrs.define
+    # class Stop(Exportable):
+    #     station: str = attrs.field(validator=instance_of(str))
+    #     """
+    #     The name of the station or planet that this train or space platform
+    #     should stop at.
+    #     """
+    #     wait_conditions: WaitConditions = attrs.field(
+    #         factory=WaitConditions,
+    #         converter=WaitConditions,
+    #         validator=instance_of(WaitConditions),
+    #     )
+    #     """
+    #     A list of :py:class:`.WaitCondition` objects to evaluate at this
+    #     particular stop.
+    #     """
+    #     allows_unloading: Optional[bool] = attrs.field(
+    #         default=True, validator=instance_of(Optional[bool])
+    #     )
+    #     """
+    #     Whether or not this stop permits this space platform to fulfill any
+    #     requests at the planet it's stopped above. Only applies to space
+    #     platform schedules.
+    #     """
+
+    Interrupt: ClassVar = ScheduleInterrupt
+
+    # @attrs.define
+    # class Interrupt(Exportable):
+    #     name: str = attrs.field(validator=instance_of(str))
+    #     """
+    #     The name of this particular interrupt.
+    #     """
+    #     conditions: WaitConditions = attrs.field(
+    #         factory=WaitConditions,
+    #         converter=WaitConditions,
+    #         validator=instance_of(WaitConditions),
+    #     )
+    #     """
+    #     The set of conditions that need to pass in order for this interrupt
+    #     to be triggered.
+    #     """
+    #     targets: list["Schedule.Stop"] = attrs.field(
+    #         factory=list,
+    #         # TODO: converter
+    #         validator=instance_of(list["Schedule.Stop"]),
+    #     )
+    #     """
+    #     The target schedule that the interrupt should execute if it's
+    #     triggered.
+    #     """
+    #     inside_interrupt: bool = attrs.field(
+    #         default=False,
+    #     )
+    #     """
+    #     Whether or not this interrupt can be triggered midway through an
+    #     already executing interrupt.
+    #     """
 
     # =========================================================================
 
@@ -375,9 +438,9 @@ class Schedule(Exportable):
 
     # =========================================================================
 
-    stops: list[Stop] = attrs.field(
+    stops: list[ScheduleStop] = attrs.field(
         factory=list,
-        validator=instance_of(list[Stop]),
+        validator=instance_of(list[ScheduleStop]),
     )
     """
     The list of all stops that this schedule uses.
@@ -388,9 +451,9 @@ class Schedule(Exportable):
 
     # =========================================================================
 
-    interrupts: list[Interrupt] = attrs.field(
+    interrupts: list[ScheduleInterrupt] = attrs.field(
         factory=list,
-        validator=instance_of(list[Interrupt]),
+        validator=instance_of(list[ScheduleInterrupt]),
     )
     """
     The list of all interrupts that apply to this schedule.
@@ -519,7 +582,7 @@ class Schedule(Exportable):
         self,
         name: str,
         conditions: Union[WaitCondition, WaitConditions],
-        targets: list[Stop],
+        targets: list[ScheduleStop],
         inside_interrupt: bool = False,
     ):
         """

{factorio_draftsman-3.1.1 → factorio_draftsman-3.2.0}/draftsman/classes/spatial_hashmap.py

@@ -4,8 +4,15 @@ from draftsman.classes.spatial_like import SpatialLike
 from draftsman.classes.spatial_data_structure import SpatialDataStructure
 from draftsman.classes.vector import PrimitiveVector, PrimitiveIntVector
 from draftsman.prototypes.straight_rail import StraightRail
+from draftsman.prototypes.half_diagonal_rail import HalfDiagonalRail
 from draftsman.prototypes.legacy_straight_rail import LegacyStraightRail
+from draftsman.prototypes.curved_rail_a import CurvedRailA
+from draftsman.prototypes.curved_rail_b import CurvedRailB
 from draftsman.prototypes.legacy_curved_rail import LegacyCurvedRail
+from draftsman.prototypes.elevated_straight_rail import ElevatedStraightRail
+from draftsman.prototypes.elevated_half_diagonal_rail import ElevatedHalfDiagonalRail
+from draftsman.prototypes.elevated_curved_rail_a import ElevatedCurvedRailA
+from draftsman.prototypes.elevated_curved_rail_b import ElevatedCurvedRailB
 from draftsman.prototypes.gate import Gate
 from draftsman.utils import (
     AABB,
@@ -97,10 +104,22 @@ 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, LegacyStraightRail, LegacyCurvedRail)
-            ) and isinstance(
-                overlapping_item, (StraightRail, LegacyStraightRail, LegacyCurvedRail)
+            # Rail ramps are excluded from these checks as they cannot overlap
+            # in this manner
+            rail_types = (
+                StraightRail,
+                LegacyStraightRail,
+                HalfDiagonalRail,
+                CurvedRailA,
+                CurvedRailB,
+                LegacyCurvedRail,
+                ElevatedStraightRail,
+                ElevatedHalfDiagonalRail,
+                ElevatedCurvedRailA,
+                ElevatedCurvedRailB,
+            )
+            if isinstance(item, rail_types) and isinstance(
+                overlapping_item, rail_types
             ):
                 identical = (
                     item.name == overlapping_item.name

{factorio_draftsman-3.1.1 → factorio_draftsman-3.2.0}/draftsman/environment/mod_list.py

@@ -90,7 +90,9 @@ class Mod:
 
         # Convert string dependencies into `Dependency` instances
         self.dependencies = [
-            Dependency(flag=m[1], name=m[2], operation=m[3], version=m[4], reference=None)
+            Dependency(
+                flag=m[1], name=m[2], operation=m[3], version=m[4], reference=None
+            )
             for dependency in dependencies
             if (m := Mod.dependency_regex.match(dependency))
         ]

{factorio_draftsman-3.1.1 → factorio_draftsman-3.2.0}/draftsman/environment/update.py

@@ -409,13 +409,15 @@ def run_settings_stage(
 
     # Factorio then converts the settings which were stored in data.raw
     # to the global 'settings' table: We emulate that here in 'settings.lua':
-    file_name = os.path.join(draftsman_path, "compatibility", "settings.lua").replace("\\", "/")
+    file_name = os.path.join(draftsman_path, "compatibility", "settings.lua").replace(
+        "\\", "/"
+    )
     lua.globals().REQUIRE_STACK = lua.eval('{{"{}"}}'.format(file_name))
     lua.globals().MODS_STACK = lua.eval("{}")
     lua.globals().lua_stage_reset()
     lua.execute(
         file_to_string(os.path.join(draftsman_path, "compatibility", "settings.lua")),
-        name=file_name
+        name=file_name,
     )
 
     # If there is a `mod-settings.dat` file present, we overwrite the current
@@ -729,7 +731,7 @@ def run_data_lifecycle(
     run_lua_file(
         lua,
         os.path.join(game_path, "core", "lualib", "dataloader.lua"),
-        custom_name="__core__/lualib/dataloader.lua"
+        custom_name="__core__/lualib/dataloader.lua",
     )
 
     # Construct and send the `mods` table to the Lua instance in `interface.lua`
@@ -741,7 +743,7 @@ def run_data_lifecycle(
     # of code to convert the `python_mods` Python dict to the `mods` Lua table
     # Factorio wants
     lua.execute(
-    """
+        """
     mods = {}
     for k in python.iter(python_mods) do
         mods[k] = python_mods[k]

{factorio_draftsman-3.1.1 → factorio_draftsman-3.2.0}/draftsman/factorio-data/base/info.json

@@ -1,6 +1,6 @@
 {
   "name": "base",
-  "version": "2.0.66",
+  "version": "2.0.71",
   "title": "Base Mod",
   "author": "Wube Software",
   "contact": "dev@factorio.com",