11576810878

Committed 29 Oct 2024 03:09PM UTC coverage: 67.508% (-0.08%) from 67.591%

Build # 11576810878

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #564 from SPF-OST/560-black-change-line-length-to-pep8-standard-of-79-and-check-ci-reaction

changed line length in black to 79

Run Details

1054 of 1475 new or added lines in 174 files covered. (71.46%)

150 existing lines in 74 files now uncovered.

10399 of 15404 relevant lines covered (67.51%)

0.68 hits per line

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

72.15

/trnsysGUI/proforma/models.py

from __future__ import annotations

import collections.abc as _cabc
import dataclasses as _dc
import typing as _tp

import trnsysGUI.placeHolderNames as _phn


@_dc.dataclass
class Variable:  # pylint: disable=too-many-instance-attributes
    tmfName: str
    definition: str | None
    order: int
    role: str
    roleOrder: int
    unit: str
    bounds: str
    defaultValue: float | int

    def getInfo(self, withRole: bool) -> str:
        roleOrEmpty = f"{self.role.capitalize()} " if withRole else ""
        info = f"{roleOrEmpty}{self.roleOrder}: {self.tmfName} [{self.unit}] ({self.bounds})"
        return info

    @property
    def info(self) -> str:
        return self.getInfo(withRole=False)


@_dc.dataclass(frozen=True)
class Unset:
    pass


UNSET = Unset()

RequiredVariable = Variable | Unset


@_dc.dataclass
class VariableNameBuilder:
    propertyName: str
    variableNamePrefix: str | None
    usePortInVariableName: bool

    def getVariableName(
        self, connectionName: str | None, portName: str
    ) -> str:
        if self.usePortInVariableName:
            qualifiedPortName = _phn.getQualifiedPortName(
                connectionName, portName
            )
            return f"{self.variableNamePrefix}{qualifiedPortName}"

        connectionNameOrEmpty = connectionName or ""

        return f"{self.variableNamePrefix}{connectionNameOrEmpty}"

    def getRhs(self, connectionName: str | None, portName: str) -> str:
        qualifiedPortName = _phn.getQualifiedPortName(connectionName, portName)
        return f"@{self.propertyName}({qualifiedPortName})"

    @staticmethod
    def _getConnectionNamePart(
        connectionName: str | None, shallCapitalize: bool
    ) -> str:
        connectionNamePart = connectionName or ""

        if shallCapitalize:
            connectionNamePart = connectionNamePart.capitalize()

        return connectionNamePart

    def _getPortNamePart(self, portName: str) -> str:
        capitalizedPortNameOrEmpty = (
            portName.capitalize() if self.usePortInVariableName else ""
        )
        return capitalizedPortNameOrEmpty


class AllVariableStringConstants:
    TEMPERATURE = VariableNameBuilder("temp", "T", usePortInVariableName=True)
    MASS_FLOW_RATE = VariableNameBuilder(
        "mfr", "M", usePortInVariableName=False
    )
    REVERSE_TEMPERATURE = VariableNameBuilder(
        "revtemp", None, usePortInVariableName=True
    )
    DENSITY = VariableNameBuilder("rho", "Rho", usePortInVariableName=False)
    HEAT_CAPACITY = VariableNameBuilder(
        "cp", "Cp", usePortInVariableName=False
    )


def _getSummaryLine(
    qualifiedPortName: str,
    variableStringConstants: VariableNameBuilder,
    variable: Variable | None | Unset,
    direction: _tp.Literal["input", "output"],
) -> str:
    if not isinstance(variable, Variable):
        return ""

    computedVariable = (
        f"@{variableStringConstants.propertyName}({qualifiedPortName})"
    )
    summaryLine = (
        f'"{variable.tmfName}" = {computedVariable}'
        if direction == "input"
        else f'{computedVariable} = "{variable.tmfName}"'
    )

    return summaryLine


def _joinNonEmptyStringsWithNewLines(*strings: str) -> str:
    nonEmptyStrings = [s for s in strings if s]
    return "\n".join(nonEmptyStrings)


