Search is not available for this dataset
text stringlengths 75 104k |
|---|
def set_doc_spdx_id(self, doc, doc_spdx_id_line):
"""Sets the document SPDX Identifier.
Raises value error if malformed value, CardinalityError
if already defined.
"""
if not self.doc_spdx_id_set:
if doc_spdx_id_line == 'SPDXRef-DOCUMENT':
doc.spdx_id = doc_spdx_id_line
self.doc_spdx_id_set = True
return True
else:
raise SPDXValueError('Document::SPDXID')
else:
raise CardinalityError('Document::SPDXID') |
def set_doc_comment(self, doc, comment):
"""Sets document comment, Raises CardinalityError if
comment already set.
Raises SPDXValueError if comment is not free form text.
"""
if not self.doc_comment_set:
self.doc_comment_set = True
if validations.validate_doc_comment(comment):
doc.comment = str_from_text(comment)
return True
else:
raise SPDXValueError('Document::Comment')
else:
raise CardinalityError('Document::Comment') |
def set_doc_namespace(self, doc, namespace):
"""Sets the document namespace.
Raise SPDXValueError if malformed value, CardinalityError
if already defined.
"""
if not self.doc_namespace_set:
self.doc_namespace_set = True
if validations.validate_doc_namespace(namespace):
doc.namespace = namespace
return True
else:
raise SPDXValueError('Document::Namespace')
else:
raise CardinalityError('Document::Comment') |
def reset_document(self):
"""Resets the state to allow building new documents"""
# FIXME: this state does not make sense
self.doc_version_set = False
self.doc_comment_set = False
self.doc_namespace_set = False
self.doc_data_lics_set = False
self.doc_name_set = False
self.doc_spdx_id_set = False |
def set_spdx_doc_uri(self, doc, spdx_doc_uri):
"""
Sets the `spdx_document_uri` attribute of the `ExternalDocumentRef`
object.
"""
if validations.validate_doc_namespace(spdx_doc_uri):
doc.ext_document_references[-1].spdx_document_uri = spdx_doc_uri
else:
raise SPDXValueError('Document::ExternalDocumentRef') |
def build_tool(self, doc, entity):
"""Builds a tool object out of a string representation.
Returns built tool. Raises SPDXValueError if failed to extract
tool name or name is malformed
"""
match = self.tool_re.match(entity)
if match and validations.validate_tool_name(match.group(self.TOOL_NAME_GROUP)):
name = match.group(self.TOOL_NAME_GROUP)
return creationinfo.Tool(name)
else:
raise SPDXValueError('Failed to extract tool name') |
def build_org(self, doc, entity):
"""Builds an organization object of of a string representation.
Returns built organization. Raises SPDXValueError if failed to extract
name.
"""
match = self.org_re.match(entity)
if match and validations.validate_org_name(match.group(self.ORG_NAME_GROUP)):
name = match.group(self.ORG_NAME_GROUP).strip()
email = match.group(self.ORG_EMAIL_GROUP)
if (email is not None) and (len(email) != 0):
return creationinfo.Organization(name=name, email=email.strip())
else:
return creationinfo.Organization(name=name, email=None)
else:
raise SPDXValueError('Failed to extract Organization name') |
def build_person(self, doc, entity):
"""Builds an organization object of of a string representation.
Returns built organization. Raises SPDXValueError if failed to extract
name.
"""
match = self.person_re.match(entity)
if match and validations.validate_person_name(match.group(self.PERSON_NAME_GROUP)):
name = match.group(self.PERSON_NAME_GROUP).strip()
email = match.group(self.PERSON_EMAIL_GROUP)
if (email is not None) and (len(email) != 0):
return creationinfo.Person(name=name, email=email.strip())
else:
return creationinfo.Person(name=name, email=None)
else:
raise SPDXValueError('Failed to extract person name') |
def add_creator(self, doc, creator):
"""Adds a creator to the document's creation info.
Returns true if creator is valid.
Creator must be built by an EntityBuilder.
Raises SPDXValueError if not a creator type.
"""
if validations.validate_creator(creator):
doc.creation_info.add_creator(creator)
return True
else:
raise SPDXValueError('CreationInfo::Creator') |
def set_created_date(self, doc, created):
"""Sets created date, Raises CardinalityError if
created date already set.
Raises SPDXValueError if created is not a date.
"""
if not self.created_date_set:
self.created_date_set = True
date = utils.datetime_from_iso_format(created)
if date is not None:
doc.creation_info.created = date
return True
else:
raise SPDXValueError('CreationInfo::Date')
else:
raise CardinalityError('CreationInfo::Created') |
def set_creation_comment(self, doc, comment):
"""Sets creation comment, Raises CardinalityError if
comment already set.
Raises SPDXValueError if not free form text.
"""
if not self.creation_comment_set:
self.creation_comment_set = True
if validations.validate_creation_comment(comment):
doc.creation_info.comment = str_from_text(comment)
return True
else:
raise SPDXValueError('CreationInfo::Comment')
else:
raise CardinalityError('CreationInfo::Comment') |
def set_lics_list_ver(self, doc, value):
"""Sets the license list version, Raises CardinalityError if
already set, SPDXValueError if incorrect value.
"""
if not self.lics_list_ver_set:
self.lics_list_ver_set = True
vers = version.Version.from_str(value)
if vers is not None:
doc.creation_info.license_list_version = vers
return True
else:
raise SPDXValueError('CreationInfo::LicenseListVersion')
else:
raise CardinalityError('CreationInfo::LicenseListVersion') |
def reset_creation_info(self):
"""
Resets builder state to allow building new creation info."""
# FIXME: this state does not make sense
self.created_date_set = False
self.creation_comment_set = False
self.lics_list_ver_set = False |
def add_reviewer(self, doc, reviewer):
"""Adds a reviewer to the SPDX Document.
Reviwer is an entity created by an EntityBuilder.
Raises SPDXValueError if not a valid reviewer type.
"""
# Each reviewer marks the start of a new review object.
# FIXME: this state does not make sense
self.reset_reviews()
if validations.validate_reviewer(reviewer):
doc.add_review(review.Review(reviewer=reviewer))
return True
else:
raise SPDXValueError('Review::Reviewer') |
def add_review_date(self, doc, reviewed):
"""Sets the review date. Raises CardinalityError if
already set. OrderError if no reviewer defined before.
Raises SPDXValueError if invalid reviewed value.
"""
if len(doc.reviews) != 0:
if not self.review_date_set:
self.review_date_set = True
date = utils.datetime_from_iso_format(reviewed)
if date is not None:
doc.reviews[-1].review_date = date
return True
else:
raise SPDXValueError('Review::ReviewDate')
else:
raise CardinalityError('Review::ReviewDate')
else:
raise OrderError('Review::ReviewDate') |
def add_review_comment(self, doc, comment):
"""Sets the review comment. Raises CardinalityError if
already set. OrderError if no reviewer defined before.
Raises SPDXValueError if comment is not free form text.
"""
if len(doc.reviews) != 0:
if not self.review_comment_set:
self.review_comment_set = True
if validations.validate_review_comment(comment):
doc.reviews[-1].comment = str_from_text(comment)
return True
else:
raise SPDXValueError('ReviewComment::Comment')
else:
raise CardinalityError('ReviewComment')
else:
raise OrderError('ReviewComment') |
def reset_annotations(self):
"""Resets the builder's state to allow building new annotations."""
# FIXME: this state does not make sense
self.annotation_date_set = False
self.annotation_comment_set = False
self.annotation_type_set = False
self.annotation_spdx_id_set = False |
def add_annotator(self, doc, annotator):
"""Adds an annotator to the SPDX Document.
Annotator is an entity created by an EntityBuilder.
Raises SPDXValueError if not a valid annotator type.
"""
# Each annotator marks the start of a new annotation object.
# FIXME: this state does not make sense
self.reset_annotations()
if validations.validate_annotator(annotator):
doc.add_annotation(annotation.Annotation(annotator=annotator))
return True
else:
raise SPDXValueError('Annotation::Annotator') |
def add_annotation_date(self, doc, annotation_date):
"""Sets the annotation date. Raises CardinalityError if
already set. OrderError if no annotator defined before.
Raises SPDXValueError if invalid value.
"""
if len(doc.annotations) != 0:
if not self.annotation_date_set:
self.annotation_date_set = True
date = utils.datetime_from_iso_format(annotation_date)
if date is not None:
doc.annotations[-1].annotation_date = date
return True
else:
raise SPDXValueError('Annotation::AnnotationDate')
else:
raise CardinalityError('Annotation::AnnotationDate')
else:
raise OrderError('Annotation::AnnotationDate') |
def add_annotation_comment(self, doc, comment):
"""Sets the annotation comment. Raises CardinalityError if
already set. OrderError if no annotator defined before.
Raises SPDXValueError if comment is not free form text.
"""
if len(doc.annotations) != 0:
if not self.annotation_comment_set:
self.annotation_comment_set = True
if validations.validate_annotation_comment(comment):
doc.annotations[-1].comment = str_from_text(comment)
return True
else:
raise SPDXValueError('AnnotationComment::Comment')
else:
raise CardinalityError('AnnotationComment::Comment')
else:
raise OrderError('AnnotationComment::Comment') |
def add_annotation_type(self, doc, annotation_type):
"""Sets the annotation type. Raises CardinalityError if
already set. OrderError if no annotator defined before.
Raises SPDXValueError if invalid value.
"""
if len(doc.annotations) != 0:
if not self.annotation_type_set:
self.annotation_type_set = True
if validations.validate_annotation_type(annotation_type):
doc.annotations[-1].annotation_type = annotation_type
return True
else:
raise SPDXValueError('Annotation::AnnotationType')
else:
raise CardinalityError('Annotation::AnnotationType')
else:
raise OrderError('Annotation::AnnotationType') |
def set_annotation_spdx_id(self, doc, spdx_id):
"""Sets the annotation SPDX Identifier.
Raises CardinalityError if already set. OrderError if no annotator
defined before.
"""
if len(doc.annotations) != 0:
if not self.annotation_spdx_id_set:
self.annotation_spdx_id_set = True
doc.annotations[-1].spdx_id = spdx_id
return True
else:
raise CardinalityError('Annotation::SPDXREF')
else:
raise OrderError('Annotation::SPDXREF') |
def reset_package(self):
"""Resets the builder's state in order to build new packages."""
# FIXME: this state does not make sense
self.package_set = False
self.package_vers_set = False
self.package_file_name_set = False
self.package_supplier_set = False
self.package_originator_set = False
self.package_down_location_set = False
self.package_home_set = False
self.package_verif_set = False
self.package_chk_sum_set = False
self.package_source_info_set = False
self.package_conc_lics_set = False
self.package_license_declared_set = False
self.package_license_comment_set = False
self.package_cr_text_set = False
self.package_summary_set = False
self.package_desc_set = False |
def create_package(self, doc, name):
"""Creates a package for the SPDX Document.
name - any string.
Raises CardinalityError if package already defined.
"""
if not self.package_set:
self.package_set = True
doc.package = package.Package(name=name)
return True
else:
raise CardinalityError('Package::Name') |
def set_pkg_vers(self, doc, version):
"""Sets package version, if not already set.
version - Any string.
Raises CardinalityError if already has a version.
Raises OrderError if no package previously defined.
"""
self.assert_package_exists()
if not self.package_vers_set:
self.package_vers_set = True
doc.package.version = version
return True
else:
raise CardinalityError('Package::Version') |
def set_pkg_file_name(self, doc, name):
"""Sets the package file name, if not already set.
name - Any string.
Raises CardinalityError if already has a file_name.
Raises OrderError if no pacakge previously defined.
"""
self.assert_package_exists()
if not self.package_file_name_set:
self.package_file_name_set = True
doc.package.file_name = name
return True
else:
raise CardinalityError('Package::FileName') |
def set_pkg_supplier(self, doc, entity):
"""Sets the package supplier, if not already set.
entity - Organization, Person or NoAssert.
Raises CardinalityError if already has a supplier.
Raises OrderError if no package previously defined.
"""
self.assert_package_exists()
if not self.package_supplier_set:
self.package_supplier_set = True
if validations.validate_pkg_supplier(entity):
doc.package.supplier = entity
return True
else:
raise SPDXValueError('Package::Supplier')
else:
raise CardinalityError('Package::Supplier') |
def set_pkg_originator(self, doc, entity):
"""Sets the package originator, if not already set.
entity - Organization, Person or NoAssert.
Raises CardinalityError if already has an originator.
Raises OrderError if no package previously defined.
"""
self.assert_package_exists()
if not self.package_originator_set:
self.package_originator_set = True
if validations.validate_pkg_originator(entity):
doc.package.originator = entity
return True
else:
raise SPDXValueError('Package::Originator')
else:
raise CardinalityError('Package::Originator') |
def set_pkg_down_location(self, doc, location):
"""Sets the package download location, if not already set.
location - A string
Raises CardinalityError if already defined.
Raises OrderError if no package previously defined.
"""
self.assert_package_exists()
if not self.package_down_location_set:
self.package_down_location_set = True
doc.package.download_location = location
return True
else:
raise CardinalityError('Package::DownloadLocation') |
def set_pkg_home(self, doc, location):
"""Sets the package homepage location if not already set.
location - A string or None or NoAssert.
Raises CardinalityError if already defined.
Raises OrderError if no package previously defined.
Raises SPDXValueError if location has incorrect value.
"""
self.assert_package_exists()
if not self.package_home_set:
self.package_home_set = True
if validations.validate_pkg_homepage(location):
doc.package.homepage = location
return True
else:
raise SPDXValueError('Package::HomePage')
else:
raise CardinalityError('Package::HomePage') |
def set_pkg_verif_code(self, doc, code):
"""Sets the package verification code, if not already set.
code - A string.
Raises CardinalityError if already defined.
Raises OrderError if no package previously defined.
Raises Value error if doesn't match verifcode form
"""
self.assert_package_exists()
if not self.package_verif_set:
self.package_verif_set = True
match = self.VERIF_CODE_REGEX.match(code)
if match:
doc.package.verif_code = match.group(self.VERIF_CODE_CODE_GRP)
if match.group(self.VERIF_CODE_EXC_FILES_GRP) is not None:
doc.package.verif_exc_files = match.group(self.VERIF_CODE_EXC_FILES_GRP).split(',')
return True
else:
raise SPDXValueError('Package::VerificationCode')
else:
raise CardinalityError('Package::VerificationCode') |
def set_pkg_chk_sum(self, doc, chk_sum):
"""Sets the package check sum, if not already set.
chk_sum - A string
Raises CardinalityError if already defined.
Raises OrderError if no package previously defined.
"""
self.assert_package_exists()
if not self.package_chk_sum_set:
self.package_chk_sum_set = True
doc.package.check_sum = checksum_from_sha1(chk_sum)
return True
else:
raise CardinalityError('Package::CheckSum') |
def set_pkg_source_info(self, doc, text):
"""Sets the package's source information, if not already set.
text - Free form text.
Raises CardinalityError if already defined.
Raises OrderError if no package previously defined.
SPDXValueError if text is not free form text.
"""
self.assert_package_exists()
if not self.package_source_info_set:
self.package_source_info_set = True
if validations.validate_pkg_src_info(text):
doc.package.source_info = str_from_text(text)
return True
else:
raise SPDXValueError('Pacckage::SourceInfo')
else:
raise CardinalityError('Package::SourceInfo') |
def set_pkg_licenses_concluded(self, doc, licenses):
"""Sets the package's concluded licenses.
licenses - License info.
Raises CardinalityError if already defined.
Raises OrderError if no package previously defined.
Raises SPDXValueError if data malformed.
"""
self.assert_package_exists()
if not self.package_conc_lics_set:
self.package_conc_lics_set = True
if validations.validate_lics_conc(licenses):
doc.package.conc_lics = licenses
return True
else:
raise SPDXValueError('Package::ConcludedLicenses')
else:
raise CardinalityError('Package::ConcludedLicenses') |
def set_pkg_license_from_file(self, doc, lic):
"""Adds a license from a file to the package.
Raises SPDXValueError if data malformed.
Raises OrderError if no package previously defined.
"""
self.assert_package_exists()
if validations.validate_lics_from_file(lic):
doc.package.licenses_from_files.append(lic)
return True
else:
raise SPDXValueError('Package::LicensesFromFile') |
def set_pkg_license_declared(self, doc, lic):
"""Sets the package's declared license.
Raises SPDXValueError if data malformed.
Raises OrderError if no package previously defined.
Raises CardinalityError if already set.
"""
self.assert_package_exists()
if not self.package_license_declared_set:
self.package_license_declared_set = True
if validations.validate_lics_conc(lic):
doc.package.license_declared = lic
return True
else:
raise SPDXValueError('Package::LicenseDeclared')
else:
raise CardinalityError('Package::LicenseDeclared') |
def set_pkg_license_comment(self, doc, text):
"""Sets the package's license comment.
Raises OrderError if no package previously defined.
Raises CardinalityError if already set.
Raises SPDXValueError if text is not free form text.
"""
self.assert_package_exists()
if not self.package_license_comment_set:
self.package_license_comment_set = True
if validations.validate_pkg_lics_comment(text):
doc.package.license_comment = str_from_text(text)
return True
else:
raise SPDXValueError('Package::LicenseComment')
else:
raise CardinalityError('Package::LicenseComment') |
def set_pkg_cr_text(self, doc, text):
"""Sets the package's copyright text.
Raises OrderError if no package previously defined.
Raises CardinalityError if already set.
Raises value error if text is not one of [None, NOASSERT, TEXT].
"""
self.assert_package_exists()
if not self.package_cr_text_set:
self.package_cr_text_set = True
if validations.validate_pkg_cr_text(text):
if isinstance(text, string_types):
doc.package.cr_text = str_from_text(text)
else:
doc.package.cr_text = text # None or NoAssert
else:
raise SPDXValueError('Package::CopyrightText')
else:
raise CardinalityError('Package::CopyrightText') |
def set_pkg_summary(self, doc, text):
"""Set's the package summary.
Raises SPDXValueError if text is not free form text.
Raises CardinalityError if summary already set.
Raises OrderError if no package previously defined.
"""
self.assert_package_exists()
if not self.package_summary_set:
self.package_summary_set = True
if validations.validate_pkg_summary(text):
doc.package.summary = str_from_text(text)
else:
raise SPDXValueError('Package::Summary')
else:
raise CardinalityError('Package::Summary') |
def set_pkg_desc(self, doc, text):
"""Set's the package's description.
Raises SPDXValueError if text is not free form text.
Raises CardinalityError if description already set.
Raises OrderError if no package previously defined.
"""
self.assert_package_exists()
if not self.package_desc_set:
self.package_desc_set = True
if validations.validate_pkg_desc(text):
doc.package.description = str_from_text(text)
else:
raise SPDXValueError('Package::Description')
else:
raise CardinalityError('Package::Description') |
def set_file_name(self, doc, name):
"""Raises OrderError if no package defined.
"""
if self.has_package(doc):
doc.package.files.append(file.File(name))
# A file name marks the start of a new file instance.
# The builder must be reset
# FIXME: this state does not make sense
self.reset_file_stat()
return True
else:
raise OrderError('File::Name') |
def set_file_spdx_id(self, doc, spdx_id):
"""
Sets the file SPDX Identifier.
Raises OrderError if no package or no file defined.
Raises SPDXValueError if malformed value.
Raises CardinalityError if more than one spdx_id set.
"""
if self.has_package(doc) and self.has_file(doc):
if not self.file_spdx_id_set:
self.file_spdx_id_set = True
if validations.validate_file_spdx_id(spdx_id):
self.file(doc).spdx_id = spdx_id
return True
else:
raise SPDXValueError('File::SPDXID')
else:
raise CardinalityError('File::SPDXID')
else:
raise OrderError('File::SPDXID') |
def set_file_comment(self, doc, text):
"""
Raises OrderError if no package or no file defined.
Raises CardinalityError if more than one comment set.
Raises SPDXValueError if text is not free form text.
"""
if self.has_package(doc) and self.has_file(doc):
if not self.file_comment_set:
self.file_comment_set = True
if validations.validate_file_comment(text):
self.file(doc).comment = str_from_text(text)
return True
else:
raise SPDXValueError('File::Comment')
else:
raise CardinalityError('File::Comment')
else:
raise OrderError('File::Comment') |
def set_file_type(self, doc, type_value):
"""
Raises OrderError if no package or file defined.
Raises CardinalityError if more than one type set.
Raises SPDXValueError if type is unknown.
"""
type_dict = {
'SOURCE': file.FileType.SOURCE,
'BINARY': file.FileType.BINARY,
'ARCHIVE': file.FileType.ARCHIVE,
'OTHER': file.FileType.OTHER
}
if self.has_package(doc) and self.has_file(doc):
if not self.file_type_set:
self.file_type_set = True
if type_value in type_dict.keys():
self.file(doc).type = type_dict[type_value]
return True
else:
raise SPDXValueError('File::Type')
else:
raise CardinalityError('File::Type')
else:
raise OrderError('File::Type') |
def set_file_chksum(self, doc, chksum):
"""
Raises OrderError if no package or file defined.
Raises CardinalityError if more than one chksum set.
"""
if self.has_package(doc) and self.has_file(doc):
if not self.file_chksum_set:
self.file_chksum_set = True
self.file(doc).chk_sum = checksum_from_sha1(chksum)
return True
else:
raise CardinalityError('File::CheckSum')
else:
raise OrderError('File::CheckSum') |
def set_concluded_license(self, doc, lic):
"""
Raises OrderError if no package or file defined.
Raises CardinalityError if already set.
Raises SPDXValueError if malformed.
"""
if self.has_package(doc) and self.has_file(doc):
if not self.file_conc_lics_set:
self.file_conc_lics_set = True
if validations.validate_lics_conc(lic):
self.file(doc).conc_lics = lic
return True
else:
raise SPDXValueError('File::ConcludedLicense')
else:
raise CardinalityError('File::ConcludedLicense')
else:
raise OrderError('File::ConcludedLicense') |
def set_file_license_in_file(self, doc, lic):
"""
Raises OrderError if no package or file defined.
Raises SPDXValueError if malformed value.
"""
if self.has_package(doc) and self.has_file(doc):
if validations.validate_file_lics_in_file(lic):
self.file(doc).add_lics(lic)
return True
else:
raise SPDXValueError('File::LicenseInFile')
else:
raise OrderError('File::LicenseInFile') |
def set_file_license_comment(self, doc, text):
"""
Raises OrderError if no package or file defined.
Raises SPDXValueError if text is not free form text.
Raises CardinalityError if more than one per file.
"""
if self.has_package(doc) and self.has_file(doc):
if not self.file_license_comment_set:
self.file_license_comment_set = True
if validations.validate_file_lics_comment(text):
self.file(doc).license_comment = str_from_text(text)
else:
raise SPDXValueError('File::LicenseComment')
else:
raise CardinalityError('File::LicenseComment')
else:
raise OrderError('File::LicenseComment') |
def set_file_copyright(self, doc, text):
"""Raises OrderError if no package or file defined.
Raises SPDXValueError if not free form text or NONE or NO_ASSERT.
Raises CardinalityError if more than one.
"""
if self.has_package(doc) and self.has_file(doc):
if not self.file_copytext_set:
self.file_copytext_set = True
if validations.validate_file_cpyright(text):
if isinstance(text, string_types):
self.file(doc).copyright = str_from_text(text)
else:
self.file(doc).copyright = text # None or NoAssert
return True
else:
raise SPDXValueError('File::CopyRight')
else:
raise CardinalityError('File::CopyRight')
else:
raise OrderError('File::CopyRight') |
def set_file_notice(self, doc, text):
"""Raises OrderError if no package or file defined.
Raises SPDXValueError if not free form text.
Raises CardinalityError if more than one.
"""
if self.has_package(doc) and self.has_file(doc):
if not self.file_notice_set:
self.file_notice_set = True
if validations.validate_file_notice(text):
self.file(doc).notice = str_from_text(text)
else:
raise SPDXValueError('File::Notice')
else:
raise CardinalityError('File::Notice')
else:
raise OrderError('File::Notice') |
def add_file_contribution(self, doc, value):
"""Raises OrderError if no package or file defined.
"""
if self.has_package(doc) and self.has_file(doc):
self.file(doc).add_contrib(value)
else:
raise OrderError('File::Contributor') |
def add_file_dep(self, doc, value):
"""Raises OrderError if no package or file defined.
"""
if self.has_package(doc) and self.has_file(doc):
self.file(doc).add_depend(value)
else:
raise OrderError('File::Dependency') |
def set_file_atrificat_of_project(self, doc, symbol, value):
"""Sets a file name, uri or home artificat.
Raises OrderError if no package or file defined.
"""
if self.has_package(doc) and self.has_file(doc):
self.file(doc).add_artifact(symbol, value)
else:
raise OrderError('File::Artificat') |
def reset_file_stat(self):
"""Resets the builder's state to enable building new files."""
# FIXME: this state does not make sense
self.file_spdx_id_set = False
self.file_comment_set = False
self.file_type_set = False
self.file_chksum_set = False
self.file_conc_lics_set = False
self.file_license_comment_set = False
self.file_notice_set = False
self.file_copytext_set = False |
def set_lic_id(self, doc, lic_id):
"""Adds a new extracted license to the document.
Raises SPDXValueError if data format is incorrect.
"""
# FIXME: this state does not make sense
self.reset_extr_lics()
if validations.validate_extracted_lic_id(lic_id):
doc.add_extr_lic(document.ExtractedLicense(lic_id))
return True
else:
raise SPDXValueError('ExtractedLicense::id') |
def set_lic_text(self, doc, text):
"""Sets license extracted text.
Raises SPDXValueError if text is not free form text.
Raises OrderError if no license ID defined.
"""
if self.has_extr_lic(doc):
if not self.extr_text_set:
self.extr_text_set = True
if validations.validate_is_free_form_text(text):
self.extr_lic(doc).text = str_from_text(text)
return True
else:
raise SPDXValueError('ExtractedLicense::text')
else:
raise CardinalityError('ExtractedLicense::text')
else:
raise OrderError('ExtractedLicense::text') |
def set_lic_name(self, doc, name):
"""Sets license name.
Raises SPDXValueError if name is not str or utils.NoAssert
Raises OrderError if no license id defined.
"""
if self.has_extr_lic(doc):
if not self.extr_lic_name_set:
self.extr_lic_name_set = True
if validations.validate_extr_lic_name(name):
self.extr_lic(doc).full_name = name
return True
else:
raise SPDXValueError('ExtractedLicense::Name')
else:
raise CardinalityError('ExtractedLicense::Name')
else:
raise OrderError('ExtractedLicense::Name') |
def set_lic_comment(self, doc, comment):
"""Sets license comment.
Raises SPDXValueError if comment is not free form text.
Raises OrderError if no license ID defined.
"""
if self.has_extr_lic(doc):
if not self.extr_lic_comment_set:
self.extr_lic_comment_set = True
if validations.validate_is_free_form_text(comment):
self.extr_lic(doc).comment = str_from_text(comment)
return True
else:
raise SPDXValueError('ExtractedLicense::comment')
else:
raise CardinalityError('ExtractedLicense::comment')
else:
raise OrderError('ExtractedLicense::comment') |
def add_lic_xref(self, doc, ref):
"""Adds a license cross reference.
Raises OrderError if no License ID defined.
"""
if self.has_extr_lic(doc):
self.extr_lic(doc).add_xref(ref)
return True
else:
raise OrderError('ExtractedLicense::CrossRef') |
def reset(self):
"""Resets builder's state for building new documents.
Must be called between usage with different documents.
"""
# FIXME: this state does not make sense
self.reset_creation_info()
self.reset_document()
self.reset_package()
self.reset_file_stat()
self.reset_reviews()
self.reset_annotations()
self.reset_extr_lics() |
def datetime_iso_format(date):
"""
Return an ISO-8601 representation of a datetime object.
"""
return "{0:0>4}-{1:0>2}-{2:0>2}T{3:0>2}:{4:0>2}:{5:0>2}Z".format(
date.year, date.month, date.day, date.hour,
date.minute, date.second) |
def datetime_from_iso_format(string):
"""
Return a datetime object from an iso 8601 representation.
Return None if string is non conforming.
"""
match = DATE_ISO_REGEX.match(string)
if match:
date = datetime.datetime(year=int(match.group(DATE_ISO_YEAR_GRP)),
month=int(match.group(DATE_ISO_MONTH_GRP)),
day=int(match.group(DATE_ISO_DAY_GRP)),
hour=int(match.group(DATE_ISO_HOUR_GRP)),
second=int(match.group(DATE_ISO_SEC_GRP)),
minute=int(match.group(DATE_ISO_MIN_GRP)))
return date
else:
return None |
def build(self, **kwargs):
"""Must be called before parse."""
self.yacc = yacc.yacc(module=self, **kwargs) |
def parse(self, data):
"""Parses a license list and returns a License or None if it failed."""
try:
return self.yacc.parse(data, lexer=self.lex)
except:
return None |
def write_document(document, out, validate=True):
"""
Write an SPDX RDF document.
- document - spdx.document instance.
- out - file like object that will be written to.
Optionally `validate` the document before writing and raise
InvalidDocumentError if document.validate returns False.
"""
if validate:
messages = []
messages = document.validate(messages)
if messages:
raise InvalidDocumentError(messages)
writer = Writer(document, out)
writer.write() |
def create_checksum_node(self, chksum):
"""
Return a node representing spdx.checksum.
"""
chksum_node = BNode()
type_triple = (chksum_node, RDF.type, self.spdx_namespace.Checksum)
self.graph.add(type_triple)
algorithm_triple = (chksum_node, self.spdx_namespace.algorithm, Literal(chksum.identifier))
self.graph.add(algorithm_triple)
value_triple = (chksum_node, self.spdx_namespace.checksumValue, Literal(chksum.value))
self.graph.add(value_triple)
return chksum_node |
def to_special_value(self, value):
"""
Return proper spdx term or Literal
"""
if isinstance(value, utils.NoAssert):
return self.spdx_namespace.noassertion
elif isinstance(value, utils.SPDXNone):
return self.spdx_namespace.none
else:
return Literal(value) |
def licenses_from_tree(self, tree):
"""
Traverse conjunctions and disjunctions like trees and return a
set of all licenses in it as nodes.
"""
# FIXME: this is unordered!
licenses = set()
self.licenses_from_tree_helper(tree, licenses)
return licenses |
def create_conjunction_node(self, conjunction):
"""
Return a node representing a conjunction of licenses.
"""
node = BNode()
type_triple = (node, RDF.type, self.spdx_namespace.ConjunctiveLicenseSet)
self.graph.add(type_triple)
licenses = self.licenses_from_tree(conjunction)
for lic in licenses:
member_triple = (node, self.spdx_namespace.member, lic)
self.graph.add(member_triple)
return node |
def create_disjunction_node(self, disjunction):
"""
Return a node representing a disjunction of licenses.
"""
node = BNode()
type_triple = (node, RDF.type, self.spdx_namespace.DisjunctiveLicenseSet)
self.graph.add(type_triple)
licenses = self.licenses_from_tree(disjunction)
for lic in licenses:
member_triple = (node, self.spdx_namespace.member, lic)
self.graph.add(member_triple)
return node |
def create_license_helper(self, lic):
"""
Handle single(no conjunction/disjunction) licenses.
Return the created node.
"""
if isinstance(lic, document.ExtractedLicense):
return self.create_extracted_license(lic)
if lic.identifier.rstrip('+') in config.LICENSE_MAP:
return URIRef(lic.url)
else:
matches = [l for l in self.document.extracted_licenses if l.identifier == lic.identifier]
if len(matches) != 0:
return self.create_extracted_license(matches[0])
else:
raise InvalidDocumentError('Missing extracted license: {0}'.format(lic.identifier)) |
def create_extracted_license(self, lic):
"""
Handle extracted license.
Return the license node.
"""
licenses = list(self.graph.triples((None, self.spdx_namespace.licenseId, lic.identifier)))
if len(licenses) != 0:
return licenses[0][0] # return subject in first triple
else:
license_node = BNode()
type_triple = (license_node, RDF.type, self.spdx_namespace.ExtractedLicensingInfo)
self.graph.add(type_triple)
ident_triple = (license_node, self.spdx_namespace.licenseId, Literal(lic.identifier))
self.graph.add(ident_triple)
text_triple = (license_node, self.spdx_namespace.extractedText, Literal(lic.text))
self.graph.add(text_triple)
if lic.full_name is not None:
name_triple = (license_node, self.spdx_namespace.licenseName, self.to_special_value(lic.full_name))
self.graph.add(name_triple)
for ref in lic.cross_ref:
triple = (license_node, RDFS.seeAlso, URIRef(ref))
self.graph.add(triple)
if lic.comment is not None:
comment_triple = (license_node, RDFS.comment, Literal(lic.comment))
self.graph.add(comment_triple)
return license_node |
def create_license_node(self, lic):
"""
Return a node representing a license.
Could be a single license (extracted or part of license list.) or
a conjunction/disjunction of licenses.
"""
if isinstance(lic, document.LicenseConjunction):
return self.create_conjunction_node(lic)
elif isinstance(lic, document.LicenseDisjunction):
return self.create_disjunction_node(lic)
else:
return self.create_license_helper(lic) |
def license_or_special(self, lic):
"""
Check for special values spdx:none and spdx:noassertion.
Return the term for the special value or the result of passing
license to create_license_node.
"""
if isinstance(lic, utils.NoAssert):
return self.spdx_namespace.noassertion
elif isinstance(lic, utils.SPDXNone):
return self.spdx_namespace.none
else:
return self.create_license_node(lic) |
def create_file_node(self, doc_file):
"""
Create a node for spdx.file.
"""
file_node = URIRef('http://www.spdx.org/files#{id}'.format(
id=str(doc_file.spdx_id)))
type_triple = (file_node, RDF.type, self.spdx_namespace.File)
self.graph.add(type_triple)
name_triple = (file_node, self.spdx_namespace.fileName, Literal(doc_file.name))
self.graph.add(name_triple)
if doc_file.has_optional_field('comment'):
comment_triple = (file_node, RDFS.comment, Literal(doc_file.comment))
self.graph.add(comment_triple)
if doc_file.has_optional_field('type'):
ftype = self.spdx_namespace[self.FILE_TYPES[doc_file.type]]
ftype_triple = (file_node, self.spdx_namespace.fileType, ftype)
self.graph.add(ftype_triple)
self.graph.add((file_node, self.spdx_namespace.checksum, self.create_checksum_node(doc_file.chk_sum)))
conc_lic_node = self.license_or_special(doc_file.conc_lics)
conc_lic_triple = (file_node, self.spdx_namespace.licenseConcluded, conc_lic_node)
self.graph.add(conc_lic_triple)
license_info_nodes = map(self.license_or_special, doc_file.licenses_in_file)
for lic in license_info_nodes:
triple = (file_node, self.spdx_namespace.licenseInfoInFile, lic)
self.graph.add(triple)
if doc_file.has_optional_field('license_comment'):
comment_triple = (file_node, self.spdx_namespace.licenseComments, Literal(doc_file.license_comment))
self.graph.add(comment_triple)
cr_text_node = self.to_special_value(doc_file.copyright)
cr_text_triple = (file_node, self.spdx_namespace.copyrightText, cr_text_node)
self.graph.add(cr_text_triple)
if doc_file.has_optional_field('notice'):
notice_triple = (file_node, self.spdx_namespace.noticeText, doc_file.notice)
self.graph.add(notice_triple)
contrib_nodes = map(lambda c: Literal(c), doc_file.contributors)
contrib_triples = [(file_node, self.spdx_namespace.fileContributor, node) for node in contrib_nodes]
for triple in contrib_triples:
self.graph.add(triple)
return file_node |
def add_file_dependencies_helper(self, doc_file):
"""
Handle dependencies for a single file.
- doc_file - instance of spdx.file.File.
"""
subj_triples = list(self.graph.triples((None, self.spdx_namespace.fileName, Literal(doc_file.name))))
if len(subj_triples) != 1:
raise InvalidDocumentError('Could not find dependency subject {0}'.format(doc_file.name))
subject_node = subj_triples[0][0]
for dependency in doc_file.dependencies:
dep_triples = list(self.graph.triples((None, self.spdx_namespace.fileName, Literal(dependency))))
if len(dep_triples) == 1:
dep_node = dep_triples[0][0]
dep_triple = (subject_node, self.spdx_namespace.fileDependency, dep_node)
self.graph.add(dep_triple)
else:
print('Warning could not resolve file dependency {0} -> {1}'.format(doc_file.name, dependency)) |
def create_review_node(self, review):
"""
Return a review node.
"""
review_node = BNode()
type_triple = (review_node, RDF.type, self.spdx_namespace.Review)
self.graph.add(type_triple)
reviewer_node = Literal(review.reviewer.to_value())
self.graph.add((review_node, self.spdx_namespace.reviewer, reviewer_node))
reviewed_date_node = Literal(review.review_date_iso_format)
reviewed_triple = (review_node, self.spdx_namespace.reviewDate, reviewed_date_node)
self.graph.add(reviewed_triple)
if review.has_comment:
comment_node = Literal(review.comment)
comment_triple = (review_node, RDFS.comment, comment_node)
self.graph.add(comment_triple)
return review_node |
def create_annotation_node(self, annotation):
"""
Return an annotation node.
"""
annotation_node = URIRef(str(annotation.spdx_id))
type_triple = (annotation_node, RDF.type, self.spdx_namespace.Annotation)
self.graph.add(type_triple)
annotator_node = Literal(annotation.annotator.to_value())
self.graph.add((annotation_node, self.spdx_namespace.annotator, annotator_node))
annotation_date_node = Literal(annotation.annotation_date_iso_format)
annotation_triple = (annotation_node, self.spdx_namespace.annotationDate, annotation_date_node)
self.graph.add(annotation_triple)
if annotation.has_comment:
comment_node = Literal(annotation.comment)
comment_triple = (annotation_node, RDFS.comment, comment_node)
self.graph.add(comment_triple)
annotation_type_node = Literal(annotation.annotation_type)
annotation_type_triple = (annotation_node, self.spdx_namespace.annotationType, annotation_type_node)
self.graph.add(annotation_type_triple)
return annotation_node |
def creators(self):
"""
Return a list of creator nodes.
Note: Does not add anything to the graph.
"""
return map(lambda c: Literal(c.to_value()), self.document.creation_info.creators) |
def create_creation_info(self):
"""
Add and return a creation info node to graph
"""
ci_node = BNode()
# Type property
type_triple = (ci_node, RDF.type, self.spdx_namespace.CreationInfo)
self.graph.add(type_triple)
created_date = Literal(self.document.creation_info.created_iso_format)
created_triple = (ci_node, self.spdx_namespace.created, created_date)
self.graph.add(created_triple)
creators = self.creators()
for creator in creators:
self.graph.add((ci_node, self.spdx_namespace.creator, creator))
if self.document.creation_info.has_comment:
comment_node = Literal(self.document.creation_info.comment)
comment_triple = (ci_node, RDFS.comment, comment_node)
self.graph.add(comment_triple)
return ci_node |
def create_external_document_ref_node(self, ext_document_references):
"""
Add and return a creation info node to graph
"""
ext_doc_ref_node = BNode()
type_triple = (ext_doc_ref_node, RDF.type, self.spdx_namespace.ExternalDocumentRef)
self.graph.add(type_triple)
ext_doc_id = Literal(
ext_document_references.external_document_id)
ext_doc_id_triple = (
ext_doc_ref_node, self.spdx_namespace.externalDocumentId, ext_doc_id)
self.graph.add(ext_doc_id_triple)
doc_uri = Literal(
ext_document_references.spdx_document_uri)
doc_uri_triple = (
ext_doc_ref_node, self.spdx_namespace.spdxDocument, doc_uri)
self.graph.add(doc_uri_triple)
checksum_node = self.create_checksum_node(
ext_document_references.check_sum)
self.graph.add(
(ext_doc_ref_node, self.spdx_namespace.checksum, checksum_node))
return ext_doc_ref_node |
def package_verif_node(self, package):
"""
Return a node representing package verification code.
"""
verif_node = BNode()
type_triple = (verif_node, RDF.type, self.spdx_namespace.PackageVerificationCode)
self.graph.add(type_triple)
value_triple = (verif_node, self.spdx_namespace.packageVerificationCodeValue, Literal(package.verif_code))
self.graph.add(value_triple)
excl_file_nodes = map(
lambda excl: Literal(excl), package.verif_exc_files)
excl_predicate = self.spdx_namespace.packageVerificationCodeExcludedFile
excl_file_triples = [(verif_node, excl_predicate, xcl_file) for xcl_file in excl_file_nodes]
for trp in excl_file_triples:
self.graph.add(trp)
return verif_node |
def handle_package_literal_optional(self, package, package_node, predicate, field):
"""
Check if optional field is set.
If so it adds the triple (package_node, predicate, $) to the graph.
Where $ is a literal or special value term of the value of the field.
"""
if package.has_optional_field(field):
value = getattr(package, field, None)
value_node = self.to_special_value(value)
triple = (package_node, predicate, value_node)
self.graph.add(triple) |
def handle_pkg_optional_fields(self, package, package_node):
"""
Write package optional fields.
"""
self.handle_package_literal_optional(package, package_node, self.spdx_namespace.versionInfo, 'version')
self.handle_package_literal_optional(package, package_node, self.spdx_namespace.packageFileName, 'file_name')
self.handle_package_literal_optional(package, package_node, self.spdx_namespace.supplier, 'supplier')
self.handle_package_literal_optional(package, package_node, self.spdx_namespace.originator, 'originator')
self.handle_package_literal_optional(package, package_node, self.spdx_namespace.sourceInfo, 'source_info')
self.handle_package_literal_optional(package, package_node, self.spdx_namespace.licenseComments, 'license_comment')
self.handle_package_literal_optional(package, package_node, self.spdx_namespace.summary, 'summary')
self.handle_package_literal_optional(package, package_node, self.spdx_namespace.description, 'description')
if package.has_optional_field('check_sum'):
checksum_node = self.create_checksum_node(package.check_sum)
self.graph.add((package_node, self.spdx_namespace.checksum, checksum_node))
if package.has_optional_field('homepage'):
homepage_node = URIRef(self.to_special_value(package.homepage))
homepage_triple = (package_node, self.doap_namespace.homepage, homepage_node)
self.graph.add(homepage_triple) |
def create_package_node(self, package):
"""
Return a Node representing the package.
Files must have been added to the graph before this method is called.
"""
package_node = BNode()
type_triple = (package_node, RDF.type, self.spdx_namespace.Package)
self.graph.add(type_triple)
# Handle optional fields:
self.handle_pkg_optional_fields(package, package_node)
# package name
name_triple = (package_node, self.spdx_namespace.name, Literal(package.name))
self.graph.add(name_triple)
# Package download location
down_loc_node = (package_node, self.spdx_namespace.downloadLocation, self.to_special_value(package.download_location))
self.graph.add(down_loc_node)
# Handle package verification
verif_node = self.package_verif_node(package)
verif_triple = (package_node, self.spdx_namespace.packageVerificationCode, verif_node)
self.graph.add(verif_triple)
# Handle concluded license
conc_lic_node = self.license_or_special(package.conc_lics)
conc_lic_triple = (package_node, self.spdx_namespace.licenseConcluded, conc_lic_node)
self.graph.add(conc_lic_triple)
# Handle declared license
decl_lic_node = self.license_or_special(package.license_declared)
decl_lic_triple = (package_node, self.spdx_namespace.licenseDeclared, decl_lic_node)
self.graph.add(decl_lic_triple)
# Package licenses from files
licenses_from_files_nodes = map(lambda el: self.license_or_special(el), package.licenses_from_files)
lic_from_files_predicate = self.spdx_namespace.licenseInfoFromFiles
lic_from_files_triples = [(package_node, lic_from_files_predicate, node) for node in licenses_from_files_nodes]
for triple in lic_from_files_triples:
self.graph.add(triple)
# Copyright Text
cr_text_node = self.to_special_value(package.cr_text)
cr_text_triple = (package_node, self.spdx_namespace.copyrightText, cr_text_node)
self.graph.add(cr_text_triple)
# Handle files
self.handle_package_has_file(package, package_node)
return package_node |
def handle_package_has_file_helper(self, pkg_file):
"""
Return node representing pkg_file
pkg_file should be instance of spdx.file.
"""
nodes = list(self.graph.triples((None, self.spdx_namespace.fileName, Literal(pkg_file.name))))
if len(nodes) == 1:
return nodes[0][0]
else:
raise InvalidDocumentError('handle_package_has_file_helper could not' +
' find file node for file: {0}'.format(pkg_file.name)) |
def handle_package_has_file(self, package, package_node):
"""
Add hasFile triples to graph.
Must be called after files have been added.
"""
file_nodes = map(self.handle_package_has_file_helper, package.files)
triples = [(package_node, self.spdx_namespace.hasFile, node) for node in file_nodes]
for triple in triples:
self.graph.add(triple) |
def create_doc(self):
"""
Add and return the root document node to graph.
"""
doc_node = URIRef('http://www.spdx.org/tools#SPDXRef-DOCUMENT')
# Doc type
self.graph.add((doc_node, RDF.type, self.spdx_namespace.SpdxDocument))
# Version
vers_literal = Literal(str(self.document.version))
self.graph.add((doc_node, self.spdx_namespace.specVersion, vers_literal))
# Data license
data_lics = URIRef(self.document.data_license.url)
self.graph.add((doc_node, self.spdx_namespace.dataLicense, data_lics))
doc_name = URIRef(self.document.name)
self.graph.add((doc_node, self.spdx_namespace.name, doc_name))
return doc_node |
def load_license_list(file_name):
"""
Return the licenses list version tuple and a mapping of licenses
name->id and id->name loaded from a JSON file
from https://github.com/spdx/license-list-data
"""
licenses_map = {}
with codecs.open(file_name, 'rb', encoding='utf-8') as lics:
licenses = json.load(lics)
version = licenses['licenseListVersion'].split('.')
for lic in licenses['licenses']:
if lic.get('isDeprecatedLicenseId'):
continue
name = lic['name']
identifier = lic['licenseId']
licenses_map[name] = identifier
licenses_map[identifier] = name
return version, licenses_map |
def validate(self, messages):
"""Returns True if the fields are valid according to the SPDX standard.
Appends user friendly messages to the messages parameter.
"""
messages = self.validate_creators(messages)
messages = self.validate_created(messages)
return messages |
def more_than_one_error(self, field):
"""Logs a more than one error.
field is the field/property that has more than one defined.
"""
msg = 'More than one {0} defined.'.format(field)
self.logger.log(msg)
self.error = True |
def value_error(self, key, bad_value):
"""Reports a value error using ERROR_MESSAGES dict.
key - key to use for ERROR_MESSAGES.
bad_value - is passed to format which is called on what key maps to
in ERROR_MESSAGES.
"""
msg = ERROR_MESSAGES[key].format(bad_value)
self.logger.log(msg)
self.error = True |
def to_special_value(self, value):
"""Checks if value is a special SPDX value such as
NONE, NOASSERTION or UNKNOWN if so returns proper model.
else returns value"""
if value == self.spdx_namespace.none:
return utils.SPDXNone()
elif value == self.spdx_namespace.noassertion:
return utils.NoAssert()
elif value == self.spdx_namespace.unknown:
return utils.UnKnown()
else:
return value |
def handle_lics(self, lics):
"""
Return a License from a `lics` license resource.
"""
# Handle extracted licensing info type.
if (lics, RDF.type, self.spdx_namespace['ExtractedLicensingInfo']) in self.graph:
return self.parse_only_extr_license(lics)
# Assume resource, hence the path separator
ident_start = lics.rfind('/') + 1
if ident_start == 0:
# special values such as spdx:noassertion
special = self.to_special_value(lics)
if special == lics:
if self.LICS_REF_REGEX.match(lics):
# Is a license ref i.e LicenseRef-1
return document.License.from_identifier(lics)
else:
# Not a known license form
raise SPDXValueError('License')
else:
# is a special value
return special
else:
# license url
return document.License.from_identifier(lics[ident_start:]) |
def get_extr_license_ident(self, extr_lic):
"""
Return an a license identifier from an ExtractedLicense or None.
"""
identifier_tripples = list(self.graph.triples((extr_lic, self.spdx_namespace['licenseId'], None)))
if not identifier_tripples:
self.error = True
msg = 'Extracted license must have licenseId property.'
self.logger.log(msg)
return
if len(identifier_tripples) > 1:
self.more_than_one_error('extracted license identifier_tripples')
return
identifier_tripple = identifier_tripples[0]
_s, _p, identifier = identifier_tripple
return identifier |
def get_extr_license_text(self, extr_lic):
"""
Return extracted text from an ExtractedLicense or None.
"""
text_tripples = list(self.graph.triples((extr_lic, self.spdx_namespace['extractedText'], None)))
if not text_tripples:
self.error = True
msg = 'Extracted license must have extractedText property'
self.logger.log(msg)
return
if len(text_tripples) > 1:
self.more_than_one_error('extracted license text')
return
text_tripple = text_tripples[0]
_s, _p, text = text_tripple
return text |
def get_extr_lic_name(self, extr_lic):
"""
Return the license name from an ExtractedLicense or None
"""
extr_name_list = list(self.graph.triples((extr_lic, self.spdx_namespace['licenseName'], None)))
if len(extr_name_list) > 1:
self.more_than_one_error('extracted license name')
return
elif len(extr_name_list) == 0:
return
return self.to_special_value(extr_name_list[0][2]) |
def get_extr_lics_xref(self, extr_lic):
"""
Return a list of cross references.
"""
xrefs = list(self.graph.triples((extr_lic, RDFS.seeAlso, None)))
return map(lambda xref_triple: xref_triple[2], xrefs) |
def get_extr_lics_comment(self, extr_lics):
"""
Return license comment or None.
"""
comment_list = list(self.graph.triples(
(extr_lics, RDFS.comment, None)))
if len(comment_list) > 1 :
self.more_than_one_error('extracted license comment')
return
elif len(comment_list) == 1:
return comment_list[0][2]
else:
return |
def parse_only_extr_license(self, extr_lic):
"""
Return an ExtractedLicense object to represent a license object.
But does not add it to the SPDXDocument model.
Return None if failed.
"""
# Grab all possible values
ident = self.get_extr_license_ident(extr_lic)
text = self.get_extr_license_text(extr_lic)
comment = self.get_extr_lics_comment(extr_lic)
xrefs = self.get_extr_lics_xref(extr_lic)
name = self.get_extr_lic_name(extr_lic)
if not ident:
# Must have identifier
return
# Set fields
# FIXME: the constructor of the license should alwas accept a name
lic = document.ExtractedLicense(ident)
if text is not None:
lic.text = text
if name is not None:
lic.full_name = name
if comment is not None:
lic.comment = comment
lic.cross_ref = map(lambda x: six.text_type(x), xrefs)
return lic |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.