wip

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

Author: jkowalleck

cyclonedx/model/__init__.py

@@ -239,7 +239,7 @@ def content(self, content: str) -> None:
 
     def __comparable_tuple(self) -> _ComparableTuple:
         return _ComparableTuple((
-            self.content_type, self.content, self.encoding
+            self.content_type, self.encoding, self.content,
         ))
 
     def __eq__(self, other: object) -> bool:

cyclonedx/model/component.py

@@ -173,7 +173,9 @@ def message(self, message: Optional[str]) -> None:
 
     def __comparable_tuple(self) -> _ComparableTuple:
         return _ComparableTuple((
-            self.uid, self.url, self.author, self.committer, self.message
+            self.uid, self.url,
+            self.author, self.committer,
+            self.message
         ))
 
     def __eq__(self, other: object) -> bool:
@@ -487,7 +489,8 @@ def url(self, url: Optional[XsUri]) -> None:
 
     def __comparable_tuple(self) -> _ComparableTuple:
         return _ComparableTuple((
-            self.text, self.url
+            self.url,
+            self.text,
         ))
 
     def __eq__(self, other: object) -> bool:
@@ -590,7 +593,8 @@ def resolves(self, resolves: Iterable[IssueType]) -> None:
 
     def __comparable_tuple(self) -> _ComparableTuple:
         return _ComparableTuple((
-            self.type, self.diff, _ComparableTuple(self.resolves)
+            self.type, self.diff,
+            _ComparableTuple(self.resolves)
         ))
 
     def __eq__(self, other: object) -> bool:
@@ -757,17 +761,23 @@ def notes(self) -> Optional[str]:
     def notes(self, notes: Optional[str]) -> None:
         self._notes = notes
 
+    def __comparable_tuple(self) -> _ComparableTuple:
+        return _ComparableTuple((
+            _ComparableTuple(self.ancestors),
+            _ComparableTuple(self.descendants),
+            _ComparableTuple(self.variants),
+            _ComparableTuple(self.commits),
+            _ComparableTuple(self.patches),
+            self.notes
+        ))
+
     def __eq__(self, other: object) -> bool:
         if isinstance(other, Pedigree):
-            return hash(other) == hash(self)
+            return self.__comparable_tuple() == other.__comparable_tuple()
         return False
 
     def __hash__(self) -> int:
-        # TODO
-        return hash((
-            tuple(self.ancestors), tuple(self.descendants), tuple(self.variants), tuple(self.commits),
-            tuple(self.patches), self.notes
-        ))
+        return hash(self.__comparable_tuple())
 
     def __repr__(self) -> str:
         return f'<Pedigree id={id(self)}, hash={hash(self)}>'
@@ -903,14 +913,23 @@ def url(self) -> Optional[XsUri]:
     def url(self, url: Optional[XsUri]) -> None:
         self._url = url
 
+    def __comparable_tuple(self) -> _ComparableTuple:
+        return _ComparableTuple((
+            self.tag_id,
+            self.name, self.version,
+            self.tag_version,
+            self.patch,
+            self.url,
+            self.text,
+        ))
+
     def __eq__(self, other: object) -> bool:
         if isinstance(other, Swid):
-            return hash(other) == hash(self)
+            return self.__comparable_tuple() == other.__comparable_tuple()
         return False
 
     def __hash__(self) -> int:
-        # TODO
-        return hash((self.tag_id, self.name, self.version, self.tag_version, self.patch, self.text, self.url))
+        return hash(self.__comparable_tuple())
 
     def __repr__(self) -> str:
         return f'<Swid tagId={self.tag_id}, name={self.name}, version={self.version}>'
@@ -1755,15 +1774,17 @@ def get_pypi_url(self) -> str:
     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,
+            self.swid, self.cpe, _ComparableTuple(self.swhids),
+            self.supplier, self.author, self.publisher,
+            self.description,
+            self.mime_type, self.scope, _ComparableTuple(self.hashes),
+            _ComparableTuple(self.licenses), self.copyright,
+            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),
+            self.crypto_properties, _ComparableTuple(self.tags),
         ))
 
     def __eq__(self, other: object) -> bool:

cyclonedx/model/crypto.py

@@ -667,15 +667,19 @@ def certificate_extension(self) -> Optional[str]:
     def certificate_extension(self, certificate_extension: Optional[str]) -> None:
         self._certificate_extension = certificate_extension
 
+    def __comparable_tuple(self) -> _ComparableTuple:
+        return _ComparableTuple((
+            self.subject_name, self.issuer_name, self.not_valid_before, self.not_valid_after,
+            self.certificate_format, self.certificate_extension
+        ))
+
     def __eq__(self, other: object) -> bool:
         if isinstance(other, CertificateProperties):
-            return hash(other) == hash(self)
+            return self.__comparable_tuple() == other.__comparable_tuple()
         return False
 
     def __hash__(self) -> int:
-        # TODO
-        return hash((self.subject_name, self.issuer_name, self.not_valid_before, self.not_valid_after,
-                     self.certificate_format, self.certificate_extension))
+        return hash(self.__comparable_tuple())
 
     def __repr__(self) -> str:
         return f'<CertificateProperties subject_name={self.subject_name}, certificate_format={self.certificate_format}>'
@@ -791,14 +795,18 @@ def algorithm_ref(self) -> Optional[BomRef]:
     def algorithm_ref(self, algorithm_ref: Optional[BomRef]) -> None:
         self._algorithm_ref = algorithm_ref
 
+    def __comparable_tuple(self) -> _ComparableTuple:
+        return _ComparableTuple((
+            self.mechanism, self.algorithm_ref
+        ))
+
     def __eq__(self, other: object) -> bool:
         if isinstance(other, RelatedCryptoMaterialSecuredBy):
-            return hash(other) == hash(self)
+            return self.__comparable_tuple() == other.__comparable_tuple()
         return False
 
     def __hash__(self) -> int:
-        # TODO
-        return hash((self.mechanism, self.algorithm_ref))
+        return hash(self.__comparable_tuple())
 
     def __repr__(self) -> str:
         return f'<RelatedCryptoMaterialSecuredBy mechanism={self.mechanism}, algorithm_ref={self.algorithm_ref}>'
@@ -1031,15 +1039,19 @@ def secured_by(self) -> Optional[RelatedCryptoMaterialSecuredBy]:
     def secured_by(self, secured_by: Optional[RelatedCryptoMaterialSecuredBy]) -> None:
         self._secured_by = secured_by
 
+    def __comparable_tuple(self) -> _ComparableTuple:
+        return _ComparableTuple((
+            self.type, self.id, self.state, self.algorithm_ref, self.creation_date, self.activation_date,
+            self.update_date, self.expiration_date, self.value, self.size, self.format, self.secured_by
+        ))
+
     def __eq__(self, other: object) -> bool:
         if isinstance(other, RelatedCryptoMaterialProperties):
-            return hash(other) == hash(self)
+            return self.__comparable_tuple() == other.__comparable_tuple()
         return False
 
     def __hash__(self) -> int:
-        # TODO
-        return hash((self.type, self.id, self.state, self.algorithm_ref, self.creation_date, self.activation_date,
-                     self.update_date, self.expiration_date, self.value, self.size, self.format, self.secured_by))
+        return hash(self.__comparable_tuple())
 
     def __repr__(self) -> str:
         return f'<RelatedCryptoMaterialProperties type={self.type}, id={self.id} state={self.state}>'
@@ -1140,23 +1152,23 @@ def identifiers(self) -> 'SortedSet[str]':
     def identifiers(self, identifiers: Iterable[str]) -> None:
         self._identifiers = SortedSet(identifiers)
 
+    def __comparable_tuple(self) -> _ComparableTuple:
+        return _ComparableTuple((
+            self.name, _ComparableTuple(self.algorithms), _ComparableTuple(self.identifiers)
+        ))
+
     def __eq__(self, other: object) -> bool:
         if isinstance(other, ProtocolPropertiesCipherSuite):
-            return hash(other) == hash(self)
+            return self.__comparable_tuple() == other.__comparable_tuple()
         return False
 
     def __lt__(self, other: Any) -> bool:
         if isinstance(other, ProtocolPropertiesCipherSuite):
-            return _ComparableTuple((
-                self.name, _ComparableTuple(self.algorithms), _ComparableTuple(self.identifiers)
-            )) < _ComparableTuple((
-                other.name, _ComparableTuple(other.algorithms), _ComparableTuple(other.identifiers)
-            ))
+            return self.__comparable_tuple() < other.__comparable_tuple()
         return NotImplemented
 
     def __hash__(self) -> int:
-        # TODO
-        return hash((self.name, tuple(self.algorithms), tuple(self.identifiers)))
+        return hash(self.__comparable_tuple())
 
     def __repr__(self) -> str:
         return f'<ProtocolPropertiesCipherSuite name={self.name}>'
@@ -1282,14 +1294,23 @@ def auth(self) -> 'SortedSet[BomRef]':
     def auth(self, auth: Iterable[BomRef]) -> None:
         self._auth = SortedSet(auth)
 
+    def __comparable_tuple(self) -> _ComparableTuple:
+        return _ComparableTuple((
+            _ComparableTuple(self.encr),
+            _ComparableTuple(self.prf),
+            _ComparableTuple(self.integ),
+            _ComparableTuple(self.ke),
+            self.esn,
+            _ComparableTuple(self.auth)
+        ))
+
     def __eq__(self, other: object) -> bool:
         if isinstance(other, Ikev2TransformTypes):
