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

97.0

/trnsysGUI/storageTank/model.py

import dataclasses as _dc
import typing as _tp
import uuid as _uuid

import dataclasses_jsonschema as _dcj

import pytrnsys.utils.serialization as _ser
from trnsysGUI import idGenerator as _id
from trnsysGUI.storageTank.side import Side


@_dc.dataclass
class StorageTankVersion0(
    _ser.UpgradableJsonSchemaMixinVersion0
):  # pylint: disable=too-many-instance-attributes
    FlippedH: bool  # pylint: disable=invalid-name
    FlippedV: bool  # pylint: disable=invalid-name
    BlockName: str  # pylint: disable=invalid-name
    BlockDisplayName: str  # pylint: disable=invalid-name
    GroupName: str  # pylint: disable=invalid-name
    size_h: int  # pylint: disable=invalid-name
    StoragePosition: _tp.Tuple[float, float]  # pylint: disable=invalid-name
    trnsysID: int
    ID: int  # pylint: disable=invalid-name
    HxList: _tp.Sequence[  # pylint: disable=invalid-name
        "HeatExchangerLegacyVersion"
    ]
    PortPairList: _tp.Sequence[  # pylint: disable=invalid-name
        "DirectPortPairLegacyVersion"
    ]

    @classmethod
    def getVersion(cls) -> _uuid.UUID:
        return _uuid.UUID("05f422d3-41fd-48d1-b8d0-4655d9f65247")


@_dc.dataclass
class HeatExchangerLegacyVersion(
    _dcj.JsonSchemaMixin
):  # pylint: disable=too-many-instance-attributes
    SideNr: int  # pylint: disable=invalid-name
    Width: float  # pylint: disable=invalid-name
    Height: float  # pylint: disable=invalid-name
    Offset: _tp.Tuple[float, float]  # pylint: disable=invalid-name
    DisplayName: str  # pylint: disable=invalid-name
    ParentID: int  # pylint: disable=invalid-name
    Port1ID: int  # pylint: disable=invalid-name
    Port2ID: int  # pylint: disable=invalid-name
    connTrnsysID: int  # pylint: disable=invalid-name
    ID: int  # pylint: disable=invalid-name


@_dc.dataclass
class DirectPortPairLegacyVersion(
    _dcj.JsonSchemaMixin
):  # pylint: disable=too-many-instance-attributes
    Side: bool  # pylint: disable=invalid-name
    Port1offset: float  # pylint: disable=invalid-name
    Port2offset: float  # pylint: disable=invalid-name
    Port1ID: int  # pylint: disable=invalid-name
    Port2ID: int  # pylint: disable=invalid-name
    ConnID: int  # pylint: disable=invalid-name
    ConnCID: int  # pylint: disable=invalid-name
    ConnDisName: str  # pylint: disable=invalid-name
    trnsysID: int  # pylint: disable=invalid-name


@_dc.dataclass
class StorageTankVersion1(
    _ser.UpgradableJsonSchemaMixin
):  # pylint: disable=too-many-instance-attributes
    isHorizontallyFlipped: bool
    isVerticallyFlipped: bool

    BlockName: str  # pylint: disable=invalid-name
    BlockDisplayName: str  # pylint: disable=invalid-name

    groupName: str
    id: int  # pylint: disable=invalid-name
    trnsysId: int

    height: int
    position: _tp.Tuple[float, float]

    heatExchangers: _tp.Sequence["HeatExchanger"]

    directPortPairs: _tp.Sequence["DirectPortPair"]

    @classmethod
    def upgrade(
        cls, superseded: _ser.UpgradableJsonSchemaMixinVersion0
    ) -> "StorageTankVersion1":
        if not isinstance(superseded, StorageTankVersion0):
            raise ValueError(
                f"Can only upgrade a {StorageTankVersion0.__name__} instance."
            )

        heatExchangers = cls._upgradeHeatExchangers(
            superseded.HxList, superseded.size_h
        )
        directPortPairs = cls._upgradeDirectPortPairs(
            superseded.PortPairList, superseded.size_h
        )

        return StorageTankVersion1(
            superseded.FlippedH,
            superseded.FlippedV,
            superseded.BlockName,
            superseded.BlockDisplayName,
            superseded.GroupName,
            superseded.ID,
            superseded.trnsysID,
            superseded.size_h,
            superseded.StoragePosition,
            heatExchangers,
            directPortPairs,
        )

    @classmethod
    def _upgradeHeatExchangers(
        cls,
        supersededHeatExchangers: _tp.Sequence[HeatExchangerLegacyVersion],
        storageTankHeight: float,
    ) -> _tp.Sequence["HeatExchanger"]:
        heatExchangers = []
        for supersededHeatExchanger in supersededHeatExchangers:
            heatExchangerVersion0 = (
                HeatExchangerVersion0.createFromLegacyHeatExchanger(
                    supersededHeatExchanger, storageTankHeight
                )
            )

            heatExchanger = HeatExchanger.fromInstance(heatExchangerVersion0)

            heatExchangers.append(heatExchanger)

        return heatExchangers

    @classmethod
    def _upgradeDirectPortPairs(
        cls,
        supersededPairs: _tp.Sequence[DirectPortPairLegacyVersion],
        storageTankHeight: float,
    ) -> _tp.Sequence["DirectPortPair"]:
        directPortPairs = []
        for supersededPair in supersededPairs:
            directPortPairVersion0 = (
                DirectPortPairVersion0.createFromLegacyPortPair(
                    supersededPair, storageTankHeight
                )
            )

            directPortPair = DirectPortPair.fromInstance(
                directPortPairVersion0
            )

            directPortPairs.append(directPortPair)

        return directPortPairs

    @classmethod
    def getVersion(cls) -> _uuid.UUID:
        return _uuid.UUID("05f422d3-41fd-48d1-b8d0-4655d9f65247")

    @classmethod
    def getSupersededClass(cls):
        return StorageTankVersion0


@_dc.dataclass
class StorageTankVersion2(
    _ser.UpgradableJsonSchemaMixin
):  # pylint: disable=too-many-instance-attributes
    isHorizontallyFlipped: bool
    isVerticallyFlipped: bool

    BlockName: str  # pylint: disable=invalid-name
    BlockDisplayName: str  # pylint: disable=invalid-name

    id: int  # pylint: disable=invalid-name
    trnsysId: int

    height: int
    position: _tp.Tuple[float, float]

    heatExchangers: _tp.Sequence["HeatExchanger"]

    directPortPairs: _tp.Sequence["DirectPortPair"]

    @classmethod
    def upgrade(
        cls, superseded: _ser.UpgradableJsonSchemaMixinVersion0
    ) -> "StorageTankVersion2":
        if not isinstance(superseded, StorageTankVersion1):
            raise ValueError(
                f"Can only upgrade a {StorageTankVersion1.__name__} instance."
            )

        return StorageTankVersion2(
            superseded.isHorizontallyFlipped,
            superseded.isVerticallyFlipped,
            superseded.BlockName,
            superseded.BlockDisplayName,
            superseded.id,
            superseded.trnsysId,
            superseded.height,
            superseded.position,
            superseded.heatExchangers,
            superseded.directPortPairs,
        )

    @classmethod
    def getVersion(cls) -> _uuid.UUID:
        return _uuid.UUID("05f422d3-41fd-48d1-b8d0-4655d9f65247")

    @classmethod
    def getSupersededClass(cls):
        return StorageTankVersion1


@_dc.dataclass
class StorageTank(
    _ser.UpgradableJsonSchemaMixin
):  # pylint: disable=too-many-instance-attributes
    isHorizontallyFlipped: bool
    isVerticallyFlipped: bool

    BlockName: str  # pylint: disable=invalid-name
    BlockDisplayName: str  # pylint: disable=invalid-name

    trnsysId: int

    height: int
    position: _tp.Tuple[float, float]

    heatExchangers: _tp.Sequence["HeatExchanger"]

    directPortPairs: _tp.Sequence["DirectPortPair"]

    @classmethod
    def from_dict(
        cls,
        data: _dcj.JsonDict,  # pylint: disable=duplicate-code  # 2
        validate=True,
        validate_enums: bool = True,
        schema_type: _dcj.SchemaType = _dcj.DEFAULT_SCHEMA_TYPE,  # /NOSONAR,
    ) -> "StorageTank":
        data.pop(".__BlockDict__")
        storageTank = super().from_dict(
            data, validate, validate_enums, schema_type
        )
        return _tp.cast(StorageTank, storageTank)

    def to_dict(
        self,
        omit_none: bool = True,
        validate: bool = False,
        validate_enums: bool = True,
        schema_type: _dcj.SchemaType = _dcj.DEFAULT_SCHEMA_TYPE,  # /NOSONAR,
    ) -> _dcj.JsonDict:
        data = super().to_dict(
            omit_none, validate, validate_enums, schema_type
        )  # pylint: disable=duplicate-code  # 1
        data[".__BlockDict__"] = True
        return data

    @classmethod
    def getSupersededClass(cls):
        return StorageTankVersion2

    @classmethod
    def upgrade(
        cls, superseded: _ser.UpgradableJsonSchemaMixinVersion0
    ) -> "StorageTank":
        if not isinstance(superseded, StorageTankVersion2):
            raise ValueError(
                f"Can only upgrade a {StorageTankVersion2.__name__} instance."
            )

        return StorageTank(
            superseded.isHorizontallyFlipped,
            superseded.isVerticallyFlipped,
            superseded.BlockName,
            superseded.BlockDisplayName,
            superseded.trnsysId,
            superseded.height,
            superseded.position,
            superseded.heatExchangers,
            superseded.directPortPairs,
        )

    @classmethod
    def getVersion(cls) -> _uuid.UUID:
        return _uuid.UUID("35f8800b-3a22-4080-acc2-13f332a84d50")


@_dc.dataclass
class Port(_dcj.JsonSchemaMixin):
    id: int  # pylint: disable=invalid-name
    relativeHeight: float


@_dc.dataclass
class PortPairVersion0(_ser.UpgradableJsonSchemaMixinVersion0):
    side: Side

    name: str

    inputPort: Port
    outputPort: Port

    @classmethod
    def getVersion(cls) -> _uuid.UUID:
        return _uuid.UUID("e1b81a7b-51ca-44f0-9d3a-6b6c42eb8e91")


