Remove old debian_copyright parsing functions

Removes old debian copyright parsing functions and also
removes debian_licenses.txt.

Signed-off-by: Ayan Sinha Mahapatra <[email protected]>

Author: AyanSinhaMahapatra

src/packagedcode/debian_copyright.py

@@ -1458,222 +1458,3 @@ def is_paragraph_primary_license(paragraph):
         paragraph, CopyrightFilesParagraph
     ) and paragraph.files.values == ['*']
 
-
-# ========================== DEPRECATED FUNCTIONS ==================================
-
-def parse_structured_copyright_file(
-    location,
-    skip_debian_packaging=False,
-):
-    """
-    Return a tuple of (list of declared license strings, list of detected license matches)
-    collected from the debian copyright file at `location`.
-
-    If `skip_debian_packaging` is False, the Debian packaging license is skipped if detected.
-
-    Note: This was the older structured file parsing method which is now discontinued.
-    """
-    if not location:
-        return None, None
-
-    deco = DebianCopyright.from_file(location)
-
-    declared_licenses = []
-    detected_licenses = []
-
-    deco = refine_debian_copyright(deco)
-
-    licensing = Licensing()
-    for paragraph in deco.paragraphs:
-
-        if is_paragraph_debian_packaging(paragraph) and not skip_debian_packaging:
-            # Skipping packaging license and copyrights since they are not
-            # relevant to the effective package license
-            continue
-
-        # rare case where we have not a structured file
-        if isinstance(paragraph, CatchAllParagraph):
-            text = paragraph.dumps()
-            if text:
-                detected = get_normalized_expression(
-                    text,
-                    try_as_expression=False,
-                    approximate=False,
-                )
-                if not detected:
-                    detected = 'unknown'
-                detected_licenses.append(detected)
-        else:
-            plicense = paragraph.license
-            if not plicense:
-                continue
-
-            declared, detected = detect_declared_license(plicense.name)
-            if declared:
-                declared_licenses.append(declared)
-            if detected:
-                detected_licenses.append(detected)
-
-            # also detect in text
-            text = paragraph.license.text
-            if text:
-                detected = get_normalized_expression(
-                    text,
-                    try_as_expression=False,
-                    approximate=True,
-                )
-                if not detected:
-                    detected = 'unknown'
-
-                detected_licenses.append(detected)
-
-    declared_license = '\n'.join(declared_licenses)
-
-    if detected_licenses:
-        detected_license = str(combine_expressions(detected_licenses))
-
-    return declared_license, detected_license
-
-
-def detect_declared_license(declared):
-    """
-    Return a tuple of (declared license, detected license expression) from a
-    declared license. Both can be None.
-    """
-    declared = normalize_and_cleanup_declared_license(declared)
-
-    if TRACE:
-        logger_debug(f'detect_declared_license: {declared}')
-
-    if not declared:
-        return None, None
-
-    # apply multiple license detection in sequence
-    detected = detect_using_name_mapping(declared)
-    if detected:
-        return declared, detected
-
-    from packagedcode import licensing
-
-    try:
-        detected = licensing.get_normalized_expression(
-            declared,
-            try_as_expression=False,
-            approximate=False,
-        )
-    except Exception:
-        # FIXME: add logging
-        # we never fail just for this
-        return 'unknown'
-
-    return declared, detected
-
-
-def normalize_and_cleanup_declared_license(declared):
-    """
-    Return a cleaned and normalized declared license.
-    """
-    declared = declared or ''
-    # there are few odd cases of license fileds starting with a colon or #
-    declared = declared.strip(': \t#')
-    # normalize spaces
-    declared = ' '.join(declared.split())
-    return declared
-
-
-def detect_using_name_mapping(declared):
-    """
-    Return a license expression detected from a declared_license.
-    """
-    declared = declared.lower()
-    detected = get_declared_to_detected().get(declared)
-    if detected:
-        licensing = Licensing()
-        return str(licensing.parse(detected, simple=True))
-
-
-def refine_debian_copyright(debian_copyright):
-    """
-    Update in place the `debian_copyright` DebianCopyright object based on
-    issues found in a large collection of Debian copyright files.
-    """
-    for paragraph in debian_copyright.paragraphs:
-        if not hasattr(paragraph, 'license'):
-            continue
-        plicense = paragraph.license
-        if not plicense:
-            continue
-
-        license_name = plicense.name
-        if not license_name:
-            continue
-
-        if license_name.startswith('200'):
-            # these are copyrights and not actual licenses, such as:
-            # - 2005 Sergio Costas
-            # - 2006-2010 by The HDF Group.
-
-            if isinstance(
-                paragraph, (CopyrightHeaderParagraph, CopyrightFilesParagraph)
-            ):
-                pcs = paragraph.copyright.statements or []
-                pcs.append(license_name)
-                paragraph.copyright.statements = pcs
-                paragraph.license.name = None
-
-        license_name_low = license_name.lower()
-        NOT_A_LICENSE_NAME = (
-            'according to',
-            'by obtaining',
-            'distributed under the terms of the gnu',
-            'gnu general public license version 2 as published by the free',
-            'gnu lesser general public license 2.1 as published by the',
-        )
-        if license_name_low.startswith(NOT_A_LICENSE_NAME):
-            text = plicense.text
-            if text:
-                text = '\n'.join([license_name, text])
-            else:
-                text = license_name
-            paragraph.license.name = None
-            paragraph.license.text = text
-
-    return debian_copyright
-
-
-_DECLARED_TO_DETECTED = None
-
-
-def get_declared_to_detected(data_file=None):
-    """
-    Return a mapping of declared to detected license expression cached and
-    loaded from a tab-separated text file, all lowercase.
-
-    Each line has this form:
-        some license name<tab>scancode license expression
-
-    For instance:
-        2-clause bsd    bsd-simplified
-
-    This data file is about license keys used in copyright files and has been
-    derived from a large collection of most copyright files from Debian (about
-    320K files from circa 2019-11) and Ubuntu (about 200K files from circa
-    2020-06)
-    """
-    global _DECLARED_TO_DETECTED
-    if _DECLARED_TO_DETECTED:
-        return _DECLARED_TO_DETECTED
-
-    _DECLARED_TO_DETECTED = {}
-    if not data_file:
-        data_file = path.join(path.dirname(__file__), 'debian_licenses.txt')
-    with io.open(data_file, encoding='utf-8') as df:
-        for line in df:
-            line = line.strip()
-            if not line or line.startswith('#'):
-                continue
-            decl, _, detect = line.strip().partition('\t')
-            if detect and detect.strip():
-                decl = decl.strip()
-                _DECLARED_TO_DETECTED[decl] = detect
-    return _DECLARED_TO_DETECTED