5859565159

pending completion

Build # 5859565159

Build Type

Pull #575

github-actions

Committed by

nllong

Commit Message

Merge remote-tracking branch 'origin/promote-teaser-loads-to-param' into add-modelica-project-parser

Pull Request Pull Request #575: Add new `ModelicaProject` class

Run Details

988 of 1176 branches covered (84.01%)

Branch coverage included in aggregate %.

170 of 170 new or added lines in 11 files covered. (100.0%)

2664 of 2950 relevant lines covered (90.31%)

1.81 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.45

/geojson_modelica_translator/modelica/package_parser.py

# :copyright (c) URBANopt, Alliance for Sustainable Energy, LLC, and other contributors.
# See also https://github.com/urbanopt/geojson-modelica-translator/blob/develop/LICENSE.md

import copy
import os
import re
from pathlib import Path
from typing import Any, List, Optional, Union

from jinja2 import Environment, FileSystemLoader

from geojson_modelica_translator.jinja_filters import ALL_CUSTOM_FILTERS


class PackageParser(object):
    """Class to read and modify the package.mo and the package.order file
    """

    def __init__(self, path: Union[str, Path] = None):
        """Create an instance to manage the package.mo/order file. If no path is provided then the user
        must add in their own package and order data. Or the user can load from the new_from_template
        class method.

        Args:
            path (Union[str, Path], optional): path to where the package.mo and package.order reside.
                                               Defaults to None.
        """
        self.path: Union[str, Path, None] = path
        self.order_data: Any = None
        self.package_data: Any = None
        self.package_name: Union[str, None] = None
        self.within: Union[list, None] = None

        self.load()

        # read in the path if it was given and pull out the package name
        if self.path is not None:
            self.path = Path(self.path)
            # The package name is also the name of the directory
            self.package_name = self.path.name

        self.template_env = Environment(
            loader=FileSystemLoader(
                searchpath=os.path.join(
                    os.path.dirname(os.path.abspath(__file__)), "templates"
                )
            )
        )
        self.template_env.filters.update(ALL_CUSTOM_FILTERS)

    def parse_within_statement(self) -> Optional[List[str]]:
        """Read in the package_data and parse out the within statement. The result will
        be returns, but will also set the within attribute.
        """
        # use a regex to pull out the string between within and ;
        if self.package_data is None:
            self.within = None
            return None

        matches = re.findall(r'within\s(.*?);', self.package_data)
        # it is possible that there is no "within" block in the root package file.
        if len(matches) == 0 or matches is None:
            self.within = None
        elif len(matches) == 1:
            self.within = matches[0].split(".")
        else:
            raise ValueError("There are more than on within statements in the package.mo file")

        return self.within

    def exists(self):
        return self.path.exists()

    @classmethod
    def new_from_template(cls, path: Union[str, Path], name: str, order: list[str], within: Union[str, None] = None) -> "PackageParser":
        """Create new package data based on the package.mo template. If within is not specified, then it is
        assumed that this is a top level package and will load from the package_base template.

        Args:
            path (str): the path where the resulting package file and order will be saved to.
            name (str): the name of the model
            order (list[str]): ordered list of which models will be loaded (saved to package.order)
            within (str, optional): name where this package is within.. Defaults to None.

        Returns:
            PackageParser: object of the package parser
        """
        klass = PackageParser(path)
        if within:
            template = klass.template_env.get_template("package.mot")
        else:
            template = klass.template_env.get_template("package_base.mot")

        klass.package_data = template.render(within=within, name=name, order=order)
        klass.order_data = "\n".join(order)
        klass.package_name = name
        klass.parse_within_statement()
        return klass

    def load(self) -> None:
        """Load the package.mo and package.mo data from the member variable path
        """
        filename = os.path.join(str(self.path), "package.mo")
        if os.path.exists(filename):
            with open(filename, "r") as f:
                self.package_data = f.read()

        filename = os.path.join(str(self.path), "package.order")
        if os.path.exists(filename):
            with open(filename, "r") as f:
                self.order_data = f.read()

        self.parse_within_statement()

    def save(self) -> None:
        """Save the updated files to the same location
        """
        with open(os.path.join(os.path.join(str(self.path), "package.mo")), "w") as f:
            f.write(self.package_data)

        with open(os.path.join(os.path.join(str(self.path), "package.order")), "w") as f:
            f.write(self.order_data)
            f.write("\n")

    def save_as(self, new_path: Union[str, Path]) -> None:
        """Save the package.mo and package.order file to the new path. Be
        careful just running this method without also updating all the related
        <model>.mo and package.mo files with the new within statement. Look at the
        ModelicaProject class for more support.

        Args:
            new_path (Union[str, Path]): Fully qualified path to save files to.
        """
        new_path = Path(new_path)
        with open(new_path / "package.mo", "w") as f:
            f.write(self.package_data)

        with open(new_path / "package.order", "w") as f:
            f.write(self.order_data)
            f.write("\n")

    @property
    def order(self) -> list[str]:
        """Return the order of the packages from the package.order file

        Returns:
            list[str]: list of the loaded models in the package.order file
        """
        data = self.order_data.split("\n")
        if "" in data:
            data.remove("")
        return data

    def rename_package(self, new_model: str):
        """Rename the model name in the package.mo file.

        Args:
            new_model (str): new name
        """
        if self.package_name is None:
            raise ValueError("Package name is not set, verify that it was parsed correctly in the source code")

        self.package_data = self.package_data.replace(self.package_name, new_model)
        self.package_name = new_model

    def rename_model(self, previous_model: str, new_model: str):
        """Rename the model name in the package.order file.

        Args:
            new_model (str): new name
        """
        self.order_data = self.order_data.replace(previous_model, new_model)

    def update_within_statement(self, new_within: str, element_index: Union[int, None] = None):
        """Update the within statement in the package.mo file

        Args:
            new_within (str): Full string of the new within statement, e.g., a.b.c.d
            element_index (int): index of the element to replace, None is the entire string
        """
        # new within
        new_within_list = copy.deepcopy(self.within)
        if element_index is not None:
            new_within_list[element_index] = new_within  # type: ignore
        else:
            new_within_list = new_within.split(".")

        self.package_data = self.package_data.replace(f"within {'.'.join(self.within)};", f"within {'.'.join(new_within_list)};")  # type: ignore
        self.within = new_within_list

    def add_model(self, new_model_name: str, insert_at: int = -1) -> None:
        """Insert a new model into the package. Note that the order_data is stored as a string right now,
        so there is a bit of a hack to get this to work correctly.

        Args:
            new_model_name (str): name of the new model to add to the package order.
            insert_at (int, optional):  location to insert package, if 0 at beginning, -1 at end. Defaults to -1.
        """
        data = self.order_data.split("\n")
        if insert_at == -1:
            data.append(new_model_name)
        else:
            data.insert(insert_at, new_model_name)
        self.order_data = "\n".join(data)

        # remove any empty lines
        self.order_data = self.order_data.replace('\n\n', '\n')

