Merge pull request #668 from idaholab/material_clear

Implemented clear for material

Author: MicahGale

doc/source/changelog.rst

@@ -24,10 +24,10 @@ MontePy Changelog
 * Added function: :func:`~montepy.mcnp_problem.MCNP_Problem.parse` to parse arbitrary MCNP object (:issue:`88`).
 * An error is now raised when typos in object attributes are used, e.g., ``cell.nubmer`` (:issue:`508`).
 * Warnings are no longer raised for comments that exceed the maximum line lengths (:issue:`188`).
-* Particle type exceptions are now warnings, not errors (:issue:`381`). 
+* Particle type exceptions are now warnings, not errors (:issue:`381`).
+* Added :func:`~montepy.data_inputs.material.Material.clear` to ``Material`` to clear out all nuclides (:issue:`665`).
 * Allow any ``Real`` type for floating point numbers and any ``Integral`` type for integer numbers during type enforcement (:issue:`679`).
 
-
 **Bugs Fixed**
 
 * Made it so that a material created from scratch can be written to file (:issue:`512`).

montepy/cell.py

@@ -4,6 +4,7 @@
 import itertools
 from typing import Union
 from numbers import Integral, Real
+import warnings
 
 from montepy.cells import Cells
 from montepy.data_inputs import importance, fill, lattice_input, universe_input, volume
@@ -752,34 +753,40 @@ def cleanup_last_line(ret):
             return ret
 
         ret = ""
