def update_licenses_relations_rec(new_neo_license, new_object_license, neo_license, object_license): # update precedings and followings of license recursively. grand_follower = False for neo_license_following in neo_license.followings: object_license_following = ObjectFactory.objectLicense( neo_license_following) if new_object_license.is_following(object_license_following): # new license is a follower of a following grand_follower = True if new_object_license.is_preceding(object_license_following): if Constraints.is_compatibility_viable(new_object_license, object_license_following): neo_license_following.precedings.connect(new_neo_license) if new_object_license.is_following(object_license): # new_license is between license and its following_license. if Constraints.is_compatibility_viable(object_license, new_object_license): neo_license.followings.connect(new_neo_license) neo_license.followings.disconnect(neo_license_following) else: update_licenses_relations_rec(new_neo_license, new_object_license, neo_license_following, object_license_following) if not grand_follower and new_object_license.is_following(object_license): # then its just the next follower of the current license if Constraints.is_compatibility_viable(object_license, new_object_license): neo_license.followings.connect(new_neo_license)
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_rec(new_neo_license, new_object_license, neo_license, object_license, viability_check, nb_visit, tested_licenses): # update precedings and followings of license recursively. if object_license in tested_licenses: return nb_visit nb_visit += 1 tested_licenses.append(object_license) grand_preceder = False for neo_license_preceding in neo_license.precedings: object_license_preceding = ObjectFactory.objectLicense( neo_license_preceding) if already_preceder(object_license_preceding, new_neo_license): continue if new_object_license.is_following(object_license_preceding) and ( Constraints.is_compatibility_viable(object_license_preceding, new_object_license) or not viability_check): update_transitivity_preceder(new_neo_license, object_license_preceding) new_neo_license.precedings.connect(neo_license_preceding) if new_object_license.is_preceding(object_license) and ( Constraints.is_compatibility_viable( new_object_license, object_license) or not viability_check): new_neo_license.followings.connect(neo_license) neo_license.precedings.disconnect(neo_license_preceding) else: if new_object_license.is_preceding(object_license_preceding) and ( Constraints.is_compatibility_viable( new_object_license, object_license_preceding) or not viability_check): grand_preceder = True nb_visit = update_licenses_relations_supremum_rec( new_neo_license, new_object_license, neo_license_preceding, object_license_preceding, viability_check, nb_visit, tested_licenses) if not grand_preceder and ( new_object_license.is_preceding(object_license) and (Constraints.is_compatibility_viable( new_object_license, object_license) or not viability_check)): new_neo_license.followings.connect(neo_license) return nb_visit
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