pyvcad-attribute-resolver 3.0.0__py3-none-any.whl

pyvcad_attribute_resolver/__init__.py

@@ -0,0 +1,25 @@
+from .registry import (register_conversion, unregister_conversion,
+                       list_conversions, clear_conversions)
+from .adapt import adapt
+from .solver import ResolverError, NoPathError, AmbiguousPathError
+from .conversion_entry import ConversionEntry
+from .modules.foaming import (register_foaming_conversions,
+                               register_tpu_conversions,
+                               register_pla_conversions)
+from .modules.j750_shore_hardness import (
+    fit_j750_shore_hardness_curve,
+    generate_j750_shore_hardness_fit_plot,
+    register_j750_shore_hardness_conversions,
+)
+from .modules.j750_modulus_toughness import (
+    register_j750_modulus_toughness_conversions,
+    generate_j750_modulus_toughness_lookup_table,
+    generate_j750_modulus_toughness_reachable_region_plot,
+)
+from .modules.stratasys_radiomatrix import (
+    register_stratasys_radiomatrix_conversions,
+)
+from .modules.generic_color import (register_generic_color_conversions,
+                                    register_rgb_to_rgba_conversion,
+                                    register_rgba_to_rgb_conversion)
+from .modules import list_modules

pyvcad_attribute_resolver/adapt.py

@@ -0,0 +1,52 @@
+import pyvcad as pv
+from .registry import _global_graph
+from .solver import solve
+
+
+def adapt(design, target_attributes,
+          allowed_conversions=None, tags=None, max_depth=10):
+    """Wrap a design node with AttributeModifiers to produce target attributes.
+
+    For each target attribute not already present on the design, the
+    solver finds a conversion path through the registered graph and
+    wraps the design in the corresponding ``AttributeModifier`` chain.
+
+    Targets are processed sequentially so that attributes produced by
+    earlier conversions are available for later ones.
+
+    Arguments:
+        design: ``pyvcad.Node``, the root of the design tree.
+        target_attributes: List of attribute name strings the caller
+            needs on the output.
+        allowed_conversions: Optional list of ``ConversionEntry`` names
+            to restrict the solver.
+        tags: Optional list of tags to filter conversions.
+        max_depth: Maximum chain length per target (default 10).
+
+    Returns:
+        ``pyvcad.Node`` — the original design wrapped in zero or more
+        ``AttributeModifier`` nodes. Returns the design unchanged if
+        all targets are already present.
+
+    Raises:
+        NoPathError: If any target attribute cannot be reached.
+        AmbiguousPathError: If disambiguation fails for any target.
+    """
+    available = design.attribute_list()
+    result = design
+
+    for target in target_attributes:
+        if target in available:
+            continue
+
+        path = solve(_global_graph, available, target,
+                     allowed_conversions=allowed_conversions,
+                     tags=tags, max_depth=max_depth)
+
+        for entry in path:
+            converter = entry.converter_factory()
+            result = pv.AttributeModifier(converter, result)
+
+        available = result.attribute_list()
+
+    return result

pyvcad_attribute_resolver/conversion_entry.py

@@ -0,0 +1,35 @@
+class ConversionEntry:
+    """A registered conversion between two attribute types.
+
+    Each entry represents a directed edge in the conversion graph, from a
+    source attribute to a target attribute. The ``converter_factory`` callable
+    produces a fresh ``AttributeConverterBase`` instance each time it is
+    invoked, supporting clone-safe, thread-safe parallel evaluation.
+
+    Attributes:
+        source: Input attribute name.
+        target: Output attribute name.
+        converter_factory: Zero-argument callable returning an
+            ``AttributeConverterBase``.
+        name: Human-readable identifier for this conversion.
+        priority: Higher values are preferred when disambiguating
+            multiple equally-short paths.
+        tags: Context-filtering labels (e.g. ``"foaming_tpu"``).
+        required_inputs: Attribute names that must already be present on the
+            design before this conversion can be applied.
+    """
+
+    def __init__(self, source, target, converter_factory,
+                 name=None, priority=0, tags=None, required_inputs=None):
+        self.source = source
+        self.target = target
+        self.converter_factory = converter_factory
+        self.name = name or f"{source}_to_{target}"
+        self.priority = priority
+        self.tags = tags or []
+        self.required_inputs = list(required_inputs) if required_inputs else [source]
+
+    def __repr__(self):
+        return (f"ConversionEntry('{self.source}' -> '{self.target}', "
+                f"name='{self.name}', priority={self.priority}, "
+                f"required_inputs={self.required_inputs})")

