ܖiUndZddlZddlZddlZddlZddlmZddlmZddlmZddl m Z ddl m Z ddl m Z dd l mZdd l mZdd l mZddlZdd lmZdd lmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlm Z ddlm!Z!ddl"m#Z$ddl"m%Z%eee&Z'ee'dZ(ee(dZ)dZ*e*evrdee*<d Z+e+evrd!ee+<d"Z,e,evrd#ee,<d$Z-e-evrd%ee-<Gd&d'e.Z/Gd(d)ee/Z0ed*d+Z1d,e1_2d-Z3e1d.e Z4e1d/e!Z5e1d0eZ6e1d1eZ7e1d2e3Z8e6e7e4e5e8fZ9e:d3e9DZ;e6e7e8d4Z<ejzd5ej|ej~zejzjZBGd6d7ZCGd8d9ejZEe)fd:ZFe)fd;ZGe)fd<ZHd=ZId>ZJd?ZKd@ZLdAZMdBZNdZdCZOGdDdEePZQGdFdGeQejZSejzdHejjZUe GdIdJeSZVe GdKdLeVZWe GdMdNeSZXGdOdPeQZYGdQdReYejZZGdSdTeYejZ[dUZ\dVZ]dZdWZ^dRdXeEfdYZ_y)[a Define a mini language to parse, validate, deduplicate, simplify, normalize and compare license expressions using a boolean logic engine. This module supports SPDX and ScanCode license expressions and also accepts other license naming conventions and license identifiers aliases to recognize and normalize licenses. Using boolean logic, license expressions can be tested for equality, containment, equivalence and can be normalized, deduplicated or simplified. The main entry point is the Licensing object. N) defaultdict)deque) namedtuple)copy)deepcopy)total_ordering)abspath)dirname)join) Expression) PARSE_ERRORS)PARSE_INVALID_EXPRESSION)PARSE_INVALID_NESTING)PARSE_INVALID_OPERATOR_SEQUENCE)PARSE_INVALID_SYMBOL_SEQUENCE)PARSE_UNBALANCED_CLOSING_PARENS)PARSE_UNKNOWN_TOKEN) ParseError) TOKEN_SYMBOL) TOKEN_AND)TOKEN_OR) TOKEN_LPAR) TOKEN_RPAR)Trie)Tokendatazscancode-licensedb-index.jsondz#Expression string must be a string.ez\A license exception symbol can only be used as an exception in a "WITH exception" statement.fzSA plain license symbol cannot be used as an exception in a "WITH symbol" statement.gz"A proper license symbol is needed.c eZdZy)ExpressionErrorN__name__ __module__ __qualname___/var/www/html/content-pipeline/venv/lib/python3.12/site-packages/license_expression/__init__.pyr"r"Yr(r"c eZdZy)ExpressionParseErrorNr#r'r(r)r,r,]r*r(r,Keywordz value typec,t|jSN)lenvalueselfs r)r4css4::r( ()andorwithc#4K|]}|jywr/)r1).0kws r) r>xs3Brxx3s)r8r9r:zi (?P[^\s\(\)]+) | (?P\s+) | (?P\() | (?P\)) c$eZdZdZ ddZdZy)ExpressionInfoa The ExpressionInfo class is returned by Licensing.validate() where it stores information about a given license expression passed into Licensing.validate(). The ExpressionInfo class has the following fields: - original_expression: str. - This is the license expression that was originally passed into Licensing.validate() - normalized_expression: str. - If a valid license expression has been passed into `validate()`, then the license expression string will be set in this field. - errors: list - If there were errors validating a license expression, the error messages will be appended here. - invalid_symbols: list - If the license expression that has been passed into `validate()` has license keys that are invalid (either that they are unknown or not used in the right context), or the syntax is incorrect because an invalid symbol was used, then those symbols will be appended here. NcL||_||_|xsg|_|xsg|_yr/original_expressionnormalized_expressionerrorsinvalid_symbols)r3rCrDrErFs r)__init__zExpressionInfo.__init__s,$7 %:"l .4"r(c pd|jd|jd|jd|jd S)Nz(ExpressionInfo( original_expression=z, normalized_expression=z , errors=z, invalid_symbols=z )rBr2s r)__repr__zExpressionInfo.__repr__sT ''+'?'?&BC))-)C)C(FG++)##'#7#7":;   r()NNN)r$r%r&__doc__rGrIr'r(r)r@r@s:# 5 r(r@ceZdZdZedffd ZdZdZdZddZ ddZ d Z dd Z dd Z dd Zdd ZdZdfd ZddZdZdZdZdZddZxZS) Licensinga! Licensing defines a mini language to parse, validate and compare license expressions. This is the main entry point in this library. Some of the features are: - licenses can be validated against user-provided lists of known licenses "symbols" (such as ScanCode licenses or the SPDX list). - flexible expression parsing and recognition of licenses (including licenses with spaces and keywords (such as AND, OR WITH) or parens in their names). - in an expression licenses can be more than just identifiers such as short or long names with spaces, symbols and even parenthesis. - A license can have multiple aliases (such as GPL-2.0, GPLv2 or GPL2) and each will be properly recognized when parsing. The expression is rendered normalized using the canononical license keys. - expressions can be deduplicated, simplified, normalized, sorted and compared for containment and/or logical equivalence thanks to a built-in boolean logic engine. - Once parsed, expressions can be rendered using simple templates (for instance to render as HTML links in a web UI). For example:: >>> l = Licensing() >>> expr = l.parse(" GPL-2.0 or LGPL-2.1 and mit ") >>> expected = 'GPL-2.0 OR (LGPL-2.1 AND mit)' >>> assert expected == expr.render('{symbol.key}') >>> expected = [ ... LicenseSymbol('GPL-2.0'), ... LicenseSymbol('LGPL-2.1'), ... LicenseSymbol('mit') ... ] >>> assert expected == l.license_symbols(expr) >>> symbols = ['GPL-2.0+', 'Classpath', 'BSD'] >>> l = Licensing(symbols) >>> expression = 'GPL-2.0+ with Classpath or (bsd)' >>> parsed = l.parse(expression) >>> expected = 'GPL-2.0+ WITH Classpath OR BSD' >>> assert expected == parsed.render('{symbol.key}') >>> expected = [ ... LicenseSymbol('GPL-2.0+'), ... LicenseSymbol('Classpath'), ... LicenseSymbol('BSD') ... ] >>> assert expected == l.license_symbols(parsed) >>> assert expected == l.license_symbols(expression) Tctt| ttt |j |_|j|j|j|j|j |j d}|jD]\}}tt|||xs t}|rmtt|}t|\}}|r|s|D] }t!||r|s|D] } t!| |rt#dj%||z|D cic]} | j&| c} |_|D cic]} | j&j+| c} |_d|_ycc} wcc} w)a4 Initialize a Licensing with an optional ``symbols`` sequence of LicenseSymbol or LicenseSymbol-like objects or license key strings. If provided and this list data is invalid, raise a ValueError. Print warning and errors found in the symbols unless ``quiet`` is True. ) Symbol_class AND_classOR_class)TRUEFALSENOTANDORSymbol N)superrLrG LicenseSymbolrTrUrVrQrRrSitemssetattrLicenseWithExceptionSymboltuple as_symbolsvalidate_symbolsprint ValueErrorr key known_symbolslowerknown_symbols_lowercaseadvanced_tokenizer) r3symbolsquiettf_naonamer1warnsrEwesymbol __class__s r)rGzLicensing.__init__sm i'& ( "[[IIZZ8888''kk  "<<> =KD% .e < =$UW Jw/0G,W5ME6UA!HeA!H 56>!:;;@GGVfjj&0GRY'Yv (8(8(:F(B'Y$#' H(Zs $E6"E;c X|j|fi|}|j|fi|}||k(S)a/ Return True if both ``expression1`` and ``expression2`` LicenseExpression objects are equivalent. If a string is provided, it will be parsed and simplified. Extra ``kwargs`` are passed down to the parse() function. Raise ExpressionError on parse errors. _parse_and_simplifyr3 expression1 expression2kwargsex1ex2s r) is_equivalentzLicensing.is_equivalent.s<'d&&{=f=&d&&{=f=czr(c V|j|fi|}|j|fi|}||vS)a  Return True if ``expression1`` contains ``expression2``. where each expression is either a string or a LicenseExpression object. If a string is provided, it will be parsed and simplified. Extra ``kwargs`` are passed down to the parse() function. rqrss r)containszLicensing.contains:s<'d&&{=f=&d&&{=f=czr(c |j|fi|}|yt|tstd||j S)Nz-expression must be LicenseExpression object: )parse isinstanceLicenseExpression TypeErrorsimplify)r3 expressionrvs r)rrzLicensing._parse_and_simplifyFsMTZZ 5f5  *&78KJ>Z[ [""$$r(c |j|fi|}|gSd|jD}|r&tjj d|D}|r t |}t |S)ao Return a list of LicenseSymbol objects used in an expression in the same order as they first appear in the expression tree. ``expression`` is either a string or a LicenseExpression object. If a string is provided, it will be parsed. If ``unique`` is True only return unique symbols. If ``decompose`` is True then composite LicenseWithExceptionSymbol instances are not returned directly; instead their underlying license and exception symbols are returned. Extra ``kwargs`` are passed down to the parse() function. For example: >>> l = Licensing() >>> expected = [ ... LicenseSymbol('GPL-2.0'), ... LicenseSymbol('LGPL-2.1+') ... ] >>> result = l.license_symbols(l.parse('GPL-2.0 or LGPL-2.1+')) >>> assert expected == result c3BK|]}t|ts|ywr/)r~ BaseSymbolr<ss r)r>z,Licensing.license_symbols..lsU:a;T1Usc3<K|]}|jywr/) decomposers r)r>z,Licensing.license_symbols..ns3SaAKKM3Ss)r} get_literals itertoolschain from_iterableordered_uniquelist)r3runiquerrvrgs r)license_symbolszLicensing.license_symbolsPsk2 TZZ 5f5  IUj557U oo333S73SSG $W-GG}r(c <|j|fd|i|}|r|dSy)a Return the left-most license symbol of an ``expression`` or None. ``expression`` is either a string or a LicenseExpression object. If ``decompose`` is True, only the left-hand license symbol of a decomposed LicenseWithExceptionSymbol symbol will be returned if this is the left most member. Otherwise a composite LicenseWithExceptionSymbol is returned in this case. Extra ``kwargs`` are passed down to the parse() function. rrN)r)r3rrrvrgs r)primary_license_symbolz Licensing.primary_license_symbolss2'$&&zQYQ&Q 1:  r(c J|jd|dd|}|r |jSy)a  Return the left-most license key of an ``expression`` or None. The underlying symbols are decomposed. ``expression`` is either a string or a LicenseExpression object. Extra ``kwargs`` are passed down to the parse() function. T)rrNr')rrb)r3rrvprims r)primary_license_keyzLicensing.primary_license_keys>+t** !   88O r(c R|jd|ddd|}|j||S)an Return a list of licenses keys used in an ``expression`` in the same order as they first appear in the expression. ``expression`` is either a string or a LicenseExpression object. If ``unique`` is True only return unique symbols. Extra ``kwargs`` are passed down to the parse() function. For example: >>> l = Licensing() >>> expr = ' GPL-2.0 and mit+ with blabla and mit or LGPL-2.1 and mit and mit+ with GPL-2.0' >>> expected = ['GPL-2.0', 'mit+', 'blabla', 'mit', 'LGPL-2.1'] >>> assert expected == l.license_keys(l.parse(expr)) FTrrrr')r_keysr3rrrvrgs r) license_keyszLicensing.license_keyssA'$&& !    zz'6**r(c\|Dcgc]}|j}}|r t|}|Scc}wr/)rbr)r3rgrlskeyss r)rzLicensing._keyss2!()2)) !$'D *s)c |jd||dd|}|Dcgc]}|j|jvs|c}Scc}w)a` Return a list of unknown license symbols used in an ``expression`` in the same order as they first appear in the ``expression``. ``expression`` is either a string or a LicenseExpression object. If ``unique`` is True only return unique symbols. Extra ``kwargs`` are passed down to the parse() function. Trr')rrbrc)r3rrrvrgrs r)unknown_license_symbolsz!Licensing.unknown_license_symbolssU'$&& !    %IrBFFd6H6H,HIIIs AAc P|jd|dd|}|j||S)a Return a list of unknown licenses keys used in an ``expression`` in the same order as they first appear in the ``expression``. ``expression`` is either a string or a LicenseExpression object. If a string is provided, it will be parsed. If ``unique`` is True only return unique keys. Extra ``kwargs`` are passed down to the parse() function. F)rrr')rrrs r)unknown_license_keyszLicensing.unknown_license_keyss>/$.. !   zz'6**r(c|j|d}|r+djdj|}t|y)NT)rzUnknown license key(s): {}, )rformatr r")r3r unknown_keysmsgs r)validate_license_keyszLicensing.validate_license_keyssC00D0I .55dii 6MNC!#& & r(c n|yt|tr|St|tr t|}t|tst |}t d||r|j sy t|j|||}tt|/|}t|ts t d|r|j%||S#t |}t d|xYw#t$r=}t|j|j|j |j"|d}~wwxYw)a Return a new license LicenseExpression object by parsing a license ``expression``. Check that the ``expression`` syntax is valid and raise an ExpressionError or an ExpressionParseError on errors. Return None for empty expressions. ``expression`` is either a string or a LicenseExpression object. If ``expression`` is a LicenseExpression it is returned as-is. Symbols are always recognized from known Licensing symbols if `symbols` were provided at Licensing creation time: each license and exception is recognized from known license keys (and from aliases for a symbol if available). If ``validate`` is True and a license is unknown, an ExpressionError error is raised with a message listing the unknown license keys. If ``validate`` is False, no error is raised if the ``expression`` syntax is correct. You can call further call the `unknown_license_keys()` or `unknown_license_symbols()` methods to get unknown license keys or symbols found in the parsed LicenseExpression. If ``strict`` is True, an ExpressionError will be raised if in a "WITH" expression such as "XXX with ZZZ" if the XXX symbol has `is_exception` set to True or the YYY symbol has `is_exception` set to False. This checks that symbols are used strictly as intended in a "WITH" subexpression using a license on the left and an exception on thr right. If ``simple`` is True, parsing will use a simple tokenizer that assumes that license symbols are all license keys and do not contain spaces. For example: >>> expression = 'EPL-1.0 and Apache-1.1 OR GPL-2.0 with Classpath-exception' >>> parsed = Licensing().parse(expression) >>> expected = '(EPL-1.0 AND Apache-1.1) OR GPL-2.0 WITH Classpath-exception' >>> assert expected == parsed.render(template='{symbol.key}') Nz%expression must be a string and not: )rstrictsimple token_type token_stringposition error_codez3expression must be a LicenseExpression once parsed.)r~rbytesstrtyper"striprtokenizerXrLr}rr,rrrrr) r3rvalidaterrrvexttokensrmros r)r}zLicensing.parsesDN    j"3 4  j% ( W _ *c*z"C!$I#"QR R!1!1!3   )!!Fy$5f=J*&78!"WX X   & &z 2G W:&%(McW&UVV& &<<^^<<     s# C00C.C+. D478D//D4c#K|syt|tstt|r|j |}n!|j }|j |}t|}d|D}t||}|D]m}|j}|j}|j} t| tr| } n-t| tr | j} ntt| ||foyw)a8 Return an iterable of 3-tuple describing each token given an ``expression`` string. See boolean.BooleanAlgreba.tokenize() for API details. This 3-tuple contains these items: (token, token string, position): - token: either a Symbol instance or one of TOKEN_* token types.. - token string: the original token string. - position: the starting index of the token string in the `expr` string. If ``strict`` is True, additional exceptions will be raised in a expression such as "XXX with ZZZ" if the XXX symbol has is_exception` set to True or the ZZZ symbol has `is_exception` set to False. If ``simple`` is True, use a simple tokenizer that assumes that license symbols are all license keys that do not contain spaces. N)rc3pK|].}|js|jjs+|0ywr/stringrr<ts r)r>z%Licensing.tokenize..Ss#EqxxAHHNN4D!Es 666)r~rrPARSE_EXPRESSION_NOT_UNICODEsimple_tokenizerget_advanced_tokenizerr!build_symbols_from_unknown_tokens,replace_with_subexpression_by_license_symbolstartrr1rr-rr) r3rrrrrftokenposr token_value token_objs r)rzLicensing.tokenize1s$ *c*(DE E **:6F!%! '00ffM /E++C <> B" " # #  " " ) )#a& 144Z@L  + + 2 2< @" "  #s<A&C& C/A B?9C?C D,AD'!D,'D,)TT)T)FFF)FF)r$r%r&rJr]rGryr{rrrrrrrrrrr}rrrfrrr __classcell__ros@r)rLrLsz7r %wd5'n  %!F "+.J"+$' Sj4/l#J..<`6p,r(rLc*tt|S)z Return a Licensing object using ScanCode license keys loaded from a ``license_index_location`` location of a license db JSON index files See https://scancode-licensedb.aboutcode.org/index.json )build_licensingget_license_indexlicense_index_locations r)get_scancode_licensingr*s ,-CD EEr(c*tt|S)z Return a Licensing object using SPDX license keys loaded from a ``license_index_location`` location of a license db JSON index files See https://scancode-licensedb.aboutcode.org/index.json )build_spdx_licensingrrs r)get_spdx_licensingr3s 12H I JJr(cnt|5}tj|cdddS#1swYyxYw)a Return a list of mappings that contain license key information from ``license_index_location`` The default value of `license_index_location` points to a vendored copy of the license index from https://scancode-licensedb.aboutcode.org/ N)openjsonload)rfs r)rr<s/ $ %yy|s+4cR|Dcgc] }tdi|}}t|Scc}w)z Return a Licensing object that has been loaded with license keys and attributes from a ``license_index`` list of license mappings. r')rYrL) license_indexlsymss r)!load_licensing_from_license_indexrHs. )6 61M A  6D 6 T? 7s$c |Dcgc]8}|jdd|jdd|jddd:}}t|Scc}w)z Return a Licensing object that has been loaded with license keys and attributes from a ``license_index`` list of simple ScanCode license mappings. license_key is_deprecatedF is_exception)rbrrrrr r licss r)rrQsa    55+UU?E:EE.%8  D  -T 22 s=Ac |Dcgc]Z}|jdrG|jdd|jdg|jdd|jddd\}}t|Scc}w)z Return a Licensing object that has been loaded with license keys and attributes from a ``license_index`` list of simple SPDX license mappings. spdx_license_keyrother_spdx_license_keysrFr)rbrrrrrs r)rras~   55# $ 55+R0uu6;UU?E:EE.%8   D  -T 22 sAA1c#Kt|}tfd}|D]U}|jr|D]}||$s|jj s|Ej |W|D]}|yw)z Yield Token given a ``token`` sequence of Token replacing unmatched contiguous tokens by a single token with a LicenseSymbol. c3Ksyg}r\djjs?|jjrdjjs?radj dD}dj }dj }t|}jt|||||D]}|yw)zY Build and return a new Token from accumulated unmatched tokens or None. Nrc3jK|]+}|jjs|j-ywr/rrs r)r>zUbuild_symbols_from_unknown_tokens..build_token_with_symbol..s!N1QXX^^=MahhNs33r) rrrpopr rrrYclearr)trailing_spacesrrrtoksymts unmatcheds r)build_token_with_symbolzBbuild_symbols_from_unknown_tokens..build_token_with_symbol}s  " 4 4 : : <  " "9==? 3 " 4 4 : : < XXN NNFaL&&EB-##C"6*F OO sFF3 3! BH s A#C'A/CN)rrr1rrr)rr%toksymtokr$s @r)rrts &\FI, & 9913   ISZZ%5%5%7   % &*+ sBB c#Kt|}d}t||kr |D]}|f yt}|j}|j}|j }|D]D}t||k(r,t |rt||n |}|f||F|r4t||k(rt |rt|y|D]}|f yyw)z Yield tuples of Token given a ``tokens`` sequence of Token such that: - all "XXX WITH YYY" sequences of 3 tokens are grouped in a three-tuple - single tokens are just wrapped in a tuple for consistency. N)rr0rpopleftr ris_with_subexpressionr])r triple_lenr&tripletriple_popleft triple_cleartripple_appendprev_toks r))build_token_groups_for_with_subexpressionr2s&\FJ 6{Z C&L WF^^N<v)F-  f   sCCc|\}}}t|jtxr/|jtk(xrt|jtS)zd Return True if a ``tokens_tripple`` Token tripple is a "WITH" license sub- expression. )r~r1rYKW_WITH)tokens_tripplelicwitexcs r)r+r+sF #MCc399m, 1 II  1 syy- 0r(c#pKt|}|D]}t|}|s|dk(r|d}|j}t|tr>|j t k(rtt |j|jtt|tr9|rE|jr9tt|j|jttd|||dk7rOdj!|Dcgc]}|jc}}|dj} tt|| t|\} } } | j} | j}| jj#} | d| d|}| j}t|ts+tt| j| jt$|r7|jr+tt| j| jt| j}t|ts+tt|j|jt$|r7|js+tt| j| jt&t)|||}t+| j| j,||}|y cc}ww) a Given a ``tokens`` iterable of Token, yield updated Token(s) replacing any "XXX WITH ZZZ" subexpression by a LicenseWithExceptionSymbol symbol. Check validity of WITH subexpessions and raise ParseError on errors. If ``strict`` is True also raise ParseError if the left hand side LicenseSymbol has `is_exception` True or if the right hand side LicenseSymbol has `is_exception` False. rrrz.Licensing.tokenize is internally confused...: r)r)license_symbolexception_symbolr)rrrr1N)r2r0r1r~r-r TOKEN_WITHrrrrrYrrPARSE_INVALID_EXCEPTION Exceptionr rPARSE_INVALID_SYMBOL!PARSE_INVALID_SYMBOL_AS_EXCEPTIONr\rr)rr token_groups token_group len_grouprtvalr&rr lic_tokenWITH exc_tokenr6r8rlic_symexc_sym lic_exc_syms r)rrs=VDL#o  $   >NE;;D$(99 *%#-%*\\!&#; D-0d//$#/%*\\!&#:  "PQUPX YZZK  >XX[AcszzABFN((E'#3  &1" 4{{  "avQse, //'=1'&--"/   g**'&--"2  //'=1'$^^ /   '..'&--"<  1"$ //     _oTBsC4J66J1 F-J6c eZdZdZddZddZy) Renderablez. An interface for renderable objects. ctS)a Return a formatted string rendering for this expression using the ``template`` format string to render each license symbol. The variables available are `symbol.key` and any other attribute attached to a LicenseSymbol-like instance; a custom ``template`` can be provided to handle custom rendering such as HTML. For symbols that hold multiple licenses (e.g. in a "XXX WITH YYY" statement) the template is applied to each symbol individually. Note that when render() is called the ``*args`` and ``**kwargs`` are passed down recursively to any Renderable object render() method. NotImplementedErrorr3templaterrvs r)renderzRenderable.rendercs #"r(cvt|tr|j||dd|S|j||dd|S)a, Return a formatted string rendering for this expression using the ``template`` format string to render each symbol. Add extra parenthesis around "WITH" sub-expressions such as in "(XXX WITH YYY)"for improved readbility. See ``render()`` for other arguments. F)rQwrap_with_in_parensT)r~r\rRrPs r)render_as_readablezRenderable.render_as_readablessE d6 74;;de]V\] ]t{{H$XQWXXr(N {symbol.key})r$r%r&rJrRrUr'r(r)rLrL^s# Yr(rLceZdZdZdZdZy)rz' A base class for all symbols. ct)z> Yield the underlying symbols of this symbol. rNr2s r)rzBaseSymbol.decomposes "!r(cvttsy|k(rytfd|jDS)zK Test if the ``other`` symbol is contained in this symbol. FTc3(K|] }|k( ywr/r')r<mineothers r)r>z*BaseSymbol.__contains__..s>T45=>s)r~ranyrr3r]s `r) __contains__zBaseSymbol.__contains__s4%, 5=>T^^-=>>>r(N)r$r%r&rJrr`r'r(r)rrs" ?r(rz^[-:\w\s\.\+]+$ceZdZdZeddffd ZdZdZdZdZ dZ d xZ Z dd Z d Zd Zd ZdZedZxZS)rYze A LicenseSymbol represents a license key or identifier as used in a license expression. Fc|std|t|ts+t|tr t|}ntd||j }|std|t |std|dj |j}|jtvrtd|||_ |r1t|ttfstd|dt|d |xr t|xs t|_||_||_t$t&|S|jy#td|xYw) NzA license key cannot be empty: z A license key must be a string: zA license key cannot be blank: zwInvalid license key: the valid characters are: letters and numbers, underscore, dot, colon or hyphen signs and spaces: rzPInvalid license key: a key cannot be a reserved keyword: "or", "and" or "with": zLicense aliases: z must be a sequence and not: .)r"r~rrris_valid_license_keyr rrdKEYWORDS_STRINGSrbrr]rrrrrrXrYrG)r3rbrrrrrvros r)rGzLicenseSymbol.__init__s~!$CC7"KL L#s##u%Vc(C&(H&PQQiik!$CC7"KL L$C(!'# hhsyy{# 99;* *!%%(G-   :   #G;.KDQXM?Z[\ 15>P>P)PPr(c||uryt||js|j|sy|j|jk7xs|j|jk7SNFTror_s r)__ne__zLicenseSymbol.__ne__sS 5=5$..1T5E5Ee5Lxx599$O(9(9U=O=O(OOr(crt|tttfrt |t |kSt Sr/r~rYr\LicenseSymbolLikerNotImplementedr_s r)__lt__zLicenseSymbol.__lt__s4   68I J t9s5z) )! !r(cyNTr'rs r)r4zLicenseSymbol.r(c&|j|S)N)rn)rrPs r)rRzLicenseSymbol.rendersd++r(c|jSr/rr2s r)__str__zLicenseSymbol.__str__s xxr(c,t|jSr/)r0rbr2s r)__len__zLicenseSymbol.__len__s488}r(c|jj}|j}|jxrd|jdxsd}|j}|d|d|d|dS)Nzaliases=rrr6z is_exception=r7)ror$rbrr)r3clsrbrrs r)rIzLicenseSymbol.__repr__ sfnn%%hh,,@Xdll-=R#@FB(( awb |6FaHHr(ct|j|jxrt|jxs t|jS)N)rbrr)rYrbrr]rr2s r)__copy__zLicenseSymbol.__copy__s;LL8U4<<%8CEG**  r(c6t|dxr t|dS)zj Return True if ``symbol`` is a symbol-like object with its essential attributes. rbr)hasattr)rrns r)rpzLicenseSymbol.symbol_likes vu%I'&.*IIr(rV)r$r%r&rJr]rGrrkrqrtry __nonzero____bool__rRrrrIr classmethodrprrs@r)rYrYsp !7%e66p 3QP",+K(,I JJr(rYcVeZdZdZfdZdZd fd ZdxZZdZ dZ dZ d Z xZ S) rwzj A LicenseSymbolLike object wraps a symbol-like object to expose it's LicenseSymbol behavior. cp|j|std|||_tt||d|jj i||jj|_t|jdt|_ d|_ t|dd}t|r||_ yy)NzNot a symbol-like object: rbrrR) rpr"wrappedrXrwrGrbrrr]r_rendercallable)r3rprrvrendererros r)rGzLicenseSymbolLike.__init__*s ,!$>{o"NO O"  /tVDLL4D4DVvV LL55t||Y@  ;$7 H #DL r(c.t|jS)N)rp)rwrr2s r)rzLicenseSymbolLike.__copy__;s T\\::r(cv|jr|j|g|i|Stt||g|i|Sr/)rrXrwrR)r3rQrrvros r)rRzLicenseSymbolLike.render>sB <<4<<:4:6: :&4XOOOOr(cyr{r'r|s r)r4zLicenseSymbolLike.Dr}r(cDt|j|jfSr/rhrjs r)rkzLicenseSymbolLike.__hash__Frlr(c||uryt||js|j|sy|j|jk(xr|j|jk(Srnror_s r)rqzLicenseSymbolLike.__eq__IsS 5=5$..1T5E5Ee5Lxx599$P):):e>P>P)PPr(c||uryt||js|j|sy|j|jk7xs|j|jk7Srsror_s r)rtzLicenseSymbolLike.__ne__PsS 5=5$..1T5E5Ee5Lxx599$O(9(9U=O=O(OOr(crt|tttfrt |t |kSt Sr/rvr_s r)ryzLicenseSymbolLike.__lt__W. em-GIZ[ \t9s5z) )! !r(rV)r$r%r&rJrGrrRrrrkrqrtryrrs@r)rwrw#s: $";P ,+K(3QP"r(rwcfeZdZdZd fd ZdZdZddZdZdZ dZ d Z d xZ Z d Zd ZxZS)r\a A LicenseWithExceptionSymbol represents a license with a "WITH" keyword and a license exception such as the Classpath exception. When used in a license expression, this is treated as a single Symbol. It holds two LicenseSymbols objects: one for the left-hand side license proper and one for the right- hand side exception to the license and deals with the specifics of resolution, validation and representation. cVtj|std||r|jrtd|tj|std||r|jstd|||_||_t t|#t|y)aF Initialize a new LicenseWithExceptionSymbol from a ``license_symbol`` and a ``exception_symbol`` symbol-like objects. Raise a ExpressionError exception if ``strict`` is True and either: - ``license_symbol``.is_exception is True - ``exception_symbol``.is_exception is not True z4license_symbol must be a LicenseSymbol-like object: zTlicense_symbol cannot be an exception with the "is_exception" attribute set to True:z6exception_symbol must be a LicenseSymbol-like object: zGexception_symbol must be an exception with "is_exception" set to True: N) rYrpr"rr:r;rXr\rGr)r3r:r;rrrvros r)rGz#LicenseWithExceptionSymbol.__init__js((8!F~FXY  n11!))7(:<  (()9:!HIYH\]  *77! 035  - 0 ($8TCr(chtt|jt|jS)Nr:r;)r\rr:r;r2s r)rz#LicenseWithExceptionSymbol.__copy__s+) 3 34!$"7"78  r(c#DK|j|jywr/rr2s r)rz$LicenseWithExceptionSymbol.decomposes!!!###s c|jj|g|i|}|jj|g|i|}|d|}|rd|d}|S)z Return a formatted "WITH" expression. If ``wrap_with_in_parens``, wrap the expression in parens as in "(XXX WITH YYY)".  WITH r6r7)r:rRr;)r3rQrTrrvr6r8rends r)rRz!LicenseWithExceptionSymbol.rendersm )d!!((CDCFC*d##**8EdEfEfSE" tfA;D r(cDt|j|jfSr/)rir:r;rjs r)rkz#LicenseWithExceptionSymbol.__hash__s&##%%   r(c||uryt||jsy|j|jk(xr|j|jk(Srnr~ror:r;r_s r)rqz!LicenseWithExceptionSymbol.__eq__sR 5=%0   5#7#7 7 @%%)?)?? r(c||uryt||jsy|j|jk(xr|j|jk( Srsrr_s r)rtz!LicenseWithExceptionSymbol.__ne__sW 5=%0   5#7#7 7 @%%)?)??  r(crt|tttfrt |t |kSt Sr/rvr_s r)ryz!LicenseWithExceptionSymbol.__lt__rr(cyr{r'r|s r)r4z#LicenseWithExceptionSymbol.r}r(c`|jjd|jjS)Nr)r:rbr;r2s r)rz"LicenseWithExceptionSymbol.__str__s-%%))*&1F1F1J1J0KLLr(c|jj}t|jj}|j|j|d|j d|j dS)N)rz(license_symbol=z, exception_symbol=r7)ror$dictupdate__dict__r:r;)r3rrs r)rIz#LicenseWithExceptionSymbol.__repr__shnn%%//0 DMM"e"1145 $ 5 58 ; r(F)rWF)r$r%r&rJrGrrrRrkrqrtryrrrrIrrs@r)r\r\_sI"DH $      " ,+K(M r(r\ceZdZddZy)RenderableFunctioncH|j}t|dk(rw|d}t|tr|j|g|i|}nt d|t |}|jr|j|}|S|jd|d}|Sg}|j}|D]d} t| tr| j|g|i|}nt d| dt | }| jr ||Y|d|df|jj|S)z Render an expression as a string, recursively applying the string ``template`` to every symbols and operators. rrzFWARNING: symbol is not renderable: using plain string representation: r6r7z^WARNING: object in expression is not renderable: falling back to plain string representation: rc) rr0r~rLrRr`r isliteralrrr ) r3rQrrvexpression_argsrrenderedrendered_itemsrendered_items_appendrs r)rRzRenderableFunction.rendersJ ))  1 $!!$C#z* cjj;D;F;\]`\cd#h~~"mm_SE2O#mm_AcU!4O . 5 5" 7C#z*%3::h@@@DDG7!Ms8}}%h/%(1o6! 7$}}!!.11r(NrV)r$r%r&rRr'r(r)rrs.2r(rc"eZdZdZfdZxZS)rTzB Custom representation for the AND operator to uppercase. cft|dkr tdtt||d|_y)Nz4AND requires two or more licenses as in: MIT AND BSDz AND )r0r"rXrTrGrr3rros r)rGz AND.__init__s0 t9q=!"XY Y c4!4( r(r$r%r&rJrGrrs@r)rTrTs  r(rTc"eZdZdZfdZxZS)rUzA Custom representation for the OR operator to uppercase. cft|dkr tdtt||d|_y)Nrz2OR requires two or more licenses as in: MIT OR BSDz OR )r0r"rXrUrGrrs r)rGz OR.__init__s0 t9q=!"VW W b$ $' r(rrs@r)rUrUsr(rUcL|sgSg}|D]}||vr|j||S)zT Return unique items in a sequence ``seq`` preserving their original order. )r)sequniquesitems r)rr&s=  G 7? t Nr(c#lK|r|D]}|st|tr t|}t|tr|j sCt |Qt|t r|ft j |rt|t|dyy#t|dxYww)az Return an iterable of LicenseSymbol objects from a ``symbols`` sequence of strings or LicenseSymbol-like objects. If an item is a string, then create a new LicenseSymbol for it using the string as key. If this is not a string it must be a LicenseSymbol- like type. Raise a TypeError expection if an item is neither a string or LicenseSymbol- like. z is not a string.z, is neither a string nor LicenseSymbol-like.N)r~rrrrrYrprw)rgrns r)r^r^4s [F&%(D [F&#&<<>'//FM2 **62'// 6*,X YZZ) [D#vj0A$BCCs"B4 B! B4 AB4!B11B4c  t}i}t}g}t}t}tt}t} tt} t} |D]} t| ts|j | &| j } | j} | j}||vr|j| |tvr| j| |j|t| dg}t|}t|Dcgc]=}dj|jjj?c}}td|D}t||k7r| j| |j||D]O}|j|}|r||k7r||j | |tvr| | j ||||<Q| j s||vr|j||j|g}t#|D]}|j d|dt#|D]}|j d|dt#|j%D].\}}dj|}|j d|d |d0t#| j%D].\}}dj|}|j d |d |d0t#|D]}|j d |dt#| D]}|j d |dg}t#|D]}|j d|d||fScc}w)a Return a tuple of (`warnings`, `errors`) given a sequence of ``symbols`` LicenseSymbol-like objects. - `warnings` is a list of validation warnings messages (possibly empty if there were no warnings). - `errors` is a list of validation error messages (possibly empty if there were no errors). Keys and aliases are cleaned and validated for uniqueness. If ``validate_keys`` also validate that license keys are known keys. rrc3&K|] }|s| ywr/r')r<as r)r>z#validate_symbols..s.AAa.sz*Invalid item: not a LicenseSymbol object: rcz Invalid duplicated license key: rz4Invalid duplicated alias pointing to multiple keys: z point to keys: z@Invalid aliases: an alias cannot be an expression keyword. key: z , aliases: z*Invalid duplicated license exception key: z4Invalid key: a key cannot be an expression keyword: z5Duplicated or empty aliases ignored for license key: )setrrr~rYrrbrrdrrerr0r rrrsortedrZ)rg validate_keys seen_keys seen_aliasesseen_exceptionsnot_symbol_classes dupe_keysdupe_exceptions dupe_aliasesinvalid_keys_as_kwinvalid_alias_as_kwwarning_dupe_aliasesrnrbkeylrinitial_alias_lenr aliased_keyrEinddupedaliasdkeysikeyialiasesikwwarnings dupe_aliass r)r_r_Vs ILeOIeOt$L%d+58*&-0  % %f - jjiikyy{ 9  MM#  # #  " "3 '  d&)R0LGT5sxx 3 3 5 ; ; =>TU... w<, , $ $S )  D 'E '**51K{d2U#**3/((#C(//6"&L  '   &##D)##D)q8*vF()M B3'KLMy!D 8BCD 2 2 45  %  Bh&uiq 2  !!4!:!:!<= h99X& 8;xj 3  'L B4&JKL()U LSEQRSTUH\*_  Mj^[\]^_ V CUsAN Tc|syt|ttfstdt ||r|j dvrtd||Dcgc]}|j |d}}|r1t|Dcic]}t||c}j}t|dk(r|dS|j|jd|}||Scc}wcc}w) aC Return a combined LicenseExpression object with the `relation`, given a list of license ``expressions`` strings or LicenseExpression objects. If ``unique`` is True remove duplicates before combining expressions. For example:: >>> a = 'mit' >>> b = 'gpl' >>> str(combine_expressions([a, b])) 'mit AND gpl' >>> assert 'mit' == str(combine_expressions([a])) >>> combine_expressions([]) >>> combine_expressions(None) >>> str(combine_expressions(('gpl', 'mit', 'apache',))) 'gpl AND mit AND apache' >>> str(combine_expressions(('gpl', 'mit', 'apache',), relation='OR')) 'gpl OR mit OR apache' >>> str(combine_expressions(('gpl', 'mit', 'mit',))) 'gpl AND mit' >>> str(combine_expressions(('mit WITH foo', 'gpl', 'mit',))) 'mit WITH foo AND gpl AND mit' >>> str(combine_expressions(('gpl', 'mit', 'mit',), relation='OR', unique=False)) 'gpl OR mit OR mit' >>> str(combine_expressions(('mit', 'gpl', 'mit',))) 'mit AND gpl' Nz/expressions should be a list or tuple and not: )rTrUz+relation should be one of AND, OR and not: T)rrr) r~rr]rrupperr}rvaluesr0rTrU)rrrrlexs r)rrs@  kD%= 1I${J[I\]^^ x~~'0EhZPQQ?JJ9??2d?3JKJ {;!CFAI;BBDE  ;11~ }}ILL9(CH [ !!K Cr)`rJrrrer collectionsrrrrr functoolsros.pathr r r booleanr rboolean.booleanr rrrrrrrrrrrr!license_expression._pyahocorasickrrr__file__curr_dirdata_dir*vendored_scancode_licensedb_index_locationrr=r@r?r>r"r,r-rr<rrKW_ANDKW_ORr4rrrercompileVERBOSE MULTILINEUNICODEfinditerrr@BooleanAlgebrarLrrrrrrrr2r+robjectrLrVrrrdrYrwr\rrTrUrr^r_rr'r(r)rsM  #"$3)41;9;/&(%$&&G3 78$ % & !-1 #.* #|31VL-.,. +() %(!$L8]23|+)ML%& i  : Y -.  #z " #z "  "h &* %      3(33% 9 BJJJJ *  (/ / dj &&j Z3]F/YK.X  3 3&-`+\ |~YYD?W^^?2"rzz"4bjjAGGAJJAJAJJ7" 7"7"vw w w t1212h  gkk    WZZ  [Dy| k 8"r(