-        for key, node in self._tree.nodes.items():
-            if key != "parameters":
-                ret += node.format()
-            else:
-                printed_importance = False
-                final_param = next(reversed(node.nodes.values()))
-                for param in node.nodes.values():
-                    if param["classifier"].prefix.value.lower() in modifier_keywords:
-                        cls = modifier_keywords[
+        with warnings.catch_warnings(record=True) as ws:
+
+            for key, node in self._tree.nodes.items():
+                if key != "parameters":
+                    ret += node.format()
+                else:
+                    printed_importance = False
+                    final_param = next(reversed(node.nodes.values()))
+                    for param in node.nodes.values():
+                        if (
                             param["classifier"].prefix.value.lower()
-                        ]
-                        attr, _ = self._INPUTS_TO_PROPERTY[cls]
-                        if attr == "_importance":
-                            if printed_importance:
-                                continue
-                            printed_importance = True
-                        # add trailing space to comment if necessary
-                        ret = cleanup_last_line(ret)
-                        ret += "\n".join(
-                            getattr(self, attr).format_for_mcnp_input(
-                                mcnp_version, param is not final_param
+                            in modifier_keywords
+                        ):
+                            cls = modifier_keywords[
+                                param["classifier"].prefix.value.lower()
+                            ]
+                            attr, _ = self._INPUTS_TO_PROPERTY[cls]
+                            if attr == "_importance":
+                                if printed_importance:
+                                    continue
+                                printed_importance = True
+                            # add trailing space to comment if necessary
+                            ret = cleanup_last_line(ret)
+                            ret += "\n".join(
+                                getattr(self, attr).format_for_mcnp_input(
+                                    mcnp_version, param is not final_param
+                                )
                             )
-                        )
-                    else:
-                        # add trailing space to comment if necessary
-                        ret = cleanup_last_line(ret)
-                        ret += param.format()
-        # check for accidental empty lines from subsequent cell modifiers that didn't print
+                        else:
+                            # add trailing space to comment if necessary
+                            ret = cleanup_last_line(ret)
+                            ret += param.format()
+            # check for accidental empty lines from subsequent cell modifiers that didn't print
+        self._flush_line_expansion_warning(ret, ws)
         ret = "\n".join([l for l in ret.splitlines() if l.strip()])
         return self.wrap_string_for_mcnp(ret, mcnp_version, True)
 

montepy/data_inputs/material.py

@@ -68,7 +68,7 @@ def __setitem__(self, key, value):
         try:
             node = self._libraries[key]
         except KeyError:
-            node = self._generate_default_node(key)
+            node = self._generate_default_node(key, str(value))
             self._parent()._append_param_lib(node)
             self._libraries[key] = node
         node["data"].value = str(value)
@@ -79,7 +79,7 @@ def __delitem__(self, key):
         self._parent()._delete_param_lib(node)
 
     def __str__(self):
-        return str(self._libraries)
+        return "\n".join([f"{key} = {value}" for key, value in self.items()])
 
     def __iter__(self):
         return iter(self._libraries)
@@ -97,13 +97,13 @@ def _validate_key(key):
         return key
 
     @staticmethod
-    def _generate_default_node(key: LibraryType):
+    def _generate_default_node(key: LibraryType, val: str):
         classifier = syntax_node.ClassifierNode()
         classifier.prefix = key.value
         ret = {
             "classifier": classifier,
             "seperator": syntax_node.PaddingNode(" = "),
-            "data": syntax_node.ValueNode("", str),
+            "data": syntax_node.ValueNode(val, str),
         }
         return syntax_node.SyntaxNode("mat library", ret)
 
@@ -279,13 +279,12 @@ class Material(data_input.DataInputAbstract, Numbered_MCNP_Object):
     ----------
     input : Union[Input, str]
         The Input syntax object this will wrap and parse.
-    parser : MCNP_Parser
-        The parser object to parse the input with.
     number : int
         The number to set for this object.
     """
 
     _parser = MaterialParser()
+    _NEW_LINE_STR = "\n" + " " * DEFAULT_INDENT
 
     def __init__(
         self,
@@ -367,6 +366,7 @@ def _append_param_lib(self, node: syntax_node.SyntaxNode):
 
         This is called from _DefaultLibraries.
         """
+        self._ensure_has_ending_padding()
         self._tree["data"].append_param(node)
 
     def _delete_param_lib(self, node: syntax_node.SyntaxNode):
@@ -535,9 +535,9 @@ def __setitem__(self, idx, newvalue):
             raise TypeError(f"Not a valid index. {idx} given.")
         old_vals = self._components[idx]
         self._check_valid_comp(newvalue)
+        node_idx = self._tree["data"].nodes.index((old_vals[0]._tree, old_vals[1]), idx)
         # grab fraction
         old_vals[1].value = newvalue[1]
-        node_idx = self._tree["data"].nodes.index((old_vals[0]._tree, old_vals[1]), idx)
         self._tree["data"].nodes[node_idx] = (newvalue[0]._tree, old_vals[1])
         self._components[idx] = (newvalue[0], old_vals[1])
 
@@ -646,16 +646,41 @@ def append(self, nuclide_frac_pair: tuple[Nuclide, float]):
         self._check_valid_comp(nuclide_frac_pair)
         self._elements.add(nuclide_frac_pair[0].element)
         self._nuclei.add(nuclide_frac_pair[0].nucleus)
+        # node for fraction
         node = self._generate_default_node(
-            float, str(nuclide_frac_pair[1]), "\n" + " " * DEFAULT_INDENT
+            float, str(nuclide_frac_pair[1]), self._NEW_LINE_STR
         )
         syntax_node.ValueNode(str(nuclide_frac_pair[1]), float)
         node.is_negatable_float = True
         nuclide_frac_pair = (nuclide_frac_pair[0], node)
         node.is_negative = not self._is_atom_fraction
         self._components.append(nuclide_frac_pair)
+        self._ensure_has_ending_padding()
         self._tree["data"].append_nuclide(("_", nuclide_frac_pair[0]._tree, node))
 
+    def _ensure_has_ending_padding(self):
+        def get_last_val_node():
+            last_vals = self._tree["data"].nodes[-1][-1]
+            if isinstance(last_vals, syntax_node.ValueNode):
+                return last_vals
+            return last_vals["data"]
+
+        if len(self._tree["data"]) == 0:
+            return
+        padding = get_last_val_node().padding
+
+        def add_new_line_padding():
+            if padding is None:
+                get_last_val_node().padding = syntax_node.PaddingNode(
+                    self._NEW_LINE_STR
+                )
+            else:
+                padding.append(self._NEW_LINE_STR)
+
+        if padding:
+            padding.check_for_graveyard_comments(True)
+        add_new_line_padding()
+
     def change_libraries(self, new_library: Union[str, Library]):
         """Change the library for all nuclides in the material.
 
@@ -906,6 +931,14 @@ def _contains_arb(
             )
         )
 
+    def clear(self):
+        """Clears all nuclide components from this material.
+
+        .. versionadded:: 1.0.0
+        """
+        for _ in range(len(self)):
+            del self[0]
+
     def normalize(self):
         """Normalizes the components fractions so that they sum to 1.0.
 

montepy/errors.py

@@ -200,9 +200,7 @@ def __init__(self, message):
 class LineExpansionWarning(Warning):
     """Warning for when a field or line expands that may damage user formatting."""
 
-    def __init__(self, message):
-        self.message = message
-        super().__init__(self.message)
+    pass
 
 
 def add_line_number_to_exception(error, broken_robot):

montepy/input_parser/input_syntax_reader.py

@@ -15,7 +15,7 @@
 from montepy.utilities import is_comment
 
 
-reading_queue = []
+reading_queue = deque()
 
 
 def read_input_syntax(input_file, mcnp_version=DEFAULT_VERSION, replace=True):

montepy/input_parser/material_parser.py

@@ -46,10 +46,12 @@ def batch_gen():
                 yield batch
 
         for group in batch_gen():
+            if group[0].type != str:
+                group[0]._convert_to_str()
             new_list.append(("foo", *group))
         return new_list
 
-    @_("isotope_fraction", "number_sequence", "parameter", "mat_parameter")
+    @_("isotope_fraction", "even_number_sequence", "parameter", "mat_parameter")
     def mat_datum(self, p):
         return p[0]
 

montepy/input_parser/mcnp_input.py

@@ -32,6 +32,9 @@ def __str__(self):
     def __repr__(self):
         return f"Jump: {hex(id(self))}"
 
+    def __format__(self, spec):
+        return format(str(self), spec)
+
     def __bool__(self):
         raise TypeError("Jump doesn't have a truthiness or falsiness")
 

montepy/input_parser/parser_base.py

@@ -202,6 +202,28 @@ def number_sequence(self, p):
                 sequence.append(p[1])
         return sequence
 
+    @_(
+        "numerical_phrase numerical_phrase",
+        "shortcut_phrase",
+        "even_number_sequence numerical_phrase numerical_phrase",
+        "even_number_sequence shortcut_phrase",
+    )
+    def even_number_sequence(self, p):
+        """
+        A list of numbers with an even number of elements*.
+
+        * shortcuts will break this.
+        """
+        if not hasattr(p, "even_number_sequence"):
+            sequence = syntax_node.ListNode("number sequence")
+            sequence.append(p[0])
+        else:
+            sequence = p[0]
+        if len(p) > 1:
+            for idx in range(1, len(p)):
+                sequence.append(p[idx])
+        return sequence
+
     @_("number_phrase", "null_phrase")
     def numerical_phrase(self, p):
         """Any number, including 0, with its padding.

montepy/input_parser/syntax_node.py

@@ -1055,6 +1055,17 @@ def _convert_to_enum(
             self._value = enum_class(value)
         self._formatter = self._FORMATTERS[format_type].copy()
 
+    def _convert_to_str(self):
+        """Converts this ValueNode to being a string type.
+
+        .. versionadded:: 1.0.0
+
+        """
+        self._type = str
+        self._value = str(self._token)
+        self._og_value = self._token
+        self._formatter = self._FORMATTERS[str].copy()
+
     @property
     def is_negatable_identifier(self):
         """Whether or not this value is a negatable identifier.
@@ -1292,7 +1303,14 @@ def format(self):
                 )
         else:
             temp = str(value)
