8162728520

Committed 05 Mar 2024 06:14PM UTC coverage: 88.409% (-0.6%) from 88.963%

Build # 8162728520

Build Type

Pull #622

github

Committed by

vtnate

Commit Message

update tests to use new system type designation

Pull Request Pull Request #622: Enable more detail when specifying district types

Run Details

918 of 1104 branches covered (83.15%)

Branch coverage included in aggregate %.

29 of 35 new or added lines in 2 files covered. (82.86%)

190 existing lines in 21 files now uncovered.

2560 of 2830 relevant lines covered (90.46%)

1.81 hits per line

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

85.86

/geojson_modelica_translator/utils.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 logging
import os
import shutil
from pathlib import Path
from uuid import uuid4

_log = logging.getLogger(__name__)


def copytree(src, dst, symlinks=False, ignore=None):
    """
    Alternate version of copytree that will work if the directory already exists (use instead of shutil)
    """
    for item in os.listdir(src):
        s = os.path.join(src, item)
        d = os.path.join(dst, item)
        if os.path.isdir(s):
            shutil.copytree(s, d, symlinks, ignore)
        else:
            shutil.copy2(s, d)


def convert_c_to_k(c):
    """Converts a temperature in celsius to kelvin

    :param c: float, temperature in celsius
    :return: float, temperature in kelvin
    """
    return c + 273.15


def linecount(filename: Path) -> int:
    """Counts the number of lines in a file
    Probably not the most efficient way to do this, but it works
    """
    return len(open(filename).readlines())


def mbl_version():
    """
    Returns the version of the Modelica Buildings Library (MBL) used by the
    geojson-modelica-translator.
    """
    return "10.0.0"


class ModelicaPath(object):
    """
    Class for storing Modelica paths. This allows the path to point to
    the model directory, resources, and scripts directory.
    """

    def __init__(self, name, root_dir, overwrite=False):
        """
        Create a new modelica-based path with name of 'name'

        :param name: Name to create
        """
        self.name = name
        self.root_dir = root_dir
        self.overwrite = overwrite

        # create the directories
        if root_dir is not None:
            check_path = os.path.join(self.files_dir)
            self.clear_or_create_path(check_path)
            check_path = os.path.join(self.resources_dir)
            self.clear_or_create_path(check_path)
            check_path = os.path.join(self.scripts_dir)
            self.clear_or_create_path(check_path)

    def clear_or_create_path(self, path):
        if os.path.exists(path):
            if not self.overwrite:
                raise Exception("Directory already exists and overwrite is false for %s" % path)
            else:
                shutil.rmtree(path)
        os.makedirs(path, exist_ok=True)

    @property
    def files_dir(self):
        """
        Return the path to the files (models) for the specified ModelicaPath. This path does not include the
        trailing slash.

        :return: string, path to where files (models) are stored, without trailing slash
        """
        if self.root_dir is None:
            return self.files_relative_dir
        else:
            return f"{self.root_dir}/{self.name}"

    @property
    def resources_relative_dir(self):
        """
        Return the relative resource directory instead of the full path. This is useful when replacing
        strings within modelica files which are relative to the package.

        :return: string, relative resource's data path
        """
        return f"Resources/Data/{self.name}"

    @property
    def scripts_relative_dir(self, platform='Dymola'):
        """Return the scripts directory that is in the resources directory. This only returns the
        relative directory and is useful when replacing string values within Modelica files.

        :return: string, relative scripts path
        """
        return f"Resources/Scripts/{self.name}/{platform}"

    @property
    def files_relative_dir(self):
        """Return the path to the files relative to the project name."""
        return os.path.join(self.name)

    @property
    def resources_dir(self):
        """
        Return the path to the resources directory for the specified ModelicaPath. This path does not include
        the trailing slash.

        :return: string, path to where resources are stored, without trailing slash.
        """
        if self.root_dir is None:
            return self.resources_relative_dir
        else:
            return f"{self.root_dir}/{self.resources_relative_dir}"

    @property
    def scripts_dir(self):
        """
        Return the path to the scripts directory (in the resources dir) for the specified ModelicaPath.
        This path does not include the trailing slash.

        :return: string, path to where scripts are stored, without trailing slash.
        """
        if self.root_dir is None:
            return self.scripts_relative_dir
        else:
            return f"{self.root_dir}/{self.scripts_relative_dir}"


# This is used for some test cases where we need deterministic IDs to be generated
USE_DETERMINISTIC_ID = bool(os.environ.get('GMT_DETERMINISTIC_ID', False))

counter = 0


