Пример #1
0
    def __init__(self):
        self.by_key = load_licenses(with_deprecated=True)
        self.by_spdx_key = get_licenses_by_spdx_key(self.by_key.values())

        # TODO: not yet used
        foreign_dir = join(licensedcode.models.data_dir, 'non-english', 'licenses')
        self.non_english_by_key = load_licenses(foreign_dir, with_deprecated=True)
        self.non_english_by_spdx_key = get_licenses_by_spdx_key(self.non_english_by_key.values())
Пример #2
0
 def test_dump_license(self):
     test_dir = self.get_test_loc('models/licenses', copy=True)
     lics = models.load_licenses(test_dir, with_deprecated=True)
     for l in lics.values():
         l.dump()
     lics = models.load_licenses(test_dir, with_deprecated=True)
     # Note: one license is obsolete and not loaded. Other are various exception/version cases
     results = as_sorted_mapping_seq(lics.values())
     expected = self.get_test_loc('models/licenses.dump.expected.json')
     check_json(expected, results)
Пример #3
0
    def test_relocate_license_with_key(self):
        test_dir = self.get_test_loc('models/licenses')
        lics = models.load_licenses(test_dir, with_deprecated=True)
        new_dir = self.get_temp_dir('relocate_lics')
        for l in lics.values():
            l.relocate(new_dir, new_key='new_key-' + l.key)

        lics = models.load_licenses(new_dir, with_deprecated=True)
        # Note: one license is obsolete and not loaded. Other are various exception/version cases
        results = as_sorted_mapping_seq(lics.values())
        expected = self.get_test_loc('models/licenses-new-key.expected.json')
        check_json(expected, results)
Пример #4
0
    def __init__(self, src_dir, match_text=False, match_approx=False):
        """
        `src_dir` is where the License objects are dumped.
        """
        src_dir = os.path.realpath(src_dir)
        self.src_dir = src_dir

        self.match_text = match_text
        self.match_approx = match_approx

        self.fetched = False
        if os.path.exists(src_dir):
            # fetch ONLY if the directory is empty
            self.fetched = True
        else:
            os.mkdir(src_dir)

        self.update_dir = self.src_dir.rstrip('\\/') + '-update'
        if not os.path.exists(self.update_dir):
            os.mkdir(self.update_dir)

        self.new_dir = self.src_dir.rstrip('\\/') + '-new'
        if not os.path.exists(self.new_dir):
            os.mkdir(self.new_dir)

        self.del_dir = self.src_dir.rstrip('\\/') + '-del'
        if not os.path.exists(self.del_dir):
            os.mkdir(self.del_dir)

        self.scancodes_by_key = get_licenses_db()

        self.scancodes_by_spdx_key = {
            l.spdx_license_key.lower(): l
            for l in self.scancodes_by_key.values() if l.spdx_license_key
        }

        composites_dir = os.path.join(licensedcode.data_dir, 'composites',
                                      'licenses')
        self.composites_by_key = load_licenses(composites_dir,
                                               with_deprecated=True)
        self.composites_by_spdx_key = {
            l.spdx_license_key.lower(): l
            for l in self.composites_by_key.values() if l.spdx_license_key
        }

        foreign_dir = os.path.join(licensedcode.data_dir, 'non-english',
                                   'licenses')
        self.non_english_by_key = load_licenses(foreign_dir,
                                                with_deprecated=True)
        self.non_english_by_spdx_key = {
            l.spdx_license_key.lower(): l
            for l in self.non_english_by_key.values() if l.spdx_license_key
        }