pyvcad_attribute_resolver/conversion_graph.py

@@ -0,0 +1,58 @@
+class ConversionGraph:
+    """Directed graph of attribute conversions.
+
+    Vertices are attribute name strings. Edges are ``ConversionEntry``
+    objects representing registered conversions from one attribute to
+    another. Implemented as a pure adjacency-list with no external
+    dependencies.
+    """
+
+    def __init__(self):
+        self._adjacency = {}  # dict[str, list[ConversionEntry]]
+        self._by_name = {}    # dict[str, ConversionEntry]
+
+    def add_edge(self, entry):
+        """Add a ConversionEntry as a directed edge.
+
+        If an entry with the same name already exists it is replaced.
+        """
+        if entry.name in self._by_name:
+            self.remove_edge(entry.name)
+        self._adjacency.setdefault(entry.source, []).append(entry)
+        self._by_name[entry.name] = entry
+
+    def remove_edge(self, name):
+        """Remove an edge by its ConversionEntry.name.
+
+        Raises ``KeyError`` if the name is not found.
+        """
+        if name not in self._by_name:
+            raise KeyError(f"No conversion named '{name}'")
+        entry = self._by_name.pop(name)
+        edges = self._adjacency.get(entry.source, [])
+        self._adjacency[entry.source] = [e for e in edges if e.name != name]
+        if not self._adjacency[entry.source]:
+            del self._adjacency[entry.source]
+
+    def neighbors(self, source):
+        """Return all ConversionEntry objects from a given source attribute."""
+        return list(self._adjacency.get(source, []))
+
+    def edges(self):
+        """Return all ConversionEntry objects in the graph."""
+        return list(self._by_name.values())
+
+    def has_edge(self, source, target):
+        """Check if any edge exists from source to target."""
+        return any(e.target == target
+                   for e in self._adjacency.get(source, []))
+
+    def find_edges(self, source, target):
+        """Return all edges from source to target."""
+        return [e for e in self._adjacency.get(source, [])
+                if e.target == target]
+
+    def clear(self):
+        """Remove all edges."""
+        self._adjacency.clear()
+        self._by_name.clear()

pyvcad_attribute_resolver/modules/__init__.py

@@ -0,0 +1,14 @@
+"""Domain-specific conversion modules.
+
+Each sub-package registers its own set of ConversionEntry objects.
+To discover the installed modules, call :func:`list_modules`.
+"""
+
+import importlib
+import pkgutil
+
+
+def list_modules():
+    """Return the names of all installed sub-packages under ``modules/``."""
+    return [name for _, name, is_pkg in pkgutil.iter_modules(__path__)
+            if is_pkg]

pyvcad_attribute_resolver/modules/foaming/.gitignore

@@ -0,0 +1 @@
+/output/

pyvcad_attribute_resolver/modules/foaming/__init__.py

