wip

Signed-off-by: Jan Kowalleck <[email protected]>

Author: jkowalleck

cyclonedx/model/bom.py

@@ -48,6 +48,8 @@
 from .service import Service
 from .tool import Tool, ToolRepository, _ToolRepositoryHelper
 from .vulnerability import Vulnerability
+from .._internal.compare import ComparableTuple as _ComparableTuple
+
 
 if TYPE_CHECKING:  # pragma: no cover
     from packageurl import PackageURL
@@ -293,16 +295,20 @@ def properties(self) -> 'SortedSet[Property]':
     def properties(self, properties: Iterable[Property]) -> None:
         self._properties = SortedSet(properties)
 
+    def __comparable_tuple(self) -> _ComparableTuple:
+        return _ComparableTuple((
+            _ComparableTuple(self.authors), self.component, _ComparableTuple(self.licenses), self.manufacture,
+            _ComparableTuple(self.properties),
+            _ComparableTuple(self.lifecycles), self.supplier, self.timestamp, self.tools, self.manufacturer
+        ))
+
     def __eq__(self, other: object) -> bool:
         if isinstance(other, BomMetaData):
-            return hash(other) == hash(self)
+            return self.__comparable_tuple() == other.__comparable_tuple()
         return False
 
     def __hash__(self) -> int:
-        return hash((
-            tuple(self.authors), self.component, tuple(self.licenses), self.manufacture, tuple(self.properties),
-            tuple(self.lifecycles), self.supplier, self.timestamp, self.tools, self.manufacturer
-        ))
+        return hash(self.__comparable_tuple())
 
     def __repr__(self) -> str:
         return f'<BomMetaData timestamp={self.timestamp}, component={self.component}>'
@@ -722,17 +728,20 @@ def validate(self) -> bool:
 
         return True
 
+    def __comparable_tuple(self) -> _ComparableTuple:
+        return _ComparableTuple((
+            self.serial_number, self.version, self.metadata, _ComparableTuple(self.components), _ComparableTuple(self.services),
+            _ComparableTuple(self.external_references), _ComparableTuple(self.dependencies), _ComparableTuple(self.properties),
+            _ComparableTuple(self.vulnerabilities),
+        ))
+
     def __eq__(self, other: object) -> bool:
         if isinstance(other, Bom):
-            return hash(other) == hash(self)
+            return self.__comparable_tuple() == other.__comparable_tuple()
         return False
 
     def __hash__(self) -> int:
-        return hash((
-            self.serial_number, self.version, self.metadata, tuple(self.components), tuple(self.services),
-            tuple(self.external_references), tuple(self.dependencies), tuple(self.properties),
-            tuple(self.vulnerabilities),
-        ))
+        return hash(self.__comparable_tuple())
 
     def __repr__(self) -> str:
         return f'<Bom uuid={self.serial_number}, hash={hash(self)}>'

cyclonedx/model/component.py

@@ -171,22 +171,23 @@ def message(self) -> Optional[str]:
     def message(self, message: Optional[str]) -> None:
         self._message = message
 
+    def __comparable_tuple(self) -> _ComparableTuple:
+        return _ComparableTuple((
+            self.uid, self.url, self.author, self.committer, self.message
+        ))
+
     def __eq__(self, other: object) -> bool:
         if isinstance(other, Commit):
-            return hash(other) == hash(self)
+            return self.__comparable_tuple() == other.__comparable_tuple()
         return False
 
     def __lt__(self, other: Any) -> bool:
         if isinstance(other, Commit):
-            return _ComparableTuple((
-                self.uid, self.url, self.author, self.committer, self.message
-            )) < _ComparableTuple((
-                other.uid, other.url, other.author, other.committer, other.message
-            ))
+            return self.__comparable_tuple() < other.__comparable_tuple()
         return NotImplemented
 
     def __hash__(self) -> int:
-        return hash((self.uid, self.url, self.author, self.committer, self.message))
+        return hash(self.__comparable_tuple())
 
     def __repr__(self) -> str:
         return f'<Commit uid={self.uid}, url={self.url}, message={self.message}>'
@@ -281,13 +282,19 @@ def copyright(self) -> 'SortedSet[Copyright]':
     def copyright(self, copyright: Iterable[Copyright]) -> None:
         self._copyright = SortedSet(copyright)
 
