sm-blueprint-lib 0.0.1__tar.gz

sm_blueprint_lib-0.0.1/.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

sm_blueprint_lib-0.0.1/.gitignore

@@ -0,0 +1,160 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

sm_blueprint_lib-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Maurice
+
+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.

sm_blueprint_lib-0.0.1/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: sm_blueprint_lib
+Version: 0.0.1
+Summary: Scrap Mechanic Library for Blueprint manipulation.
+Project-URL: Homepage, https://github.com/pypa/sampleproject
+Project-URL: Issues, https://github.com/pypa/sampleproject/issues
+Author-email: Maurice <mauriciotorrez00@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# sm_blueprint_lib
+ Scrap Mechanic Library for Blueprint manipulation.

sm_blueprint_lib-0.0.1/README.md

@@ -0,0 +1,2 @@
+# sm_blueprint_lib
+ Scrap Mechanic Library for Blueprint manipulation.

sm_blueprint_lib-0.0.1/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "sm_blueprint_lib"
+version = "0.0.1"
+authors = [
+  { name="Maurice", email="mauriciotorrez00@gmail.com" },
+]
+description = "Scrap Mechanic Library for Blueprint manipulation."
+readme = "README.md"
+requires-python = ">=3.8"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+license = "MIT"
+license-files = ["LICEN[CS]E*"]
+
+[project.urls]
+Homepage = "https://github.com/pypa/sampleproject"
+Issues = "https://github.com/pypa/sampleproject/issues"

sm_blueprint_lib-0.0.1/src/sm_blueprint_lib/__init__.py

@@ -0,0 +1,138 @@
+from dataclasses import asdict
+from json import load, dump, loads, dumps
+from math import ceil, log2
+
+from numpy import ndarray
+
+from sm_blueprint_lib.bases.parts.baseinteractablepart import BaseInteractablePart
+from sm_blueprint_lib.blueprint import Blueprint
+from sm_blueprint_lib.parts.barrierblock import BarrierBlock
+from sm_blueprint_lib.parts.logicgate import LogicGate
+from sm_blueprint_lib.parts.timer import Timer
+from sm_blueprint_lib.pos import Pos
+
+
+def load_blueprint(path):
+    """Load a blueprint from a path file (normally a blueprint.json).
+
+    Args:
+        path (str): The path to the json file.
+
+    Returns:
+        Blueprint: The loaded blueprint.
+    """
+    with open(path) as fp:
+        return Blueprint(**load(fp))
+
+
+def save_blueprint(path, bp: Blueprint):
+    """Save a blueprint to a file (normally a blueprint.json).
+
+    Args:
+        path (str): The path to save the json file.
+        bp (Blueprint): The blueprint to be saved.
+    """
+    with open(path, mode="w") as fp:
+        return dump(asdict(bp), fp, sort_keys=True, separators=(',', ':'))
+
+
+def load_string(str):
+    """Load a blueprint from a json string.
+
+    Args:
+        str (str): The string to be loaded.
+
+    Returns:
+        Blueprint: The loaded blueprint.
+    """
+    return Blueprint(**loads(str))
+
+
+def dump_string(bp: Blueprint):
+    """Dump a blueprint into a json-formatted string.
+
+    Args:
+        bp (Blueprint): The blueprint to be dumped.
+
+    Returns:
+        str: The json-formatted string.
+    """
+    return dumps(asdict(bp), sort_keys=True, separators=(',', ':'))
+
+
+def connect(_from, _to, *, parallel=True):
+    """Connect interactable parts together, recursively.
+
+    Args:
+        _from (Any): Must be an instance of BaseInteractablePart or a subclass.
+        Also it can be any nested iterable of instances (list of parts, list of lists of parts, etc).
+        _to (Any): Must be an instance of BaseInteractablePart or a subclass.
+        Also it can be any nested iterable of instances (list of parts, list of lists of parts, etc).
+        parallel (bool, optional): Defines the behaviour of the connections in the following way:
+
+        With parallel=False, everything connects to everything:
+            from1 🔀 to1
+
+            from2 🔀 to2
+
+        With parallel=True, every row is connected respectively:
+            from1 → to1
+
+            from2 → to2
+
+        Also, if the dimensions does not match it tries to adapt (many to one, one to many, etc)
+
+        Defaults to True.
+    """
+    if isinstance(_from, BaseInteractablePart) and isinstance(_to, BaseInteractablePart):
+        _from.connect(_to)
+        return
+    if parallel:    # Try connect things row-by-row if possible (one to one, one to many, many to many)
+        if not isinstance(_from, BaseInteractablePart) and not isinstance(_to, BaseInteractablePart):   # Assume both are sequence of parts
+            for subfrom, subto in zip(_from, _to):
+                connect(subfrom, subto, parallel=parallel)
+        elif not isinstance(_from, BaseInteractablePart):   # Assume _from is a sequence of parts
+            for subfrom in _from:
+                connect(subfrom, _to, parallel=parallel)
+        else:                                               # Assume _to is a sequence of parts
+            for subto in _to:
+                connect(_from, subto, parallel=parallel)
+    else:           # Just connect everything to everything lol
+        if not isinstance(_from, BaseInteractablePart) and not isinstance(_to, BaseInteractablePart):   # Assume both are sequence of parts
+            for subfrom in _from:
+                for subto in _to:
+                    connect(subfrom, subto, parallel=parallel)
+        elif not isinstance(_from, BaseInteractablePart):   # Assume _from is a sequence of parts
+            for subfrom in _from:
+                connect(subfrom, _to, parallel=parallel)
+        else:                                               # Assume _to is a sequence of parts
+            for subto in _to:
+                connect(_from, subto, parallel=parallel)
+
+
+def check_pos(pos):
+    if not isinstance(pos, Pos):
+        pos = Pos(*pos)
+    return pos
+
+
+def get_bits_required(number: int | float):
+    """Calculates how many bits are required to store this number.
+
+    Args:
+        number (int | float): The target number.
+    """
+    return ceil(log2(number))
+
+
+def num_to_bit_list(number: int, bit_length: int):
+    """Converts a number to a numpy array of its bits.
+
+    Args:
+        number (int): The number to convert.
+        bit_length (int): The number of bits the list will have.
+    """
+    output = ndarray(bit_length, dtype=bool)
+    for b in range(bit_length):
+        output[b] = bool((number >> b) & 1)
+    return output