@@ -0,0 +1,110 @@
+"""Foaming filament conversion registrations.
+
+Each entry wraps empirical lookup-table data measured for ColorFabb
+VarioShore TPU and ColorFabb LW-PLA foaming filaments.
+
+Usage::
+
+    import pyvcad_attribute_resolver as resolver
+    resolver.register_foaming_conversions()          # all 5
+    resolver.register_tpu_conversions()              # TPU-only (3)
+    resolver.register_pla_conversions()              # PLA-only (2)
+"""
+
+import pyvcad as pv
+from pyvcad_attribute_resolver.registry import register_conversion
+from .data import (
+    TPU_SHORE_HARDNESS,
+    TPU_DENSITY,
+    TPU_FLOW_COMPENSATION,
+    PLA_DENSITY,
+    PLA_FLOW_COMPENSATION,
+)
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _lut_factory(source_attr, target_attr, data):
+    """Return a zero-arg callable that builds a fresh LookupTableConverter."""
+    entries = [pv.LookupTableEntry(kv[0], kv[0], kv[1]) for kv in data]
+
+    def _factory():
+        return pv.LookupTableConverter(
+            [source_attr], [target_attr],
+            entries, pv.InterpolationMode.LINEAR,
+        )
+    return _factory
+
+
+# ---------------------------------------------------------------------------
+# Public registration functions
+# ---------------------------------------------------------------------------
+
+def register_tpu_conversions():
+    """Register the three VarioShore TPU conversions."""
+    register_conversion(
+        source="shore_hardness", target="temperature",
+        converter_factory=_lut_factory(
+            pv.DefaultAttributes.SHORE_HARDNESS,
+            pv.DefaultAttributes.TEMPERATURE,
+            TPU_SHORE_HARDNESS,
+        ),
+        name="tpu_shore_hardness_to_temperature",
+        priority=0,
+        tags=["foaming_tpu"],
+    )
+    register_conversion(
+        source="density", target="temperature",
+        converter_factory=_lut_factory(
+            pv.DefaultAttributes.DENSITY,
+            pv.DefaultAttributes.TEMPERATURE,
+            TPU_DENSITY,
+        ),
+        name="tpu_density_to_temperature",
+        priority=0,
+        tags=["foaming_tpu"],
+    )
+    register_conversion(
+        source="temperature", target="flow_rate",
+        converter_factory=_lut_factory(
+            pv.DefaultAttributes.TEMPERATURE,
+            pv.DefaultAttributes.FLOW_RATE,
+            TPU_FLOW_COMPENSATION,
+        ),
+        name="tpu_temperature_to_flow_rate",
+        priority=0,
+        tags=["foaming_tpu"],
+    )
+
+
+def register_pla_conversions():
+    """Register the two LW-PLA conversions."""
+    register_conversion(
+        source="density", target="temperature",
+        converter_factory=_lut_factory(
+            pv.DefaultAttributes.DENSITY,
+            pv.DefaultAttributes.TEMPERATURE,
+            PLA_DENSITY,
+        ),
+        name="pla_density_to_temperature",
+        priority=0,
+        tags=["foaming_pla"],
+    )
+    register_conversion(
+        source="temperature", target="flow_rate",
+        converter_factory=_lut_factory(
+            pv.DefaultAttributes.TEMPERATURE,
+            pv.DefaultAttributes.FLOW_RATE,
+            PLA_FLOW_COMPENSATION,
+        ),
+        name="pla_temperature_to_flow_rate",
+        priority=0,
+        tags=["foaming_pla"],
+    )
+
+
+def register_foaming_conversions():
+    """Register all five foaming filament conversions (TPU + PLA)."""
+    register_tpu_conversions()
+    register_pla_conversions()

pyvcad_attribute_resolver/modules/foaming/data.py