1	# :copyright (c) URBANopt, Alliance for Sustainable Energy, LLC, and other contributors.
2	# See also https://github.com/urbanopt/geojson-modelica-translator/blob/develop/LICENSE.md
3
4	import copy	2✔
5	import os	2✔
6	import re	2✔
7	from pathlib import Path	2✔
8	from typing import Any, List, Optional, Union	2✔
9
10	from jinja2 import Environment, FileSystemLoader	2✔
11
12	from geojson_modelica_translator.jinja_filters import ALL_CUSTOM_FILTERS	2✔
13
14
15	class PackageParser(object):	2✔
16	"""Class to read and modify the package.mo and the package.order file
17	"""
18
19	def __init__(self, path: Union[str, Path] = None):	2✔
20	"""Create an instance to manage the package.mo/order file. If no path is provided then the user
21	must add in their own package and order data. Or the user can load from the new_from_template
22	class method.
23
24	Args:
25	path (Union[str, Path], optional): path to where the package.mo and package.order reside.
26	Defaults to None.
27	"""
28	self.path: Union[str, Path, None] = path	2✔
29	self.order_data: Any = None	2✔
30	self.package_data: Any = None	2✔
31	self.package_name: Union[str, None] = None	2✔
32	self.within: Union[list, None] = None	2✔
33
34	self.load()	2✔
35
36	# read in the path if it was given and pull out the package name
37	if self.path is not None:	2!
38	self.path = Path(self.path)	2✔
39	# The package name is also the name of the directory
40	self.package_name = self.path.name	2✔
41
42	self.template_env = Environment(	2✔
43	loader=FileSystemLoader(
44	searchpath=os.path.join(
45	os.path.dirname(os.path.abspath(__file__)), "templates"
46	)
47	)
48	)
49	self.template_env.filters.update(ALL_CUSTOM_FILTERS)	2✔
50
51	def parse_within_statement(self) -> Optional[List[str]]:	2✔
52	"""Read in the package_data and parse out the within statement. The result will
53	be returns, but will also set the within attribute.
54	"""
55	# use a regex to pull out the string between within and ;
56	if self.package_data is None:	2✔
57	self.within = None	2✔
58	return None	2✔
59
60	matches = re.findall(r'within\s(.*?);', self.package_data)	2✔
61	# it is possible that there is no "within" block in the root package file.
62	if len(matches) == 0 or matches is None:	2✔
63	self.within = None	2✔
64	elif len(matches) == 1:	2!
65	self.within = matches[0].split(".")	2✔
66	else:
67	raise ValueError("There are more than on within statements in the package.mo file")	×
68
69	return self.within	2✔
70
71	def exists(self):	2✔
72	return self.path.exists()	×
73
74	@classmethod	2✔
75	def new_from_template(cls, path: Union[str, Path], name: str, order: list[str], within: Union[str, None] = None) -> "PackageParser":	2✔
76	"""Create new package data based on the package.mo template. If within is not specified, then it is
77	assumed that this is a top level package and will load from the package_base template.
78
79	Args:
80	path (str): the path where the resulting package file and order will be saved to.
81	name (str): the name of the model
82	order (list[str]): ordered list of which models will be loaded (saved to package.order)
83	within (str, optional): name where this package is within.. Defaults to None.
84
85	Returns:
86	PackageParser: object of the package parser
87	"""
88	klass = PackageParser(path)	2✔
89	if within:	2✔
90	template = klass.template_env.get_template("package.mot")	2✔
91	else:
92	template = klass.template_env.get_template("package_base.mot")	2✔
93
94	klass.package_data = template.render(within=within, name=name, order=order)	2✔
95	klass.order_data = "\n".join(order)	2✔
96	klass.package_name = name	2✔
97	klass.parse_within_statement()	2✔
98	return klass	2✔
99
100	def load(self) -> None:	2✔
101	"""Load the package.mo and package.mo data from the member variable path
102	"""
103	filename = os.path.join(str(self.path), "package.mo")	2✔
104	if os.path.exists(filename):	2✔
105	with open(filename, "r") as f:	2✔
106	self.package_data = f.read()	2✔
107
108	filename = os.path.join(str(self.path), "package.order")	2✔
109	if os.path.exists(filename):	2✔
110	with open(filename, "r") as f:	2✔
111	self.order_data = f.read()	2✔
112
113	self.parse_within_statement()	2✔
114
115	def save(self) -> None:	2✔
116	"""Save the updated files to the same location
117	"""
118	with open(os.path.join(os.path.join(str(self.path), "package.mo")), "w") as f:	2✔
119	f.write(self.package_data)	2✔
120
121	with open(os.path.join(os.path.join(str(self.path), "package.order")), "w") as f:	2✔
122	f.write(self.order_data)	2✔
123	f.write("\n")	2✔
124
125	def save_as(self, new_path: Union[str, Path]) -> None:	2✔
126	"""Save the package.mo and package.order file to the new path. Be
127	careful just running this method without also updating all the related
128	<model>.mo and package.mo files with the new within statement. Look at the
129	ModelicaProject class for more support.
130
131	Args:
132	new_path (Union[str, Path]): Fully qualified path to save files to.
133	"""
134	new_path = Path(new_path)	2✔
135	with open(new_path / "package.mo", "w") as f:	2✔
136	f.write(self.package_data)	2✔
137
138	with open(new_path / "package.order", "w") as f:	2✔
139	f.write(self.order_data)	2✔
140	f.write("\n")	2✔
141
142	@property	2✔
143	def order(self) -> list[str]:	2✔
144	"""Return the order of the packages from the package.order file
145
146	Returns:
147	list[str]: list of the loaded models in the package.order file
148	"""
149	data = self.order_data.split("\n")	2✔
150	if "" in data:	2✔
151	data.remove("")	2✔
152	return data	2✔
153
154	def rename_package(self, new_model: str):	2✔
155	"""Rename the model name in the package.mo file.
156
157	Args:
158	new_model (str): new name
159	"""
160	if self.package_name is None:	2!
161	raise ValueError("Package name is not set, verify that it was parsed correctly in the source code")	×
162
163	self.package_data = self.package_data.replace(self.package_name, new_model)	2✔
164	self.package_name = new_model	2✔
165
166	def rename_model(self, previous_model: str, new_model: str):	2✔
167	"""Rename the model name in the package.order file.
168
169	Args:
170	new_model (str): new name
171	"""
172	self.order_data = self.order_data.replace(previous_model, new_model)	2✔
173
174	def update_within_statement(self, new_within: str, element_index: Union[int, None] = None):	2✔
175	"""Update the within statement in the package.mo file
176
177	Args:
178	new_within (str): Full string of the new within statement, e.g., a.b.c.d
179	element_index (int): index of the element to replace, None is the entire string
180	"""
181	# new within
182	new_within_list = copy.deepcopy(self.within)	2✔
183	if element_index is not None:	2✔
184	new_within_list[element_index] = new_within # type: ignore	2✔
185	else:
186	new_within_list = new_within.split(".")	2✔
187
188	self.package_data = self.package_data.replace(f"within {'.'.join(self.within)};", f"within {'.'.join(new_within_list)};") # type: ignore	2✔
189	self.within = new_within_list	2✔
190
191	def add_model(self, new_model_name: str, insert_at: int = -1) -> None:	2✔
192	"""Insert a new model into the package. Note that the order_data is stored as a string right now,
193	so there is a bit of a hack to get this to work correctly.
194
195	Args:
196	new_model_name (str): name of the new model to add to the package order.
197	insert_at (int, optional): location to insert package, if 0 at beginning, -1 at end. Defaults to -1.
198	"""
199	data = self.order_data.split("\n")	2✔
200	if insert_at == -1:	2✔
201	data.append(new_model_name)	2✔
202	else:
203	data.insert(insert_at, new_model_name)	2✔
204	self.order_data = "\n".join(data)	2✔
205
206	# remove any empty lines
207	self.order_data = self.order_data.replace('\n\n', '\n')	2✔

urbanopt / geojson-modelica-translator / 5859565159

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous