11662562960

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

Build # 11662562960

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

91.0

/trnsysGUI/connection/doublePipeConnection.py

from __future__ import annotations

import typing as _tp

import PyQt5.QtWidgets as _qtw

import trnsysGUI.connection.connectionBase as _cb
import trnsysGUI.connection.createMassFlowSolverNetworkPipes as _cmnp
import trnsysGUI.connection.deleteDoublePipeConnectionCommand as _ddpcc
import trnsysGUI.connection.doublePipeConnectionModel as _model
import trnsysGUI.connection.doublePipeDefaultValues as _defaults
import trnsysGUI.connection.hydraulicExport.common as _hecom
import trnsysGUI.connection.hydraulicExport.doublePipe as _he
import trnsysGUI.connection.hydraulicExport.doublePipe.createExportHydraulicDoublePipeConnection as _cehc
import trnsysGUI.connection.hydraulicExport.doublePipe.doublePipeConnection as _hedpc
import trnsysGUI.doublePipePortItem as _dppi
import trnsysGUI.internalPiping as _ip
import trnsysGUI.massFlowSolver.networkModel as _mfn
import trnsysGUI.names.undo as _nu
import trnsysGUI.segments.doublePipeSegmentItem as _dpsi
from . import _massFlowLabels as _mfl

if _tp.TYPE_CHECKING:
    import trnsysGUI.diagram.Editor as _ed