Пример #5
0
    def test_relocate_license(self):
        test_dir = self.get_test_loc('models/licenses')
        lics = models.load_licenses(test_dir, with_deprecated=True)
        new_dir = self.get_temp_dir('relocate_lics')
        for l in lics.values():
            l.relocate(new_dir)

        lics = models.load_licenses(new_dir, with_deprecated=True)
        # Note: one license is obsolete and not loaded. Other are various exception/version cases
        results = sorted(l.to_dict() for l in lics.values())
        expected = self.get_test_loc('models/licenses.expected.json')
        check_json(expected, results)
 def test_rules_from_licenses(self):
     test_dir = self.get_test_loc('models/licenses')
     lics = models.load_licenses(test_dir)
     rules = list(models.rules_from_licenses(lics))
     assert 4 == len(rules)
     for rule in rules:
         assert 'distribut' in rule.text().lower()
Пример #7
0
 def test_build_rules_from_licenses(self):
     test_dir = self.get_test_loc('models/licenses')
     lics = models.load_licenses(test_dir)
     rules = models.build_rules_from_licenses(lics)
     results = sorted(r.to_dict() for r in rules)
     expected = self.get_test_loc('models/license_rules.expected.json')
     check_json(expected, results)
Пример #8
0
 def test_get_rules_from_license_texts(self):
     test_dir = self.get_test_loc('models/licenses')
     lics = models.load_licenses(test_dir)
     rules = [r for r in models.get_rules_from_license_texts(lics)]
     self.assertEqual(4, len(rules))
     for rule in rules:
         self.assertTrue('distribut' in rule.text.lower())
def add_spdx_key_rules():
    """
    Check that every known SPDX license key is properly detected exactly by a license rule.
    If not, create a new rule

    """
    by_key = load_licenses(with_deprecated=True)
    by_spdx_key = synclic.get_licenses_by_spdx_key(by_key.values(),
                                                   include_other=True)

    click.echo("Checking all SPDX ids.")
    # first accumulate non-matches
    unmatched_licenses = {}
    for spdx_key, license_obj in sorted(by_spdx_key.items()):
        #         click.echo('.', nl=False)

        if spdx_key in very_common_ids:
            continue

        if is_matched(spdx_key, license_obj.key):
            continue

        unmatched_licenses[spdx_key] = license_obj

    click.echo("")
    click.echo("{} SPDX ids not matched.".format(len(unmatched_licenses)))

    # then create all rules at once
    for spdx_key, license_obj in sorted(unmatched_licenses.items()):
        add_rule(spdx_key, license_obj)
Пример #10
0
 def test_load_license(self):
     test_dir = self.get_test_loc('models/licenses')
     lics = models.load_licenses(test_dir)
     # Note: one license is obsolete and not loaded. Other are various exception/version cases
     results = as_sorted_mapping_seq(lics.values())
     expected = self.get_test_loc('models/licenses.load.expected.json')
     check_json(expected, results)
Пример #11
0
def build_index(licenses_db=None, licenses_data_dir=None, rules_data_dir=None):
    """
    Return an index built from rules and licenses directories
    """
    from licensedcode.index import LicenseIndex
    from licensedcode.models import get_rules
    from licensedcode.models import get_all_spdx_key_tokens
    from licensedcode.models import get_license_tokens
    from licensedcode.models import licenses_data_dir as ldd
    from licensedcode.models import rules_data_dir as rdd
    from licensedcode.models import load_licenses
    from licensedcode.legalese import common_license_words

    licenses_data_dir = licenses_data_dir or ldd
    rules_data_dir = rules_data_dir or rdd

    licenses_db = licenses_db or load_licenses(
        licenses_data_dir=licenses_data_dir)
    rules = get_rules(licenses_db=licenses_db, rules_data_dir=rules_data_dir)

    legalese = common_license_words
    spdx_tokens = set(get_all_spdx_key_tokens(licenses_db))
    license_tokens = set(get_license_tokens())

    return LicenseIndex(
        rules,
        _legalese=legalese,
        _spdx_tokens=spdx_tokens,
        _license_tokens=license_tokens,
    )
