1→# SPDX-FileCopyrightText: 2017 Free Software Foundation Europe e.V. 2→# SPDX-FileCopyrightText: 2021 Alliander N.V. 3→# SPDX-FileCopyrightText: 2023 Carmen Bianca BAKKER 4→# SPDX-FileCopyrightText: 2025 Martijn Saelens 5→# 6→# SPDX-License-Identifier: GPL-3.0-or-later 7→ 8→"""Utilities related to the parsing and storing of copyright notices.""" 9→ 10→import difflib 11→import logging 12→import re 13→from collections import Counter, defaultdict 14→from collections.abc import Iterable 15→from dataclasses import InitVar, dataclass, field 16→from enum import Enum, unique 17→from functools import cached_property 18→from io import StringIO 19→from itertools import chain 20→from typing import Any, Literal, NewType, cast 21→ 22→from license_expression import ( 23→ ExpressionError, 24→ LicenseExpression, 25→ Licensing, 26→ combine_expressions, 27→) 28→ 29→from .exceptions import CopyrightNoticeParseError, YearRangeParseError 30→ 31→# REUSE-IgnoreStart 32→ 33→_LOGGER = logging.getLogger(__name__) 34→ 35→_LICENSING = Licensing() 36→ 37→#: A string that is four digits long. 38→FourDigitString = NewType("FourDigitString", str) 39→#: A range separator between two years. 40→YearRangeSeparator = Literal[ 41→ "--", # ascii en dash 42→ "–", # en dash 43→ "-", # ascii dash 44→] 45→ 46→ 47→def is_four_digits(value: str) -> FourDigitString | Literal[False]: 48→ """Identify a string as a four-digit string. Return the string as 49→ :type:`FourDigitString` if it is one. 50→ 51→ >>> is_four_digits("1234") 52→ '1234' 53→ >>> is_four_digits("abcd") 54→ False 55→ >>> is_four_digits("12345") 56→ False 57→ """ 58→ if value.isdigit() and len(value) == 4: 59→ return FourDigitString(value) 60→ return False 61→ 62→ 63→def validate_four_digits(value: str) -> FourDigitString: 64→ """Validate whether a given string is a :type:`FourDigitString`. 65→ 66→ >>> validate_four_digits("1234") 67→ '1234' 68→ >>> validate_four_digits("abcd") 69→ Traceback (most recent call last): 70→ ... 71→ ValueError: 'abcd' is not a four-digit year. 72→ >>> validate_four_digits("12345") 73→ Traceback (most recent call last): 74→ ... 75→ ValueError: '12345' is not a four-digit year. 76→ 77→ Raises: 78→ ValueError: The string is not four digits. 79→ """ 80→ if not (result := is_four_digits(value)): 81→ raise ValueError(f"'{value}' is not a four-digit year.") 82→ return result 83→ 84→ 85→_ANY_SEPARATOR = ( 86→ r"(?:" + r"|".join(YearRangeSeparator.__args__) + r")" # type: ignore 87→) 88→#: A regex pattern to match e.g. '2017-2020'. 89→YEAR_RANGE_PATTERN = re.compile( 90→ r"(?P\d{4})" 91→ r"(?:" 92→ r"(?:(?P" + _ANY_SEPARATOR + r")" 93→ r"(?P[^\s,]+)?)" # Non-whitespace AND no commas. 94→ r"|" 95→ r"(?:\s+(?P" + _ANY_SEPARATOR + r")" 96→ r"\s+(?P\d{4}))" 97→ r")?" 98→) 99→_YEAR_RANGE_PATTERN_ANONYMISED = re.sub( 100→ r"$\?P<\w+>", r"(?:", YEAR_RANGE_PATTERN.pattern 101→) 102→_SYMBOL_OR_C_SUBPATTERN = r"(©|\([Cc]$)" 103→_STRING_SUBPATTERN = ( 104→ r"(Copyright((\s*" + _SYMBOL_OR_C_SUBPATTERN + r")|(?=\s)))" 105→) 106→#: A regex pattern to match a complete and valid REUSE copyright notice. 107→COPYRIGHT_NOTICE_PATTERN = re.compile( 108→ r"(?P(" 109→ r"SPDX-(File|Snippet)CopyrightText:" 110→ + r"(\s*(" 111→ + _SYMBOL_OR_C_SUBPATTERN 112→ + "|" 113→ + _STRING_SUBPATTERN 114→ + "))?" 115→ + r"|" 116→ + _STRING_SUBPATTERN 117→ + r"|" 118→ r"©" 119→ r"))" 120→ r"\s*" 121→ r"(?P.*?)" 122→ r"\s*" 123→) 124→_YEARS_PATTERN = re.compile( 125→ r"(?P(^|,?\s+))(?P" 126→ + _YEAR_RANGE_PATTERN_ANONYMISED 127→ + r"((\s*,\s*|\s+)" 128→ + _YEAR_RANGE_PATTERN_ANONYMISED 129→ + r")*)(?P(,|\s+|$))" 130→) 131→_COMMA_SPACE_PATTERN = re.compile(r"^,?\s*") 132→ 133→_LOOKBEHINDS = "".join( 134→ rf"(? str: 180→ """Given an uppercase NAME, return name. Underscores are converted to 181→ dashes. 182→ 183→ >>> CopyrightPrefix.lowercase_name("SPDX_STRING") 184→ 'spdx-string' 185→ """ 186→ return name.lower().replace("_", "-") 187→ 188→ @staticmethod 189→ def uppercase_name(name: str) -> str: 190→ """Given a lowercase name, return NAME. Dashes are converted to 191→ underscores. 192→ 193→ >>> CopyrightPrefix.uppercase_name("spdx-string") 194→ 'SPDX_STRING' 195→ """ 196→ return name.upper().replace("-", "_") 197→ 198→ 199→@dataclass(frozen=True) 200→class YearRange: 201→ """Represents a year range, such as '2017-2025', or '2017'. This only 202→ represents a single range; multiple separated ranges should be put in a 203→ collection (typically a tuple). 204→ """ 205→ 206→ #: The first year in the range. If it is only a single year, this is the 207→ #: only relevant value. 208→ start: FourDigitString 209→ #: The separator between :attr:`start` and :attr:`end`. If no value for 210→ #: :attr:`end` is provided, a range into infinity is implied, and 211→ #: :attr:`end` becomes an empty string. 212→ separator: YearRangeSeparator | None = field(default=None, compare=False) 213→ #: The second year in the range. This can also be a word like 'Present'. 214→ #: This is bad practice, but still supported. 215→ end: FourDigitString | str | None = None 216→ 217→ #: If parsed from a string, this contains the original string. 218→ original: str | None = field( 219→ default=None, init=False, repr=False, compare=False 220→ ) 221→ 222→ def __post_init__(self) -> None: 223→ if self.separator is not None and self.end is None: 224→ object.__setattr__(self, "end", "") 225→ 226→ # TODO: In Python 3.11, return Self 227→ @classmethod 228→ def from_string(cls, value: str) -> "YearRange": 229→ """Create a :class:`YearRange` object from a string. 230→ 231→ Raises: 232→ YearRangeParseError: The string is not a valid year range. 233→ """ 234→ re_result = YEAR_RANGE_PATTERN.fullmatch(value) 235→ if not re_result: 236→ raise YearRangeParseError(f"'{value}' is not a valid year range.") 237→ 238→ groups = re_result.groupdict() 239→ start = groups["start"] 240→ separator = groups["separator_nonspaced"] or groups["separator_spaced"] 241→ end = groups["end_nonspaced"] or groups["end_spaced"] 242→ 243→ # Mypy is disabled for this because the values are enforced by the 244→ # regex. This could be cleaner, but would require a lot of useless code 245→ # to validate what the regex already enforces. 246→ result = cls(start, separator, end) # type: ignore 247→ object.__setattr__(result, "original", value) 248→ return result 249→ 250→ @classmethod 251→ def tuple_from_string(cls, value: str) -> tuple["YearRange", ...]: 252→ """Create a tuple of :class:`YearRange` objects from a string containing 253→ multiple ranges. 254→ 255→ Raises: 256→ YearRangeParseError: The substring is not a valid year range. 257→ """ 258→ years: list[YearRange] = [] 259→ # Convert all spaces to single spaces. The regex cannot handle anything 260→ # else. This technically results in year ranges with 'original' values 261→ # that aren't quite right, but it's the best we can do without complex 262→ # logic. 263→ value = _WHITESPACE_PATTERN.sub(" ", value) 264→ for year in _YEAR_RANGE_SPLIT_PATTERN.split(value): 265→ if not year: 266→ continue 267→ years.append(YearRange.from_string(year)) 268→ return tuple(years) 269→ 270→ def __str__(self) -> str: 271→ result = StringIO() 272→ result.write(self.start) 273→ if self.separator: 274→ result.write(self.separator) 275→ if self.end: 276→ # Use a default separator if one is not defined. 277→ if not self.separator: 278→ result.write("-") 279→ result.write(self.end) 280→ return result.getvalue() 281→ 282→ def to_string(self, original: bool = False) -> str: 283→ """Converts the internal representation of the date range into a 284→ string. If *original* is :const:`True`, :attr:`original` is returned if 285→ it exists. 286→ 287→ If :attr:`start` and :attr:`end` are provided without :attr:`separator`, 288→ ``-`` will be used as default separator in the output. 289→ 290→ This method is identical to calling :func:`str` on this object, provided 291→ *original* is :const:`False`. 292→ """ 293→ if original and self.original is not None: 294→ return self.original 295→ return str(self) 296→ 297→ def __lt__(self, other: Any) -> bool: 298→ # pylint: disable=too-many-return-statements 299→ if not isinstance(other, YearRange): 300→ return NotImplemented 301→ # Start year determines most of the storting. 302→ if self.start < other.start: 303→ return True 304→ if self.start > other.start: 305→ return False 306→ # Ranges with end dates are sorted after those who don't. 307→ if self.end is None and other.end is not None: 308→ return True 309→ if self.end is not None and other.end is not None: 310→ # Non-digit ends are sorted after digit ends. 311→ if not is_four_digits(self.end) and is_four_digits(other.end): 312→ return False 313→ if is_four_digits(self.end) and not is_four_digits(other.end): 314→ return True 315→ return self.end < other.end 316→ # No comparing on separators. 317→ return False 318→ 319→ # TODO: In Python 3.11, use Self 320→ @classmethod 321→ def compact(cls, ranges: Iterable["YearRange"]) -> tuple["YearRange", ...]: 322→ """Given an iterable of :class:`YearRange`, compact them such that a new 323→ more concise list is returne without losing information. This process 324→ also sorts the ranges, such that ranges with lower starts come before 325→ ranges with higher starts. 326→ 327→ - Consecutive years (e.g. 2017, 2018, 2019) are turned into a single 328→ range (2017-2019). 329→ - Two consecutive years (e.g. 2017, 2018) are NOT turned turned into a 330→ single range. 331→ - Consecutive ranges (e.g. 2017-2019, 2020-2022) are turned into a 332→ single range (2017-2022). 333→ - Overlapping ranges (e.g. 2017-2022, 2019-2021) are turned into a 334→ single range (2017-2022). 335→ - Repeated ranges are removed. 336→ - Ranges with non-year ends (e.g. 2017-Present, 2020-Present) are only 337→ turned into a single range with ranges that have identical ends 338→ (2017-Present). 339→ """ 340→ ranges = sorted(ranges) 341→ compacted: list[YearRange] = [] 342→ 343→ if not ranges: 344→ return tuple() 345→ 346→ # TODO: In Python 3.11, use Self 347→ def filter_same_end(ranges: Iterable[YearRange]) -> list[YearRange]: 348→ """If some year ranges have the same end, then only take the ones 349→ with the lowest start. 350→ """ 351→ result: list[YearRange] = [] 352→ ends: defaultdict[str | None, list[YearRange]] = defaultdict(list) 353→ for item in ranges: 354→ ends[item.end].append(item) 355→ for key, range_list in ends.items(): 356→ if key is None: 357→ for item in range_list: 358→ result.append(item) 359→ else: 360→ # *ranges* is sorted, so take the first item with the lowest 361→ # start. 362→ result.append(range_list[0]) 363→ return sorted(result) 364→ 365→ ranges = filter_same_end(ranges) 366→ 367→ current_start: int = int(ranges[0].start) 368→ current_end: str = ( 369→ ranges[0].end if ranges[0].end is not None else ranges[0].start 370→ ) 371→ 372→ # TODO: In Python 3.11, use Self 373→ def add_to_compacted( 374→ start: int, end: str, next_range: YearRange | None 375→ ) -> None: 376→ nonlocal compacted 377→ if is_four_digits(end): 378→ if int(end) - start == 0: 379→ compacted.append(cls(validate_four_digits(str(start)))) 380→ elif int(end) - start == 1: 381→ compacted.append(cls(validate_four_digits(str(start)))) 382→ compacted.append(cls(validate_four_digits(end))) 383→ else: 384→ compacted.append( 385→ cls( 386→ validate_four_digits(str(start)), 387→ end=end, 388→ ) 389→ ) 390→ else: 391→ compacted.append(cls(validate_four_digits(str(start)), end=end)) 392→ nonlocal current_start 393→ nonlocal current_end 394→ if next_range is not None: 395→ current_start = int(next_range.start) 396→ current_end = ( 397→ next_range.end 398→ if next_range.end is not None 399→ else next_range.start 400→ ) 401→ 402→ next_start: int | None = None 403→ next_end: str | None = None 404→ for next_range in ranges[1:]: 405→ next_start = int(next_range.start) 406→ next_end = ( 407→ next_range.end 408→ if next_range.end is not None 409→ else next_range.start 410→ ) 411→ 412→ current_end_int: int | None = ( 413→ int(current_end) if is_four_digits(current_end) else None 414→ ) 415→ next_end_int: int | None = ( 416→ int(next_end) if is_four_digits(next_end) else None 417→ ) 418→ # The end lines up with next start. 419→ if ( 420→ current_end_int is not None 421→ and current_end_int + 1 >= next_start 422→ ): 423→ if next_end_int is not None: 424→ # In a strange scenario where the next range's end is BEFORE 425→ # its start, just save our progress and continue the loop. 426→ if next_end_int < next_start: 427→ add_to_compacted(current_start, current_end, next_range) 428→ # Increment the end. 429→ elif next_end_int >= current_end_int: 430→ current_end = next_end 431→ else: 432→ add_to_compacted(current_start, current_end, next_range) 433→ 434→ add_to_compacted(current_start, current_end, None) 435→ # If the beforelast range's end was int-y, and the last range's end is 436→ # string-y, we need to separately add the last range. 437→ if ( 438→ next_end is not None 439→ and is_four_digits(current_end) 440→ and not is_four_digits(next_end) 441→ ): 442→ add_to_compacted(cast(int, next_start), next_end, None) 443→ return tuple(compacted) 444→ 445→ 446→def _most_common_prefix( 447→ copyright_notices: Iterable["CopyrightNotice"], 448→) -> CopyrightPrefix: 449→ """Given a number of :class:`CopyrightNotice`s, find the most common one. If 450→ there is a tie for the most common prefix, return enum which is defined 451→ before all others in :class:`CopyrightPrefix`. 452→ """ 453→ counter = Counter(notice.prefix for notice in copyright_notices) 454→ max_count = max(counter.values()) 455→ most_common = {key for key, value in counter.items() if value == max_count} 456→ # One prefix is more common than all others. 457→ if len(most_common) == 1: 458→ return next(iter(most_common)) 459→ # Enums preserve order of their members. Return the first match. 460→ for prefix in CopyrightPrefix: 461→ if prefix in most_common: 462→ return prefix 463→ # This shouldn't be reached. 464→ return CopyrightPrefix.SPDX 465→ 466→ 467→@dataclass(frozen=True) 468→class CopyrightNotice: 469→ """Represents a single copyright notice.""" 470→ 471→ #: The copyright holder. Strictly, this is all text in the copyright notice 472→ #: which is not part of *years*. 473→ name: str 474→ #: The prefix with which the copyright statement begins. 475→ prefix: CopyrightPrefix = CopyrightPrefix.SPDX 476→ #: The dates associated with the copyright notice. 477→ years: tuple[YearRange, ...] = field(default_factory=tuple) 478→ 479→ #: If parsed from a string, this contains the original string. 480→ original: str | None = field( 481→ default=None, init=False, repr=False, compare=False 482→ ) 483→ 484→ # TODO: In Python 3.11, return Self. 485→ @classmethod 486→ def from_string(cls, value: str) -> "CopyrightNotice": 487→ """Create a :class:`CopyrightNotice` object from a string. 488→ 489→ Raises: 490→ CopyrightNoticeParseError: The string is not a valid copyright 491→ notice. 492→ """ 493→ re_result = COPYRIGHT_NOTICE_PATTERN.fullmatch(value) 494→ if not re_result: 495→ raise CopyrightNoticeParseError( 496→ f"'{value}' is not a copyright notice." 497→ ) 498→ return cls.from_match(re_result) 499→ 500→ @staticmethod 501→ def _detect_prefix(prefix: str) -> CopyrightPrefix: 502→ """Given a matched prefix from :const:`COPYRIGHT_NOTICE_PATTERN`, detect 503→ the associated prefix. 504→ """ 505→ # String-match the prefix. 506→ for prefix_enum in ( 507→ cast(CopyrightPrefix, item) for item in reversed(CopyrightPrefix) 508→ ): 509→ if prefix == prefix_enum.value: 510→ return prefix_enum 511→ # The prefix could not be string-matched, most likely because there 512→ # was unexpected spacing in the prefix. Get a close match using 513→ # difflib. 514→ matches = difflib.get_close_matches( 515→ prefix, 516→ # TODO: In Python 3.11, this list comprehension is not needed. 517→ [item.value for item in CopyrightPrefix], 518→ n=1, 519→ cutoff=0.2, 520→ ) 521→ if matches: 522→ return CopyrightPrefix(matches[0]) 523→ # This shouldn't happen, but if no prefix could be found, 524→ # default to SPDX. 525→ return CopyrightPrefix.SPDX 526→ 527→ @classmethod 528→ def from_match(cls, value: re.Match) -> "CopyrightNotice": 529→ """Create a :class:`CopyrightNotice` object from a regular expression 530→ match using the :const:`COPYRIGHT_NOTICE_PATTERN` :class:`re.Pattern`. 531→ """ 532→ prefix = cls._detect_prefix(value.group("prefix")) 533→ 534→ re_text = value.group("text") 535→ year_ranges_substrings = list(_YEARS_PATTERN.finditer(re_text)) 536→ start_ends: list[tuple[int, int]] = [ 537→ (match.start("prefix"), match.end("years")) 538→ for match in year_ranges_substrings 539→ ] 540→ name_parts: list[str] = [] 541→ last = 0 542→ for start, end in start_ends: 543→ name_parts.append(re_text[last:start]) 544→ last = end 545→ name_parts.append(re_text[last:]) 546→ 547→ name = "".join(name_parts) 548→ # Remove ', ' from the start of the name, which appears in e.g. 549→ # 'Copyright 2017, Jane Doe'. 550→ name = _COMMA_SPACE_PATTERN.sub("", name) 551→ years: tuple[YearRange, ...] = tuple() 552→ if year_ranges_substrings: 553→ # Corner case where the notice only contains year ranges. 554→ if not name: 555→ name = re_text 556→ else: 557→ years = tuple( 558→ chain.from_iterable( 559→ YearRange.tuple_from_string(match.group("years")) 560→ for match in year_ranges_substrings 561→ ) 562→ ) 563→ result = cls( 564→ name=name, 565→ prefix=prefix, 566→ years=years, 567→ ) 568→ object.__setattr__(result, "original", value.string) 569→ return result 570→ 571→ @classmethod 572→ def merge( 573→ cls, copyright_notices: Iterable["CopyrightNotice"] 574→ ) -> set["CopyrightNotice"]: 575→ """Given an iterable of :class:`CopyrightNotice`, merge all notices 576→ which have the same name. The years are compacted, and from the 577→ :class:`CopyrightPrefix` prefixes in *copyright_notices*, the most 578→ common is chosen. If there is a tie in frequency, choose the one which 579→ appears first in the enum. 580→ """ 581→ matches: defaultdict[str, list[CopyrightNotice]] = defaultdict(list) 582→ result: set[CopyrightNotice] = set() 583→ for notice in copyright_notices: 584→ matches[notice.name].append(notice) 585→ for key, value in matches.items(): 586→ result.add( 587→ cls( 588→ key, 589→ prefix=_most_common_prefix(value), 590→ years=YearRange.compact( 591→ chain.from_iterable(notice.years for notice in value) 592→ ), 593→ ) 594→ ) 595→ return result 596→ 597→ def __str__(self) -> str: 598→ result = StringIO() 599→ result.write(self.prefix.value) 600→ if self.years: 601→ result.write(" ") 602→ result.write( 603→ ", ".join(str(date_range) for date_range in self.years) 604→ ) 605→ result.write(f" {self.name}") 606→ return result.getvalue() 607→ 608→ def __lt__(self, other: "CopyrightNotice") -> bool: 609→ def norm(item: Any | None) -> tuple[int, Any]: 610→ """If no item is defined, return a tuple that sorts _after_ 611→ items that are defined. 612→ """ 613→ return (0, item) if item else (1, "") 614→ 615→ return ( 616→ norm(self.years), 617→ self.name, 618→ self.prefix.value, 619→ ) < ( 620→ norm(other.years), 621→ other.name, 622→ other.prefix.value, 623→ ) 624→ 625→ def to_string(self, original: bool = False) -> str: 626→ """Converts the internal representation of the copyright notice into a 627→ string. If *original* is :const:`True`, :attr:`original` is returned if 628→ it exists. 629→ 630→ This method is identical to calling :func:`str` on this object, provided 631→ *original* is :const:`False`. 632→ """ 633→ if original and self.original is not None: 634→ return self.original 635→ return str(self) 636→ 637→ 638→@dataclass(frozen=True) 639→class SpdxExpression: 640→ """A simple dataclass that contains an SPDX License Expression. 641→ 642→ Use :meth:`SpdxExpression.__str__` to get a string representation of the 643→ expression. 644→ """ 645→ 646→ #: A string representing an SPDX License Expression. It may be invalid. 647→ text: InitVar[str] 648→ _text: str = field(init=False, repr=True) 649→ 650→ def __post_init__(self, text: str) -> None: 651→ object.__setattr__(self, "_text", text) 652→ 653→ @cached_property 654→ def is_valid(self) -> bool: 655→ """If :attr:`text` is a valid SPDX License Expression, this property is 656→ :const:`True`. 657→ 658→ To be 'valid', it has to follow the grammar and syntax of the SPDX 659→ specification. The licenses and exceptions need not appear on the 660→ license list. 661→ """ 662→ return self._expression is not None 663→ 664→ @cached_property 665→ def _expression(self) -> LicenseExpression | None: 666→ """A parsed :class:`LicenseExpression` from :attr:`text`. If 667→ :attr:`text` could not be parsed, *_expression*'s value is 668→ :const:`None`. 669→ """ 670→ try: 671→ return _LICENSING.parse(self._text, simple=True) 672→ except ExpressionError: 673→ return None 674→ 675→ @cached_property 676→ def licenses(self) -> list[str]: 677→ """Return a list of licenses used in the expression, in order of 678→ appearance, without duplicates. 679→ 680→ If the expression is invalid, the list contains a single item 681→ :attr:`text`. 682→ """ 683→ if self._expression is not None: 684→ return _LICENSING.license_keys(self._expression) 685→ return [self._text] 686→ 687→ @classmethod 688→ def combine( 689→ cls, 690→ spdx_expressions: Iterable["SpdxExpression"], 691→ ) -> "SpdxExpression": 692→ """Combine the *spdx_expressions* into a single :class:`SpdxExpression`, 693→ joined by AND operators. 694→ """ 695→ is_valid = True 696→ for expression in spdx_expressions: 697→ if not expression.is_valid: 698→ is_valid = False 699→ if is_valid: 700→ return cls( 701→ str( 702→ combine_expressions( 703→ list( 704→ # pylint: disable=protected-access 705→ expression._expression 706→ for expression in spdx_expressions 707→ ) 708→ ) 709→ ) 710→ ) 711→ return cls( 712→ " AND ".join(f"({expression})" for expression in spdx_expressions) 713→ ) 714→ 715→ def simplify(self) -> "SpdxExpression": 716→ """If the expression is valid, return a new :class:`SpdxExpression` 717→ which is 'simplified', meaning that boolean operators are collapsed. 718→ 'MIT OR MIT' simplifies to 'MIT', and so forth. 719→ 720→ If the expression is not valid, ``self`` is returned. 721→ """ 722→ if self.is_valid: 723→ return self.__class__( 724→ str(cast(LicenseExpression, self._expression).simplify()) 725→ ) 726→ return self 727→ 728→ def __str__(self) -> str: 729→ """Return a string representation of the expression if it is valid. 730→ Otherwise, return :attr:`text`. 731→ """ 732→ if self._expression is not None: 733→ return str(self._expression) 734→ return self._text 735→ 736→ def __eq__(self, other: Any) -> bool: 737→ if not isinstance(other, SpdxExpression): 738→ return NotImplemented 739→ if self._expression is not None and other._expression is not None: 740→ return self._expression == other._expression 741→ return self._text == other._text 742→ 743→ def __lt__(self, other: Any) -> bool: 744→ if not isinstance(other, SpdxExpression): 745→ return NotImplemented 746→ return str(self) < str(other) 747→ 748→ 749→class SourceType(Enum): 750→ """ 751→ An enumeration representing the types of sources for license information. 752→ """ 753→ 754→ #: A .license file containing license information. 755→ DOT_LICENSE = "dot-license" 756→ #: A file header containing license information. 757→ FILE_HEADER = "file-header" 758→ #: A .reuse/dep5 file containing license information. 759→ DEP5 = "dep5" 760→ #: A REUSE.toml file containing license information. 761→ REUSE_TOML = "reuse-toml" 762→ 763→ 764→@dataclass(frozen=True, kw_only=True) 765→class ReuseInfo: 766→ """Simple dataclass holding licensing and copyright information""" 767→ 768→ spdx_expressions: set[SpdxExpression] = field(default_factory=set) 769→ copyright_notices: set[CopyrightNotice] = field(default_factory=set) 770→ contributor_lines: set[str] = field(default_factory=set) 771→ path: str | None = None 772→ source_path: str | None = None 773→ source_type: SourceType | None = None 774→ 775→ def _check_nonexistent(self, **kwargs: Any) -> None: 776→ nonexistent_attributes = set(kwargs) - set(self.__dict__) 777→ if nonexistent_attributes: 778→ raise KeyError( 779→ f"The following attributes do not exist in" 780→ f" {self.__class__}: {', '.join(nonexistent_attributes)}" 781→ ) 782→ 783→ def copy(self, **kwargs: Any) -> "ReuseInfo": 784→ """Return a copy of ReuseInfo, replacing the values of attributes with 785→ the values from *kwargs*. 786→ """ 787→ self._check_nonexistent(**kwargs) 788→ new_kwargs = {} 789→ for key, value in self.__dict__.items(): 790→ new_kwargs[key] = kwargs.get(key, value) 791→ return self.__class__(**new_kwargs) # type: ignore 792→ 793→ def union(self, *other: "ReuseInfo") -> "ReuseInfo": 794→ """Return a new instance of ReuseInfo where all set attributes are equal 795→ to the union of the set in *self* and the set(s) in *other*. 796→ 797→ All non-set attributes are set to their values in *self*. 798→ 799→ >>> one = ReuseInfo(copyright_notices={CopyrightNotice("Jane Doe")}, 800→ ... source_path="foo.py") 801→ >>> two = ReuseInfo(copyright_notices={CopyrightNotice("John Doe")}, 802→ ... source_path="bar.py") 803→ >>> result = one.union(two) 804→ >>> print([notice.name for notice in sorted(result.copyright_notices)]) 805→ ['Jane Doe', 'John Doe'] 806→ >>> print(result.source_path) 807→ foo.py 808→ """ 809→ if not other: 810→ return self 811→ new_kwargs = {} 812→ for key, attr_val in self.__dict__.items(): 813→ if isinstance(attr_val, set): 814→ new_kwargs[key] = attr_val.union( 815→ *(getattr(info, key) for info in other) 816→ ) 817→ else: 818→ new_kwargs[key] = attr_val 819→ return self.__class__(**new_kwargs) # type: ignore 820→ 821→ def contains_copyright_or_licensing(self) -> bool: 822→ """Either *spdx_expressions* or *copyright_notices* is non-empty.""" 823→ return bool(self.spdx_expressions or self.copyright_notices) 824→ 825→ def contains_copyright_xor_licensing(self) -> bool: 826→ """One of *spdx_expressions* or *copyright_notices* is non-empty.""" 827→ return bool(self.spdx_expressions) ^ bool(self.copyright_notices) 828→ 829→ def contains_info(self) -> bool: 830→ """Any field except *path*, *source_path* and *source_type* is 831→ non-empty. 832→ """ 833→ keys = { 834→ key 835→ for key in self.__dict__ 836→ if key not in ("path", "source_path", "source_type") 837→ } 838→ return any(self.__dict__[key] for key in keys) 839→ 840→ def __bool__(self) -> bool: 841→ return any(self.__dict__.values()) 842→ 843→ def __or__(self, value: "ReuseInfo") -> "ReuseInfo": 844→ return self.union(value) 845→ 846→ 847→# REUSE-IgnoreEnd 848→

Summary