class DoublePipeConnection(
    _cb.ConnectionBase
):  # pylint: disable=too-many-instance-attributes
    def __init__(
        self,
        displayName: str,
        fromPort: _dppi.DoublePipePortItem,
        toPort: _dppi.DoublePipePortItem,
        parent: _ed.Editor,  # type: ignore[name-defined]
    ) -> None:
        super().__init__(
            displayName,
            fromPort,
            toPort,
            _defaults.DEFAULT_SHALL_BE_SIMULATED,
            _defaults.DEFAULT_DOUBLE_PIPE_LENGTH_IN_M,
            parent,
        )

        self.childIds = []
        self.childIds.append(self.trnsysId)
        self.childIds.append(self.parent.idGen.getTrnsysID())

        self._setModels()

    @property
    def fromPort(self) -> _dppi.DoublePipePortItem:
        assert isinstance(self._fromPort, _dppi.DoublePipePortItem)
        return self._fromPort

    @property
    def toPort(self) -> _dppi.DoublePipePortItem:
        assert isinstance(self._toPort, _dppi.DoublePipePortItem)
        return self._toPort

    def getModelPipe(self, portItemType: _mfn.PortItemType) -> _mfn.Pipe:
        if portItemType == _mfn.PortItemType.COLD:
            return self.coldModelPipe

        if portItemType == _mfn.PortItemType.HOT:
            return self.hotModelPipe

        raise ValueError(f"Don't have a model pipe of type {portItemType}.")

    def _createSegmentItem(self, startNode, endNode):
        return _dpsi.DoublePipeSegmentItem(startNode, endNode, self)

    def getRadius(self):
        rad = 4
        return rad

    def createDeleteUndoCommand(
        self, parentCommand: _tp.Optional[_qtw.QUndoCommand] = None
    ) -> _qtw.QUndoCommand:
        undoNamingHelper = _nu.UndoNamingHelper.create(
            self._editor.namesManager
        )

        undoCommand = _ddpcc.DeleteDoublePipeConnectionCommand(
            self, undoNamingHelper, self._editor.diagramScene, parentCommand
        )
        return undoCommand

    def encode(self):
        if len(self.segments) > 0:
            labelPos = self._label.pos().x(), self._label.pos().y()
            labelMassPos = (
                self.massFlowLabel.pos().x(),
                self.massFlowLabel.pos().y(),
            )
        else:
            self.logger.debug("This connection has no segment")
            defaultPos = (
                self.fromPort.pos().x(),
                self.fromPort.pos().y(),
            )  # pylint: disable = duplicate-code # 1
            labelPos = defaultPos
            labelMassPos = defaultPos

        corners = []
        for corner in self.getCorners():
            cornerTupel = (corner.pos().x(), corner.pos().y())
            corners.append(cornerTupel)

        doublePipeConnectionModel = _model.DoublePipeConnectionModel(
            self.connId,
            self.displayName,
            self.id,
            self.childIds,
            corners,
            labelPos,
            labelMassPos,
            self.fromPort.id,
            self.toPort.id,
            self.trnsysId,
            self.lengthInM,
            self.shallBeSimulated,
        )

        dictName = "Connection-"
        return dictName, doublePipeConnectionModel.to_dict()

    def decode(self, i):
        model = _model.DoublePipeConnectionModel.from_dict(i)

        self.id = model.id
        self.connId = model.connectionId
        self.trnsysId = model.trnsysId
        self.childIds = model.childIds
        self.setDisplayName(model.name)

        self.setLabelPos(model.labelPos)
        self.setMassLabelPos(model.massFlowLabelPos)
        self.lengthInM = model.lengthInM
        self.shallBeSimulated = model.shallBeSimulated

        if len(model.segmentsCorners) > 0:
            self._loadSegments(model.segmentsCorners)

    def getInternalPiping(self) -> _ip.InternalPiping:
        coldModelPortItemsToGraphicalPortItem = {
            self.coldModelPipe.fromPort: self.toPort,
            self.coldModelPipe.toPort: self.fromPort,
        }

        hotModelPortItemsToGraphicalPortItem = {
            self.hotModelPipe.fromPort: self.fromPort,
            self.hotModelPipe.toPort: self.toPort,
        }

        modelPortItemsToGraphicalPortItem = (
            coldModelPortItemsToGraphicalPortItem
            | hotModelPortItemsToGraphicalPortItem
        )
        return _ip.InternalPiping(
            [self.coldModelPipe, self.hotModelPipe],
            modelPortItemsToGraphicalPortItem,
        )

    def exportPipeAndTeeTypesForTemp(
        self, startingUnit: int
    ) -> _tp.Tuple[str, int]:
        unitNumber = startingUnit

        exportModel = self._getHydraulicExportConnectionModel()
        return _he.export(exportModel, unitNumber)

    def _getHydraulicExportConnectionModel(
        self,
    ) -> _hedpc.ExportDoublePipeConnection:
        hydraulicConnection = _cehc.HydraulicDoublePipeConnection(
            self.displayName,
            _hecom.getAdjacentBlockItem(self.fromPort),
            _hecom.getAdjacentBlockItem(self.toPort),
            self.coldModelPipe,
            self.hotModelPipe,
        )

        exportHydraulicConnection = _cehc.createModel(hydraulicConnection)

        assert isinstance(self.lengthInM, float)

        exportConnection = _hedpc.ExportDoublePipeConnection(
            exportHydraulicConnection, self.lengthInM, self.shallBeSimulated
        )

        return exportConnection

    def _setModels(self):
        self.coldModelPipe, self.hotModelPipe = (
            _cmnp.createMassFlowSolverNetworkPipes()
        )

    def setMassFlowAndTemperature(
        self,
        coldMassFlow: float,
        coldTemperature: float,
        hotMassFlow: float,
        hotTemperature: float,
    ) -> None:
        formattedColdMassFlowAndTemperature = (
            _mfl.getFormattedMassFlowAndTemperature(
                coldMassFlow, coldTemperature
            )
        )
        formattedHotMassFlowAndTemperature = (
            _mfl.getFormattedMassFlowAndTemperature(
                hotMassFlow, hotTemperature
            )
        )
        labelText = f"""\
Cold: {formattedColdMassFlowAndTemperature}
Hot: {formattedHotMassFlowAndTemperature}
"""
        self.massFlowLabel.setPlainText(labelText)