Пример #12
0
    def test_validate_license_library_can_return_errors(self):
        test_dir = self.get_test_loc('models/validate')
        lics = models.load_licenses(test_dir)
        errors, warnings, infos = models.License.validate(lics,
                                                          no_dupe_urls=True,
                                                          verbose=True)
        expected_errors = {
            'GLOBAL': [
                'Duplicate texts in multiple licenses:apache-2.0: TEXT, bsd-ack-carrot2: TEXT',
                'Duplicate short name:GPL 1.0 in licenses:gpl-1.0-plus, gpl-1.0',
                'Duplicate name:GNU General Public License 1.0 in licenses:gpl-1.0-plus, gpl-1.0'
            ],
            'bsd-ack-carrot2':
            ['No short name', 'No name', 'No category', 'No owner'],
            'gpl-1.0': ['Unknown license category: GNU Copyleft'],
            'w3c-docs-19990405':
            ['Unknown license category: Permissive Restricted']
        }

        assert expected_errors == errors
        expected_warnings = {
            'gpl-1.0': [
                'Some empty text_urls values', 'Some empty other_urls values',
                'Homepage URL also in text_urls',
                'Homepage URL also in other_urls',
                'Homepage URL same as faq_url', 'Homepage URL same as osi_url',
                'osi_url same as faq_url', 'Some duplicated URLs'
            ]
        }

        assert expected_warnings == warnings

        expected_infos = {'w3c-docs-19990405': [u'No license text']}
        assert expected_infos == infos
Пример #13
0
 def test_get_rules_from_license_texts(self):
     test_dir = self.get_test_loc('models/licenses')
     lics = models.load_licenses(test_dir)
     rules = [r for r in models.get_rules_from_license_texts(lics)]
     assert 4 == len(rules)
     for rule in rules:
         assert 'distribut' in rule.text.lower()
Пример #14
0
 def test_get_rules_from_license_texts(self):
     test_dir = self.get_test_loc('models/licenses')
     lics = models.load_licenses(test_dir)
     rules = [r for r in models.get_rules_from_license_texts(lics)]
     assert 4 == len(rules)
     for rule in rules:
         assert 'distribut' in rule.text.lower()
Пример #15
0
 def test_load_licenses_fails_if_directory_contains_orphaned_files(self):
     test_dir = self.get_test_loc('models/orphaned_licenses')
     try:
         list(models.load_licenses(test_dir))
         self.fail('Exception not raised')
     except Exception as e:
         assert 'Some License data or text files are orphaned' in str(e)
Пример #16
0
 def test_build_rules_from_licenses(self):
     test_dir = self.get_test_loc('models/licenses')
     lics = models.load_licenses(test_dir)
     rules = models.build_rules_from_licenses(lics)
     results = sorted(r.to_dict() for r in rules)
     expected = self.get_test_loc('models/rules.expected.json')
     check_json(expected, results)
Пример #17
0
    def get_licenses(self, scancode_licenses):
        """
        Return a mapping of key -> ScanCode License objects either fetched
        externally or loaded from the existing `self.original_dir`
        """
        print('Fetching and storing external licenses in:', self.original_dir)

        licenses = []
        for lic, text in self.fetch_licenses(scancode_licenses):
            try:
                with io.open(lic.text_file, 'w', encoding='utf-8') as tf:
                    tf.write(text)
                lic.dump()
                licenses.append(lic)
            except:
                if TRACE:
                    print()
                    print(repr(lic))
                raise

        print('Stored %d external licenses in: %r.' % (
            len(licenses),
            self.original_dir,
        ))

        print('Modified (or not modified) external licenses will be in: %r.' %
              (self.update_dir, ))
        fileutils.copytree(self.original_dir, self.update_dir)

        print('New external licenses will be in: %r.' % (self.new_dir, ))

        return load_licenses(self.update_dir, with_deprecated=True)
Пример #18
0
 def test_load_license(self):
     test_dir = self.get_test_loc('models/licenses')
     lics = models.load_licenses(test_dir)
     # Note: one license is obsolete and not loaded. Other are various exception/version cases
     results = sorted(l.to_dict() for l in lics.values())
     expected = self.get_test_loc('models/licenses.expected.json')
     check_json(expected, results)