sm_blueprint_lib-0.0.1/src/sm_blueprint_lib/bases/controllers/basecontroller.py

@@ -0,0 +1,20 @@
+from dataclasses import dataclass, field
+from typing import Any, Optional
+
+from sm_blueprint_lib.constants import get_new_id
+from sm_blueprint_lib.id import ID
+
+
+@dataclass
+class BaseController:
+    """Base class for controller objects (used in interactable parts and so)
+    """
+    controllers: Optional[list[ID]] = field(kw_only=True, default=None)
+    id: int = field(kw_only=True, default_factory=get_new_id)
+    joints: Optional[list[ID]] = field(kw_only=True, default=None)
+
+    def __post_init__(self):
+        try:
+            self.controllers = [ID(**c) for c in self.controllers]
+        except TypeError:
+            pass

sm_blueprint_lib-0.0.1/src/sm_blueprint_lib/bases/controllers/baselogiccontroller.py

@@ -0,0 +1,10 @@
+from dataclasses import dataclass, field
+
+from sm_blueprint_lib.bases.controllers.basecontroller import BaseController
+
+
+@dataclass
+class BaseLogicController(BaseController):
+    """Base class for Logic parts' Controllers (mostly Logic Gate and Timer)
+    """
+    active: bool = field(kw_only=True, default=False)

sm_blueprint_lib-0.0.1/src/sm_blueprint_lib/bases/controllers/logicgatecontroller.py

@@ -0,0 +1,10 @@
+from dataclasses import dataclass, field
+
+from sm_blueprint_lib.bases.controllers.baselogiccontroller import BaseLogicController
+
+
+@dataclass
+class LogicGateController(BaseLogicController):
+    """Logic Gate's Controller
+    """
+    mode: int = 0