@_dc.dataclass
class Fluid:
    density: Variable | None = None
    heatCapacity: Variable | None = None

    @property
    def allVariables(self) -> _cabc.Sequence[Variable]:
        return _removeUnsetAndNone(self.density, self.heatCapacity)

    @property
    def areAnyRequiredVariablesUnset(self) -> bool:
        return False

    def getSummary(self, qualifiedPortName: str) -> str:
        summary = _joinNonEmptyStringsWithNewLines(
            _getSummaryLine(
                qualifiedPortName,
                AllVariableStringConstants.DENSITY,
                self.density,
                "input",
            ),
            _getSummaryLine(
                qualifiedPortName,
                AllVariableStringConstants.HEAT_CAPACITY,
                self.heatCapacity,
                "input",
            ),
        )

        return summary


@_dc.dataclass
class Connection:
    name: str | None
    inputPort: "InputPort"
    outputPort: "OutputPort"
    fluid: "Fluid" = _dc.field(default_factory=Fluid)

    @property
    def allVariables(self) -> _cabc.Sequence[Variable]:
        return [
            *self.inputPort.allVariables,
            *self.outputPort.allVariables,
            *self.fluid.allVariables,
        ]

    @property
    def areAnyRequiredVariablesUnset(self) -> bool:
        return (
            self.inputPort.areAnyRequiredVariablesUnset
            or self.outputPort.areAnyRequiredVariablesUnset
            or self.fluid.areAnyRequiredVariablesUnset
        )

    def getSummary(self) -> str:
        qualifiedInputPortName = _getQualifiedPortName(
            self.name, self.inputPort.name
        )
        fluidSummary = self.fluid.getSummary(qualifiedInputPortName)
        inputPortSummary = self.inputPort.getSummary(self.name)
        outputPortSummary = self.outputPort.getSummary(self.name)

        subSummaries = _joinNonEmptyStringsWithNewLines(
            fluidSummary, inputPortSummary, outputPortSummary
        )

        if not subSummaries:
            return ""

        connectionName = self.name if self.name else "Default connection"
        summary = f"""\
** {connectionName}
{subSummaries}
"""
        return summary


def _getQualifiedPortName(connectionName: str | None, portName: str) -> str:
    capitalizedPortName = portName.capitalize()

    qualifiedPortName = (
        f"{connectionName.capitalize()}{capitalizedPortName}"
        if connectionName
        else capitalizedPortName
    )

    return qualifiedPortName


def _getSetVariable(variable: Variable | Unset) -> Variable:
    if not isinstance(variable, Variable):
        raise ValueError("Required variable not set.")

    return variable


@_dc.dataclass
class InputPort:
    name: str
    temperature: "RequiredVariable" = UNSET
    massFlowRate: "RequiredVariable" = UNSET

    @property
    def temperatureSet(self) -> Variable:
        return _getSetVariable(self.temperature)

    @property
    def massFlowRateSet(self) -> "Variable":
        return _getSetVariable(self.massFlowRate)

    @property
    def allVariables(self) -> _cabc.Sequence[Variable]:
        return _removeUnsetAndNone(self.temperature, self.massFlowRate)

    @property
    def areAnyRequiredVariablesUnset(self) -> bool:
        return UNSET in (self.temperature, self.massFlowRate)

    def getSummary(self, connectionName: str | None) -> str:
        qualifiedPortName = _getQualifiedPortName(connectionName, self.name)
        summary = _joinNonEmptyStringsWithNewLines(
            _getSummaryLine(
                qualifiedPortName,
                AllVariableStringConstants.MASS_FLOW_RATE,
                self.massFlowRate,
                "input",
            ),
            _getSummaryLine(
                qualifiedPortName,
                AllVariableStringConstants.TEMPERATURE,
                self.temperature,
                "input",
            ),
        )

        return summary


