pycba-tools 0.1.0__py3-none-any.whl

pycba_tools/__init__.py

@@ -0,0 +1,41 @@
+"""
+pycba-tools: Serialization and bulk results extraction for pycba continuous beam models, interchangeable with pynite-tools.
+
+Modules included:
+
+- model: CBAModel, a pycba beam with named load cases, load combinations and
+  Pynite-shaped result views
+- reports: Functions for bulk exporting structured analysis results
+- serialize: Functions for serializing/deserializing CBAModel objects
+- combos: Functions for bulk importing load combinations
+"""
+
+__version__ = "0.1.0"
+
+from .model import CBAModel, LoadCombo
+
+from .reports import (
+    extract_node_reactions,
+    extract_node_displacements,
+    extract_member_arrays,
+    extract_member_envelopes,
+    extract_member_actions_by_location,
+    extract_span_envelopes,
+    extract_load_combinations,
+    merge_result_trees,
+)
+
+from .serialize import (
+    to_json,
+    from_json,
+    dump,
+    dumps,
+    dump_dict,
+    load,
+    loads,
+    load_dict,
+)
+
+from .combos import (
+    model_add_combos,
+)

pycba_tools/combos.py

@@ -0,0 +1,31 @@
+from copy import deepcopy
+from typing import Optional
+
+from .model import CBAModel
+
+
+def model_add_combos(
+    load_combos: list[dict[str, dict[str, float]]], model: CBAModel, as_copy: bool = False
+) -> Optional[CBAModel]:
+    """
+    Bulk adds a list of load combination dictionaries into the 'model' all at once.
+
+    'load_combos': a list of load combination elements, each in the following format:
+        {
+            "name": "load_combo_name",
+            "factors": {
+                "case_1_name": 1.0,
+                "case_2_name": 1.0,
+                ...
+            }
+        }
+    'model': A pycba_tools.CBAModel
+    'as_copy': If True, will return a copy of the CBAModel with the load combos applied.
+        If False, returns None and modifies the CBAModel in place. Default is False.
+    """
+    if as_copy:
+        model = deepcopy(model)
+    for load_combo in load_combos:
+        model.add_load_combo(**load_combo)
+    if as_copy:
+        return model

pycba_tools/envelope.py

@@ -0,0 +1,86 @@
+from copy import copy
+from typing import Hashable
+
+PYMAX = max
+PYMIN = min
+
+def envelope_tree(tree: dict | list, levels: list[Hashable | None], leaf: Hashable | None, agg_func: callable, with_trace: bool = True) -> dict:
+    """
+    Envelopes the tree at the leaf node with 'agg_func'.
+    """
+    env_acc = {}
+    # If we are at the last branch...
+    if not levels:
+        if isinstance(tree, list):
+            tree = {idx: leaf for idx, leaf in enumerate(tree)}
+        leaf_acc = {}
+        for k, leaves in tree.items():
+            if leaf is not None:
+                leaf_acc.update({k: leaves[leaf]})
+            else:
+                leaf_acc = tree
+        # ...create a dict of the enveloped value and the key
+        # that it belongs to and return it.
+        env_values = list(leaf_acc.values())
+        env_value = agg_func(env_values)
+        env_keys = list(leaf_acc.keys())
+        try:
+            env_key = env_keys[env_values.index(env_value)]
+        except ValueError: # The value was transformed, likely due to abs()
+            env_key = env_keys[env_values.index(-1 * env_value)]
+        env_acc.update({"key": env_key, "value": env_value})
+        if with_trace:
+            return env_acc
+        else:
+            return env_value
+    else:
+        # Otherwise, pop the next level and dive into the tree on that branch
+        level = levels[0]
+        if level is not None:
+            try:
+                tree[level]
+            except KeyError:
+                raise KeyError(f"Key '{level}' does not exist at this level. Available keys: {list(tree.keys())}")
+            env_acc.update({level: envelope_tree(tree[level], levels[1:], leaf, agg_func, with_trace)})
+            return env_acc
+        else:
+            # If None, then walk all branches of this node of the tree
+            if isinstance(tree, list):
+                tree = {idx: leaf for idx, leaf in enumerate(tree)}
+            for k, v in tree.items():
+                env_acc.update({k: envelope_tree(v, levels[1:], leaf, agg_func, with_trace)})
+            return env_acc
+
+    
+def absmax(x: list[float | int]) -> float | int:
+    """
+    Returns the absolute maximum value in 'x'.
+    """
+    abs_acc = [abs(y) for y in x]
+    return max(abs_acc)
+
+
+def absmin(x: list[float | int]) -> float | int:
+    """
+    Returns the absolute minimum value in 'x'.
+    """
+    abs_acc = [abs(y) for y in x]
+    return min(abs_acc)
+
+
+def max(x: list[float | int | None]) -> float | int | None:
+    """
+    Returns the max value in 'x' while ignoring "None".
+    If all values in 'x' are None, then None is returned.
+    """
+    return PYMAX([y for y in x if y is not None])
+
+
+def min(x: list[float | int | None]) -> float | int | None:
+    """
+    Returns the max value in 'x' while ignoring "None".
+    If all values in 'x' are None, then None is returned.
+    """
+    return PYMIN([y for y in x if y is not None])
+
+