Release 0.4.0

.github/scripts/check_sitemap.py

@@ -0,0 +1,31 @@
+import xml.etree.ElementTree as ET
+import urllib.request
+
+NS = {"a": "http://www.sitemaps.org/schemas/sitemap/0.9"}
+TOLERANCE = 0.8
+
+
+def discover_urls():
+    tree = ET.parse("doc/build/html/sitemap.xml")
+    root = tree.getroot()
+    return [node.find("a:loc", NS).text for node in root.findall("a:url", NS)]
+
+
+def test_urls(urls):
+    passed = 0
+    for url in urls:
+        code = 404
+        try:
+            code = urllib.request.urlopen(url).getcode()
+        except urllib.error.HTTPError as e:
+            print(url, e)
+        if code == 200:
+            passed += 1
+        else:
+            print(url, code)
+    if passed / len(urls) < TOLERANCE:
+        raise ValueError(f"Too many URLs failed")
+
+
+if __name__ == "__main__":
+    test_urls(discover_urls())

.github/workflows/main.yml

@@ -101,13 +101,7 @@ jobs:
         with: 
           python-version: 3.12
       - run: pip install . montepy[doc,build]
-      - uses: mathieudutour/[email protected]
-        name: Get next version number
-        id: version_num
-        with: 
-          dry_run: True
-          github_token: ${{ secrets.GITHUB_TOKEN }}
-      - run: sphinx-build doc/source/ doc/build/ -W --keep-going -E
+      - run: sphinx-build doc/source/ doc/build/html -W --keep-going -E
         name: Build site strictly
       - uses: actions/upload-artifact@v4
         with:
@@ -121,6 +115,8 @@ jobs:
         run: |
              cd doc
              make linkcheck
+      - name: test sitemap
+        run: python .github/scripts/check_sitemap.py 
 
   format-test:
     runs-on: ubuntu-latest

README.md

