partomatic 0.0.1__tar.gz

partomatic-0.0.1/.gitignore

@@ -0,0 +1,163 @@
+# 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/
+
+#VS Code Counter
+.VSCodeCounter/

partomatic-0.0.1/.vscode/settings.json

@@ -0,0 +1,7 @@
+{
+    "python.testing.pytestArgs": [
+        "tests"
+    ],
+    "python.testing.unittestEnabled": false,
+    "python.testing.pytestEnabled": true
+}

partomatic-0.0.1/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2024 Christopher Litsinger
+
+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.

partomatic-0.0.1/PKG-INFO

@@ -0,0 +1,32 @@
+Metadata-Version: 2.4
+Name: partomatic
+Version: 0.0.1
+Summary: build123d Part extended for CI/CD automation
+Project-URL: Homepage, https://github.com/x0pher/partomatic
+Project-URL: Issues, https://github.com/x0pher/partomatic/issues
+Project-URL: docs, https://partomatic.readthedocs.org
+Project-URL: documentation, https://partomatic.readthedocs.org
+Author: x0pherl
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# Partomatic
+
+Partomatic is an attempt to build an automatable ecosystem for generating parametric models through automation -- making CI/CD automation possible for your 3d models.
+
+# The Partomatic philosophy
+
+Build123d is a powerful library, but it leaves the creation of final parts up to the developer. For a large project with many related and interlocking parts, this can make releasing a new version a project in and of itself.
+
+[Partomatic](https://github.com/x0pherl/partomatic) enables _parametric modeling_ and standardizes some _build automation_ for a part.
+
+## Parametric Modeling
+Parametric 3D modeling is a method of creating 3D models where the geometry is defined by parameters, allowing for easy adjustment by simply changing the values of these parameters. This approach enables the creation of flexible and reusable designs that can be quickly adapted to different requirements.
+
+## Build Automation
+
+Build automation is a common practice in the software delivery world. Continuous Integration uses build automation to deliver software into testing and production environments whenever changes are checked in by a developer. Partomatic wraps additional information about how to name files and where to store them, so that an automated build script generate and save those parts.

partomatic-0.0.1/README.md

@@ -0,0 +1,16 @@
+# Partomatic
+
+Partomatic is an attempt to build an automatable ecosystem for generating parametric models through automation -- making CI/CD automation possible for your 3d models.
+
+# The Partomatic philosophy
+
+Build123d is a powerful library, but it leaves the creation of final parts up to the developer. For a large project with many related and interlocking parts, this can make releasing a new version a project in and of itself.
+
+[Partomatic](https://github.com/x0pherl/partomatic) enables _parametric modeling_ and standardizes some _build automation_ for a part.
+
+## Parametric Modeling
+Parametric 3D modeling is a method of creating 3D models where the geometry is defined by parameters, allowing for easy adjustment by simply changing the values of these parameters. This approach enables the creation of flexible and reusable designs that can be quickly adapted to different requirements.
+
+## Build Automation
+
+Build automation is a common practice in the software delivery world. Continuous Integration uses build automation to deliver software into testing and production environments whenever changes are checked in by a developer. Partomatic wraps additional information about how to name files and where to store them, so that an automated build script generate and save those parts.

partomatic-0.0.1/docs/Makefile

@@ -0,0 +1,20 @@
+# Minimal makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line, and also
+# from the environment for the first two.
+SPHINXOPTS    ?=
+SPHINXBUILD   ?= sphinx-build
+SOURCEDIR     = .
+BUILDDIR      = _build
+
+# Put it first so that "make" without argument is like "make help".
+help:
+	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+
+.PHONY: help Makefile
+
+# Catch-all target: route all unknown targets to Sphinx using the new
+# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
+%: Makefile
+	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)

partomatic-0.0.1/docs/conf.py

@@ -0,0 +1,124 @@
+# Configuration file for the Sphinx documentation builder.
+#
+# This file only contains a selection of the most common options. For a full
+# list see the documentation:
+# https://www.sphinx-doc.org/en/master/usage/configuration.html
+
+# -- Path setup --------------------------------------------------------------
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+#
+import os
+import sys
+
+partomatic_path = os.path.dirname(os.path.abspath(os.getcwd()))
+source_files_path = os.path.join(partomatic_path, "src", "partomatic")
+sys.path.insert(0, source_files_path)
+sys.path.append(os.path.abspath("sphinxext"))
+sys.path.insert(0, os.path.abspath("."))
+sys.path.insert(0, os.path.abspath("../"))
+
+# -- Project information -----------------------------------------------------
+
+project = "partomatic"
+copyright = "2024, x0pherl"
+author = "x0pherl"
+
+# The full version, including alpha/beta/rc tags
+release = "latest"
+
+
+# -- General configuration ---------------------------------------------------
+
+# Add any Sphinx extension module names here, as strings. They can be
+# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
+# ones.
+extensions = [
+    "sphinx.ext.napoleon",
+    "sphinx.ext.autodoc",
+    #    "sphinx_autodoc_typehints",
+    "sphinx.ext.autodoc.typehints",
+    "sphinx.ext.doctest",
+    "sphinx.ext.graphviz",
+    "sphinx.ext.inheritance_diagram",
+    "sphinx.ext.viewcode",
+    "sphinx_design",
+    "sphinx_copybutton",
+    "hoverxref.extension",
+]
+
+# Napoleon settings
+napoleon_google_docstring = True
+napoleon_numpy_docstring = True
+napoleon_include_init_with_doc = False
+napoleon_include_private_with_doc = False
+napoleon_include_special_with_doc = False
+napoleon_use_admonition_for_examples = False
+napoleon_use_admonition_for_notes = False
+napoleon_use_admonition_for_references = False
+napoleon_use_ivar = True
+napoleon_use_param = True
+napoleon_use_rtype = True
+napoleon_use_keyword = True
+napoleon_custom_sections = None
+
+autodoc_typehints = ["signature"]
+# autodoc_typehints = ["description"]
+# autodoc_typehints = ["both"]
+
+autodoc_default_options = {
+    "members": True,
+    "undoc-members": True,
+    "member-order": "alphabetical",
+    "show-inheriance": False,
+}
+
+# Sphinx settings
+add_module_names = False
+python_use_unqualified_type_names = True
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ["_templates"]
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+# This pattern also affects html_static_path and html_extra_path.
+exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"]
+
+
+# -- Options for HTML output -------------------------------------------------
+
+# The theme to use for HTML and HTML Help pages.  See the documentation for
+# a list of builtin themes.
+#
+# html_theme = "alabaster"
+html_theme = "sphinx_rtd_theme"
+
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named "default.css" will overwrite the builtin "default.css".
+html_static_path = ["_static"]
+
+# -- Options for hoverxref -------------------------------------------------
+hoverxref_role_types = {
+    "hoverxref": "tooltip",
+    "ref": "tooltip",  # for hoverxref_auto_ref config
+    "confval": "tooltip",  # for custom object
+    "mod": "tooltip",  # for Python Sphinx Domain
+    "class": "tooltip",  # for Python Sphinx Domain
+    "meth": "tooltip",  # for Python Sphinx Domain
+    "func": "tooltip",  # for Python Sphinx Domain
+}
+
+hoverxref_roles = [
+    "class",
+    "meth",
+]
+
+hoverxref_domains = [
+    "py",
+]
+
+html_logo = "assets/logo.svg"

partomatic-0.0.1/docs/index.md

@@ -0,0 +1 @@
+{!README.md!}

partomatic-0.0.1/docs/partomatic.md

@@ -0,0 +1,225 @@
+## The elements of Partomatic
+
+There are three elements of Partomatic.
+- `BuildablePart`
+- `PartomaticConfig`
+- `Partomatic`
+
+## BuildablePart
+
+BuildablePart is a small wrapper around build123d's Part class that adds some useful additional data for generating parts in an automated context. These variables are members of the BuildablePart class:]
+```
+    part: Part = field(default_factory=Part)
+    display_location: Location = field(default_factory=Location)
+    stl_folder: str = getcwd()
+    _file_name: str = "partomatic"
+```
+
+`part` is simply a build123d `Part` object
+`display_location` defines a build123d `Location` in which to display the object (this is useful combining multiple `BuildablePart`s into a single Partomatic object, and will be covered below)
+`stl_folder` defines the folder in which the part should be saved
+`file_name` (there are getters and setters for the `_filename` variable) defines the base file name. Note that this base will likely be combined with prefixes and suffixes that describe the parametric configuration, so any extension that is passed will be automatically stripped off.
+
+## PartomaticConfig
+
+The first element of Partomatic is the PartomaticConfig class. Descending a class from PartomaticConfig allows you to define any parametric values for your design.
+
+PartomaticConfig makes it easy to load parametric values from Python parameters passed on instantiation, or through a YAML file -- you can even nest PartomaticConfig object definitions in a single YAML file.
+
+YAML was chosen because YAML files are easily human-readable without deep technical knowledge. As an example, imagine a simple model of a wheel with a cut in the center for a bearing. We'll define both the wheel and the bearing. A simple example of a YAML configuration for a wheel with a bearing axle might look like:
+
+```
+wheel:
+    depth: 10
+    radius: 30
+    bearing:
+        radius: 4
+        spindle_radius: 1.5
+```
+Now we can define PartomaticConfig objects for both the Wheel and the Bearing as follows:
+
+```
+from partomatic import PartomaticConfig
+from dataclasses import field
+
+class BearingConfig(PartomaticConfig):
+    yaml_tree: str = "wheel/bearing"
+    radius: float = 10
+    spindle_radius: float = 2
+
+class WheelConfig(PartomaticConfig):
+    yaml_tree = "wheel"
+    depth: float = 2
+    radius: float = 50
+    bearing: BearingConfig = field(default_factory=BearingConfig)
+```
+
+You may have noted a few things that aren't obvious given the YAML section above. Let's take a deeper look at yaml_tree and the field definition for the bearing.
+
+### yaml_tree
+
+The value `yaml_tree` defines the tree of the configuration within a file that you would like to load. For our example, not that "wheel" is the root object of our yaml file because our first line reads `wheel:`.
+
+Bearing is a sub element of that wheel object, because it is at the same indent level as `depth` and `radius`. Partomatic separates objects on the tree with the `/` character, so we define the bearing's `yaml_tree` as `wheel/bearing` so it could be loaded independently from the same file.
+
+Note that the yaml tree of the sub object is not _required_ to follow this pattern. In our sample case it makes it easy to load a bearing object from the same file as the wheel if only the bearing is required for some python files within our project. `yaml_tree` can also be passed when initializing the BearingConfig object, so it could be overwritten if appropriate.
+
+### field factory
+
+Field factory functions are beyond the scope of this documentation, however the [*dataclass* documentation](https://docs.python.org/3/library/dataclasses.html#default-factory-functions) covers this thoroughly.
+
+For PartomaticConfig, all you need to understand is that if you are nesting PartomaticConfig objects, you should follow this pattern when adding the sub-object to the base part:
+`<object_name>: <ObjectClass> = field(default_factory=<ObjectClass>)`
+Have a look again at the bearing field of the `WheelConfig` object for an example.
+
+### Instantiating a PartomaticConfig descendant
+
+Now that we've got the `WheelConfig` (and it's member class `BearingConfig`) defined we need to create an instance of `WheelConfig`. We can instantiate this in several ways:
+- default configuration
+- loading from a file
+- loading from a yaml string
+- defining parameters
+
+#### Instantiating with default configuration
+
+If you're happy with the default values for your wheel configuration (and its bearing), it couldn't be simpler to instantiate:
+`wheel_config = WheelConfig()`
+
+#### Instantiating by loading from a file
+
+Loading from a yaml file can make it easy to build multiple parts with different configurations.
+
+In our example, you might define multiple wheel parts to support different bearings sizes and add prefixes with the standard bearing names. Each of these configurations can be defined in a separate file, and we can use automation to process each of them.
+
+Instantiating a Partomatic object from a yaml file is as simple as passing a filename to a valid yaml file as the only parameter:
+`wheel_config = WheelConfig('~/wheel/config/base_wheel.yml')`
+
+
+#### Instantiating with a yaml string
+
+If you've loaded a yaml string out of another object or from an environment variable, you can pass the entire yaml string instead of a filename as shown in this example:
+```
+wheel_yaml = """
+wheel:
+    depth: 10
+    radius: 30
+    bearing:
+        radius: 4
+        spindle_radius: 1.5
+"""
+wheel_config = WheelConfig(wheel_yaml)
+```
+
+Remember that you can also load the object from anywhere in a `yaml_tree`; so if the `wheel` object is defined in a yaml tree for a parent object you could use that as follows:
+
+```
+car_yaml = """
+car:
+    <some car values>
+    drivetrain:
+        <some drivetrain values>
+        wheel:
+            depth: 10
+            radius: 30
+            bearing:
+                radius: 4
+                spindle_radius: 1.5
+"""
+wheel_config = WheelConfig(car_yaml, yaml_tree='car/drivetrain/wheel')
+```
+
+#### Instantiating with parameters passed
+
+If you understand the correct parameters from elsewhere in your code, you could simply define each of those as kwargs and pass them to the definition as in this example:
+
+```
+bearing_config = BearingConfig(radius=20, spindle_radius=10)
+wheel_config = WheelConfig(depth=5, radius=50, bearing=bearing_config)
+```
+
+### Other PartomaticConfig fields
+
+The base PartomaticConfig object also declares the following fields:
+```
+    stl_folder: str = "NONE"
+    file_prefix: str = ""
+    file_suffix: str = ""
+    create_folders_if_missing: bool = True
+```
+
+#### `stl_folder`
+This defines the folder in which Partomatic STL files will be generated
+
+#### `file_prefix`
+Your `Partomatic` object will generate one or more parts, and it defines file names for each part. The `file_prefix` allows you to define a prefix that will be added to each file when saving. This makes it possible to generate parts from multiple configurations in the same folder.
+
+In our example, where we are defining multiple wheel parts to support different bearings sizes, we might add prefixes with the standard bearing names.
+
+#### `file_suffix`
+This works the same way as `file_prefix` (described above), but adds this string to the end of each generated file.
+
+#### `create_folders_if_missing`
+By default, Partomatic will create folders if they don't exist when exporting stl files. If you prefer it to only save parts if the folders already exist, you set this to `False`
+
+## Partomatic
+
+Partomatic is an [abstract base class](https://docs.python.org/3/library/abc.html) for components within a larger project.
+
+Partomatic automatically handles the `__init__` method as well as `load_config`. Overriding these methods is not recommended.
+
+### Defined Partomatic Variables
+
+Partomatic defines two important variables that you descendent classes will inherit:
+```
+    _config: PartomaticConfig
+    parts: list[BuildablePart] = field(default_factory=list)
+```
+
+`_config` stores the parameters from a PartomaticConfig object. `parts` is a list of BuildableParts, which partomatic will display or export when the appropriate methods are called.
+
+### Abstract `compile` method
+
+Partomatic defines an abstract methods which must be defined within a descendent class.
+
+This method is responsible for generating the 3d geometry for each component. It should clear the parts list and regenerate each element of your design as a BuildablePart.
+
+A simple example might look like this:
+
+```
+# ... Partomatic descendant class fragment
+
+    def complete_wheel() -> Part:
+        # <CODE TO GENERATE PART>
+
+    def compile(self):
+        """
+        Builds the relevant parts for the filament wheel
+        """
+        self.parts.clear()
+        self.parts.append(
+            BuildablePart(
+                self.complete_wheel(),
+                "complete-wheel",
+                stl_folder=self._config.stl_folder,
+            )
+        )
+
+```
+
+### Partomatic built-in methods
+
+#### `display`
+
+The `display` method will display each BuildablePart in the `parts` list in the appropriate display_location
+
+#### `export_stls`
+
+ This method calculates the appropriate file path based on the descendant class' `stl_folder`, `file_prefix`, the `BuildablePart`'s `file_name` and the `file_prefix`. If `create_folders_if_missing` is set to False, no part will be saved if the file is not present.
+
+ #### `load_config`
+
+ This method will load a configuration from file, kwargs, or a yaml string -- see the `PartomaticConfig` documentation for more details.
+
+ #### `partomate`
+
+ `partomate` is a convenience function that will execute the `compile` and `export_stls` functions of the Partomatic descendant.

partomatic-0.0.1/docs/requirements.txt

@@ -0,0 +1,3 @@
+mkdocs
+mkdocs-material
+markdown-include

partomatic-0.0.1/mkdocs.yml

@@ -0,0 +1,20 @@
+site_name: Partomatic
+site_url: https://partomatic.readthedocs.io/
+theme:
+  name: material
+  features:
+    - navigation.instant
+    - navigation.expand
+    - navigation.path
+    - toc.integrate
+markdown_extensions:
+  - attr_list
+  - pymdownx.emoji:
+      emoji_index: !!python/name:material.extensions.emoji.twemoji
+      emoji_generator: !!python/name:material.extensions.emoji.to_svg
+  - toc:
+      toc_depth: 3
+  - markdown_include.include:
+      base_path: .
+nav:
+  - Developer’s Guide: partomatic.md

partomatic-0.0.1/pyproject.toml

@@ -0,0 +1,24 @@
+[project]
+name = "partomatic"
+version = "0.0.1"
+authors = [
+  { name="x0pherl"},
+]
+description = "build123d Part extended for CI/CD automation"
+readme = "README.md"
+requires-python = ">=3.8"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+[project.urls]
+Homepage = "https://github.com/x0pher/partomatic"
+Issues = "https://github.com/x0pher/partomatic/issues"
+docs = "https://partomatic.readthedocs.org"
+documentation = "https://partomatic.readthedocs.org"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"

partomatic-0.0.1/readthedocs.yaml

@@ -0,0 +1,13 @@
+version: 2
+
+build:
+  os: ubuntu-24.04
+  tools:
+    python: "3"
+
+python:
+  install:
+    - requirements: docs/requirements.txt
+
+mkdocs:
+  configuration: mkdocs.yml

partomatic-0.0.1/requirements.txt

@@ -0,0 +1,4 @@
+build123d
+yaml
+pytest
+unittest

partomatic-0.0.1/src/partomatic/__init__.py

@@ -0,0 +1,3 @@
+from .partomatic import Partomatic
+from .buildable_part import BuildablePart
+from .partomatic_config import PartomaticConfig

partomatic-0.0.1/src/partomatic/buildable_part.py

@@ -0,0 +1,39 @@
+"""BuildablePart is a dataclass that contains a Part object and additional inormation for saving and
+displaying the part"""
+
+from dataclasses import dataclass, field, fields, is_dataclass, MISSING
+from pathlib import Path
+from os import getcwd
+
+from build123d import Part, Location
+
+
+@dataclass
+class BuildablePart(Part):
+    part: Part = field(default_factory=Part)
+    display_location: Location = field(default_factory=Location)
+    stl_folder: str = getcwd()
+    _file_name: str = "partomatic"
+
+    def __init__(self, part, file_name, **kwargs):
+        self.display_location = Location()
+        self.file_name = file_name
+        self.part = part
+        if "display_location" in kwargs:
+            display_location = kwargs["display_location"]
+            if isinstance(display_location, Location):
+                self.display_location = display_location
+        if "stl_folder" in kwargs:
+            self.stl_folder = kwargs["stl_folder"]
+
+    @property
+    def file_name(self) -> str:
+        return self._file_name
+
+    @file_name.setter
+    def file_name(self, value: str):
+        """
+        Assigns the file name to the BuildablePart, ensuring that no
+        file extension is included.
+        """
+        self._file_name = Path(value).stem

partomatic-0.0.1/src/partomatic/partomatic.py

@@ -0,0 +1,124 @@
+"""Part extended for CI/CD automation"""
+
+from dataclasses import dataclass, field, fields, is_dataclass, MISSING
+from abc import ABC, abstractmethod
+from pathlib import Path
+
+from build123d import Part, Location, export_stl
+
+import ocp_vscode
+
+import yaml
+
+from .partomatic_config import PartomaticConfig
+from .buildable_part import BuildablePart
+
+
+class Partomatic(ABC):
+    """
+    Partomatic is an extension of the Compound class from build123d
+    that allows for automation within a continuous integration
+    environment. Descendant classes must implement:
+    - compile: generating the geometry of components in the parts list
+    """
+
+    _config: PartomaticConfig
+    parts: list[BuildablePart] = field(default_factory=list)
+
+    @abstractmethod
+    def compile(self):
+        """
+        Builds the relevant parts for the partomatic part
+        """
+
+    def display(self):
+        """
+        Shows the relevant parts in OCP CAD Viewer
+        """
+        ocp_vscode.show(
+            (
+                [
+                    part.part.move(Location(part.display_location))
+                    for part in self.parts
+                ]
+            ),
+            reset_camera=ocp_vscode.Camera.KEEP,
+        )
+
+    def complete_stl_file_path(self, part: BuildablePart) -> str:
+        return str(
+            Path(
+                Path(part.stl_folder)
+                / f"{self._config.file_prefix}{part.file_name}{self._config.file_suffix}"
+            ).with_suffix(".stl")
+        )
+
+    def export_stls(self):
+        """
+        Generates the relevant STLs in the configured
+        folder
+        """
+        if self._config.stl_folder == "NONE":
+            return
+        for part in self.parts:
+            Path(self.complete_stl_file_path(part)).parent.mkdir(
+                parents=True, exist_ok=self._config.create_folders_if_missing
+            )
+            if (
+                not Path(self.complete_stl_file_path(part)).parent.exists()
+                or not Path(self.complete_stl_file_path(part)).parent.is_dir()
+            ):
+                raise FileNotFoundError(
+                    f"Directory {Path(self.complete_stl_file_path(part)).parent} does not exist"
+                )
+            export_stl(part.part, self.complete_stl_file_path(part))
+
+    def load_config(self, configuration: any, **kwargs):
+        """
+        loads a partomatic configuration from a file or valid yaml
+        -------
+        arguments:
+            - configuration: the path to the configuration file
+                OR
+              a valid yaml configuration string
+        -------
+        notes:
+            if yaml_tree is set in the PartomaticConfig descendent,
+            PartomaticConfig will use that tree to find a node deep
+            within the yaml tree, following the node names separated by slashes
+            (example: "BigObject/Partomatic")
+        """
+        self._config.load_config(configuration, **kwargs)
+
+    def __init__(self, configuration: any = None, **kwargs):
+        """
+        loads a partomatic configuration from a file or valid yaml
+        -------
+        arguments:
+            - configuration: the path to the configuration file
+                OR
+              a valid yaml configuration string
+                OR
+              None (default) for an empty object
+            - **kwargs: specific fields to set in the configuration
+        -------
+        notes:
+            you can assign yaml_tree as a kwarg here to load a
+            configuration from a node node deep within the yaml tree,
+            following the node names separated by slashes
+            (example: "BigObject/Partomatic")
+        """
+        self.parts = []
+        self._config = self.__class__._config
+        self.load_config(configuration, **kwargs)
+
+    def partomate(self):
+        """automates the part generation and exports stl and step models
+         -------
+        notes:
+            - if you want to avoid exporting one of those file formats,
+              you can override the export_stls or export_steps methods
+              with a no-op method using the pass keyword
+        """
+        self.compile()
+        self.export_stls()

partomatic-0.0.1/src/partomatic/partomatic_config.py

@@ -0,0 +1,131 @@
+"""Part extended for CI/CD automation"""
+
+from dataclasses import dataclass, field, fields, is_dataclass, MISSING
+from enum import Enum, Flag
+from pathlib import Path
+
+import yaml
+
+
+class AutoDataclassMeta(type):
+    def __new__(cls, name, bases, dct):
+        new_cls = super().__new__(cls, name, bases, dct)
+        return dataclass(init=False)(new_cls)
+
+
+@dataclass
+class PartomaticConfig(metaclass=AutoDataclassMeta):
+    yaml_tree: str = "Part"
+    stl_folder: str = "NONE"
+    file_prefix: str = ""
+    file_suffix: str = ""
+    create_folders_if_missing: bool = True
+
+    def _default_config(self):
+        """
+        Resets all values to their default values.
+        """
+        for field in fields(self):
+            if field.default is not MISSING:
+                setattr(self, field.name, field.default)
+            elif field.default_factory is not MISSING:
+                setattr(self, field.name, field.default_factory())
+            else:
+                raise ValueError(f"Field {field.name} has no default value")
+
+    def load_config(self, configuration: any, **kwargs):
+        """
+        loads a partomatic configuration from a file or valid yaml
+        -------
+        arguments:
+            - configuration: the path to the configuration file
+                OR
+              a valid yaml configuration string
+        -------
+        notes:
+            if yaml_tree is set in the PartomaticConfig descendent,
+            PartomaticConfig will use that tree to find a node deep
+            within the yaml tree, following the node names separated by slashes
+            (example: "BigObject/Partomatic")
+        """
+        if "yaml_tree" in kwargs:
+            self.yaml_tree = kwargs["yaml_tree"]
+        if isinstance(configuration, self.__class__):
+            for field in fields(self):
+                setattr(self, field.name, getattr(configuration, field.name))
+            return
+        if configuration is not None:
+            configuration = str(configuration)
+            if "\n" not in configuration:
+                path = Path(configuration)
+                if path.exists() and path.is_file():
+                    configuration = path.read_text()
+            bracket_dict = yaml.safe_load(configuration)
+            for node in self.yaml_tree.split("/"):
+                if node not in bracket_dict:
+                    raise ValueError(
+                        f"Node {node} not found in configuration file"
+                    )
+                bracket_dict = bracket_dict[node]
+
+            for classfield in fields(self.__class__):
+                if classfield.name in bracket_dict:
+                    value = bracket_dict[classfield.name]
+                    if isinstance(classfield.type, type) and issubclass(
+                        classfield.type, (Enum, Flag)
+                    ):
+                        setattr(
+                            self,
+                            classfield.name,
+                            classfield.type[value.upper()],
+                        )
+                    elif is_dataclass(classfield.type) and isinstance(
+                        value, dict
+                    ):
+                        setattr(
+                            self,
+                            classfield.name,
+                            classfield.type(**value),
+                        )
+                    else:
+                        setattr(self, classfield.name, value)
+
+    def __init__(self, configuration: any = None, **kwargs):
+        """
+        loads a partomatic configuration from a file or valid yaml
+        -------
+        arguments:
+            - configuration: the path to the configuration file
+                OR
+              a valid yaml configuration string
+                OR
+              None (default) for an empty object
+            - **kwargs: specific fields to set in the configuration
+        -------
+        notes:
+            you can assign yaml_tree as a kwarg here to load a
+            configuration from a node node deep within the yaml tree,
+            following the node names separated by slashes
+            (example: "BigObject/Partomatic")
+        """
+        if "yaml_tree" in kwargs:
+            self.yaml_tree = kwargs["yaml_tree"]
+        if configuration is not None:
+            self.load_config(configuration, yaml_tree=self.yaml_tree)
+        elif kwargs:
+            self._default_config()
+            for key, value in kwargs.items():
+                classfield = next(
+                    (f for f in fields(self.__class__) if f.name == key),
+                    None,
+                )
+                if classfield:
+                    if is_dataclass(classfield.type):
+                        if isinstance(value, dict):
+                            setattr(self, key, classfield.type(**value))
+                        else:
+                            setattr(self, key, value)
+                    else:
+                        setattr(self, key, value)
+        else:
+            self._default_config()

partomatic-0.0.1/tests/conftest.py

@@ -0,0 +1,6 @@
+import sys
+import os
+
+sys.path.insert(
+    0, os.path.abspath(os.path.join(os.path.dirname(__file__), "../src"))
+)

partomatic-0.0.1/tests/test_buildablepart.py

@@ -0,0 +1,15 @@
+from dataclasses import dataclass, field
+from enum import Enum, auto
+import pytest
+from unittest.mock import patch
+from pathlib import Path
+
+from partomatic import BuildablePart
+from build123d import BuildPart, Box, Sphere, Align, Mode, Location, Part
+
+
+class TestBuildablePart:
+    def test_extension_removed(self):
+        widget_part = Part()
+        widget = BuildablePart(widget_part, "widget.stl")
+        assert widget.file_name == "widget"

partomatic-0.0.1/tests/test_partomatic.py

@@ -0,0 +1,178 @@
+from dataclasses import dataclass, field
+from enum import Enum, auto
+import pytest
+from unittest.mock import patch
+from pathlib import Path
+
+from partomatic import BuildablePart, PartomaticConfig, Partomatic
+from build123d import BuildPart, Box, Part, Sphere, Align, Mode, Location
+
+
+class FakeEnum(Enum):
+    ONE = auto()
+    TWO = auto()
+    THREE = auto()
+
+
+class SubConfig(PartomaticConfig):
+    sub_field: str = "sub_default"
+    sub_enum: FakeEnum = FakeEnum.ONE
+
+
+class ContainerConfig(PartomaticConfig):
+    container_field: str = "container_default"
+    sub: SubConfig = field(default_factory=SubConfig)
+
+
+class TestPartomaticConfig:
+    config_yaml = """
+Part:
+    stl_folder: "yaml_folder"
+    file_prefix: "yaml_prefix"
+    file_suffix: "yaml_suffix"
+"""
+    blah_config_yaml = """
+Foo:
+    container_field: "yaml_container_field"
+    Blah:
+        stl_folder: "yaml_blah_folder"
+        file_prefix: "yaml_blah_prefix"
+        file_suffix: "yaml_blah_suffix"
+        sub_field: "yaml_sub_field"
+        sub_enum: "TWO"
+"""
+
+    sub_config_yaml = """
+Part:
+    container_field: "yaml_container_field"
+    sub:
+        stl_folder: "yaml_blah_folder"
+        file_prefix: "yaml_blah_prefix"
+        file_suffix: "yaml_blah_suffix"
+        sub_field: "yaml_sub_field"
+        sub_enum: "TWO"
+"""
+
+    def test_yaml_partomat(self):
+        config = PartomaticConfig(self.config_yaml)
+        assert config.stl_folder == "yaml_folder"
+
+    def test_empty_partomat(self):
+        config = PartomaticConfig()
+        assert config.stl_folder == "NONE"
+
+    def test_subconfig(self):
+        config = SubConfig(self.blah_config_yaml, yaml_tree="Foo/Blah")
+        assert config.stl_folder == "yaml_blah_folder"
+        assert config.sub_field == "yaml_sub_field"
+        assert config.sub_enum == FakeEnum.TWO
+
+    def test_kwargs(self):
+        config = SubConfig(yaml_tree="Part/Blah", sub_field="kwargsub")
+        assert config.stl_folder == "NONE"
+        assert config.sub_field == "kwargsub"
+
+    def test_yaml_container_partomat(self):
+        config = ContainerConfig(self.sub_config_yaml)
+        assert config.container_field == "yaml_container_field"
+        assert config.sub.sub_field == "yaml_sub_field"
+
+    def test_invalid_config(self):
+        with pytest.raises(ValueError):
+            ContainerConfig("invalid_config")
+
+    def test_yaml_container_with_dict_partomat(self):
+        config = ContainerConfig(
+            sub={
+                "stl_folder": "yaml_blah_folder",
+                "file_prefix": "yaml_blah_prefix",
+                "file_suffix": "yaml_blah_suffix",
+                "sub_field": "yaml_sub_field",
+                "sub_enum": "TWO",
+            }
+        )
+        assert config.sub.sub_field == "yaml_sub_field"
+
+    def test_yaml_container_with_class_partomat(self):
+        sub_config = SubConfig(self.blah_config_yaml, yaml_tree="Foo/Blah")
+
+        config = ContainerConfig(sub=sub_config)
+        assert config.sub.sub_field == "yaml_sub_field"
+
+    def test_default_container_partomat(self):
+        config = ContainerConfig()
+        assert config.container_field == "container_default"
+        assert config.sub.sub_field == "sub_default"
+
+    def test_config_create(self):
+        config = PartomaticConfig()
+        config.stl_folder = "config_create_folder"
+        config = PartomaticConfig(config)
+        assert config.stl_folder == "config_create_folder"
+
+
+class TestBuildablePart:
+    def test_extension_removed(self):
+        widget_part = Part()
+        widget = BuildablePart(widget_part, "widget.stl")
+        assert widget.file_name == "widget"
+
+
+@dataclass
+class WidgetConfig(PartomaticConfig):
+    stl_folder: str = field(default="C:\\Users\\xopher\\Downloads")
+    radius: float = field(default=10)
+    length: float = field(default=17)
+
+
+class Widget(Partomatic):
+
+    _config: WidgetConfig = WidgetConfig()
+
+    def compile(self):
+        self.parts.clear()
+        with BuildPart() as holebox:
+            Box(
+                self._config.length,
+                self._config.length,
+                self._config.length,
+                align=(Align.CENTER, Align.CENTER, Align.CENTER),
+            )
+            Sphere(
+                self._config.radius,
+                align=(Align.CENTER, Align.CENTER, Align.CENTER),
+                mode=Mode.SUBTRACT,
+            )
+
+        self.parts.append(
+            BuildablePart(
+                holebox.part,
+                "test",
+                display_location=Location((9, 0, 9)),
+                stl_folder=str(Path(self._config.stl_folder) / "stls"),
+                step_folder=str(Path(self._config.stl_folder) / "steps"),
+                create_folders=True,
+            )
+        )
+
+
+class TestPartomatic:
+
+    def test_partomatic_class(self):
+        wc = WidgetConfig()
+        assert wc.stl_folder == "C:\\Users\\xopher\\Downloads"
+        foo = Widget(wc)
+        assert foo._config.radius == 10
+        assert foo._config.length == 17
+        with (
+            patch("pathlib.Path.mkdir"),
+            patch("pathlib.Path.exists"),
+            patch("pathlib.Path.is_dir"),
+            patch("ocp_vscode.show"),
+            patch("build123d.export_stl"),
+            patch("build123d.export_step"),
+        ):
+            foo.display()
+            foo.partomate()
+        foo._config.stl_folder = "NONE"
+        foo.export_stls()

partomatic-0.0.1/tests/test_partomaticconfig.py

@@ -0,0 +1,112 @@
+from dataclasses import dataclass, field
+from enum import Enum, auto
+import pytest
+from unittest.mock import patch
+from pathlib import Path
+from partomatic import PartomaticConfig
+
+
+from build123d import BuildPart, Box, Sphere, Align, Mode, Location, Part
+
+
+class FakeEnum(Enum):
+    ONE = auto()
+    TWO = auto()
+    THREE = auto()
+
+
+class SubConfig(PartomaticConfig):
+    sub_field: str = "sub_default"
+    sub_enum: FakeEnum = FakeEnum.ONE
+
+
+class ContainerConfig(PartomaticConfig):
+    container_field: str = "container_default"
+    sub: SubConfig = field(default_factory=SubConfig)
+
+
+class TestPartomaticConfig:
+    config_yaml = """
+Part:
+    stl_folder: "yaml_folder"
+    file_prefix: "yaml_prefix"
+    file_suffix: "yaml_suffix"
+"""
+    blah_config_yaml = """
+Foo:
+    container_field: "yaml_container_field"
+    Blah:
+        stl_folder: "yaml_blah_folder"
+        file_prefix: "yaml_blah_prefix"
+        file_suffix: "yaml_blah_suffix"
+        sub_field: "yaml_sub_field"
+        sub_enum: "TWO"
+"""
+
+    sub_config_yaml = """
+Part:
+    container_field: "yaml_container_field"
+    sub:
+        stl_folder: "yaml_blah_folder"
+        file_prefix: "yaml_blah_prefix"
+        file_suffix: "yaml_blah_suffix"
+        sub_field: "yaml_sub_field"
+        sub_enum: "TWO"
+"""
+
+    def test_yaml_partomat(self):
+        config = PartomaticConfig(self.config_yaml)
+        assert config.stl_folder == "yaml_folder"
+
+    def test_empty_partomat(self):
+        config = PartomaticConfig()
+        assert config.stl_folder == "NONE"
+
+    def test_subconfig(self):
+        config = SubConfig(self.blah_config_yaml, yaml_tree="Foo/Blah")
+        assert config.stl_folder == "yaml_blah_folder"
+        assert config.sub_field == "yaml_sub_field"
+        assert config.sub_enum == FakeEnum.TWO
+
+    def test_kwargs(self):
+        config = SubConfig(yaml_tree="Part/Blah", sub_field="kwargsub")
+        assert config.stl_folder == "NONE"
+        assert config.sub_field == "kwargsub"
+
+    def test_yaml_container_partomat(self):
+        config = ContainerConfig(self.sub_config_yaml)
+        assert config.container_field == "yaml_container_field"
+        assert config.sub.sub_field == "yaml_sub_field"
+
+    def test_invalid_config(self):
+        with pytest.raises(ValueError):
+            ContainerConfig("invalid_config")
+
+    def test_yaml_container_with_dict_partomat(self):
+        config = ContainerConfig(
+            sub={
+                "stl_folder": "yaml_blah_folder",
+                "file_prefix": "yaml_blah_prefix",
+                "file_suffix": "yaml_blah_suffix",
+                "sub_field": "yaml_sub_field",
+                "sub_enum": "TWO",
+            }
+        )
+        assert config.sub.sub_field == "yaml_sub_field"
+
+    def test_yaml_container_with_class_partomat(self):
+        sub_config = SubConfig(self.blah_config_yaml, yaml_tree="Foo/Blah")
+
+        config = ContainerConfig(sub=sub_config)
+        assert config.sub.sub_field == "yaml_sub_field"
+
+    def test_default_container_partomat(self):
+        config = ContainerConfig()
+        assert config.container_field == "container_default"
+        assert config.sub.sub_field == "sub_default"
+
+    def test_config_create(self):
+        config = PartomaticConfig()
+        config.stl_folder = "config_create_folder"
+        config = PartomaticConfig(config)
+        assert config.stl_folder == "config_create_folder"