-            return hash(other) == hash(self)
+            return self.__comparable_tuple() == other.__comparable_tuple()
         return False
 
     def __hash__(self) -> int:
-        # TODO
-        return hash((tuple(self.encr), tuple(self.prf), tuple(self.integ), tuple(self.ke), self.esn, tuple(self.auth)))
+        return hash(self.__comparable_tuple())
 
     def __repr__(self) -> str:
         return f'<Ikev2TransformTypes esn={self.esn}>'
@@ -1382,14 +1403,18 @@ def ikev2_transform_types(self) -> Optional[Ikev2TransformTypes]:
     def ikev2_transform_types(self, ikev2_transform_types: Optional[Ikev2TransformTypes]) -> None:
         self._ikev2_transform_types = ikev2_transform_types
 
+    def __comparable_tuple(self) -> _ComparableTuple:
+        return _ComparableTuple((
+            self.type, self.version, _ComparableTuple(self.cipher_suites), self.ikev2_transform_types
+        ))
+
     def __eq__(self, other: object) -> bool:
         if isinstance(other, ProtocolProperties):
-            return hash(other) == hash(self)
+            return self.__comparable_tuple() == other.__comparable_tuple()
         return False
 
     def __hash__(self) -> int:
-        # TODO
-        return hash((self.type, self.version, tuple(self.cipher_suites), self.ikev2_transform_types))
+        return hash(self.__comparable_tuple())
 
     def __repr__(self) -> str:
         return f'<ProtocolProperties type={self.type}, version={self.version}>'
@@ -1520,34 +1545,28 @@ def oid(self) -> Optional[str]:
     def oid(self, oid: Optional[str]) -> None:
         self._oid = oid
 
+    def __comparable_tuple(self) -> _ComparableTuple:
+        return _ComparableTuple((
+            self.asset_type,
+            self.algorithm_properties,
+            self.certificate_properties,
+            self.related_crypto_material_properties,
+            self.protocol_properties,
+            self.oid,
+        ))
+
     def __eq__(self, other: object) -> bool:
         if isinstance(other, CryptoProperties):
-            return hash(other) == hash(self)
+            return self.__comparable_tuple() == other.__comparable_tuple()
         return False
 
     def __lt__(self, other: Any) -> bool:
         if isinstance(other, CryptoProperties):
-            return _ComparableTuple((
-                self.asset_type,
-                self.algorithm_properties,
-                self.certificate_properties,
-                self.related_crypto_material_properties,
-                self.protocol_properties,
-                self.oid,
-            )) < _ComparableTuple((
-                other.asset_type,
-                other.algorithm_properties,
-                other.certificate_properties,
-                other.related_crypto_material_properties,
-                other.protocol_properties,
-                other.oid,
-            ))
+            return self.__comparable_tuple() < other.__comparable_tuple()
         return NotImplemented
 
     def __hash__(self) -> int:
-        # TODO
-        return hash((self.asset_type, self.algorithm_properties, self.certificate_properties,
-                     self.related_crypto_material_properties, self.protocol_properties, self.oid))
+        return hash(self.__comparable_tuple())
 
     def __repr__(self) -> str:
         return f'<CryptoProperties asset_type={self.asset_type}, oid={self.oid}>'

cyclonedx/model/dependency.py

@@ -83,23 +83,23 @@ def dependencies(self, dependencies: Iterable['Dependency']) -> None:
     def dependencies_as_bom_refs(self) -> Set[BomRef]:
         return set(map(lambda d: d.ref, self.dependencies))
 
+    def __comparable_tuple(self) -> _ComparableTuple:
+        return _ComparableTuple((
+            self.ref, _ComparableTuple(self.dependencies)
+        ))
+
     def __eq__(self, other: object) -> bool:
         if isinstance(other, Dependency):
-            return hash(other) == hash(self)
+            return self.__comparable_tuple() == other.__comparable_tuple()
         return False
 
     def __lt__(self, other: Any) -> bool:
         if isinstance(other, Dependency):
-            return _ComparableTuple((
-                self.ref, _ComparableTuple(self.dependencies)
-            )) < _ComparableTuple((
-                other.ref, _ComparableTuple(other.dependencies)
-            ))
+            return self.__comparable_tuple() < other.__comparable_tuple()
         return NotImplemented
 
     def __hash__(self) -> int:
-        # TODO
-        return hash((self.ref, tuple(self.dependencies)))
+        return hash(self.__comparable_tuple())
 
     def __repr__(self) -> str:
         return f'<Dependency ref={self.ref!r}, targets={len(self.dependencies)}>'