sm_blueprint_lib-0.0.1/src/sm_blueprint_lib/bases/controllers/sensorcontroller.py

@@ -0,0 +1,24 @@
+from dataclasses import dataclass, field
+
+from sm_blueprint_lib.bases.controllers.basecontroller import BaseController
+
+
+@dataclass
+class SensorController(BaseController):
+    """Sensor's Controller
+    """
+    audioEnable: bool
+    buttonMode: bool
+    color: str
+    colorMode: bool
+    range: int
+
+    def __post_init__(self):
+        super().__post_init__()
+        # if color given as (r, g, b) then convert to hex string
+        if not isinstance(self.color, str):
+            self.color = "%02X%02X%02X" % (
+                self.color[0], self.color[1], self.color[2])
+        self.audioEnable = bool(self.audioEnable)
+        self.buttonMode = bool(self.buttonMode)
+        self.colorMode = bool(self.colorMode)

sm_blueprint_lib-0.0.1/src/sm_blueprint_lib/bases/controllers/timercontroller.py

@@ -0,0 +1,11 @@
+from dataclasses import dataclass, field
+
+from sm_blueprint_lib.bases.controllers.baselogiccontroller import BaseLogicController
+
+
+@dataclass
+class TimerController(BaseLogicController):
+    """Timer's Controller
+    """
+    seconds: int
+    ticks: int

sm_blueprint_lib-0.0.1/src/sm_blueprint_lib/blueprint.py

@@ -0,0 +1,31 @@
+from dataclasses import dataclass, field
+
+from sm_blueprint_lib.bases.parts.basepart import BasePart
+from sm_blueprint_lib.body import Body
+from sm_blueprint_lib.constants import VERSION
+
+
+@dataclass
+class Blueprint:
+    bodies: list[Body] = field(default_factory=lambda: [Body()])
+    version: int = VERSION.BLUEPRINT_VERSION
+
+    def __post_init__(self):
+        try:
+            self.bodies = [Body(**body) for body in self.bodies]
+        except TypeError:
+            pass
+
+    def add(self, *obj, body=0):
+        """Adds the object(s) to the blueprint.
+
+        Args:
+            obj (Any): Can be a instance of BasePart or a subclass. It also can be any nested iterable of instances (list of parts, list of lists of parts, etc).
+            body (int, optional): Specify in which blueprint's body the object will be placed. Defaults to 0.
+        """
+        for subobj in obj:
+            if isinstance(subobj, BasePart):
+                self.bodies[body].childs.append(subobj)
+            else:
+                for subsubobj in subobj:
+                    self.add(subsubobj, body=body)

sm_blueprint_lib-0.0.1/src/sm_blueprint_lib/body.py

@@ -0,0 +1,13 @@
+from dataclasses import dataclass, field
+
+from sm_blueprint_lib.bases.parts.basepart import BasePart
+from sm_blueprint_lib.constants import SHAPEID
+
+
+@dataclass
+class Body:
+    childs: list[BasePart] = field(default_factory=list)
+
+    def __post_init__(self):
+        self.childs = [SHAPEID.SHAPEID_TO_CLASS[child["shapeId"]](**child)
+                       for child in self.childs]

sm_blueprint_lib-0.0.1/src/sm_blueprint_lib/bounds.py

@@ -0,0 +1,10 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class Bounds:
+    """Class that represents the bounds of a boundable block (x, y, z)
+    """
+    x: int
+    y: int
+    z: int

sm_blueprint_lib-0.0.1/src/sm_blueprint_lib/constants.py