@_dc.dataclass
class OutputPort:
    name: str
    temperature: "RequiredVariable" = UNSET
    reverseTemperature: Variable | None = None

    @property
    def temperatureSet(self) -> Variable:
        return _getSetVariable(self.temperature)

    @property
    def allVariables(self) -> _cabc.Sequence[Variable]:
        return _removeUnsetAndNone(self.temperature, self.reverseTemperature)

    @property
    def areAnyRequiredVariablesUnset(self):
        return self.temperature == UNSET

    def getSummary(self, connectionName: str | None) -> str:
        qualifiedPortName = _getQualifiedPortName(connectionName, self.name)
        summary = _joinNonEmptyStringsWithNewLines(
            _getSummaryLine(
                qualifiedPortName,
                AllVariableStringConstants.TEMPERATURE,
                self.temperature,
                "output",
            ),
            _getSummaryLine(
                qualifiedPortName,
                AllVariableStringConstants.REVERSE_TEMPERATURE,
                self.reverseTemperature,
                "input",
            ),
        )

        return summary


def _removeUnsetAndNone(
    *variables: Variable | Unset | None,
) -> _cabc.Sequence[Variable]:
    return [v for v in variables if isinstance(v, Variable)]


@_dc.dataclass
class VariablesByRole:
    parameters: _cabc.Sequence[Variable]
    inputs: _cabc.Sequence[Variable]
    outputs: _cabc.Sequence[Variable]

    @property
    def allVariables(self) -> _cabc.Sequence[Variable]:
        return [*self.parameters, *self.inputs, *self.outputs]