Пример #19
0
 def test_build_rules_from_licenses(self):
     test_dir = self.get_test_loc('models/licenses')
     lics = models.load_licenses(test_dir)
     rules = models.build_rules_from_licenses(lics)
     results = as_sorted_mapping_seq(rules)
     expected = self.get_test_loc('models/license_rules.expected.json')
     check_json(expected, results)
Пример #20
0
    def __init__(self, src_dir, match_text=False, match_approx=False):
        """
        `src_dir` is where the License objects are dumped.
        """
        src_dir = os.path.realpath(src_dir)
        self.src_dir = src_dir

        self.match_text = match_text
        self.match_approx = match_approx

        self.fetched = False
        if os.path.exists(src_dir):
            # fetch ONLY if the directory is empty
            self.fetched = True
        else:
            os.mkdir(src_dir)

        self.update_dir = self.src_dir.rstrip('\\/') + '-update'
        if not os.path.exists(self.update_dir):
            os.mkdir(self.update_dir)

        self.new_dir = self.src_dir.rstrip('\\/') + '-new'
        if not os.path.exists(self.new_dir):
            os.mkdir(self.new_dir)

        self.del_dir = self.src_dir.rstrip('\\/') + '-del'
        if not os.path.exists(self.del_dir):
            os.mkdir(self.del_dir)

        self.scancodes_by_key = get_licenses_db()

        self.scancodes_by_spdx_key = {l.spdx_license_key.lower(): l
            for l in self.scancodes_by_key.values()
            if l.spdx_license_key}

        composites_dir = os.path.join(licensedcode.data_dir, 'composites', 'licenses')
        self.composites_by_key = load_licenses(composites_dir, with_deprecated=True)
        self.composites_by_spdx_key = {l.spdx_license_key.lower(): l
            for l in self.composites_by_key.values()
            if l.spdx_license_key}

        foreign_dir = os.path.join(licensedcode.data_dir, 'non-english', 'licenses')
        self.non_english_by_key = load_licenses(foreign_dir, with_deprecated=True)
        self.non_english_by_spdx_key = {l.spdx_license_key.lower(): l
            for l in self.non_english_by_key.values()
            if l.spdx_license_key}
Пример #21
0
 def get_licenses(self):
     """
     Return a mapping of key -> ScanCode License objects either
     fetched externally or loaded from the existing `self.src_dir`
     """
     if self.fetched:
         print('Reusing (possibly modified) external licenses stored in:', self.update_dir)
         return load_licenses(self.update_dir, with_deprecated=True)
     else:
         print('Fetching and storing external licenses in:', self.src_dir)
         licenses = {l.key: l for l in self.fetch_licenses()}
         print('Stored %d external licenses in: %r.' % (len(licenses), self.src_dir,))
         fileutils.copytree(self.src_dir, self.update_dir)
         print('Modified external licenses will be in: %r.' % (self.update_dir,))
         print('New external licenses will be in: %r.' % (self.new_dir,))
         print('Deleted external licenses will be in: %r.' % (self.del_dir,))
         return load_licenses(self.update_dir, with_deprecated=True)
Пример #22
0
def get_licenses():
    """
    Load the licenses from the ScanCode-toolkit `licensedcode` data and
    return a mapping of `key` to `license` objects.
    The result is cached in memory so the load_licenses() process is only
    executed once on the first `get_licenses()` call.
    """
    return load_licenses()
Пример #23
0
 def test_validate_license_library_data(self):
     errors, warnings, infos = models.License.validate(
         licenses=models.load_licenses(with_deprecated=False),
         verbose=False,
     )
     assert errors == {}
     assert warnings == {}
     assert infos