@_dc.dataclass
class PortPair(_ser.UpgradableJsonSchemaMixin):
    side: Side

    trnsysId: int
    inputPort: Port
    outputPort: Port

    @classmethod
    def getSupersededClass(
        cls,
    ) -> _tp.Type[_ser.UpgradableJsonSchemaMixinVersion0]:
        return PortPairVersion0

    @classmethod
    def upgrade(
        cls, superseded: _ser.UpgradableJsonSchemaMixinVersion0
    ) -> "PortPair":
        if not isinstance(superseded, PortPairVersion0):
            raise ValueError(
                f"Superseded instance is not of type {PortPairVersion0.__name__}"
            )

        return PortPair(
            superseded.side,
            _id.IdGenerator.UNINITIALIZED_ID,  # type: ignore[attr-defined]
            superseded.inputPort,
            superseded.outputPort,
        )

    @classmethod
    def getVersion(cls) -> _uuid.UUID:
        return _uuid.UUID("ed17e7a7-4798-4a80-beb7-81730523cf35")


@_dc.dataclass
class HeatExchangerVersion0(_ser.UpgradableJsonSchemaMixinVersion0):
    portPair: PortPairVersion0

    width: float

    parentId: int

    id: int  # pylint: disable=invalid-name
    connectionTrnsysId: int

    @classmethod
    def createFromLegacyHeatExchanger(
        cls,
        superseded: HeatExchangerLegacyVersion,
        storageTankHeight: float,
    ) -> "HeatExchangerVersion0":
        absoluteInputHeight = storageTankHeight - superseded.Offset[1]
        absoluteOutputHeight = absoluteInputHeight - superseded.Height

        relativeInputHeight = round(absoluteInputHeight / storageTankHeight, 2)
        relativeOutputHeight = round(
            absoluteOutputHeight / storageTankHeight, 2
        )

        inputPort = Port(superseded.Port1ID, relativeInputHeight)
        outputPort = Port(superseded.Port2ID, relativeOutputHeight)

        side = Side.createFromSideNr(superseded.SideNr)

        portPair = PortPairVersion0(
            side, superseded.DisplayName, inputPort, outputPort
        )

        heatExchanger = HeatExchangerVersion0(
            portPair,
            superseded.Width,
            superseded.ParentID,
            superseded.ID,
            superseded.connTrnsysID,
        )

        return heatExchanger

    @classmethod
    def getVersion(cls) -> _uuid.UUID:
        return _uuid.UUID("23938d79-dc02-4752-ba1b-25d7a610de27")


@_dc.dataclass
class HeatExchangerVersion1(_ser.UpgradableJsonSchemaMixin):
    portPair: PortPairVersion0
    width: float
    parentId: int
    id: int  # pylint: disable=invalid-name

    @classmethod
    def getSupersededClass(
        cls,
    ) -> _tp.Type[_ser.UpgradableJsonSchemaMixinVersion0]:
        return HeatExchangerVersion0

    @classmethod
    def upgrade(
        cls, superseded: _ser.UpgradableJsonSchemaMixinVersion0
    ) -> "HeatExchangerVersion1":
        if not isinstance(superseded, HeatExchangerVersion0):
            raise ValueError(
                f"`superseded` is not of type {HeatExchangerVersion0.__name__}"
            )

        return HeatExchangerVersion1(
            superseded.portPair,
            superseded.width,
            superseded.parentId,
            superseded.id,
        )

    @classmethod
    def getVersion(cls) -> _uuid.UUID:
        return _uuid.UUID("68c5cebb-0c47-4dec-8c85-8872b7f6c238")


@_dc.dataclass
class HeatExchangerVersion2(_ser.UpgradableJsonSchemaMixin):
    portPair: PortPair
    name: str
    width: float
    parentId: int
    id: int  # pylint: disable=invalid-name

    @classmethod
    def getSupersededClass(
        cls,
    ) -> _tp.Type[_ser.UpgradableJsonSchemaMixinVersion0]:
        return HeatExchangerVersion1

    @classmethod
    def upgrade(
        cls, superseded: _ser.UpgradableJsonSchemaMixinVersion0
    ) -> "HeatExchangerVersion2":
        if not isinstance(superseded, HeatExchangerVersion1):
            raise ValueError(
                f"`superseded` is not of type {HeatExchangerVersion1.__name__}"
            )

        portPair = PortPair.fromInstance(superseded.portPair)

        return HeatExchangerVersion2(
            portPair,
            superseded.portPair.name,
            superseded.width,
            superseded.parentId,
            superseded.id,
        )

    @classmethod
    def getVersion(cls) -> _uuid.UUID:
        return _uuid.UUID("be068f84-2627-4f53-87a9-9a1f4fd1c529")


@_dc.dataclass
class HeatExchangerVersion3(_ser.UpgradableJsonSchemaMixin):
    portPair: PortPair
    name: str
    width: int
    parentId: int
    id: int  # pylint: disable=invalid-name

    @classmethod
    def getSupersededClass(
        cls,
    ) -> _tp.Type[_ser.UpgradableJsonSchemaMixinVersion0]:
        return HeatExchangerVersion2

    @classmethod
    def upgrade(
        cls, superseded: _ser.UpgradableJsonSchemaMixinVersion0
    ) -> "HeatExchangerVersion3":
        if not isinstance(superseded, HeatExchangerVersion2):
            raise ValueError(
                f"`superseded` is not of type {HeatExchangerVersion2.__name__}"
            )

        return HeatExchangerVersion3(
            superseded.portPair,
            superseded.name,
            int(superseded.width),
            superseded.parentId,
            superseded.id,
        )

    @classmethod
    def getVersion(cls) -> _uuid.UUID:
        return _uuid.UUID("2edc9b30-baef-4c2f-b105-e88987007e74")