@@ -0,0 +1,29 @@
+class SHAPEID:
+    BARRIER_BLOCK = "09ca2713-28ee-4119-9622-e85490034758"
+    LOGIC_GATE = "9f0f56e8-2c31-4d83-996c-d00a9b296c3f"
+    TIMER = "8f7fd0e7-c46e-4944-a414-7ce2437bb30f"
+    SENSOR5 = "20dcd41c-0a11-4668-9b00-97f278ce21af"
+    SWITCH = "7cf717d7-d167-4f2d-a6e7-6b2c70aa3986"
+    SHAPEID_TO_CLASS = {}
+
+
+class AXIS:
+    DEFAULT_XAXIS = 1
+    DEFAULT_ZAXIS = 3
+
+
+class VERSION:
+    BLUEPRINT_VERSION = 4
+
+
+TICKS_PER_SECOND = 40
+
+__global_id_counter = 0
+"""Atempting to modify this global variable may cause to break your blueprints lol.
+"""
+
+
+def get_new_id():
+    global __global_id_counter
+    __global_id_counter = (new_id := __global_id_counter) + 1
+    return new_id

sm_blueprint_lib-0.0.1/src/sm_blueprint_lib/id.py

@@ -0,0 +1,5 @@
+from dataclasses import dataclass
+
+@dataclass
+class ID:
+    id: int

sm_blueprint_lib-0.0.1/src/sm_blueprint_lib/pos.py

@@ -0,0 +1,16 @@
+from dataclasses import dataclass
+from typing import Sequence
+
+
+@dataclass
+class Pos:
+    """Class that represents the position of a block (x, y, z)
+    """
+    x: int
+    y: int
+    z: int
+
+    def __add__(self, o: "Pos" | Sequence):
+        if isinstance(o, Pos):
+            return Pos(self.x + o.x, self.y + o.y, self.z + o.z)
+        return Pos(self.x + o[0], self.y + o[1], self.z + o[2])

sm_blueprint_lib-0.0.1/src/sm_blueprint_lib/prebuilds/adder.py

@@ -0,0 +1,44 @@
+from typing import Sequence
+from numpy import ndarray
+from sm_blueprint_lib import get_bits_required, check_pos, connect, num_to_bit_list
+from sm_blueprint_lib.blueprint import Blueprint
+from sm_blueprint_lib.parts.logicgate import LogicGate
+from sm_blueprint_lib.pos import Pos
+
+
+def simple_adder_subtractor(bp: Blueprint,
+                            bit_length: int,
+                            pos: Pos | Sequence = (0, 0, 0)):
+    pos = check_pos(pos)
+    input_a = [LogicGate(pos+(x, 0, 2), "FF0000", 1)
+               for x in range(bit_length)]
+    input_b = [LogicGate(pos+(x, 0, 0), "FF0000", 2)
+               for x in range(bit_length)]
+    and_0 = [LogicGate(pos+(x, -1, 2), "000000", 0)
+             for x in range(bit_length)]
+    xor_0 = [LogicGate(pos+(x, -1, 0), "000000", 2)
+             for x in range(bit_length)]
+    or_0 = [LogicGate(pos+((x, -2, 0) if x + 1 != bit_length else (x+1, -2, 2)), "000000" if x + 1 != bit_length else "0000FF", 1)
+            for x in range(bit_length)]
+    and_1 = [LogicGate(pos+(x, -2, 1), "000000", 0)
+             for x in range(bit_length)]
+    xor_1 = [LogicGate(pos+(x, -2, 2), "0000FF", 2)
+             for x in range(bit_length)]
+    carry_in = LogicGate(pos+(-1, -2, 0), "FF0000", 1)
+
+    connect(input_a, and_0)
+    connect(input_a, xor_0)
+    connect(input_b, and_0)
+    connect(input_b, xor_0)
+    connect(and_0, or_0)
+    connect(xor_0, and_1)
+    connect(xor_0, xor_1)
+    connect(and_1, or_0)
+    connect(or_0, and_1[1:])
+    connect(or_0, xor_1[1:])
+    connect(carry_in, and_1[0])
+    connect(carry_in, xor_1[0])
+    connect(carry_in, input_b)
+
+    bp.add(input_a, input_b, and_0, xor_0, or_0, and_1, xor_1, carry_in)
+    return input_a, input_b, and_0, xor_0, or_0, and_1, xor_1, carry_in