Пример #24
0
 def test_get_spdx_symbols_fails_on_duplicated_other_spdx_keys(self):
     test_dir = self.get_test_loc('spdx/db-dupe-other')
     from licensedcode.models import load_licenses
     test_licenses = load_licenses(test_dir)
     try:
         cache.get_spdx_symbols(_test_licenses=test_licenses)
         self.fail('ValueError not raised!')
     except ValueError as e:
         assert 'Duplicated "other" SPDX license key' in str(e)
Пример #25
0
def build_unknown_spdx_symbol(licenses_db=None):
    """
    Return the unknown SPDX license symbol given a `licenses_db` mapping of
    {key: License} or the standard license db.
    """
    from license_expression import LicenseSymbolLike
    from licensedcode.models import load_licenses
    licenses_db = licenses_db or load_licenses()
    return LicenseSymbolLike(licenses_db['unknown-spdx'])
Пример #26
0
    def test_load_license(self):
        test_dir = self.get_test_loc('models/licenses')
        lics = models.load_licenses(test_dir)
        # one license is obsolete and not loaded
        expected = [u'apache-2.0', u'bsd-ack-carrot2', u'w3c-docs-19990405']
        assert expected == sorted(lics.keys())

        assert all(isinstance(l, models.License) for l in lics.values())
        # test a sample of a licenses field
        assert '1994-2002 World Wide Web Consortium' in lics[u'w3c-docs-19990405'].text
Пример #27
0
    def test_validate_license_library_can_return_errors(self):
        test_dir = self.get_test_loc('models/validate')
        lics = models.load_licenses(test_dir)
        errors, warnings, infos = models.License.validate(
            lics,
            no_dupe_urls=True,
            verbose=False,
        )

        expected_errors = {
            'GLOBAL': [
                'Duplicate texts in multiple licenses: apache-2.0: TEXT, bsd-ack-carrot2: TEXT',
                'Duplicate short name (ignoring case): gpl 1.0 in licenses: gpl-1.0-plus, gpl-1.0',
                'Duplicate name (ignoring case): gnu general public license 1.0 in licenses: gpl-1.0-plus, gpl-1.0'
            ],
            'bsd-ack-carrot2': [
                'No short name', 'No name',
                'No category: Use "Unstated License" if not known.',
                'No owner: Use "Unspecified" if not known.',
                'No SPDX license key'
            ],
            'foo-2.0': ['Unknown language: foobar', 'No SPDX license key'],
            'gpl-1.0': [
                'Unknown license category: GNU Copyleft.\nUse one of these valid categories:\n'
                'Commercial\nCopyleft\nCopyleft Limited\nFree Restricted\n'
                'Patent License\nPermissive\nProprietary Free\nPublic Domain\nSource-available\nUnstated License',
                'No SPDX license key'
            ],
            'w3c-docs-19990405': [
                'Unknown license category: Permissive Restricted.\nUse one of these valid categories:\n'
                'Commercial\nCopyleft\nCopyleft Limited\nFree Restricted\n'
                'Patent License\nPermissive\nProprietary Free\nPublic Domain\nSource-available\nUnstated License',
                'No SPDX license key'
            ],
        }

        assert errors == expected_errors

        expected_warnings = {
            'gpl-1.0': [
                'Some empty text_urls values', 'Some empty other_urls values',
                'Homepage URL also in text_urls',
                'Homepage URL also in other_urls',
                'Homepage URL same as faq_url', 'Homepage URL same as osi_url',
                'osi_url same as faq_url', 'Some duplicated URLs'
            ]
        }

        assert warnings == expected_warnings

        expected_infos = {
            'foo-2.0': ['No license text'],
            'w3c-docs-19990405': ['No license text'],
        }
        assert infos == expected_infos