+        end_line_padding = False
         if self.padding:
+            for node in self.padding.nodes:
+                if node == "\n":
+                    end_line_padding = True
+                    break
+                if isinstance(node, CommentNode):
+                    break
             if self.padding.is_space(0):
                 # if there was and end space, and we ran out of space, and there isn't
                 # a saving space later on
@@ -1313,16 +1331,24 @@ def format(self):
         buffer = "{temp:<{value_length}}{padding}".format(
             temp=temp, padding=pad_str, **self._formatter
         )
-        if len(buffer) > self._formatter["value_length"] and self._token is not None:
-            warning = LineExpansionWarning(
-                f"The value has expanded, and may change formatting. The original value was {self._token}, new value is {temp}."
-            )
+        """
+        If:
+            1. expanded
+            2. had an original value
+            3. and value doesn't end in a new line (without a comment)
+        """
+        if (
+            len(buffer) > self._formatter["value_length"]
+            and self._token is not None
+            and not end_line_padding
+        ):
+            warning = LineExpansionWarning("")
             warning.cause = "value"
             warning.og_value = self._token
             warning.new_value = temp
             warnings.warn(
                 warning,
-                stacklevel=2,
+                category=LineExpansionWarning,
             )
         return buffer + extra_pad_str
 

montepy/mcnp_object.py

@@ -4,7 +4,6 @@
 import copy
 import functools
 import itertools as it
-import numpy as np
 import sys
 import textwrap
 from typing import Union
@@ -237,9 +236,36 @@ def format_for_mcnp_input(self, mcnp_version: tuple[int]) -> list[str]:
         self.validate()
         self._update_values()
         self._tree.check_for_graveyard_comments()
-        lines = self.wrap_string_for_mcnp(self._tree.format(), mcnp_version, True)
+        message = None
+        with warnings.catch_warnings(record=True) as ws:
+            lines = self.wrap_string_for_mcnp(self._tree.format(), mcnp_version, True)
+        self._flush_line_expansion_warning(lines, ws)
         return lines
 
+    def _flush_line_expansion_warning(self, lines, ws):
+        if not ws:
+            return
+        message = f"""The input had a value expand that may change formatting.
+The new input was:\n\n"""
+        for line in lines:
+            message += f"    {line}"
+        width = 15
+        message += f"\n\n    {'old value': ^{width}s} {'new value': ^{width}s}"
+        message += f"\n    {'':-^{width}s} {'':-^{width}s}\n"
+        olds = []
+        news = []
+        for w in ws:
+            warning = w.message
+            formatter = f"    {{w.og_value: >{width}}} {{w.new_value: >{width}}}\n"
+            message += formatter.format(w=warning)
+            olds.append(warning.og_value)
+            news.append(warning.new_value)
+        if message is not None:
+            warning = LineExpansionWarning(message)
+            warning.olds = olds
+            warning.news = news
+            warnings.warn(warning, stacklevel=4)
+
     @property
     def comments(self) -> list[PaddingNode]:
         """The comments associated with this input if any.