@_dc.dataclass
class HeatExchanger(_ser.UpgradableJsonSchemaMixin):
    portPair: PortPair
    name: str
    width: int
    id: int  # pylint: disable=invalid-name

    @classmethod
    def getSupersededClass(
        cls,
    ) -> _tp.Type[_ser.UpgradableJsonSchemaMixinVersion0]:
        return HeatExchangerVersion3

    @classmethod
    def upgrade(
        cls, superseded: _ser.UpgradableJsonSchemaMixinVersion0
    ) -> "HeatExchanger":
        if not isinstance(superseded, HeatExchangerVersion3):
            raise ValueError(
                f"`superseded` is not of type {HeatExchangerVersion3.__name__}"
            )

        return HeatExchanger(
            superseded.portPair,
            superseded.name,
            superseded.width,
            superseded.id,
        )

    @classmethod
    def getVersion(cls) -> _uuid.UUID:
        return _uuid.UUID("2a5d6090-3ef5-4959-bba4-332654f007ac")


@_dc.dataclass
class DirectPortPairVersion0(_ser.UpgradableJsonSchemaMixinVersion0):
    portPair: PortPairVersion0

    id: int  # pylint: disable=invalid-name

    connectionId: int
    trnsysId: int

    @classmethod
    def createFromLegacyPortPair(
        cls, superseded: DirectPortPairLegacyVersion, storageTankHeight: float
    ) -> "DirectPortPairVersion0":
        absoluteInputHeight = storageTankHeight - superseded.Port1offset
        relativeInputHeight = round(absoluteInputHeight / storageTankHeight, 2)
        inputPort = Port(superseded.Port1ID, relativeInputHeight)

        absoluteOutputHeight = storageTankHeight - superseded.Port2offset
        relativeOutputHeight = round(
            absoluteOutputHeight / storageTankHeight, 2
        )
        outputPort = Port(superseded.Port2ID, relativeOutputHeight)

        side = Side.LEFT if superseded.Side else Side.RIGHT
        portPair = PortPairVersion0(
            side, superseded.ConnDisName, inputPort, outputPort
        )

        return DirectPortPairVersion0(
            portPair,
            superseded.ConnID,
            superseded.ConnCID,
            superseded.trnsysID,
        )

    @classmethod
    def getVersion(cls) -> _uuid.UUID:
        return _uuid.UUID("2629b768-3cfe-4bff-b28d-658ab6154202")


@_dc.dataclass
class DirectPortPair(_ser.UpgradableJsonSchemaMixin):
    portPair: PortPair

    @classmethod
    def getSupersededClass(
        cls,
    ) -> _tp.Type[_ser.UpgradableJsonSchemaMixinVersion0]:
        return DirectPortPairVersion0

    @classmethod
    def upgrade(
        cls, superseded: _ser.UpgradableJsonSchemaMixinVersion0
    ) -> "DirectPortPair":
        if not isinstance(superseded, DirectPortPairVersion0):
            raise ValueError(
                f"Superseded instance is not of type {DirectPortPairVersion0.__name__}"
            )

        portPair = PortPair.fromInstance(superseded.portPair)

        return DirectPortPair(portPair)

    @classmethod
    def getVersion(cls) -> _uuid.UUID:
        return _uuid.UUID("67aaee05-7d09-40e1-a6e2-d367c7196832")