1	from __future__ import annotations	1✔
2
3	import typing as _tp	1✔
4
5	import PyQt5.QtWidgets as _qtw	1✔
6
7	import trnsysGUI.connection.connectionBase as _cb	1✔
8	import trnsysGUI.connection.createMassFlowSolverNetworkPipes as _cmnp	1✔
9	import trnsysGUI.connection.deleteDoublePipeConnectionCommand as _ddpcc	1✔
10	import trnsysGUI.connection.doublePipeConnectionModel as _model	1✔
11	import trnsysGUI.connection.doublePipeDefaultValues as _defaults	1✔
12	import trnsysGUI.connection.hydraulicExport.common as _hecom	1✔
13	import trnsysGUI.connection.hydraulicExport.doublePipe as _he	1✔
14	import trnsysGUI.connection.hydraulicExport.doublePipe.createExportHydraulicDoublePipeConnection as _cehc	1✔
15	import trnsysGUI.connection.hydraulicExport.doublePipe.doublePipeConnection as _hedpc	1✔
16	import trnsysGUI.doublePipePortItem as _dppi	1✔
17	import trnsysGUI.internalPiping as _ip	1✔
18	import trnsysGUI.massFlowSolver.networkModel as _mfn	1✔
19	import trnsysGUI.names.undo as _nu	1✔
20	import trnsysGUI.segments.doublePipeSegmentItem as _dpsi	1✔
21	from . import _massFlowLabels as _mfl	1✔
22
23	if _tp.TYPE_CHECKING:	1✔
24	import trnsysGUI.diagram.Editor as _ed	×
25
26
27	class DoublePipeConnection(	1✔
28	_cb.ConnectionBase
29	): # pylint: disable=too-many-instance-attributes
30	def __init__(	1✔
31	self,
32	displayName: str,
33	fromPort: _dppi.DoublePipePortItem,
34	toPort: _dppi.DoublePipePortItem,
35	parent: _ed.Editor, # type: ignore[name-defined]
36	) -> None:
37	super().__init__(	1✔
38	displayName,
39	fromPort,
40	toPort,
41	_defaults.DEFAULT_SHALL_BE_SIMULATED,
42	_defaults.DEFAULT_DOUBLE_PIPE_LENGTH_IN_M,
43	parent,
44	)
45
46	self.childIds = []	1✔
47	self.childIds.append(self.trnsysId)	1✔
48	self.childIds.append(self.parent.idGen.getTrnsysID())	1✔
49
50	self._setModels()	1✔
51
52	@property	1✔
53	def fromPort(self) -> _dppi.DoublePipePortItem:	1✔
54	assert isinstance(self._fromPort, _dppi.DoublePipePortItem)	1✔
55	return self._fromPort	1✔
56
57	@property	1✔
58	def toPort(self) -> _dppi.DoublePipePortItem:	1✔
59	assert isinstance(self._toPort, _dppi.DoublePipePortItem)	1✔
60	return self._toPort	1✔
61
62	def getModelPipe(self, portItemType: _mfn.PortItemType) -> _mfn.Pipe:	1✔
63	if portItemType == _mfn.PortItemType.COLD:	1✔
64	return self.coldModelPipe	1✔
65
66	if portItemType == _mfn.PortItemType.HOT:	1✔
67	return self.hotModelPipe	1✔
68
69	raise ValueError(f"Don't have a model pipe of type {portItemType}.")	×
70
71	def _createSegmentItem(self, startNode, endNode):	1✔
72	return _dpsi.DoublePipeSegmentItem(startNode, endNode, self)	1✔
73
74	def getRadius(self):	1✔
75	rad = 4	1✔
76	return rad	1✔
77
78	def createDeleteUndoCommand(	1✔
79	self, parentCommand: _tp.Optional[_qtw.QUndoCommand] = None
80	) -> _qtw.QUndoCommand:
NEW 81	undoNamingHelper = _nu.UndoNamingHelper.create(	×
82	self._editor.namesManager
83	)
84
85	undoCommand = _ddpcc.DeleteDoublePipeConnectionCommand(	×
86	self, undoNamingHelper, self._editor.diagramScene, parentCommand
87	)
88	return undoCommand	×
89
90	def encode(self):	1✔
91	if len(self.segments) > 0:	1✔
92	labelPos = self._label.pos().x(), self._label.pos().y()	1✔
93	labelMassPos = (	1✔
94	self.massFlowLabel.pos().x(),
95	self.massFlowLabel.pos().y(),
96	)
97	else:
98	self.logger.debug("This connection has no segment")	×
NEW 99	defaultPos = (	×
100	self.fromPort.pos().x(),
101	self.fromPort.pos().y(),
102	) # pylint: disable = duplicate-code # 1
103	labelPos = defaultPos	×
104	labelMassPos = defaultPos	×
105
106	corners = []	1✔
107	for corner in self.getCorners():	1✔
108	cornerTupel = (corner.pos().x(), corner.pos().y())	1✔
109	corners.append(cornerTupel)	1✔
110
111	doublePipeConnectionModel = _model.DoublePipeConnectionModel(	1✔
112	self.connId,
113	self.displayName,
114	self.id,
115	self.childIds,
116	corners,
117	labelPos,
118	labelMassPos,
119	self.fromPort.id,
120	self.toPort.id,
121	self.trnsysId,
122	self.lengthInM,
123	self.shallBeSimulated,
124	)
125
126	dictName = "Connection-"	1✔
127	return dictName, doublePipeConnectionModel.to_dict()	1✔
128
129	def decode(self, i):	1✔
130	model = _model.DoublePipeConnectionModel.from_dict(i)	1✔
131
132	self.id = model.id	1✔
133	self.connId = model.connectionId	1✔
134	self.trnsysId = model.trnsysId	1✔
135	self.childIds = model.childIds	1✔
136	self.setDisplayName(model.name)	1✔
137
138	self.setLabelPos(model.labelPos)	1✔
139	self.setMassLabelPos(model.massFlowLabelPos)	1✔
140	self.lengthInM = model.lengthInM	1✔
141	self.shallBeSimulated = model.shallBeSimulated	1✔
142
143	if len(model.segmentsCorners) > 0:	1✔
144	self._loadSegments(model.segmentsCorners)	1✔
145
146	def getInternalPiping(self) -> _ip.InternalPiping:	1✔
147	coldModelPortItemsToGraphicalPortItem = {	1✔
148	self.coldModelPipe.fromPort: self.toPort,
149	self.coldModelPipe.toPort: self.fromPort,
150	}
151
152	hotModelPortItemsToGraphicalPortItem = {	1✔
153	self.hotModelPipe.fromPort: self.fromPort,
154	self.hotModelPipe.toPort: self.toPort,
155	}
156
157	modelPortItemsToGraphicalPortItem = (	1✔
158	coldModelPortItemsToGraphicalPortItem
159	\| hotModelPortItemsToGraphicalPortItem
160	)
161	return _ip.InternalPiping(	1✔
162	[self.coldModelPipe, self.hotModelPipe],
163	modelPortItemsToGraphicalPortItem,
164	)
165
166	def exportPipeAndTeeTypesForTemp(	1✔
167	self, startingUnit: int
168	) -> _tp.Tuple[str, int]:
169	unitNumber = startingUnit	1✔
170
171	exportModel = self._getHydraulicExportConnectionModel()	1✔
172	return _he.export(exportModel, unitNumber)	1✔
173
174	def _getHydraulicExportConnectionModel(	1✔
175	self,
176	) -> _hedpc.ExportDoublePipeConnection:
177	hydraulicConnection = _cehc.HydraulicDoublePipeConnection(	1✔
178	self.displayName,
179	_hecom.getAdjacentBlockItem(self.fromPort),
180	_hecom.getAdjacentBlockItem(self.toPort),
181	self.coldModelPipe,
182	self.hotModelPipe,
183	)
184
185	exportHydraulicConnection = _cehc.createModel(hydraulicConnection)	1✔
186
187	assert isinstance(self.lengthInM, float)	1✔
188
189	exportConnection = _hedpc.ExportDoublePipeConnection(	1✔
190	exportHydraulicConnection, self.lengthInM, self.shallBeSimulated
191	)
192
193	return exportConnection	1✔
194
195	def _setModels(self):	1✔
196	self.coldModelPipe, self.hotModelPipe = (	1✔
197	_cmnp.createMassFlowSolverNetworkPipes()
198	)
199
200	def setMassFlowAndTemperature(	1✔
201	self,
202	coldMassFlow: float,
203	coldTemperature: float,
204	hotMassFlow: float,
205	hotTemperature: float,
206	) -> None:
207	formattedColdMassFlowAndTemperature = (	1✔
208	_mfl.getFormattedMassFlowAndTemperature(
209	coldMassFlow, coldTemperature
210	)
211	)
212	formattedHotMassFlowAndTemperature = (	1✔
213	_mfl.getFormattedMassFlowAndTemperature(
214	hotMassFlow, hotTemperature
215	)
216	)
217	labelText = f"""\	1✔
218	Cold: {formattedColdMassFlowAndTemperature}
219	Hot: {formattedHotMassFlowAndTemperature}
220	"""
221	self.massFlowLabel.setPlainText(labelText)	1✔

SPF-OST / pytrnsys_gui / 11662562960

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