def add_license_to_db(object_license):
neo_license = LicenseModel.nodes.get_or_none(
hashed_sets=object_license.hash())
if neo_license:
# update of labels list if needed
neo_license.labels = list(
set(object_license.get_labels()).union(neo_license.labels))
neo_license.save()
else:
# license does not exists in db
license_leaves = get_leaf_licenses()
neo_license = NeoFactory.NeoLicense(object_license)
neo_license.save()
for neo_license_leaf in license_leaves:
object_license_leaf = ObjectFactory.objectLicense(neo_license_leaf)
if object_license.is_preceding(object_license_leaf):
if Constraints.is_compatibility_viable(object_license,
object_license_leaf):
neo_license_leaf.precedings.connect(neo_license)
else:
update_licenses_relations_rec(neo_license, object_license,
neo_license_leaf,
object_license_leaf)
for dataset in object_license.get_datasets():
neo_dataset = DatasetModel.nodes.get_or_none(hashed_uri=dataset.hash())
if not neo_dataset:
neo_dataset = NeoFactory.NeoDataset(dataset)
neo_dataset.save()
neo_license.datasets.connect(neo_dataset)
object_license = ObjectFactory.objectLicense(neo_license)
return object_license
def update_licenses_relations_supremum(object_license,
viability_check,
nb_visit,
graph='ld'):
tested_licenses = [object_license]
license_roots = get_root_licenses(graph)
neo_license = NeoFactory.NeoLicense(object_license, graph)
neo_license.save()
for neo_license_root in license_roots:
object_license_root = ObjectFactory.objectLicense(neo_license_root)
if object_license.is_following(object_license_root) and (
Constraints.is_compatibility_viable(object_license_root,
object_license)
or not viability_check):
update_transitivity_preceder(neo_license, object_license_root)
neo_license_root.followings.connect(neo_license)
else:
nb_visit = update_licenses_relations_supremum_rec(
neo_license, object_license, neo_license_root,
object_license_root, viability_check, nb_visit,
tested_licenses)
return neo_license, nb_visit
def update_licenses_relations_infimum(object_license,
viability_check,
nb_visit,
graph='ld'):
tested_licenses = [object_license]
license_leaves = get_leaf_licenses(graph)
neo_license = NeoFactory.NeoLicense(object_license, graph)
neo_license.save()
for neo_license_leaf in license_leaves:
object_license_leaf = ObjectFactory.objectLicense(neo_license_leaf)
if object_license.is_preceding(object_license_leaf) and (
Constraints.is_compatibility_viable(object_license,
object_license_leaf)
or not viability_check):
update_transitivity_follower(neo_license, object_license_leaf)
neo_license_leaf.precedings.connect(neo_license)
else:
nb_visit = update_licenses_relations_infimum_rec(
neo_license, object_license, neo_license_leaf,
object_license_leaf, viability_check, nb_visit,
tested_licenses)
return neo_license, nb_visit