@@ -8,7 +8,7 @@
 [![PyPI version](https://badge.fury.io/py/montepy.svg)](https://badge.fury.io/py/montepy)
 [![Project Status: Active – The project has reached a stable, usable state and is being actively developed.](https://www.repostatus.org/badges/latest/active.svg)](https://www.repostatus.org/#active)
 
-MontePy is a python library to read, edit, and write MCNP input files. 
+MontePy is the most user friendly Python library for reading, editing, and writing MCNP input files. 
 
 ## Installing
 
@@ -24,35 +24,56 @@ see the [Installing section in the user guide](https://www.montepy.org/starting.
 
 ## User Documentation
 
-MontePy has a [sphinx website](https://www.montepy.org/). 
-This has a getting started guide for users,
-as well as API documentation. 
-There is also a developer's guide covering the design and approach of MontePy, and how to contribute.
+MontePy has a website [documenting how to work with MCNP in python with MontePy](https://www.montepy.org/). 
+The website contains a user's guide for getting started, 
+a developer's guide covering the design and approach of MontePy,
+instructions for contributing, 
+and the Python API documentation.
 
 ## Features
 
-* Handles almost all MCNP input syntax including: message blocks, & continue, comments, etc.
-* Parses Cells, surfaces, materials, and transforms very well.	
-* Can parse the following surfaces exactly P(X|Y|Z), C(X|Y|Z), C/(X|Y|Z) (I mean it can do PX, and PY, etc.)
-* Can read in all other inputs but not understand them	
-* Can write out full MCNP problem even if it doesn't fully understand an input.	
-* Can write out the MCNP problem verbatim, and try to match the original user formatting. 
-* Can quickly access cells, surfaces, and materials by their numbers. For example: `cell = problem.cells[105]`.
-* Can quickly update cell importances. For example `cell.importance.neutron = 2.0`.
-* Has over 240 test cases right now 
+* Handles almost all MCNP input syntax.
+* Parses Cells, Surfaces, Materials, and Transforms very well.	
+* Can parse all surface types except macrobody facets ([Issue #354](https://github.com/idaholab/MontePy/issues/354)).
+* Can read and write out all other MCNP inputs, even if it doesn't not understand them	
+* Attempts to write out the MCNP problem verbatim, even matching the original user formatting. (See some of the [open issues](https://github.com/idaholab/MontePy/issues).)
+* Can quickly [access cells, surfaces, and materials by their numbers](https://www.montepy.org/starting.html#collections-are-accessible-by-number). For example: `cell = problem.cells[105]`.
+* Can quickly update cell parameters, [such as importances](https://www.montepy.org/starting.html#setting-cell-importances). For example `cell.importance.neutron = 2.0`.
+* Can easily [create universes, and fill other cells with universes](https://www.montepy.org/starting.html#universes).
+* Currently has over 430 test cases.
 
 
-Quick example for renumbering all of the cells in a problem:
+Here is a quick example showing multiple tasks in MontePy:
 
 ```python
 import montepy
-foo = montepy.read_input("foo.imcnp")
-i = 9500
-for cell in foo.cells:
-  cell.number = i
-  i = i + 5
+# read in file
+problem = montepy.read_input("foo.imcnp")
 
-foo.write_to_file("foo_update.imcnp")
+# set photon importance for multiple cells
+importances = {1: 0.005,
+    2: 0.1,
+    3: 1.0,
+    99: 1.235
+}
+for cell_num, importance in importances.items():
+    problem.cells[cell_num].importance.photon = importance
+
+#create a universe and fill another cell with it
+universe = montepy.Universe(123)
+problem.univeres.append(universe)
+# add all cells with numbers between 1 and 4
+universe.claim(problem.cells[1:5])
+# fill cell 99 with universe 123
+problem.cells[99].fill.universe = universe
+
+# update all surfaces numbers by adding 1000 to them
+for surface in problem.surfaces:
+    surface.number += 1000
+# all cells using these surfaces will be automatically updated as well
+
+#write out an updated file
+problem.write_problem("foo_update.imcnp")
 
 ```
 
@@ -62,16 +83,16 @@ Here a few of the known bugs and limitations:
 
 
 * Cannot handle vertical input mode.
-* Does not support tallies in an easy way.
-* Does not support source definition in an easy way.
+* Does not support editing tallies in a user-friendly way.
+* Does not support editing source definition in a user-friendly way.
 
 ## Bugs, Requests and Development
 
-So MontePy doesn't do what you want? Right now development is done with a  Just-In-Time development approach, as in features are added JIT for a developer to use them on my current projects. 
-If there's a feature you want add an issue here with the feature request tag. 
-If you want to add a feature on your own talk to Micah Gale (but still add the issue). 
+So MontePy doesn't do what you want? 
+Add an issue here with the "feature request" tag. 
 The system is very modular and you should be able to develop it pretty quickly.
-Also read the [developer's guide](https://www.montepy.org/developing.html).
+Read the [developer's guide](https://www.montepy.org/developing.html) for more details.
+If you have any questions feel free to ask [@micahgale](mailto:[email protected]).
 
 
-# Finally: make objects not regexes!
+# Finally: make objects, not regexes!

doc/source/changelog.rst

@@ -1,6 +1,21 @@
 MontePy Changelog
 =================
 
+0.4.0
+--------------
+
+**Features Added**
+
+* Write problems to either file paths or streams (file handles) with MCNP_Problem.write_problem() (:issue:`492`).
+* When adding a material to problem.materials it will also be added to problem.data_inputs, ensuring it is printed to the file (:pull:`488`).
+
+**Bug Fixes**
+
+* Fixed bug that didn't show metastable states for pretty printing and isotope. Also handled the case that Am-241 metstable states break convention (:issue:`486`).
+* Fixed bug where cell modifiers could be made irrelevant by being added after a comment (:issue:`483`).
+* Fixed bug where parentheses in cell geometry are not properly exported (:pull:`491`).
+
+
 0.3.3
 --------------
 

doc/source/conf.py

@@ -45,6 +45,7 @@
 html_logo = "monty.svg"
 
 html_baseurl = "https://www.montepy.org/"
+sitemap_url_scheme = "{link}"
 html_extra_path = ["robots.txt"]
 # List of patterns, relative to source directory, that match files and
 # directories to ignore when looking for source files.

doc/source/developing.rst

@@ -347,8 +347,8 @@ SURFACE: 1005, RCC
 
 Writing to File (Format for MCNP Input)
 """""""""""""""""""""""""""""""""""""""
-MontePy (via :func:`~montepy.mcnp_problem.MCNP_Problem.write_to_file`) writes
-a class to file by calling its :func:`~montepy.mcnp_object.MCNP_Object.format_for_mcnp_input` method.
+MontePy (via :func:`~montepy.mcnp_problem.MCNP_Problem.write_problem`) writes
+a class to file path or file handle  by calling its :func:`~montepy.mcnp_object.MCNP_Object.format_for_mcnp_input` method.
 This must return a list of strings that faithfully represent this objects state, and tries to replicate the user formatting.
 Each string in the list represents one line in the MCNP input file to be written.
 
@@ -397,6 +397,12 @@ For example the init function for ``Cells``
         def __init__(self, cells=None):
             super().__init__(montepy.Cell, cells)
 
+Collection: :class:`~montepy.numbered_object_collection.NumberedDataObjectCollection`
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+This is a subclass of :class:`~montepy.numbered_object_collection.NumberedObjectCollection`,
+which is designed for :class:`~montepy.data_inputs.data_input.DataInputAbstract` instances.
+It is a wrapper that will ensure that all of its items are also in :func:`~montepy.mcnp_problem.MCNP_Problem.data_inputs`.
+
 
 Numbered Object :class:`~montepy.numbered_mcnp_object.Numbered_MCNP_Object`
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

doc/source/starting.rst

@@ -81,12 +81,13 @@ It will read the specified MCNP input file, and return an MontePy :class:`~monte
 Writing a File
 --------------
 
-The :class:`~montepy.mcnp_problem.MCNP_Problem` object has the method :func:`~montepy.mcnp_problem.MCNP_Problem.write_to_file`, which writes the problem's current 
+The :class:`~montepy.mcnp_problem.MCNP_Problem` object has
+the method :func:`~montepy.mcnp_problem.MCNP_Problem.write_problem`, which writes the problem's current
 state as a valid MCNP input file.
 
->>> problem.write_to_file("bar.imcnp")
+>>> problem.write_problem("bar.imcnp")
 
-The :func:`~montepy.mcnp_problem.MCNP_Problem.write_to_file` method does take an optional argument: ``overwrite``. 
+The :func:`~montepy.mcnp_problem.MCNP_Problem.write_problem` method does take an optional argument: ``overwrite``.
 By default if the file exists, it will not be overwritten and an error will be raised.
 This can be changed by ``overwrite=True``.
 
@@ -97,8 +98,15 @@ This can be changed by ``overwrite=True``.
    Instead of constantly having to override the same file you can add a timestamp to the output file,
    or create an always unique file name with the `UUID <https://docs.python.org/3/library/uuid.html>`_ library.
 
+The method :func:`~montepy.mcnp_problem.MCNP_Problem.write_problem`
+also accepts an open file handle, stream, or other object with a ``write()`` method.
 
-If no changes are made to the problem in MontePy the entire file will be just parroted out as it was in the original file.
+>>> with open("/path/to/file", "w") as fh:
+...     problem.write_problem(fh)
+
+
+If no changes are made to the problem in MontePy, the entire file should just be parroted out as it was in the original file
+(see Issues :issue:`397` and :issue:`492`).
 However any objects (e.g., two cells) that were changed (i.e., mutated) may have their formatting changed slightly.
 MontePy will do its best to guess the formatting of the original value and to replicate it with the new value. 
 However, this may not always be possible, especially if more digits are needed to keep information (e.g., ``10`` versus ``1000``).
@@ -127,7 +135,7 @@ We can then open this file in MontePy, and then modify it slightly, and save it
         problem = montepy.read_input("foo.imcnp")
         problem.cells[1].number = 5
         problem.surfaces[1].number = 1000
-        problem.write_to_file("bar.imcnp")
+        problem.write_problem("bar.imcnp")
 
 This new file we can see is now reformatted according to MontePy's preferences for formatting::
 

montepy/__init__.py

@@ -21,6 +21,7 @@
 from montepy.particle import Particle
 from montepy.surfaces.surface_type import SurfaceType
 from montepy.universe import Universe
+import montepy.errors
 import sys
 
 

montepy/cell.py

@@ -675,6 +675,7 @@ def format_for_mcnp_input(self, mcnp_version):
         """
         self.validate()
         self._update_values()
+        self._tree.check_for_graveyard_comments()
         modifier_keywords = {
             cls._class_prefix(): cls for cls in self._INPUTS_TO_PROPERTY.keys()
         }
@@ -694,6 +695,7 @@ def cleanup_last_line(ret):
                 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[
@@ -707,10 +709,14 @@ def cleanup_last_line(ret):
                         # add trailing space to comment if necessary
                         ret = cleanup_last_line(ret)
                         ret += "\n".join(
-                            getattr(self, attr).format_for_mcnp_input(mcnp_version)
+                            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
+        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/cell_modifier.py

@@ -230,7 +230,7 @@ def _format_tree(self):
         """
         return self._tree.format()
 
-    def format_for_mcnp_input(self, mcnp_version):
+    def format_for_mcnp_input(self, mcnp_version, has_following=False):
         """
         Creates a string representation of this MCNP_Object that can be
         written to file.
@@ -241,6 +241,7 @@ def format_for_mcnp_input(self, mcnp_version):
         :rtype: list
         """
         self.validate()
+        self._tree.check_for_graveyard_comments(has_following)
         if not self._problem:
             print_in_data_block = not self.in_cell_block
         else:

montepy/data_inputs/isotope.py

@@ -14,6 +14,10 @@ class Isotope:
 
     #                   Cl-52      Br-101     Xe-150      Os-203    Cm-251     Og-296
     _BOUNDING_CURVE = [(17, 52), (35, 101), (54, 150), (76, 203), (96, 251), (118, 296)]
+    _STUPID_MAP = {
+        "95642": {"_is_metastable": False, "_meta_state": None},
+        "95242": {"_is_metastable": True, "_meta_state": 1},
+    }
     """
     Points on bounding curve for determining if "valid" isotope
     """
@@ -38,6 +42,14 @@ def __init__(self, ZAID="", node=None):
             self._library = ""
         if node is None:
             self._tree = ValueNode(self.mcnp_str(), str, PaddingNode(" "))
+        self._handle_stupid_legacy_stupidity()
+
+    def _handle_stupid_legacy_stupidity(self):
+        # TODO work on this for mat_redesign
+        if self.ZAID in self._STUPID_MAP:
+            stupid_overwrite = self._STUPID_MAP[self.ZAID]
+            for key, value in stupid_overwrite.items():
+                setattr(self, key, value)
 
     def __parse_zaid(self):
         """
@@ -183,8 +195,9 @@ def mcnp_str(self):
         return f"{self.ZAID}.{self.library}" if self.library else self.ZAID
 
     def nuclide_str(self):
+        meta_suffix = f"m{self.meta_state}" if self.is_metastable else ""
         suffix = f".{self._library}" if self._library else ""
-        return f"{self.element.symbol}-{self.A}{suffix}"
+        return f"{self.element.symbol}-{self.A}{meta_suffix}{suffix}"
 
     def get_base_zaid(self):
         """
@@ -198,8 +211,9 @@ def get_base_zaid(self):
         return self.Z * 1000 + self.A
 
     def __str__(self):
+        meta_suffix = f"m{self.meta_state}" if self.is_metastable else ""
         suffix = f" ({self._library})" if self._library else ""
-        return f"{self.element.symbol:>2}-{self.A:<3}{suffix}"
+        return f"{self.element.symbol:>2}-{self.A:<3}{meta_suffix:<2}{suffix}"
 
     def __hash__(self):
         return hash(self._ZAID)

montepy/geometry_operators.py

@@ -23,5 +23,9 @@ class Operator(Enum):
     """
     Internal operator essentially equivalent to No-op.
 
-    This is used to properly handle parentheses while parsing.
+    This is used to properly handle some leaf nodes.
+    """
+    GROUP = "()"
+    """
+    Grouping operator that represents parentheses.
     """

montepy/input_parser/cell_parser.py

@@ -138,7 +138,10 @@ def geometry_term(self, p):
             else:
                 ret.padding = p.padding
         else:
-            ret.nodes["end_pad"] = p.padding
+            if "end_pad" in ret.nodes:
+                ret.nodes["end_pad"] += p.padding
+            else:
+                ret.nodes["end_pad"] = p.padding
         return ret
 
     @_("geometry_factor")
@@ -176,7 +179,7 @@ def geometry_factory(self, p):
         if hasattr(p, "padding"):
             for node in p.padding.nodes:
                 nodes["start_pad"].append(node)
-        return syntax_node.GeometryTree("geom parens", nodes, ">", p.geometry_expr)
+        return syntax_node.GeometryTree("geom parens", nodes, "()", p.geometry_expr)
 
     # support for fill card weirdness
     @_(