Пример #28
0
    def test_load_license(self):
        test_dir = self.get_test_loc('models/licenses')
        lics = models.load_licenses(test_dir)
        # one license is obsolete and not loaded
        expected = [u'apache-2.0', u'bsd-ack-carrot2', u'w3c-docs-19990405']
        assert expected == sorted(lics.keys())

        assert all(isinstance(l, models.License) for l in lics.values())
        # test a sample of a licenses field
        assert '1994-2002 World Wide Web Consortium' in lics[
            u'w3c-docs-19990405'].text
def build_licenses_db(licenses_data_dir=None):
    """
    Return a mapping of license key -> license object loaded from a
    ``licenses_data_dir``.
    """
    from licensedcode.models import load_licenses

    if not licenses_data_dir:
        from licensedcode.models import licenses_data_dir as ldd
        licenses_data_dir = ldd
    return load_licenses(licenses_data_dir)
Пример #30
0
def build_licensing(licenses_db=None):
    """
    Return a `license_expression.Licensing` objet built from a `licenses_db`
    mapping of {key: License} or the standard license db.
    """
    from license_expression import LicenseSymbolLike
    from license_expression import Licensing
    from licensedcode.models import load_licenses

    licenses_db = licenses_db or load_licenses()
    return Licensing((LicenseSymbolLike(lic) for lic in licenses_db.values()))
Пример #31
0
def get_licenses_db(licenses_data_dir=None):
    """
    Return a mapping of license key -> license object.
    """
    global _LICENSES
    if not _LICENSES:
        from licensedcode.models import load_licenses
        if not licenses_data_dir:
            from licensedcode.models import licenses_data_dir as ldd
            licenses_data_dir = ldd
        _LICENSES = load_licenses(licenses_data_dir)
    return _LICENSES
Пример #32
0
def get_licenses_db(licenses_data_dir=None):
    """
    Return a mapping of license key -> license object.
    """
    global _LICENSES
    if not _LICENSES :
        from licensedcode.models import load_licenses
        if not licenses_data_dir:
            from licensedcode.models import licenses_data_dir as ldd
            licenses_data_dir = ldd
        _LICENSES = load_licenses(licenses_data_dir)
    return _LICENSES
Пример #33
0
def _patch_license_list():
    """
    Patch the SPDX library license list to match the list of ScanCode known SPDX
    licenses.
    """
    global _spdx_list_is_patched
    if not _spdx_list_is_patched:
        from spdx.config import LICENSE_MAP
        from licensedcode.models import load_licenses
        licenses = load_licenses(with_deprecated=True)
        spdx_licenses = get_licenses_by_spdx_key(licenses.values())
        LICENSE_MAP.update(spdx_licenses)
        _spdx_list_is_patched = True
Пример #34
0
 def get_licenses(self):
     """
     Return a mapping of key -> ScanCode License objects either
     fetched externally or loaded from the existing `self.src_dir`
     """
     if self.fetched:
         print('Reusing (possibly modified) external licenses stored in:',
               self.update_dir)
         return load_licenses(self.update_dir, with_deprecated=True)
     else:
         print('Fetching and storing external licenses in:', self.src_dir)
         licenses = {l.key: l for l in self.fetch_licenses()}
         print('Stored %d external licenses in: %r.' % (
             len(licenses),
             self.src_dir,
         ))
         fileutils.copytree(self.src_dir, self.update_dir)
         print('Modified external licenses will be in: %r.' %
               (self.update_dir, ))
         print('New external licenses will be in: %r.' % (self.new_dir, ))
         print('Deleted external licenses will be in: %r.' %
               (self.del_dir, ))
         return load_licenses(self.update_dir, with_deprecated=True)