1	from __future__ import annotations	1✔
2
3	import collections.abc as _cabc	1✔
4	import dataclasses as _dc	1✔
5	import typing as _tp	1✔
6
7	import trnsysGUI.placeHolderNames as _phn	1✔
8
9
10	@_dc.dataclass	1✔
11	class Variable: # pylint: disable=too-many-instance-attributes	1✔
12	tmfName: str	1✔
13	definition: str \| None	1✔
14	order: int	1✔
15	role: str	1✔
16	roleOrder: int	1✔
17	unit: str	1✔
18	bounds: str	1✔
19	defaultValue: float \| int	1✔
20
21	def getInfo(self, withRole: bool) -> str:	1✔
22	roleOrEmpty = f"{self.role.capitalize()} " if withRole else ""	1✔
23	info = f"{roleOrEmpty}{self.roleOrder}: {self.tmfName} [{self.unit}] ({self.bounds})"	1✔
24	return info	1✔
25
26	@property	1✔
27	def info(self) -> str:	1✔
28	return self.getInfo(withRole=False)	1✔
29
30
31	@_dc.dataclass(frozen=True)	1✔
32	class Unset:	1✔
33	pass	1✔
34
35
36	UNSET = Unset()	1✔
37
38	RequiredVariable = Variable \| Unset	1✔
39
40
41	@_dc.dataclass	1✔
42	class VariableNameBuilder:	1✔
43	propertyName: str	1✔
44	variableNamePrefix: str \| None	1✔
45	usePortInVariableName: bool	1✔
46
47	def getVariableName(	1✔
48	self, connectionName: str \| None, portName: str
49	) -> str:
50	if self.usePortInVariableName:	1✔
51	qualifiedPortName = _phn.getQualifiedPortName(	1✔
52	connectionName, portName
53	)
54	return f"{self.variableNamePrefix}{qualifiedPortName}"	1✔
55
56	connectionNameOrEmpty = connectionName or ""	1✔
57
58	return f"{self.variableNamePrefix}{connectionNameOrEmpty}"	1✔
59
60	def getRhs(self, connectionName: str \| None, portName: str) -> str:	1✔
61	qualifiedPortName = _phn.getQualifiedPortName(connectionName, portName)	1✔
62	return f"@{self.propertyName}({qualifiedPortName})"	1✔
63
64	@staticmethod	1✔
65	def _getConnectionNamePart(	1✔
66	connectionName: str \| None, shallCapitalize: bool
67	) -> str:
UNCOV 68	connectionNamePart = connectionName or ""	×
69
70	if shallCapitalize:	×
71	connectionNamePart = connectionNamePart.capitalize()	×
72
73	return connectionNamePart	×
74
75	def _getPortNamePart(self, portName: str) -> str:	1✔
NEW 76	capitalizedPortNameOrEmpty = (	×
77	portName.capitalize() if self.usePortInVariableName else ""
78	)
UNCOV 79	return capitalizedPortNameOrEmpty	×
80
81
82	class AllVariableStringConstants:	1✔
83	TEMPERATURE = VariableNameBuilder("temp", "T", usePortInVariableName=True)	1✔
84	MASS_FLOW_RATE = VariableNameBuilder(	1✔
85	"mfr", "M", usePortInVariableName=False
86	)
87	REVERSE_TEMPERATURE = VariableNameBuilder(	1✔
88	"revtemp", None, usePortInVariableName=True
89	)
90	DENSITY = VariableNameBuilder("rho", "Rho", usePortInVariableName=False)	1✔
91	HEAT_CAPACITY = VariableNameBuilder(	1✔
92	"cp", "Cp", usePortInVariableName=False
93	)
94
95
96	def _getSummaryLine(	1✔
97	qualifiedPortName: str,
98	variableStringConstants: VariableNameBuilder,
99	variable: Variable \| None \| Unset,
100	direction: _tp.Literal["input", "output"],
101	) -> str:
102	if not isinstance(variable, Variable):	×
103	return ""	×
104
NEW 105	computedVariable = (	×
106	f"@{variableStringConstants.propertyName}({qualifiedPortName})"
107	)
UNCOV 108	summaryLine = (	×
109	f'"{variable.tmfName}" = {computedVariable}'
110	if direction == "input"
111	else f'{computedVariable} = "{variable.tmfName}"'
112	)
113
114	return summaryLine	×
115
116
117	def _joinNonEmptyStringsWithNewLines(*strings: str) -> str:	1✔
118	nonEmptyStrings = [s for s in strings if s]	×
119	return "\n".join(nonEmptyStrings)	×
120
121
122	@_dc.dataclass	1✔
123	class Fluid:	1✔
124	density: Variable \| None = None	1✔
125	heatCapacity: Variable \| None = None	1✔
126
127	@property	1✔
128	def allVariables(self) -> _cabc.Sequence[Variable]:	1✔
129	return _removeUnsetAndNone(self.density, self.heatCapacity)	×
130
131	@property	1✔
132	def areAnyRequiredVariablesUnset(self) -> bool:	1✔
133	return False	×
134
135	def getSummary(self, qualifiedPortName: str) -> str:	1✔
136	summary = _joinNonEmptyStringsWithNewLines(	×
137	_getSummaryLine(
138	qualifiedPortName,
139	AllVariableStringConstants.DENSITY,
140	self.density,
141	"input",
142	),
143	_getSummaryLine(
144	qualifiedPortName,
145	AllVariableStringConstants.HEAT_CAPACITY,
146	self.heatCapacity,
147	"input",
148	),
149	)
150
151	return summary	×
152
153
154	@_dc.dataclass	1✔
155	class Connection:	1✔
156	name: str \| None	1✔
157	inputPort: "InputPort"	1✔
158	outputPort: "OutputPort"	1✔
159	fluid: "Fluid" = _dc.field(default_factory=Fluid)	1✔
160
161	@property	1✔
162	def allVariables(self) -> _cabc.Sequence[Variable]:	1✔
NEW 163	return [	×
164	*self.inputPort.allVariables,
165	*self.outputPort.allVariables,
166	*self.fluid.allVariables,
167	]
168
169	@property	1✔
170	def areAnyRequiredVariablesUnset(self) -> bool:	1✔
171	return (	×
172	self.inputPort.areAnyRequiredVariablesUnset
173	or self.outputPort.areAnyRequiredVariablesUnset
174	or self.fluid.areAnyRequiredVariablesUnset
175	)
176
177	def getSummary(self) -> str:	1✔
NEW 178	qualifiedInputPortName = _getQualifiedPortName(	×
179	self.name, self.inputPort.name
180	)
181	fluidSummary = self.fluid.getSummary(qualifiedInputPortName)	×
182	inputPortSummary = self.inputPort.getSummary(self.name)	×
183	outputPortSummary = self.outputPort.getSummary(self.name)	×
184
NEW 185	subSummaries = _joinNonEmptyStringsWithNewLines(	×
186	fluidSummary, inputPortSummary, outputPortSummary
187	)
188
189	if not subSummaries:	×
190	return ""	×
191
192	connectionName = self.name if self.name else "Default connection"	×
193	summary = f"""\	×
194	** {connectionName}
195	{subSummaries}
196	"""
197	return summary	×
198
199
200	def _getQualifiedPortName(connectionName: str \| None, portName: str) -> str:	1✔
201	capitalizedPortName = portName.capitalize()	×
202
NEW 203	qualifiedPortName = (	×
204	f"{connectionName.capitalize()}{capitalizedPortName}"
205	if connectionName
206	else capitalizedPortName
207	)
208
209	return qualifiedPortName	×
210
211
212	def _getSetVariable(variable: Variable \| Unset) -> Variable:	1✔
213	if not isinstance(variable, Variable):	1✔
214	raise ValueError("Required variable not set.")	×
215
216	return variable	1✔
217
218
219	@_dc.dataclass	1✔
220	class InputPort:	1✔
221	name: str	1✔
222	temperature: "RequiredVariable" = UNSET	1✔
223	massFlowRate: "RequiredVariable" = UNSET	1✔
224
225	@property	1✔
226	def temperatureSet(self) -> Variable:	1✔
227	return _getSetVariable(self.temperature)	1✔
228
229	@property	1✔
230	def massFlowRateSet(self) -> "Variable":	1✔
231	return _getSetVariable(self.massFlowRate)	1✔
232
233	@property	1✔
234	def allVariables(self) -> _cabc.Sequence[Variable]:	1✔
235	return _removeUnsetAndNone(self.temperature, self.massFlowRate)	×
236
237	@property	1✔
238	def areAnyRequiredVariablesUnset(self) -> bool:	1✔
239	return UNSET in (self.temperature, self.massFlowRate)	×
240
241	def getSummary(self, connectionName: str \| None) -> str:	1✔
242	qualifiedPortName = _getQualifiedPortName(connectionName, self.name)	×
243	summary = _joinNonEmptyStringsWithNewLines(	×
244	_getSummaryLine(
245	qualifiedPortName,
246	AllVariableStringConstants.MASS_FLOW_RATE,
247	self.massFlowRate,
248	"input",
249	),
250	_getSummaryLine(
251	qualifiedPortName,
252	AllVariableStringConstants.TEMPERATURE,
253	self.temperature,
254	"input",
255	),
256	)
257
258	return summary	×
259
260
261	@_dc.dataclass	1✔
262	class OutputPort:	1✔
263	name: str	1✔
264	temperature: "RequiredVariable" = UNSET	1✔
265	reverseTemperature: Variable \| None = None	1✔
266
267	@property	1✔
268	def temperatureSet(self) -> Variable:	1✔
269	return _getSetVariable(self.temperature)	1✔
270
271	@property	1✔
272	def allVariables(self) -> _cabc.Sequence[Variable]:	1✔
273	return _removeUnsetAndNone(self.temperature, self.reverseTemperature)	×
274
275	@property	1✔
276	def areAnyRequiredVariablesUnset(self):	1✔
277	return self.temperature == UNSET	×
278
279	def getSummary(self, connectionName: str \| None) -> str:	1✔
280	qualifiedPortName = _getQualifiedPortName(connectionName, self.name)	×
281	summary = _joinNonEmptyStringsWithNewLines(	×
282	_getSummaryLine(
283	qualifiedPortName,
284	AllVariableStringConstants.TEMPERATURE,
285	self.temperature,
286	"output",
287	),
288	_getSummaryLine(
289	qualifiedPortName,
290	AllVariableStringConstants.REVERSE_TEMPERATURE,
291	self.reverseTemperature,
292	"input",
293	),
294	)
295
296	return summary	×
297
298
299	def _removeUnsetAndNone(	1✔
300	*variables: Variable \| Unset \| None,
301	) -> _cabc.Sequence[Variable]:
UNCOV 302	return [v for v in variables if isinstance(v, Variable)]	×
303
304
305	@_dc.dataclass	1✔
306	class VariablesByRole:	1✔
307	parameters: _cabc.Sequence[Variable]	1✔
308	inputs: _cabc.Sequence[Variable]	1✔
309	outputs: _cabc.Sequence[Variable]	1✔
310
311	@property	1✔
312	def allVariables(self) -> _cabc.Sequence[Variable]:	1✔
313	return [self.parameters, self.inputs, *self.outputs]	1✔

SPF-OST / pytrnsys_gui / 11576810878

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