@@ -0,0 +1,256 @@
+"""Raw empirical lookup-table data for foaming filaments.
+
+The raw constants in this module are the maintained source of truth for the
+foaming filament characterization data. Runtime lookup tables are derived from
+the raw measurements so the conversion data and plot data stay synchronized.
+"""
+
+DESIGNED_WALL_THICKNESS_MM = 0.45
+
+# ---------------------------------------------------------------------------
+# ColorFabb VarioShore TPU
+# ---------------------------------------------------------------------------
+
+TPU_BASE_FLOW_MULTIPLIER = 1.4
+TPU_DENSITY_SAMPLE_VOLUME_CM3 = 6.3
+TPU_FLOW_RUNTIME_TEMPERATURE_RANGE = (204, 240)
+
+#: Temperature (C) -> uncompensated wall-thickness measurements (mm)
+TPU_WALL_EXPANSION_RAW = {
+    196: [0.41, 0.41, 0.40, 0.40],
+    200: [0.43, 0.42, 0.42, 0.42],
+    204: [0.41, 0.41, 0.41, 0.40],
+    208: [0.43, 0.43, 0.43, 0.43],
+    212: [0.48, 0.49, 0.48, 0.47],
+    216: [0.55, 0.55, 0.56, 0.56],
+    220: [0.67, 0.67, 0.65, 0.65],
+    224: [0.74, 0.74, 0.73, 0.73],
+    228: [0.84, 0.83, 0.84, 0.84],
+    232: [0.87, 0.89, 0.90, 0.89],
+    236: [0.91, 0.96, 0.93, 0.92],
+    240: [0.95, 0.95, 0.95, 0.94],
+    244: [0.94, 0.94, 0.95, 0.97],
+    248: [0.97, 0.97, 0.97, 0.95],
+    252: [0.99, 1.01, 0.95, 0.91],
+    256: [0.99, 0.99, 0.95, 0.95],
+    260: [0.99, 0.99, 0.95, 0.96],
+}
+
+#: Temperature (C) -> flow factor used during compensated validation
+TPU_WALL_CALIBRATION_FLOW_FACTORS = {
+    204: 1.5460122699386503,
+    208: 1.4651162790697674,
+    212: 1.3125,
+    216: 1.1351351351351349,
+    220: 0.9545454545454544,
+    224: 0.8571428571428571,
+    228: 0.7522388059701494,
+    232: 0.7098591549295774,
+    236: 0.6774193548387096,
+    240: 0.6649076517150396,
+}
+
+#: Temperature (C) -> compensated wall-thickness measurements (mm)
+TPU_WALL_CALIBRATION_VALIDATION_RAW = {
+    204: [0.46, 0.47, 0.43, 0.42],
+    208: [0.43, 0.44, 0.41, 0.41],
+    212: [0.46, 0.45, 0.46, 0.47],
+    216: [0.49, 0.44, 0.47, 0.47],
+    220: [0.47, 0.46, 0.47, 0.48],
+    224: [0.47, 0.45, 0.45, 0.49],
+    228: [0.45, 0.43, 0.45, 0.46],
+    232: [0.42, 0.43, 0.44, 0.46],
+    236: [0.44, 0.42, 0.44, 0.43],
+    240: [0.42, 0.43, 0.45, 0.44],
+}
+
+#: Temperature (C) -> density block samples with weight and Shore A repeats
+TPU_SHORE_DENSITY_RAW = {
+    196: {"weight_g": 7.1, "shore_hardness": [91.0, 93.5]},
+    200: {"weight_g": 7.1, "shore_hardness": [91.0, 93.5]},
+    204: {"weight_g": 6.0, "shore_hardness": [90.0, 89.0]},
+    208: {"weight_g": 5.6, "shore_hardness": [85.5, 87.5]},
+    212: {"weight_g": 5.3, "shore_hardness": [83.0, 86.0]},
+    216: {"weight_g": 4.4, "shore_hardness": [76.5, 79.0]},
+    220: {"weight_g": 3.5, "shore_hardness": [71.0, 74.0]},
+    224: {"weight_g": 3.1, "shore_hardness": [68.5, 69.0]},
+    228: {"weight_g": 2.8, "shore_hardness": [65.0, 66.0]},
+    232: {"weight_g": 2.6, "shore_hardness": [62.0, 61.0]},
+}
+
+# Backward-compatible private name used by older local plotting code.
+_TPU_SHORE_HARDNESS_RAW = {
+    temperature: row["shore_hardness"]
+    for temperature, row in TPU_SHORE_DENSITY_RAW.items()
+}
+
+# ---------------------------------------------------------------------------
+# ColorFabb LW-PLA
+# ---------------------------------------------------------------------------
+
+PLA_BASE_FLOW_MULTIPLIER = 1.25
+PLA_DENSITY_SAMPLE_VOLUME_CM3 = 3.7
+PLA_FLOW_RUNTIME_TEMPERATURE_RANGE = (220, 256)
+
+#: Temperature (C) -> uncompensated wall-thickness measurements (mm)
+PLA_WALL_EXPANSION_RAW = {
+    196: [0.40, 0.40, 0.40, 0.39],
+    200: [0.39, 0.39, 0.40, 0.40],
+    204: [0.39, 0.40, 0.40, 0.40],
+    208: [0.40, 0.41, 0.39, 0.39],
+    212: [0.39, 0.39, 0.41, 0.41],
+    216: [0.39, 0.39, 0.40, 0.39],
+    220: [0.39, 0.40, 0.40, 0.40],
+    224: [0.45, 0.45, 0.46, 0.47],
+    228: [0.52, 0.52, 0.52, 0.51],
+    232: [0.58, 0.57, 0.58, 0.57],
+    236: [0.66, 0.65, 0.65, 0.65],
+    240: [0.74, 0.73, 0.74, 0.74],
+    244: [0.76, 0.80, 0.79, 0.78],
+    248: [0.82, 0.82, 0.81, 0.80],
+    252: [0.84, 0.83, 0.82, 0.84],
+    256: [0.86, 0.86, 0.84, 0.85],
+    258: [0.85, 0.84, 0.86, 0.86],
+    260: [0.85, 0.83, 0.84, 0.83],
+    261: [0.83, 0.82, 0.82, 0.81],
+    262: [0.79, 0.82, 0.80, 0.80],
+    263: [0.80, 0.80, 0.78, 0.79],
+    264: [0.79, 0.78, 0.78, 0.76],
+    268: [0.80, 0.77, 0.74, 0.79],
+    272: [0.77, 0.76, 0.76, 0.77],
+    276: [0.77, 0.74, 0.74, 0.75],
+    280: [0.71, 0.73, 0.74, 0.70],
+}
+
+#: Temperature (C) -> flow factor used during compensated validation
+PLA_WALL_CALIBRATION_FLOW_FACTORS = {
+    220: 1.4150943396226419,
+    224: 1.2295081967213115,
+    228: 1.0869565217391304,
+    232: 0.9782608695652174,
+    236: 0.8620689655172414,
+    240: 0.7627118644067796,
+    244: 0.7188498402555911,
+    248: 0.6923076923076923,
+    252: 0.6756756756756757,
+    256: 0.6598240469208211,
+}
+
+#: Temperature (C) -> compensated wall-thickness measurements (mm)
+PLA_WALL_CALIBRATION_VALIDATION_RAW = {
+    220: [0.45, 0.46, 0.46, 0.45],
+    224: [0.44, 0.44, 0.44, 0.45],
+    228: [0.47, 0.46, 0.47, 0.47],
+    232: [0.49, 0.48, 0.47, 0.47],
+    236: [0.49, 0.48, 0.50, 0.47],
+    240: [0.48, 0.48, 0.47, 0.49],
+    244: [0.48, 0.47, 0.48, 0.49],
+    248: [0.48, 0.45, 0.46, 0.46],
+    252: [0.43, 0.44, 0.46, 0.45],
+    256: [0.45, 0.45, 0.44, 0.45],
+}
+
+#: Temperature (C) -> density block samples with flow factor and weight
+PLA_DENSITY_RAW = {
+    216: {"flow_factor": 1.43312101910828, "weight_g": 3.7},
+    220: {"flow_factor": 1.4150943396226419, "weight_g": 3.7},
+    224: {"flow_factor": 1.2295081967213115, "weight_g": 3.2},
+    228: {"flow_factor": 1.0869565217391304, "weight_g": 2.9},
+    232: {"flow_factor": 0.9782608695652174, "weight_g": 2.6},
+    236: {"flow_factor": 0.8620689655172414, "weight_g": 2.2},
+    240: {"flow_factor": 0.7627118644067796, "weight_g": 2.0},
+    244: {"flow_factor": 0.7188498402555911, "weight_g": 1.9},
+    248: {"flow_factor": 0.6923076923076923, "weight_g": 1.9},
+    252: {"flow_factor": 0.6756756756756757, "weight_g": 1.8},
+    256: {"flow_factor": 0.6598240469208211, "weight_g": 1.8},
+    260: {"flow_factor": 0.671641791044776, "weight_g": 1.8},
+    264: {"flow_factor": 0.7234726688102894, "weight_g": 1.8},
+}
+
+
+def _mean(values):
+    return sum(values) / len(values)
+
+
+def _within_range(value, bounds):
+    return bounds[0] <= value <= bounds[1]
+
+
+def _flow_compensation_from_wall_expansion(raw_data, base_multiplier, bounds):
+    rows = []
+    for temperature, samples in raw_data.items():
+        if _within_range(temperature, bounds):
+            flow_rate = (
+                base_multiplier
+                * DESIGNED_WALL_THICKNESS_MM
+                / _mean(samples)
+            )
+            rows.append((temperature, flow_rate))
+    return sorted(rows)
+
+
+def _unique_density_to_temperature(rows):
+    seen = set()
+    unique_rows = []
+    for density, temperature in sorted(rows, key=lambda row: row[1]):
+        if density in seen:
+            continue
+        seen.add(density)
+        unique_rows.append((density, temperature))
+    return sorted(unique_rows)
+
+
+def _unique_input_rows(rows):
+    seen = set()
+    unique_rows = []
+    for input_value, output_value in sorted(rows, key=lambda row: row[1]):
+        if input_value in seen:
+            continue
+        seen.add(input_value)
+        unique_rows.append((input_value, output_value))
+    return sorted(unique_rows)
+
+
+def _tpu_density_rows():
+    rows = []
+    for temperature, row in TPU_SHORE_DENSITY_RAW.items():
+        density = row["weight_g"] / TPU_DENSITY_SAMPLE_VOLUME_CM3
+        rows.append((density, temperature))
+    return rows
+
+
+def _pla_density_rows():
+    rows = []
+    for temperature, row in PLA_DENSITY_RAW.items():
+        density = row["weight_g"] / PLA_DENSITY_SAMPLE_VOLUME_CM3
+        rows.append((density, temperature))
+    return rows
+
+
+#: Shore hardness (Shore A) -> temperature (C)
+TPU_SHORE_HARDNESS = _unique_input_rows(
+    [
+        (_mean(row["shore_hardness"]), temperature)
+        for temperature, row in TPU_SHORE_DENSITY_RAW.items()
+    ]
+)
+
+#: Density (g/cm^3) -> temperature (C)
+TPU_DENSITY = _unique_density_to_temperature(_tpu_density_rows())
+
+#: Temperature (C) -> flow rate multiplier
+TPU_FLOW_COMPENSATION = _flow_compensation_from_wall_expansion(
+    TPU_WALL_EXPANSION_RAW,
+    TPU_BASE_FLOW_MULTIPLIER,
+    TPU_FLOW_RUNTIME_TEMPERATURE_RANGE,
+)
+
+#: Density (g/cm^3) -> temperature (C)
+PLA_DENSITY = _unique_density_to_temperature(_pla_density_rows())
+
+#: Temperature (C) -> flow rate multiplier
+PLA_FLOW_COMPENSATION = _flow_compensation_from_wall_expansion(
+    PLA_WALL_EXPANSION_RAW,
+    PLA_BASE_FLOW_MULTIPLIER,
+    PLA_FLOW_RUNTIME_TEMPERATURE_RANGE,
+)