EKgoLUdZddlZddlmZmZddlmZddlm Z ddl m Z ddl m Z mZmZmZmZmZmZmZmZmZmZmZmZmZddlmZdd lmZmZdd l m!Z!m"Z"m#Z#m$Z$dd l%m&Z&m'Z'm(Z(dd l)m*Z*m+Z+erdd l,m-Z-ne.Z-Gdde-Z/Gdde-Z0ee/e0fZ1ee2ge2fZ3ee ge fZ4ee5Z6eee5Z7ee6e7fZ8ee5ge8fZ9ee dfZ:ee:dfZ;ee:e;fZee2e5e?e@fZAeee2geeAfZBedeKf d!ZSede deLdeeHeIfde9d e>deKf d"ZSdeeJe fdeMdeeHeIfde9d e>deKf d#ZSde&de9fd$ZTde&d%e!d&e2de>fd'ZUde&d%e!d(eGd)e3d*eBd+eDdeHfd,ZVd-eHdeIfd.ZWd/ee d%e!dee fd0ZXde&de3fd1ZYde&deBfd2ZZde&d%e!d&e2deDfd3Z[ee3e d4Z\e3e]d5<e\fde2d6e3de2fd7Z^d8ee4de4fd9Z_ed:e5d;e2de2fd<Z`ed:e d;e2de fd=Z`d:e d;e2de fd>Z`d?ejd@jfd:eEdAecdBeFdee2fdCZdy)Da Utilities and definitions for natsort, mostly all used to define the natsort_key function. SOME CONVENTIONS USED IN THIS FILE. 1 - Factory Functions Most of the logic of natsort revolves around factory functions that create branchless transformation functions. For example, rather than making a string transformation function that has an if statement to determine whether or not to perform .lowercase() at runtime for each element to transform, there is a string transformation factory function that will return a function that either calls .lowercase() or does nothing. In this way, all the branches and decisions are taken care of once, up front. In addition to a slight speed improvement, this provides a more extensible infrastructure. Each of these factory functions will end with the suffix "_factory" to indicate that they themselves return a function. 2 - Keyword Parameters For Local Scope Many of the closures that are created by the factory functions have signatures similar to the following >>> def factory(parameter): ... val = 'yes' if parameter else 'no' ... def closure(x, _val=val): ... return '{} {}'.format(_val, x) ... return closure ... The variable value is passed as the default to a keyword argument. This is a micro-optimization that ensures "val" is a local variable instead of global variable and thus has a slightly improved performance at runtime. N)partialreduce)chain) methodcaller)PurePath)AnyCallableDictIterableIteratorListMatchOptionalPattern TYPE_CHECKINGTupleUnioncastoverload) normalize) try_floattry_int) StrOrBytesget_decimal_point get_strxfrmget_thousands_sep)NSTypeNS_DUMBns)digits_no_decimalsnumeric_no_decimals)ProtocolceZdZdedefdZy)SupportsDunderLT_SupportsDunderLT__otherreturncyN)selfr%s Q/home/alanp/www/video.onchill/myenv/lib/python3.12/site-packages/natsort/utils.py__lt__zSupportsDunderLT.__lt__U N)__name__ __module__ __qualname__rboolr,r)r.r+r$r$T c d r.r$ceZdZdedefdZy)SupportsDunderGT_SupportsDunderGT__otherr&cyr(r))r*r6s r+__gt__zSupportsDunderGT.__gt__Zr-r.N)r/r0r1rr2r8r)r.r+r5r5Yr3r.r5.ceZdZUdZeZeed<eZ eed<dZ eed<dZ eed<e ded e efd Ze d e efd Ze d e efd Ze d e efd Ze d e efdZe d e efdZe d e efdZy)NumericalRegularExpressionsz Container of regular expressions that match numbers. The numbers also account for unicode non-decimal characters. Not intended to be made an instance - use class methods only. numericdigitsz(?:[eE][-+]?\d+)?expz(?:\d+\.?\d*|\.\d+) float_numfmtr&c ~tj|jdit|tjS)zAGiven a format string, construct the regex with class attributes.flagsr))recompileformatvarsU)clsr?s r+_construct_regexz,NumericalRegularExpressions._construct_regexs+zz*#**1tCy1>>r.c$|jdS)z)Regular expression to match a signed int.z([-+]?\d+|[{digits}])rIrHs r+int_signz$NumericalRegularExpressions.int_signs##$<==r.c$|jdS)z,Regular expression to match an unsigned int.z(\d+|[{digits}])rKrLs r+ int_nosignz&NumericalRegularExpressions.int_nosigns##$788r.c$|jdS)z9Regular expression to match a signed float with exponent.z#([-+]?{float_num}{exp}|[{numeric}])rKrLs r+float_sign_expz*NumericalRegularExpressions.float_sign_exps##$JKKr.c$|jdS)z classmethodrrIrMrOrQrSrVrXr)r.r+r:r:s'GS&$FC$#C#+Is+?3?73<??>>>973<99Lws|LLGGGGGGB73<BBr.r:algr&c (|tjzr6|tjtjztjzz}n$|tjtjzz}tjt j tjt jtjtjzt jtjtjzt jtjtjzt jtjtjztjzt ji|S)a9 Select an appropriate regex for the type of number of interest. Parameters ---------- alg : ns enum Used to indicate the regular expression to select. Returns ------- regex : compiled regex object Regular expression object that matches the desired number type. ) rFLOATSIGNEDNOEXPINTr:rOrSrMrQrXrVr]s r+ regex_chooserrds RXX~ rxx"))#bhh.. rvv !! +668 ->>@ 7@@B 2999HHJ 2888KKM 299rxx')D)U)U)W     r.xc|S)z9A function that does nothing and returns the input as-is.r)res r+_no_oprhs Hr.cP|tjzrdnd}tt|S)a` Create a function that will normalize unicode input data. Parameters ---------- alg : ns enum Used to indicate how to normalize unicode. Returns ------- func : callable A function that accepts string (unicode) input and returns the the input normalized with the desired normalization scheme. NFKDNFDrCOMPATIBILITYNORMALIZErrr]normalization_forms r+_normalize_input_factoryrps' $')B)B#B 90 11r.cP|tjzrdnd}tt|S)aY Create a function that will compose unicode input data. Parameters ---------- alg : ns enum Used to indicate how to compose unicode. Returns ------- func : callable A function that accepts string (unicode) input and returns the the input normalized with the desired composition scheme. NFKCNFCrlrns r+_compose_input_factoryrts'$')B)B#B 90 11r.valkey string_func bytes_funcnum_funccyr(r)rurvrwrxrys r+ natsort_keyr| r.cyr(r)r{s r+r|r|r}r.c|||}t|ttfr|St|tr|St|trt fd|DS|S)a Key to sort strings and numbers naturally. It works by splitting the string into components of strings and numbers, and then converting the numbers into actual ints or floats. Parameters ---------- val : str | bytes | int | float | iterable key : callable | None A key to apply to the *val* before any other operations are performed. string_func : callable If *val* (or the output of *key* if given) is of type *str*, this function will be applied to it. The function must return a tuple. bytes_func : callable If *val* (or the output of *key* if given) is of type *bytes*, this function will be applied to it. The function must return a tuple. num_func : callable If *val* (or the output of *key* if given) is not of type *bytes*, *str*, nor is iterable, this function will be applied to it. The function must return a tuple. Returns ------- out : tuple The string split into its string and numeric components. It *always* starts with a string, and then alternates between numbers and strings (unless it was applied recursively, in which case it will return tuples of tuples, but the lowest-level tuples will then *always* start with a string etc.). See Also -------- parse_string_factory parse_bytes_factory parse_number_or_none_factory c3<K|]}t|dywr()r|).0rerxryrws r+ znatsort_key..Zs" MPK4j( CSs) isinstancerZrbytesr tupler{s ```r+r|r|sqd #h#X'3 C # C " MP   }r.c|tjzr|tjzrdS|tjzrdS|tjzrdSdS)a Create a function that will format a *bytes* object into a tuple. Parameters ---------- alg : ns enum Indicate how to format the *bytes*. Returns ------- func : callable A function that accepts *bytes* input and returns a tuple with the formatted *bytes*. Intended to be used as the *bytes_func* argument to *natsort_key*. See Also -------- natsort_key c&|jffSr(lowerrgs r+z%parse_bytes_factory..ys1779,r.c |ffSr(r)rgs r+rz%parse_bytes_factory..{s1$r.c$|jfSr(rrgs r+rz%parse_bytes_factory..}s !'')r.c|fSr(r)rgs r+rz%parse_bytes_factory..s!r.)rPATH IGNORECASErcs r+parse_bytes_factoryrasI. RWW}r}},(( rww  r}} %%r.seppre_sepc |tjzr tdn td}|||tdk(fdtdtdtdt dt f d|tjzr,|tjzr|tjzrfd S|tjzr|tjzrfd S|tjzrfd SS) a Create a function that will format a number (or None) into a tuple. Parameters ---------- alg : ns enum Indicate how to format the *bytes*. sep : str The string character to be inserted before the number in the returned tuple. pre_sep : str In the event that *alg* contains ``UNGROUPLETTERS``, this string will be placed in a single-element tuple at the front of the returned nested tuple. Returns ------- func : callable A function that accepts numeric input (e.g. *int* or *float*) and returns a tuple containing the number with the leading string *sep*. Intended to be used as the *num_func* argument to *natsort_key*. See Also -------- natsort_key +inf-infru _nan_replace_sepreverser&cT||k7r |||rdfSdfS|||dfS||k(r |||rdfSdfS||fS)z?Given a number, place it in a tuple with a leading null string.312r))rurrrs r+funcz*parse_number_or_none_factory..funcs] #:gs> >3> > [s* * L gs> >3> >9 r.cf|ffSr(r)rerrs r+rz.parse_number_or_none_factory..sG:tAw/1r.cf|fSr(r)rs r+rz.parse_number_or_none_factory..s7*d1g.r.c|fSr(r))rers r+rz.parse_number_or_none_factory..s $q'r.) rNANLASTfloatrrr2 BasicTuplerUNGROUPLETTERS LOCALEALPHA)r]rr nan_replacers ` @r+parse_number_or_none_factoryrs>$'#3%-vK*#uV}4     ( RWW}r000S2>>5I11 r  S2>>%9.. rww## r.splitterinput_transformcomponent_transformfinal_transformc  |tzxr|tjz }|rnt t | |tjzr t |ntdt dtf fd }|S)a Create a function that will split and format a *str* into a tuple. Parameters ---------- alg : ns enum Indicate how to format and split the *str*. sep : str The string character to be inserted between adjacent numeric objects in the returned tuple. splitter : callable A function the will accept a string and returns an iterable of strings where the numbers are separated from the non-numbers. input_transform : callable A function to apply to the string input *before* applying the *splitter* function. Must return a string. component_transform : callable A function that is operated elementwise on the output of *splitter*. It must accept a single string and return either a string or a number. final_transform : callable A function to operate on the return value as a whole. It must accept a tuple and a string argument - the tuple should be the result of applying the above functions, and the string is the original input value. It must return a tuple. Returns ------- func : callable A function that accepts string input and returns a tuple containing the string split into numeric and non-numeric components, where the numeric components are converted into numeric objects. The first element is *always* a string, and then alternates number then string. Intended to be used as the *string_func* argument to *natsort_key*. See Also -------- natsort_key input_string_transform_factory string_component_transform_factory final_data_transform_factory rer&ct|tr t|} |} ||}} |}|}td|} |}t |} ||Sr()rrrZfilter sep_inserter)reaboriginalcdefgr compose_inputrrnormalize_input original_funcrrs r+rz"parse_string_factory..funcsx a "AA A %a(-*:8 !  QK 4O  " C q(++r.)rrrrhrprtPathArgFinalTransform) r]rrrrrorig_after_xfrmrrrrs ````` @@@r+parse_string_factoryrsjl=AS2>>-ABO'6OFM.s3O363G*3/VM,,N,," Kr. str_splitcfdS)aA Create a function that will properly split and format a path. Parameters ---------- str_split : callable The output of the *parse_string_factory* function. Returns ------- func : callable A function that accepts a string or path-like object and splits it into its path components, then passes each component to *str_split* and returns the result as a nested tuple. Can be used as the *string_func* argument to *natsort_key*. See Also -------- natsort_key parse_string_factory c@ttt|Sr()rmap path_splitter)rers r+rz$parse_path_factory..(sU3y-*:;tjt}|d|zdzz }|d|zdzz }|d|zdzz }|jtjt| }tj|tj }|jt|j dt}|tjzrf|d k7rad } | jtj| } tj| } |jt| j d t#|S)aR Create a function to transform a string. Parameters ---------- alg : ns enum Indicate how to format the *str*. Returns ------- func : callable A function to be used as the *input_transform* argument to *parse_string_factory*. See Also -------- parse_string_factory swapcasecasefolda^ (?<=[0-9]{{1}}) # At least 1 number (? +-.A 1y0 0I 1|3 3I 1|3 3I)00,./91  ZZrzzJg&8&<&gnFN+22299W;M2NN " > :   ! !'*;*?*?"E F > **r.c|tjz}|tz}|tjzxs|xr|}|tjzr t dn t d}g}|r|j t|r|j t|r dt|ini}d|d<|tjzr#||d<ttttfi|Sttttfi|S)at Create a function to either transform a string or convert to a number. Parameters ---------- alg : ns enum Indicate how to format the *str*. Returns ------- func : callable A function to be used as the *component_transform* argument to *parse_string_factory*. See Also -------- parse_string_factory rron_failTrnan)rrr GROUPLETTERSrrr grouplettersrrr_rStrTransformerrrr)r] use_localer group_lettersnan_val func_chainkwargss r+"string_component_transform_factoryrs*r~~%J =D2??*D 0CtM"RZZ/eFmU6]G57J,'+-(:Di4 5FF5M RXX~u NGI$@$@AANGG$>v$>??r.c |tjzr|tjzrt|tzxr|tjz}t t |r tdnt}|||fdttdtdt dtdtdtf d}|St||fdttdtdt dtdtdtf d }|S) a6 Create a function to transform a tuple. Parameters ---------- alg : ns enum Indicate how to format the *str*. sep : str Separator that was passed to *parse_string_factory*. pre_sep : str String separator to insert at the at the front of the return tuple in the case that the first element is *sep*. Returns ------- func : callable A function to be used as the *final_transform* argument to *parse_string_factory*. See Also -------- parse_string_factory r split_valru _transformr_pre_sepr&cTt|}|sy|d|k(r|f|fS||df|fS)a Return a tuple with the first character of the first element of the return value as the first element, and the return value as the second element. This will be used to perform gross sorting by the first letter. )r)r)rrrrurrrs r+rz*final_data_transform_factory..funcsDi(I1% {I--"3q6*,i77r.ct|Sr(rrs r+rz*final_data_transform_factory..funcs# #r.)rrrrrrStrToStrrrhr NatsortInTyperZrr)r]rrswap transformrs r+final_data_transform_factoryrs8 R  3#7W}8r'8'8!8t< #;P $-"#  8 . 8 8! 8  8   8   8@ K $*"#  $ . $ $! $  $   $   $ Kr.rlower_function_lowc^djtjfd|DS)z Double all characters, making doubled letters lowercase. Parameters ---------- x : str Returns ------- str Examples -------- >>> groupletters("Apple") 'aAppppllee' rc32K|]}||fywr(r))ryrs r+rzgroupletters..$s'@aa! as)joinichain from_iterable)rers `r+rrs%& 776'''@a'@@ AAr. functionscrt|}|stSt|dk(r|dSttd|S)aS Chain a list of single-argument functions together and return. The functions are applied in list order, and the output of the previous functions is passed to the next function. Parameters ---------- functions : list A list of single-argument functions to chain together. Returns ------- func : callable A single argument function. Examples -------- Chain several functions together! >>> funcs = [lambda x: x * 4, len, lambda x: x + 5] >>> func = chain_functions(funcs) >>> func('hey') 17 rc||Sr(r))resrs r+rz!chain_functions..Isafr.)listrhlenrr)rs r+rr's=6YI  Y1 |v4i@@r.sencodingcyr(r)rrs r+ do_decodingrLr.cyr(r)rs r+rrQrr.cHt|tr|j|S|S)aH Helper to decode a *bytes* object, or return the object as-is. Parameters ---------- s : bytes | object encoding : str The encoding to use to decode *s*. Returns ------- decoded *str* if *s* was *bytes* and the decoding was successful. *s* if *s* was not *bytes*. )rrdecoders r+rrVs""!Uxx!!r.Tz\.\d treat_base_d_matchct|ts t|} |j^}}g}|rmt t t|jD]3\}}||s|dkDst|dkDrn|j|5|j|jdj|d}|r|gng}tdt|||S#t$rg}t |}YwxYw)a: Split a string into its path components. Assumes a string is a path or is path-like. Parameters ---------- s : str | pathlib.Path treat_base: bool, optional If True, treat the base of component of the file path as special and split off extensions. If False, do not do this. The default is True. Returns ------- split : tuple The path split by directory components and extensions. Examples -------- >>> tuple(path_splitter("this/thing.ext")) ('this', 'thing', '.ext') r rN)rrparts ValueErrorrZ enumeratereversedsuffixesr rrreplacerrr) rrr path_partsbaserisuffixbase_components r+rrns8 a " QKGGT H #8HTN,C,C#DEIAv1q5CK!O OOF #F  <<)2 .D#dVN $z>8D EE-  1vsCC54C5)erYrC functoolsrr itertoolsrroperatorrpathlibrtypingrr r r r r rrrrrrrr unicodedatarnatsort.compat.fastnumbersrrnatsort.compat.localerrrrnatsort.ns_enumrrrnatsort.unicode_numbersr r!typing_extensionsr"objectr$r5SortablerZrAnyCallr BytesTupleNestedBytesTupleBytesTransformBytesTransformerrNestedAnyTupleAnyTuple NumTransformNumTransformerrr StrBytesNumrrFinalTransformerrMatchFn StrSplitter StrParser PathSplitterrNatsortOutTypeKeyType MaybeKeyTyper:rdrhrprtr|rrrrrrrrrr[rrrrDmatchr2rr)r.r+rFs&N %%! "9 0/K*H x  x !#33 4 SE3J  C5#: 5\ u&z#334UG^3438_ z3' ^+ , 3%-.Cs*+ 8C=/8K+@@AXc]C0.@A X  C5(5/) *uhsm+, gY. /  5)<#==> " x}% C5-' ( 3B3Bl v '#, < c c 2&2X2(2282&   y,./!         y,./!      ? }c! "? ?y,./?! ?  ?  ?DV(8B< < <+.<<~L L LL L ( L & LL^=)= =6*8C=*z*hsm*ZC+C+8C+L)@F)@~)@X@ @ @+.@@F ,z*BCC+9BCBxBSB,"Ax0"AW"AJ 5CC  3## 3##2$(ZRZZ=P=V=V8F8F 8F3:8F c]8Fr.