+    def __comparable_tuple(self) -> _ComparableTuple:
+        return _ComparableTuple((
+            _ComparableTuple(self.licenses),
+            _ComparableTuple(self.copyright),
+        ))
+
     def __eq__(self, other: object) -> bool:
         if isinstance(other, ComponentEvidence):
-            return hash(other) == hash(self)
+            return self.__comparable_tuple() == other.__comparable_tuple()
         return False
 
     def __hash__(self) -> int:
-        return hash((tuple(self.licenses), tuple(self.copyright)))
+        return hash(self.__comparable_tuple())
 
     def __repr__(self) -> str:
         return f'<ComponentEvidence id={id(self)}>'
@@ -478,22 +485,23 @@ def url(self) -> Optional[XsUri]:
     def url(self, url: Optional[XsUri]) -> None:
         self._url = url
 
+    def __comparable_tuple(self) -> _ComparableTuple:
+        return _ComparableTuple((
+            self.text, self.url
+        ))
+
     def __eq__(self, other: object) -> bool:
         if isinstance(other, Diff):
-            return hash(other) == hash(self)
+            return self.__comparable_tuple() == other.__comparable_tuple()
         return False
 
     def __lt__(self, other: Any) -> bool:
         if isinstance(other, Diff):
-            return _ComparableTuple((
-                self.url, self.text
-            )) < _ComparableTuple((
-                other.url, other.text
-            ))
+            return self.__comparable_tuple() < other.__comparable_tuple()
         return NotImplemented
 
     def __hash__(self) -> int:
-        return hash((self.text, self.url))
+        return hash(self.__comparable_tuple())
 
     def __repr__(self) -> str:
         return f'<Diff url={self.url}>'
@@ -580,22 +588,23 @@ def resolves(self) -> 'SortedSet[IssueType]':
     def resolves(self, resolves: Iterable[IssueType]) -> None:
         self._resolves = SortedSet(resolves)
 
+    def __comparable_tuple(self) -> _ComparableTuple:
+        return _ComparableTuple((
+            self.type, self.diff, _ComparableTuple(self.resolves)
+        ))
+
     def __eq__(self, other: object) -> bool:
         if isinstance(other, Patch):
-            return hash(other) == hash(self)
+            return self.__comparable_tuple() == other.__comparable_tuple()
         return False
 
     def __lt__(self, other: Any) -> bool:
         if isinstance(other, Patch):
-            return _ComparableTuple((
-                self.type, self.diff, _ComparableTuple(self.resolves)
-            )) < _ComparableTuple((
-                other.type, other.diff, _ComparableTuple(other.resolves)
-            ))
+            return self.__comparable_tuple() < other.__comparable_tuple()
         return NotImplemented
 
     def __hash__(self) -> int:
-        return hash((self.type, self.diff, tuple(self.resolves)))
+        return hash(self.__comparable_tuple())
 
     def __repr__(self) -> str:
         return f'<Patch type={self.type}, id={id(self)}>'
@@ -1741,52 +1750,33 @@ def get_pypi_url(self) -> str:
         else:
             return f'https://pypi.org/project/{self.name}'
 
+    def __comparable_tuple(self) -> _ComparableTuple:
+        return _ComparableTuple((
+            self.type, self.group, self.name, self.version,
+            self.mime_type, self.supplier, self.author, self.publisher,
+            self.description, self.scope, _ComparableTuple(self.hashes),
+            _ComparableTuple(self.licenses), self.copyright, self.cpe,
+            None if self.purl is None else _ComparablePackageURL(self.purl),
+            self.swid, self.pedigree,
+            _ComparableTuple(self.external_references), _ComparableTuple(self.properties),
+            _ComparableTuple(self.components), self.evidence, self.release_notes, self.modified,
+            _ComparableTuple(self.authors), _ComparableTuple(self.omnibor_ids), self.manufacturer,
+            _ComparableTuple(self.swhids), self.crypto_properties, _ComparableTuple(self.tags),
+        ))
+
     def __eq__(self, other: object) -> bool:
         if isinstance(other, Component):