def simple_uuid():
    """Generates a simple string uuid

    :return: string, uuid
    """
    global counter

    if not USE_DETERMINISTIC_ID:
        return str(uuid4()).split("-")[0]
    else:
        id = str(counter)
        counter += 1
        return id

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 logging	2✔
5	import os	2✔
6	import shutil	2✔
7	from pathlib import Path	2✔
8	from uuid import uuid4	2✔
9
10	_log = logging.getLogger(__name__)	2✔
11
12
13	def copytree(src, dst, symlinks=False, ignore=None):	2✔
14	"""
15	Alternate version of copytree that will work if the directory already exists (use instead of shutil)
16	"""
17	for item in os.listdir(src):	2✔
18	s = os.path.join(src, item)	2✔
19	d = os.path.join(dst, item)	2✔
20	if os.path.isdir(s):	2!
21	shutil.copytree(s, d, symlinks, ignore)	×
22	else:
23	shutil.copy2(s, d)	2✔
24
25
26	def convert_c_to_k(c):	2✔
27	"""Converts a temperature in celsius to kelvin
28
29	:param c: float, temperature in celsius
30	:return: float, temperature in kelvin
31	"""
32	return c + 273.15	2✔
33
34
35	def linecount(filename: Path) -> int:	2✔
36	"""Counts the number of lines in a file
37	Probably not the most efficient way to do this, but it works
38	"""
39	return len(open(filename).readlines())	2✔
40
41
42	def mbl_version():	2✔
43	"""
44	Returns the version of the Modelica Buildings Library (MBL) used by the
45	geojson-modelica-translator.
46	"""
47	return "10.0.0"	2✔
48
49
50	class ModelicaPath(object):	2✔
51	"""
52	Class for storing Modelica paths. This allows the path to point to
53	the model directory, resources, and scripts directory.
54	"""
55
56	def __init__(self, name, root_dir, overwrite=False):	2✔
57	"""
58	Create a new modelica-based path with name of 'name'
59
60	:param name: Name to create
61	"""
62	self.name = name	2✔
63	self.root_dir = root_dir	2✔
64	self.overwrite = overwrite	2✔
65
66	# create the directories
67	if root_dir is not None:	2✔
68	check_path = os.path.join(self.files_dir)	2✔
69	self.clear_or_create_path(check_path)	2✔
70	check_path = os.path.join(self.resources_dir)	2✔
71	self.clear_or_create_path(check_path)	2✔
72	check_path = os.path.join(self.scripts_dir)	2✔
73	self.clear_or_create_path(check_path)	2✔
74
75	def clear_or_create_path(self, path):	2✔
76	if os.path.exists(path):	2!
UNCOV 77	if not self.overwrite:	×
UNCOV 78	raise Exception("Directory already exists and overwrite is false for %s" % path)	×
79	else:
80	shutil.rmtree(path)	×
81	os.makedirs(path, exist_ok=True)	2✔
82
83	@property	2✔
84	def files_dir(self):	2✔
85	"""
86	Return the path to the files (models) for the specified ModelicaPath. This path does not include the
87	trailing slash.
88
89	:return: string, path to where files (models) are stored, without trailing slash
90	"""
91	if self.root_dir is None:	2✔
92	return self.files_relative_dir	2✔
93	else:
94	return f"{self.root_dir}/{self.name}"	2✔
95
96	@property	2✔
97	def resources_relative_dir(self):	2✔
98	"""
99	Return the relative resource directory instead of the full path. This is useful when replacing
100	strings within modelica files which are relative to the package.
101
102	:return: string, relative resource's data path
103	"""
104	return f"Resources/Data/{self.name}"	2✔
105
106	@property	2✔
107	def scripts_relative_dir(self, platform='Dymola'):	2✔
108	"""Return the scripts directory that is in the resources directory. This only returns the
109	relative directory and is useful when replacing string values within Modelica files.
110
111	:return: string, relative scripts path
112	"""
113	return f"Resources/Scripts/{self.name}/{platform}"	2✔
114
115	@property	2✔
116	def files_relative_dir(self):	2✔
117	"""Return the path to the files relative to the project name."""
118	return os.path.join(self.name)	2✔
119
120	@property	2✔
121	def resources_dir(self):	2✔
122	"""
123	Return the path to the resources directory for the specified ModelicaPath. This path does not include
124	the trailing slash.
125
126	:return: string, path to where resources are stored, without trailing slash.
127	"""
128	if self.root_dir is None:	2✔
129	return self.resources_relative_dir	2✔
130	else:
131	return f"{self.root_dir}/{self.resources_relative_dir}"	2✔
132
133	@property	2✔
134	def scripts_dir(self):	2✔
135	"""
136	Return the path to the scripts directory (in the resources dir) for the specified ModelicaPath.
137	This path does not include the trailing slash.
138
139	:return: string, path to where scripts are stored, without trailing slash.
140	"""
141	if self.root_dir is None:	2!
UNCOV 142	return self.scripts_relative_dir	×
143	else:
144	return f"{self.root_dir}/{self.scripts_relative_dir}"	2✔
145
146
147	# This is used for some test cases where we need deterministic IDs to be generated
148	USE_DETERMINISTIC_ID = bool(os.environ.get('GMT_DETERMINISTIC_ID', False))	2✔
149
150	counter = 0	2✔
151
152
153	def simple_uuid():	2✔
154	"""Generates a simple string uuid
155
156	:return: string, uuid
157	"""
158	global counter
159
160	if not USE_DETERMINISTIC_ID:	2!
161	return str(uuid4()).split("-")[0]	2✔
162	else:
UNCOV 163	id = str(counter)	×
UNCOV 164	counter += 1	×
UNCOV 165	return id	×

urbanopt / geojson-modelica-translator / 8162728520

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