Пример #35
0
def cli(license_dir, verbose):
    """
    Create one SPDX tag-value document for each non-SPDX ScanCode licenses.
    Store these in the DIR directory
    """

    base_kwargs = dict(
        license=True,
        license_text=True,
        info=True,
        strip_root=True,
        quiet=True,
        return_results=False,
    )

    licenses_by_key = load_licenses(with_deprecated=False)

    for i, lic in enumerate(licenses_by_key.values()):
        ld = lic.to_dict()

        if lic.spdx_license_key:
            if verbose:
                click.echo(
                    "Skipping ScanCode: {key} that is an SPDX license: {spdx_license_key}"
                    .format(**ld))
            continue

        if not lic.text_file or not os.path.exists(lic.text_file):
            if verbose:
                click.echo("Skipping license without text: {key}".format(**ld))
            continue

        if lic.category not in FOSS_CATEGORIES:
            if verbose:
                click.echo("Skipping non FOSS license: {key}".format(**ld))
            continue

        output = "licenseref-scancode-{key}.spdx".format(**ld)
        output = os.path.join(license_dir, output)

        if verbose:
            click.echo(
                "Creating SPDX document for license: {key}".format(**ld))
            click.echo("at: {output}".format(**locals()))

        with io.open(output, "w", encoding="utf-8") as ouput_file:
            kwargs = dict(input=lic.text_file, spdx_tv=ouput_file)
            kwargs.update(base_kwargs)
            run_scan(**kwargs)
Пример #36
0
    def test_get_spdx_symbols_from_dir(self):
        test_dir = self.get_test_loc('spdx/db')
        from licensedcode.models import load_licenses
        test_licenses = load_licenses(test_dir)
        result = {
            key: val.key for key, val
            in cache.get_spdx_symbols(_test_licenses=test_licenses).items()
        }
        expected = {
            u'bar': u'xxd',
            u'foo': u'xxd',
            u'qt-lgpl-exception-1.1': u'qt-lgpl-exception-1.1',
            u'xskat': u'xskat'
        }

        assert expected == result
Пример #37
0
def get_licenses_db(licenses_data_dir=None, _test_mode=False):
    """
    Return a mapping of license key -> license object.
    """
    global _LICENSES_BY_KEY
    if not _LICENSES_BY_KEY or _test_mode:
        from licensedcode.models import load_licenses
        if not licenses_data_dir:
            from licensedcode.models import licenses_data_dir as ldd
            licenses_data_dir = ldd
        lics_by_key = load_licenses(licenses_data_dir)

        if _test_mode:
            # Do not cache when testing
            return lics_by_key

        _LICENSES_BY_KEY = lics_by_key
    return _LICENSES_BY_KEY
Пример #38
0
def build_spdx_symbols(licenses_db=None):
    """
    Return a mapping of {lowercased SPDX license key: LicenseSymbolLike} where
    LicenseSymbolLike wraps a License object loaded from a `licenses_db` mapping
    of {key: License} or the standard license db.
    """
    from license_expression import LicenseSymbolLike
    from licensedcode.models import load_licenses

    licenses_db = licenses_db or load_licenses()
    symbols_by_spdx_key = {}

    for lic in licenses_db.values():
        if not (lic.spdx_license_key or lic.other_spdx_license_keys):
            continue

        symbol = LicenseSymbolLike(lic)
        if lic.spdx_license_key:
            slk = lic.spdx_license_key.lower()
            existing = symbols_by_spdx_key.get(slk)

            if existing:
                raise ValueError(
                    'Duplicated SPDX license key: %(slk)r defined in '
                    '%(lic)r and %(existing)r' % locals())

            symbols_by_spdx_key[slk] = symbol

        for other_spdx in lic.other_spdx_license_keys:
            if not (other_spdx and other_spdx.strip()):
                continue
            slk = other_spdx.lower()
            existing = symbols_by_spdx_key.get(slk)

            if existing:
                raise ValueError(
                    'Duplicated "other" SPDX license key: %(slk)r defined '
                    'in %(lic)r and %(existing)r' % locals())
            symbols_by_spdx_key[slk] = symbol

    return symbols_by_spdx_key
Пример #39
0
 def test_get_texts(self):
     test_dir = self.get_test_loc('models/licenses')
     lics = models.load_licenses(test_dir)
     for lic in lics.values():
         assert 'distribut' in lic.text.lower()