Test with dataclasses are passing. A bit more work on type hints

src/ada/__init__.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-# coding=utf-8
 from ada.concepts.connections import Bolts, Weld
 from ada.concepts.curves import ArcSegment, CurvePoly, CurveRevolve, LineSegment
 from ada.concepts.levels import FEM, Assembly, Part

src/ada/concepts/levels.py

@@ -934,6 +934,7 @@ def to_fem(
         if should_convert(res_path, overwrite):
             analysis_dir = folder_prep(scratch_dir, name, overwrite)
             _, fem_exporter = get_fem_converters("", fem_format, fem_converter)
+
             if fem_exporter is None:
                 raise ValueError(f'FEM export for "{fem_format}" using "{fem_converter}" is currently not supported')
             fem_inp_files = dict(

src/ada/fem/__init__.py

@@ -23,7 +23,6 @@
     "Constraint",
     "PredefinedField",
     "FemSet",
-    "FEM",
     "Mass",
     "HistOutput",
     "FieldOutput",

src/ada/fem/common.py

@@ -3,6 +3,7 @@
 
 class FemBase:
     def __init__(self, name, metadata, parent):
+        """:type parent: ada.FEM"""
         self.name = name
         self.parent = parent
         self._metadata = metadata if metadata is not None else dict()
@@ -51,6 +52,7 @@ def __init__(
         metadata=None,
         parent=None,
     ):
+        """:type parent: ada.FEM"""
         super().__init__(name, metadata, parent)
         self._definition = definition
         self._system = system
@@ -80,6 +82,7 @@ def __repr__(self):
 
 class Amplitude(FemBase):
     def __init__(self, name, x, y, smooth=None, metadata=None, parent=None):
+        """:type parent: ada.FEM"""
         super().__init__(name, metadata, parent)
         self._x = x
         self._y = y

src/ada/fem/constraints.py

@@ -5,18 +5,6 @@
 
 
 class Bc(FemBase):
-    """
-
-    :param name:
-    :param fem_set:
-    :param dofs:
-    :param magnitudes:
-    :param bc_type:
-    :param amplitude_name:
-    :param init_condition: List of tuples [(dof1, magnitude1), (dof2, magnitude2)]
-    :type fem_set: FemSet
-    """
-
     _valid_types = [
         "displacement",
         "velocity",

src/ada/fem/containers.py

@@ -33,7 +33,7 @@ class FemElements:
 
     :param elements:
     :param fem_obj:
-    :type fem_obj: ada.fem.FEM
+    :type fem_obj: ada.FEM
     """
 
     def __init__(self, elements=None, fem_obj=None, from_np_array=None):

src/ada/fem/interactions.py

@@ -94,15 +94,12 @@ def __init__(
 
     @property
     def parent(self):
-        """
-
-        :rtype: ada.fem.FEM
-        """
+        """:rtype: ada.FEM"""
         return self._parent
 
     @parent.setter
     def parent(self, value):
-        from . import FEM
+        from ada import FEM
 
         if type(value) not in (FEM, Step) and value is not None:
             raise ValueError(f'Parent type "{type(value)}" is not supported')

src/ada/fem/io/abaqus/execute.py

@@ -13,7 +13,7 @@ def run_abaqus(
     cpus=2,
     gpus=None,
     run_ext=False,
-    manifest=None,
+    metadata=None,
     subr_path=None,
     execute=True,
     return_bat_str=False,
@@ -25,7 +25,7 @@ def run_abaqus(
     :param cpus: Number of CPUs to run the analysis on. Default is 2.
     :param gpus: Number of GPUs to run the analysis on. Default is none.
     :param run_ext: If False the process will wait for the abaqus analysis to finish. Default is False
-    :param manifest: Dictionary containing various metadata relevant for the analysis
+    :param metadata: Dictionary containing various metadata relevant for the analysis
     :param subr_path: Path to fortran subroutine file (optional).
     :param execute: Automatically starts Abaqus analysis. Default is True
     :param return_bat_str:
@@ -89,9 +89,9 @@ def run_abaqus(
     with open(inp_path.parent / stop_bat, "w") as d:
         d.write(f"cd /d {inp_path.parent}\nabaqus terminate job={analysis_name}")
 
-    if manifest is not None:
+    if metadata is not None:
         with open(inp_path.parent / "analysis_manifest.json", "w") as fp:
-            json.dump(manifest, fp, indent=4)
+            json.dump(metadata, fp, indent=4)
 
     execute_path = _Settings.execute_dir if _Settings.execute_dir is not None else inp_path.parent
 

src/ada/fem/io/abaqus/reader.py

@@ -14,6 +14,7 @@
 from ada.concepts.containers import Nodes
 from ada.concepts.levels import FEM, Assembly, Part
 from ada.concepts.points import Node
+from ada.concepts.structural import Material
 from ada.core.utils import Counter, roundoff
 from ada.fem import (
     Bc,
@@ -152,13 +153,6 @@ def extract_instance_data(assembly_bulk) -> dict[str:InstanceData]:
     return ass_data
 
 
-def grab_instance_data(ass_data, name):
-    if name in ass_data:
-        return ass_data[name]
-    else:
-        return None, None, None
-
-
 def import_parts(bulk_str, instance_data, assembly: Assembly) -> List[Part]:
     part_list = []
 
@@ -212,7 +206,7 @@ def get_fem_from_bulk_str(name, bulk_str, assembly: Assembly, instance_name=None
     return part
 
 
-def get_initial_conditions_from_lines(assembly, bulk_str):
+def get_initial_conditions_from_lines(assembly: Assembly, bulk_str):
     """
     TODO: Optimize this function
 
@@ -268,7 +262,7 @@ def grab_init_props(m):
         assembly.fem.add_predefined_field(grab_init_props(match))
 
 
-def get_materials_from_bulk(assembly, bulk_str):
+def get_materials_from_bulk(assembly: Assembly, bulk_str):
     re_str = (
         r"(\*Material,\s*name=.*?)(?=\*|\Z)(?!\*Elastic|\*Density|\*Plastic|"
         r"\*Damage Initiation|\*Damage Evolution|\*Expansion)"
@@ -279,7 +273,7 @@ def get_materials_from_bulk(assembly, bulk_str):
         assembly.add_material(mat)
 
 
-def get_intprop_from_lines(assembly, bulk_str):
+def get_intprop_from_lines(assembly: Assembly, bulk_str):
     """
     *Surface Interaction, name=contactProp
     *Friction
@@ -322,7 +316,6 @@ def get_intprop_from_lines(assembly, bulk_str):
 
 def get_instance_data(inst_name, p_ref, inst_bulk) -> InstanceData:
     """
-
     Move/rotate data lines are specified here:
 
     https://abaqus-docs.mit.edu/2017/English/SIMACAEKEYRefMap/simakey-r-instance.htm
@@ -363,15 +356,7 @@ def get_instance_data(inst_name, p_ref, inst_bulk) -> InstanceData:
     return InstanceData(p_ref, inst_name, inst_bulk, metadata)
 
 
-def mat_str_to_mat_obj(mat_str):
-    """
-    Converts a Abaqus materials str into a ADA Materials object
-
-    :param mat_str:
-    :return:
-    """
-    from ada import Material
-
+def mat_str_to_mat_obj(mat_str) -> Material:
     rd = roundoff
 
     # Name
@@ -440,11 +425,8 @@ def read_inp(fname):
     return "".join([x for x in map(read_inp, os.listdir(input_files_dir)) if x is not None])
 
 
-def get_nodes_from_inp(bulk_str, parent):
-    """
-    Extract node information from abaqus input file string
-
-    """
+def get_nodes_from_inp(bulk_str, parent: FEM) -> Nodes:
+    """Extract node information from abaqus input file string"""
     re_no = re.compile(
         r"^\*Node\s*(?:,\s*nset=(?P<nset>.*?)\n|\n)(?P<members>(?:.*?)(?=\*|\Z))",
         _re_in,
@@ -461,10 +443,7 @@ def getnodes(m):
 
     nodes = list(chain.from_iterable(map(getnodes, re_no.finditer(bulk_str))))
 
-    return Nodes(
-        nodes,
-        parent=parent,
-    )
+    return Nodes(nodes, parent=parent)
 
 
 def get_elem_from_inp(bulk_str, fem: FEM) -> FemElements:

src/ada/fem/io/abaqus/templates.py

@@ -51,4 +51,4 @@
 ** -------------------------------------------------------
 {step_str}"""
 
-__all__ = ["main_inp_str"]
+__all__ = ["main_inp_str"]

src/ada/fem/io/abaqus/writer.py

@@ -6,11 +6,9 @@
 
 import numpy as np
 
-from ada.concepts.levels import FEM, Part
+from ada.concepts.levels import FEM, Assembly, Part
 from ada.core.utils import NewLine, bool2text
-from ada.fem import FemSet, Load, Step, Surface
-from ada.fem.common import Amplitude
-from ada.fem.elements import Connector
+from ada.fem import Amplitude, Connector, FemSet, Load, Step, Surface
 from ada.materials import Material
 from ada.sections import SectionCat
 
@@ -31,14 +29,7 @@
 ]
 
 
-def to_fem(assembly, name, analysis_dir=None, metadata=None):
-    """
-
-    :param assembly:
-    :param name:
-    :param analysis_dir:
-    :param metadata:
-    """
+def to_fem(assembly: Assembly, name, analysis_dir=None, metadata=None):
     if metadata is None:
         metadata = dict()
 
@@ -54,11 +45,6 @@ def to_fem(assembly, name, analysis_dir=None, metadata=None):
 
 
 class AbaqusWriter:
-    """
-
-    :type assembly: ada.Assembly
-    """
-
     _subr_path = None
     _subroutine = None
     _imperfections = str()
@@ -68,7 +54,7 @@ class AbaqusWriter:
     analysis_path = None
     parts_and_assemblies = True
 
-    def __init__(self, assembly):
+    def __init__(self, assembly: Assembly):
         self.assembly = assembly
 
     def write(self, name, analysis_dir, metadata=None):
@@ -170,24 +156,14 @@ def eval_interactions(self):
                 d.write(self.interact_str)
                 d.write("\n")
 
-    def write_step(self, step_in):
-        """
-
-        :param step_in:
-        :type step_in: Step
-        """
+    def write_step(self, step_in: Step):
         step_str = AbaStep(step_in).str
         with open(self.analysis_path / "core_input_files" / f"step_{step_in.name}.inp", "w") as d:
             d.write(step_str)
             if "*End Step" not in step_str:
                 d.write("*End Step\n")
 
-    def write_part_bulk(self, part_in):
-        """
-
-        :param part_in:
-        :type part_in: Part
-        """
+    def write_part_bulk(self, part_in: Part):
         bulk_path = self.analysis_path / f"bulk_{part_in.name}"
         bulk_file = bulk_path / "aba_bulk.inp"
         os.makedirs(bulk_path, exist_ok=True)
@@ -200,18 +176,6 @@ def write_part_bulk(self, part_in):
             with open(bulk_file, "w") as d:
                 d.write(fempart.bulk_str)
 
-    @staticmethod
-    def part_inp_str(part):
-        """
-
-        :param part:
-        :type part: Part
-        :return: str
-        """
-        return """**\n*Part, name={name}\n*INCLUDE,INPUT=bulk_{name}\\{inp_file}\n*End Part\n**""".format(
-            name=part.name, inp_file="aba_bulk.inp"
-        )
-
     def inst_inp_str(self, part: Part):
         """
 
@@ -239,16 +203,6 @@ def inst_inp_str(self, part: Part):
         else:
             return f"""**\n*Instance, name={part.fem.instance_name}, part={part.name}\n*End Instance"""
 
-    @staticmethod
-    def step_inp_str(step):
-        """
-
-        :param step:
-        :type step: Step
-        :return: str
-        """
-        return f"""*INCLUDE,INPUT=core_input_files\\step_{step.name}.inp"""
-
     @property
     def constraint_control(self):
         constraint_ctrl_on = True
@@ -274,10 +228,10 @@ def inst_skip(p):
                 return True
             return len(p.fem.elements) + len(p.fem.connectors) != 0
 
-        part_str = "\n".join(map(self.part_inp_str, filter(skip_if_this, self.assembly.get_all_subparts())))
+        part_str = "\n".join(map(part_inp_str, filter(skip_if_this, self.assembly.get_all_subparts())))
         instance_str = "\n".join(map(self.inst_inp_str, filter(inst_skip, self.assembly.get_all_subparts())))
         step_str = (
-            "\n".join(list(map(self.step_inp_str, self.assembly.fem.steps))).rstrip()
+            "\n".join(list(map(step_inp_str, self.assembly.fem.steps))).rstrip()
             if len(self.assembly.fem.steps) > 0
             else "** No Steps added"
         )
@@ -1005,6 +959,22 @@ def str(self):
             raise NotImplementedError(f"{self.constraint.type}")
 
 
+def step_inp_str(step: Step):
+    """
+
+    :param step:
+    :type step: Step
+    :return: str
+    """
+    return f"""*INCLUDE,INPUT=core_input_files\\step_{step.name}.inp"""
+
+
+def part_inp_str(part: Part):
+    return """**\n*Part, name={name}\n*INCLUDE,INPUT=bulk_{name}\\{inp_file}\n*End Part\n**""".format(
+        name=part.name, inp_file="aba_bulk.inp"
+    )
+
+
 def _tie(constraint):
     """