-            return hash(other) == hash(self)
+            return self.__comparable_tuple() == other.__comparable_tuple()
         return False
 
     def __lt__(self, other: Any) -> bool:
         if isinstance(other, Component):
-            return _ComparableTuple((
-                self.type, self.group, self.name, self.version,
-                self.mime_type, self.supplier, self.author, self.publisher,
-                self.description, self.scope, _ComparableTuple(self.hashes),
-                _ComparableTuple(self.licenses), self.copyright, self.cpe,
-                None if self.purl is None else _ComparablePackageURL(self.purl),
-                self.swid, self.pedigree,
-                _ComparableTuple(self.external_references), _ComparableTuple(self.properties),
-                _ComparableTuple(self.components), self.evidence, self.release_notes, self.modified,
-                _ComparableTuple(self.authors), _ComparableTuple(self.omnibor_ids), self.manufacturer,
-                _ComparableTuple(self.swhids), self.crypto_properties, _ComparableTuple(self.tags)
-            )) < _ComparableTuple((
-                other.type, other.group, other.name, other.version,
-                other.mime_type, other.supplier, other.author, other.publisher,
-                other.description, other.scope, _ComparableTuple(other.hashes),
-                _ComparableTuple(other.licenses), other.copyright, other.cpe,
-                None if other.purl is None else _ComparablePackageURL(other.purl),
-                other.swid, other.pedigree,
-                _ComparableTuple(other.external_references), _ComparableTuple(other.properties),
-                _ComparableTuple(other.components), other.evidence, other.release_notes, other.modified,
-                _ComparableTuple(other.authors), _ComparableTuple(other.omnibor_ids), other.manufacturer,
-                _ComparableTuple(other.swhids), other.crypto_properties, _ComparableTuple(other.tags)
-            ))
+            return self.__comparable_tuple() < other.__comparable_tuple()
         return NotImplemented
 
     def __hash__(self) -> int:
-        return hash((
-            self.type, self.group, self.name, self.version,
-            self.mime_type, self.supplier, self.author, self.publisher,
-            self.description, self.scope, tuple(self.hashes),
-            tuple(self.licenses), self.copyright, self.cpe,
-            self.purl,
-            self.swid, self.pedigree,
-            tuple(self.external_references), tuple(self.properties),
-            tuple(self.components), self.evidence, self.release_notes, self.modified,
-            tuple(self.authors), tuple(self.omnibor_ids), self.manufacturer,
-            tuple(self.swhids), self.crypto_properties, tuple(self.tags)
-        ))
+        return hash(self.__comparable_tuple())
 
     def __repr__(self) -> str:
         return f'<Component bom-ref={self.bom_ref!r}, group={self.group}, name={self.name}, ' \
-               f'version={self.version}, type={self.type}>'
+            f'version={self.version}, type={self.type}>'

cyclonedx/model/contact.py

@@ -163,25 +163,26 @@ def street_address(self) -> Optional[str]:
     def street_address(self, street_address: Optional[str]) -> None:
         self._street_address = street_address
 
+    def __comparable_tuple(self) -> _ComparableTuple:
+       return  _ComparableTuple((
+            self.bom_ref,
+            self.country, self.region, self.locality, self.postal_code,
+            self.post_office_box_number,
+            self.street_address
+        ))
+
     def __eq__(self, other: object) -> bool:
         if isinstance(other, PostalAddress):
-            return hash(other) == hash(self)
+            return self.__comparable_tuple() == other.__comparable_tuple()
         return False
 
     def __lt__(self, other: Any) -> bool:
         if isinstance(other, PostalAddress):
-            return _ComparableTuple((
-                self.bom_ref, self.country, self.region, self.locality, self.post_office_box_number, self.postal_code,
-                self.street_address
-            )) < _ComparableTuple((
-                other.bom_ref, other.country, other.region, other.locality, other.post_office_box_number,
-                other.postal_code, other.street_address
-            ))
+            return self.__comparable_tuple() < other.__comparable_tuple()
         return NotImplemented
 
     def __hash__(self) -> int:
-        return hash((self.bom_ref, self.country, self.region, self.locality, self.post_office_box_number,
-                     self.postal_code, self.street_address))
+        return hash(self.__comparable_tuple())
 
     def __repr__(self) -> str:
         return f'<PostalAddress bom-ref={self.bom_ref}, street_address={self.street_address}, country={self.country}>'