1	import dataclasses as _dc	1✔
2	import typing as _tp	1✔
3	import uuid as _uuid	1✔
4
5	import dataclasses_jsonschema as _dcj	1✔
6
7	import pytrnsys.utils.serialization as _ser	1✔
8	from trnsysGUI import idGenerator as _id	1✔
9	from trnsysGUI.storageTank.side import Side	1✔
10
11
12	@_dc.dataclass	1✔
13	class StorageTankVersion0(	1✔
14	_ser.UpgradableJsonSchemaMixinVersion0
15	): # pylint: disable=too-many-instance-attributes
16	FlippedH: bool # pylint: disable=invalid-name	1✔
17	FlippedV: bool # pylint: disable=invalid-name	1✔
18	BlockName: str # pylint: disable=invalid-name	1✔
19	BlockDisplayName: str # pylint: disable=invalid-name	1✔
20	GroupName: str # pylint: disable=invalid-name	1✔
21	size_h: int # pylint: disable=invalid-name	1✔
22	StoragePosition: _tp.Tuple[float, float] # pylint: disable=invalid-name	1✔
23	trnsysID: int	1✔
24	ID: int # pylint: disable=invalid-name	1✔
25	HxList: _tp.Sequence[ # pylint: disable=invalid-name	1✔
26	"HeatExchangerLegacyVersion"
27	]
28	PortPairList: _tp.Sequence[ # pylint: disable=invalid-name	1✔
29	"DirectPortPairLegacyVersion"
30	]
31
32	@classmethod	1✔
33	def getVersion(cls) -> _uuid.UUID:	1✔
34	return _uuid.UUID("05f422d3-41fd-48d1-b8d0-4655d9f65247")	1✔
35
36
37	@_dc.dataclass	1✔
38	class HeatExchangerLegacyVersion(	1✔
39	_dcj.JsonSchemaMixin
40	): # pylint: disable=too-many-instance-attributes
41	SideNr: int # pylint: disable=invalid-name	1✔
42	Width: float # pylint: disable=invalid-name	1✔
43	Height: float # pylint: disable=invalid-name	1✔
44	Offset: _tp.Tuple[float, float] # pylint: disable=invalid-name	1✔
45	DisplayName: str # pylint: disable=invalid-name	1✔
46	ParentID: int # pylint: disable=invalid-name	1✔
47	Port1ID: int # pylint: disable=invalid-name	1✔
48	Port2ID: int # pylint: disable=invalid-name	1✔
49	connTrnsysID: int # pylint: disable=invalid-name	1✔
50	ID: int # pylint: disable=invalid-name	1✔
51
52
53	@_dc.dataclass	1✔
54	class DirectPortPairLegacyVersion(	1✔
55	_dcj.JsonSchemaMixin
56	): # pylint: disable=too-many-instance-attributes
57	Side: bool # pylint: disable=invalid-name	1✔
58	Port1offset: float # pylint: disable=invalid-name	1✔
59	Port2offset: float # pylint: disable=invalid-name	1✔
60	Port1ID: int # pylint: disable=invalid-name	1✔
61	Port2ID: int # pylint: disable=invalid-name	1✔
62	ConnID: int # pylint: disable=invalid-name	1✔
63	ConnCID: int # pylint: disable=invalid-name	1✔
64	ConnDisName: str # pylint: disable=invalid-name	1✔
65	trnsysID: int # pylint: disable=invalid-name	1✔
66
67
68	@_dc.dataclass	1✔
69	class StorageTankVersion1(	1✔
70	_ser.UpgradableJsonSchemaMixin
71	): # pylint: disable=too-many-instance-attributes
72	isHorizontallyFlipped: bool	1✔
73	isVerticallyFlipped: bool	1✔
74
75	BlockName: str # pylint: disable=invalid-name	1✔
76	BlockDisplayName: str # pylint: disable=invalid-name	1✔
77
78	groupName: str	1✔
79	id: int # pylint: disable=invalid-name	1✔
80	trnsysId: int	1✔
81
82	height: int	1✔
83	position: _tp.Tuple[float, float]	1✔
84
85	heatExchangers: _tp.Sequence["HeatExchanger"]	1✔
86
87	directPortPairs: _tp.Sequence["DirectPortPair"]	1✔
88
89	@classmethod	1✔
90	def upgrade(	1✔
91	cls, superseded: _ser.UpgradableJsonSchemaMixinVersion0
92	) -> "StorageTankVersion1":
93	if not isinstance(superseded, StorageTankVersion0):	1✔
NEW 94	raise ValueError(	×
95	f"Can only upgrade a {StorageTankVersion0.__name__} instance."
96	)
97
98	heatExchangers = cls._upgradeHeatExchangers(	1✔
99	superseded.HxList, superseded.size_h
100	)
101	directPortPairs = cls._upgradeDirectPortPairs(	1✔
102	superseded.PortPairList, superseded.size_h
103	)
104
105	return StorageTankVersion1(	1✔
106	superseded.FlippedH,
107	superseded.FlippedV,
108	superseded.BlockName,
109	superseded.BlockDisplayName,
110	superseded.GroupName,
111	superseded.ID,
112	superseded.trnsysID,
113	superseded.size_h,
114	superseded.StoragePosition,
115	heatExchangers,
116	directPortPairs,
117	)
118
119	@classmethod	1✔
120	def _upgradeHeatExchangers(	1✔
121	cls,
122	supersededHeatExchangers: _tp.Sequence[HeatExchangerLegacyVersion],
123	storageTankHeight: float,
124	) -> _tp.Sequence["HeatExchanger"]:
125	heatExchangers = []	1✔
126	for supersededHeatExchanger in supersededHeatExchangers:	1✔
127	heatExchangerVersion0 = (	1✔
128	HeatExchangerVersion0.createFromLegacyHeatExchanger(
129	supersededHeatExchanger, storageTankHeight
130	)
131	)
132
133	heatExchanger = HeatExchanger.fromInstance(heatExchangerVersion0)	1✔
134
135	heatExchangers.append(heatExchanger)	1✔
136
137	return heatExchangers	1✔
138
139	@classmethod	1✔
140	def _upgradeDirectPortPairs(	1✔
141	cls,
142	supersededPairs: _tp.Sequence[DirectPortPairLegacyVersion],
143	storageTankHeight: float,
144	) -> _tp.Sequence["DirectPortPair"]:
145	directPortPairs = []	1✔
146	for supersededPair in supersededPairs:	1✔
147	directPortPairVersion0 = (	1✔
148	DirectPortPairVersion0.createFromLegacyPortPair(
149	supersededPair, storageTankHeight
150	)
151	)
152
153	directPortPair = DirectPortPair.fromInstance(	1✔
154	directPortPairVersion0
155	)
156
157	directPortPairs.append(directPortPair)	1✔
158
159	return directPortPairs	1✔
160
161	@classmethod	1✔
162	def getVersion(cls) -> _uuid.UUID:	1✔
163	return _uuid.UUID("05f422d3-41fd-48d1-b8d0-4655d9f65247")	1✔
164
165	@classmethod	1✔
166	def getSupersededClass(cls):	1✔
167	return StorageTankVersion0	1✔
168
169
170	@_dc.dataclass	1✔
171	class StorageTankVersion2(	1✔
172	_ser.UpgradableJsonSchemaMixin
173	): # pylint: disable=too-many-instance-attributes
174	isHorizontallyFlipped: bool	1✔
175	isVerticallyFlipped: bool	1✔
176
177	BlockName: str # pylint: disable=invalid-name	1✔
178	BlockDisplayName: str # pylint: disable=invalid-name	1✔
179
180	id: int # pylint: disable=invalid-name	1✔
181	trnsysId: int	1✔
182
183	height: int	1✔
184	position: _tp.Tuple[float, float]	1✔
185
186	heatExchangers: _tp.Sequence["HeatExchanger"]	1✔
187
188	directPortPairs: _tp.Sequence["DirectPortPair"]	1✔
189
190	@classmethod	1✔
191	def upgrade(	1✔
192	cls, superseded: _ser.UpgradableJsonSchemaMixinVersion0
193	) -> "StorageTankVersion2":
194	if not isinstance(superseded, StorageTankVersion1):	1✔
NEW 195	raise ValueError(	×
196	f"Can only upgrade a {StorageTankVersion1.__name__} instance."
197	)
198
199	return StorageTankVersion2(	1✔
200	superseded.isHorizontallyFlipped,
201	superseded.isVerticallyFlipped,
202	superseded.BlockName,
203	superseded.BlockDisplayName,
204	superseded.id,
205	superseded.trnsysId,
206	superseded.height,
207	superseded.position,
208	superseded.heatExchangers,
209	superseded.directPortPairs,
210	)
211
212	@classmethod	1✔
213	def getVersion(cls) -> _uuid.UUID:	1✔
214	return _uuid.UUID("05f422d3-41fd-48d1-b8d0-4655d9f65247")	1✔
215
216	@classmethod	1✔
217	def getSupersededClass(cls):	1✔
218	return StorageTankVersion1	1✔
219
220
221	@_dc.dataclass	1✔
222	class StorageTank(	1✔
223	_ser.UpgradableJsonSchemaMixin
224	): # pylint: disable=too-many-instance-attributes
225	isHorizontallyFlipped: bool	1✔
226	isVerticallyFlipped: bool	1✔
227
228	BlockName: str # pylint: disable=invalid-name	1✔
229	BlockDisplayName: str # pylint: disable=invalid-name	1✔
230
231	trnsysId: int	1✔
232
233	height: int	1✔
234	position: _tp.Tuple[float, float]	1✔
235
236	heatExchangers: _tp.Sequence["HeatExchanger"]	1✔
237
238	directPortPairs: _tp.Sequence["DirectPortPair"]	1✔
239
240	@classmethod	1✔
241	def from_dict(	1✔
242	cls,
243	data: _dcj.JsonDict, # pylint: disable=duplicate-code # 2
244	validate=True,
245	validate_enums: bool = True,
246	schema_type: _dcj.SchemaType = _dcj.DEFAULT_SCHEMA_TYPE, # /NOSONAR,
247	) -> "StorageTank":
248	data.pop(".__BlockDict__")	1✔
249	storageTank = super().from_dict(	1✔
250	data, validate, validate_enums, schema_type
251	)
252	return _tp.cast(StorageTank, storageTank)	1✔
253
254	def to_dict(	1✔
255	self,
256	omit_none: bool = True,
257	validate: bool = False,
258	validate_enums: bool = True,
259	schema_type: _dcj.SchemaType = _dcj.DEFAULT_SCHEMA_TYPE, # /NOSONAR,
260	) -> _dcj.JsonDict:
261	data = super().to_dict(	1✔
262	omit_none, validate, validate_enums, schema_type
263	) # pylint: disable=duplicate-code # 1
264	data[".__BlockDict__"] = True	1✔
265	return data	1✔
266
267	@classmethod	1✔
268	def getSupersededClass(cls):	1✔
269	return StorageTankVersion2	1✔
270
271	@classmethod	1✔
272	def upgrade(	1✔
273	cls, superseded: _ser.UpgradableJsonSchemaMixinVersion0
274	) -> "StorageTank":
275	if not isinstance(superseded, StorageTankVersion2):	1✔
NEW 276	raise ValueError(	×
277	f"Can only upgrade a {StorageTankVersion2.__name__} instance."
278	)
279
280	return StorageTank(	1✔
281	superseded.isHorizontallyFlipped,
282	superseded.isVerticallyFlipped,
283	superseded.BlockName,
284	superseded.BlockDisplayName,
285	superseded.trnsysId,
286	superseded.height,
287	superseded.position,
288	superseded.heatExchangers,
289	superseded.directPortPairs,
290	)
291
292	@classmethod	1✔
293	def getVersion(cls) -> _uuid.UUID:	1✔
294	return _uuid.UUID("35f8800b-3a22-4080-acc2-13f332a84d50")	1✔
295
296
297	@_dc.dataclass	1✔
298	class Port(_dcj.JsonSchemaMixin):	1✔
299	id: int # pylint: disable=invalid-name	1✔
300	relativeHeight: float	1✔
301
302
303	@_dc.dataclass	1✔
304	class PortPairVersion0(_ser.UpgradableJsonSchemaMixinVersion0):	1✔
305	side: Side	1✔
306
307	name: str	1✔
308
309	inputPort: Port	1✔
310	outputPort: Port	1✔
311
312	@classmethod	1✔
313	def getVersion(cls) -> _uuid.UUID:	1✔
314	return _uuid.UUID("e1b81a7b-51ca-44f0-9d3a-6b6c42eb8e91")	1✔
315
316
317	@_dc.dataclass	1✔
318	class PortPair(_ser.UpgradableJsonSchemaMixin):	1✔
319	side: Side	1✔
320
321	trnsysId: int	1✔
322	inputPort: Port	1✔
323	outputPort: Port	1✔
324
325	@classmethod	1✔
326	def getSupersededClass(	1✔
327	cls,
328	) -> _tp.Type[_ser.UpgradableJsonSchemaMixinVersion0]:
329	return PortPairVersion0	1✔
330
331	@classmethod	1✔
332	def upgrade(	1✔
333	cls, superseded: _ser.UpgradableJsonSchemaMixinVersion0
334	) -> "PortPair":
335	if not isinstance(superseded, PortPairVersion0):	1✔
NEW 336	raise ValueError(	×
337	f"Superseded instance is not of type {PortPairVersion0.__name__}"
338	)
339
340	return PortPair(	1✔
341	superseded.side,
342	_id.IdGenerator.UNINITIALIZED_ID, # type: ignore[attr-defined]
343	superseded.inputPort,
344	superseded.outputPort,
345	)
346
347	@classmethod	1✔
348	def getVersion(cls) -> _uuid.UUID:	1✔
349	return _uuid.UUID("ed17e7a7-4798-4a80-beb7-81730523cf35")	1✔
350
351
352	@_dc.dataclass	1✔
353	class HeatExchangerVersion0(_ser.UpgradableJsonSchemaMixinVersion0):	1✔
354	portPair: PortPairVersion0	1✔
355
356	width: float	1✔
357
358	parentId: int	1✔
359
360	id: int # pylint: disable=invalid-name	1✔
361	connectionTrnsysId: int	1✔
362
363	@classmethod	1✔
364	def createFromLegacyHeatExchanger(	1✔
365	cls,
366	superseded: HeatExchangerLegacyVersion,
367	storageTankHeight: float,
368	) -> "HeatExchangerVersion0":
369	absoluteInputHeight = storageTankHeight - superseded.Offset[1]	1✔
370	absoluteOutputHeight = absoluteInputHeight - superseded.Height	1✔
371
372	relativeInputHeight = round(absoluteInputHeight / storageTankHeight, 2)	1✔
373	relativeOutputHeight = round(	1✔
374	absoluteOutputHeight / storageTankHeight, 2
375	)
376
377	inputPort = Port(superseded.Port1ID, relativeInputHeight)	1✔
378	outputPort = Port(superseded.Port2ID, relativeOutputHeight)	1✔
379
380	side = Side.createFromSideNr(superseded.SideNr)	1✔
381
382	portPair = PortPairVersion0(	1✔
383	side, superseded.DisplayName, inputPort, outputPort
384	)
385
386	heatExchanger = HeatExchangerVersion0(	1✔
387	portPair,
388	superseded.Width,
389	superseded.ParentID,
390	superseded.ID,
391	superseded.connTrnsysID,
392	)
393
394	return heatExchanger	1✔
395
396	@classmethod	1✔
397	def getVersion(cls) -> _uuid.UUID:	1✔
398	return _uuid.UUID("23938d79-dc02-4752-ba1b-25d7a610de27")	1✔
399
400
401	@_dc.dataclass	1✔
402	class HeatExchangerVersion1(_ser.UpgradableJsonSchemaMixin):	1✔
403	portPair: PortPairVersion0	1✔
404	width: float	1✔
405	parentId: int	1✔
406	id: int # pylint: disable=invalid-name	1✔
407
408	@classmethod	1✔
409	def getSupersededClass(	1✔
410	cls,
411	) -> _tp.Type[_ser.UpgradableJsonSchemaMixinVersion0]:
412	return HeatExchangerVersion0	1✔
413
414	@classmethod	1✔
415	def upgrade(	1✔
416	cls, superseded: _ser.UpgradableJsonSchemaMixinVersion0
417	) -> "HeatExchangerVersion1":
418	if not isinstance(superseded, HeatExchangerVersion0):	1✔
NEW 419	raise ValueError(	×
420	f"`superseded` is not of type {HeatExchangerVersion0.__name__}"
421	)
422
423	return HeatExchangerVersion1(	1✔
424	superseded.portPair,
425	superseded.width,
426	superseded.parentId,
427	superseded.id,
428	)
429
430	@classmethod	1✔
431	def getVersion(cls) -> _uuid.UUID:	1✔
432	return _uuid.UUID("68c5cebb-0c47-4dec-8c85-8872b7f6c238")	1✔
433
434
435	@_dc.dataclass	1✔
436	class HeatExchangerVersion2(_ser.UpgradableJsonSchemaMixin):	1✔
437	portPair: PortPair	1✔
438	name: str	1✔
439	width: float	1✔
440	parentId: int	1✔
441	id: int # pylint: disable=invalid-name	1✔
442
443	@classmethod	1✔
444	def getSupersededClass(	1✔
445	cls,
446	) -> _tp.Type[_ser.UpgradableJsonSchemaMixinVersion0]:
447	return HeatExchangerVersion1	1✔
448
449	@classmethod	1✔
450	def upgrade(	1✔
451	cls, superseded: _ser.UpgradableJsonSchemaMixinVersion0
452	) -> "HeatExchangerVersion2":
453	if not isinstance(superseded, HeatExchangerVersion1):	1✔
NEW 454	raise ValueError(	×
455	f"`superseded` is not of type {HeatExchangerVersion1.__name__}"
456	)
457
458	portPair = PortPair.fromInstance(superseded.portPair)	1✔
459
460	return HeatExchangerVersion2(	1✔
461	portPair,
462	superseded.portPair.name,
463	superseded.width,
464	superseded.parentId,
465	superseded.id,
466	)
467
468	@classmethod	1✔
469	def getVersion(cls) -> _uuid.UUID:	1✔
470	return _uuid.UUID("be068f84-2627-4f53-87a9-9a1f4fd1c529")	1✔
471
472
473	@_dc.dataclass	1✔
474	class HeatExchangerVersion3(_ser.UpgradableJsonSchemaMixin):	1✔
475	portPair: PortPair	1✔
476	name: str	1✔
477	width: int	1✔
478	parentId: int	1✔
479	id: int # pylint: disable=invalid-name	1✔
480
481	@classmethod	1✔
482	def getSupersededClass(	1✔
483	cls,
484	) -> _tp.Type[_ser.UpgradableJsonSchemaMixinVersion0]:
485	return HeatExchangerVersion2	1✔
486
487	@classmethod	1✔
488	def upgrade(	1✔
489	cls, superseded: _ser.UpgradableJsonSchemaMixinVersion0
490	) -> "HeatExchangerVersion3":
491	if not isinstance(superseded, HeatExchangerVersion2):	1✔
NEW 492	raise ValueError(	×
493	f"`superseded` is not of type {HeatExchangerVersion2.__name__}"
494	)
495
496	return HeatExchangerVersion3(	1✔
497	superseded.portPair,
498	superseded.name,
499	int(superseded.width),
500	superseded.parentId,
501	superseded.id,
502	)
503
504	@classmethod	1✔
505	def getVersion(cls) -> _uuid.UUID:	1✔
506	return _uuid.UUID("2edc9b30-baef-4c2f-b105-e88987007e74")	1✔
507
508
509	@_dc.dataclass	1✔
510	class HeatExchanger(_ser.UpgradableJsonSchemaMixin):	1✔
511	portPair: PortPair	1✔
512	name: str	1✔
513	width: int	1✔
514	id: int # pylint: disable=invalid-name	1✔
515
516	@classmethod	1✔
517	def getSupersededClass(	1✔
518	cls,
519	) -> _tp.Type[_ser.UpgradableJsonSchemaMixinVersion0]:
520	return HeatExchangerVersion3	1✔
521
522	@classmethod	1✔
523	def upgrade(	1✔
524	cls, superseded: _ser.UpgradableJsonSchemaMixinVersion0
525	) -> "HeatExchanger":
526	if not isinstance(superseded, HeatExchangerVersion3):	1✔
NEW 527	raise ValueError(	×
528	f"`superseded` is not of type {HeatExchangerVersion3.__name__}"
529	)
530
531	return HeatExchanger(	1✔
532	superseded.portPair,
533	superseded.name,
534	superseded.width,
535	superseded.id,
536	)
537
538	@classmethod	1✔
539	def getVersion(cls) -> _uuid.UUID:	1✔
540	return _uuid.UUID("2a5d6090-3ef5-4959-bba4-332654f007ac")	1✔
541
542
543	@_dc.dataclass	1✔
544	class DirectPortPairVersion0(_ser.UpgradableJsonSchemaMixinVersion0):	1✔
545	portPair: PortPairVersion0	1✔
546
547	id: int # pylint: disable=invalid-name	1✔
548
549	connectionId: int	1✔
550	trnsysId: int	1✔
551
552	@classmethod	1✔
553	def createFromLegacyPortPair(	1✔
554	cls, superseded: DirectPortPairLegacyVersion, storageTankHeight: float
555	) -> "DirectPortPairVersion0":
556	absoluteInputHeight = storageTankHeight - superseded.Port1offset	1✔
557	relativeInputHeight = round(absoluteInputHeight / storageTankHeight, 2)	1✔
558	inputPort = Port(superseded.Port1ID, relativeInputHeight)	1✔
559
560	absoluteOutputHeight = storageTankHeight - superseded.Port2offset	1✔
561	relativeOutputHeight = round(	1✔
562	absoluteOutputHeight / storageTankHeight, 2
563	)
564	outputPort = Port(superseded.Port2ID, relativeOutputHeight)	1✔
565
566	side = Side.LEFT if superseded.Side else Side.RIGHT	1✔
567	portPair = PortPairVersion0(	1✔
568	side, superseded.ConnDisName, inputPort, outputPort
569	)
570
571	return DirectPortPairVersion0(	1✔
572	portPair,
573	superseded.ConnID,
574	superseded.ConnCID,
575	superseded.trnsysID,
576	)
577
578	@classmethod	1✔
579	def getVersion(cls) -> _uuid.UUID:	1✔
580	return _uuid.UUID("2629b768-3cfe-4bff-b28d-658ab6154202")	1✔
581
582
583	@_dc.dataclass	1✔
584	class DirectPortPair(_ser.UpgradableJsonSchemaMixin):	1✔
585	portPair: PortPair	1✔
586
587	@classmethod	1✔
588	def getSupersededClass(	1✔
589	cls,
590	) -> _tp.Type[_ser.UpgradableJsonSchemaMixinVersion0]:
591	return DirectPortPairVersion0	1✔
592
593	@classmethod	1✔
594	def upgrade(	1✔
595	cls, superseded: _ser.UpgradableJsonSchemaMixinVersion0
596	) -> "DirectPortPair":
597	if not isinstance(superseded, DirectPortPairVersion0):	1✔
NEW 598	raise ValueError(	×
599	f"Superseded instance is not of type {DirectPortPairVersion0.__name__}"
600	)
601
602	portPair = PortPair.fromInstance(superseded.portPair)	1✔
603
604	return DirectPortPair(portPair)	1✔
605
606	@classmethod	1✔
607	def getVersion(cls) -> _uuid.UUID:	1✔
608	return _uuid.UUID("67aaee05-7d09-40e1-a6e2-d367c7196832")	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