cyclonedx/model/definition.py

@@ -53,21 +53,26 @@ def __init__(
         self.owner = owner
         self.external_references = external_references or []  # type:ignore[assignment]
 
+    def __comparable_tuple(self) -> _ComparableTuple:
+        return _ComparableTuple((
+            self.bom_ref,
+            self.name, self.version,
+            self.description, self.owner,
+            _ComparableTuple(self.external_references)
+        ))
+
     def __lt__(self, other: Any) -> bool:
         if isinstance(other, Standard):
-            return (_ComparableTuple((self.bom_ref, self.name, self.version))
-                    < _ComparableTuple((other.bom_ref, other.name, other.version)))
+            return self.__comparable_tuple() < other.__comparable_tuple()
         return NotImplemented
 
     def __eq__(self, other: object) -> bool:
         if isinstance(other, Standard):
-            return hash(other) == hash(self)
+            return self.__comparable_tuple() == other.__comparable_tuple()
         return False
 
     def __hash__(self) -> int:
-        return hash((
-            self.bom_ref, self.name, self.version, self.description, self.owner, tuple(self.external_references)
-        ))
+        return hash(self.__comparable_tuple())
 
     def __repr__(self) -> str:
         return f'<Standard bom-ref={self.bom_ref}, name={self.name}, version={self.version}, ' \
@@ -212,20 +217,21 @@ def standards(self, standards: Iterable[Standard]) -> None:
     def __bool__(self) -> bool:
         return len(self._standards) > 0
 
-    def __eq__(self, other: object) -> bool:
-        if not isinstance(other, Definitions):
-            return False
-
-        return self._standards == other._standards
+    def __comparable_tuple(self) -> _ComparableTuple:
+        return _ComparableTuple(self._standards)
 
-    def __hash__(self) -> int:
-        return hash((tuple(self._standards)))
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, Definitions):
+            return self.__comparable_tuple() == other.__comparable_tuple()
+        return False
 
     def __lt__(self, other: Any) -> bool:
         if isinstance(other, Definitions):
-            return (_ComparableTuple(self._standards)
-                    < _ComparableTuple(other.standards))
+            return self.__comparable_tuple() < other.__comparable_tuple()
         return NotImplemented
 
+    def __hash__(self) -> int:
+        return hash(self.__comparable_tuple())
+
     def __repr__(self) -> str:
         return '<Definitions>'

cyclonedx/model/service.py

@@ -354,26 +354,26 @@ def release_notes(self) -> Optional[ReleaseNotes]:
     def release_notes(self, release_notes: Optional[ReleaseNotes]) -> None:
         self._release_notes = release_notes
 
+    def __comparable_tuple(self) -> _ComparableTuple:
+        return _ComparableTuple((
+            self.authenticated, _ComparableTuple(self.data), self.description, _ComparableTuple(self.endpoints),
+            _ComparableTuple(self.external_references), self.group, _ComparableTuple(self.licenses), self.name,
+            _ComparableTuple(self.properties), self.provider, self.release_notes, _ComparableTuple(self.services), self.version,
+            self.x_trust_boundary
+        ))
+
     def __eq__(self, other: object) -> bool:
         if isinstance(other, Service):
-            return hash(other) == hash(self)
+            return self.__comparable_tuple() == other.__comparable_tuple()
         return False
 
     def __lt__(self, other: Any) -> bool:
         if isinstance(other, Service):
-            return _ComparableTuple((
-                self.group, self.name, self.version
-            )) < _ComparableTuple((
-                other.group, other.name, other.version
-            ))
+            return self.__comparable_tuple() < other.__comparable_tuple()
         return NotImplemented
 
     def __hash__(self) -> int:
-        return hash((
-            self.authenticated, tuple(self.data), self.description, tuple(self.endpoints),
-            tuple(self.external_references), self.group, tuple(self.licenses), self.name, tuple(self.properties),
-            self.provider, self.release_notes, tuple(self.services), self.version, self.x_trust_boundary
-        ))
+        return hash(self.__comparable_tuple())
 
     def __repr__(self) -> str:
         return f'<Service bom-ref={self.bom_ref}, group={self.group}, name={self.name}, version={self.version}>'