o ˷eL@sddlZddlZddlmZddlmZddlmZddlm Z ddl m Z ddl m Z Gdd d eZGd d d eZGd d d eZGdddeZeZGdddeZddZddZddZdddZdS)N) OrderedDict)total_ordering)chain)FieldDoesNotExist)models)format_html_joinc@seZdZdZddZdS)Sequencea Represents a column sequence, e.g. ``('first_name', '...', 'last_name')`` This is used to represent `.Table.Meta.sequence` or the `.Table` constructors's *sequence* keyword argument. The sequence must be a list of column names and is used to specify the order of the columns on a table. Optionally a '...' item can be inserted, which is treated as a *catch-all* for column names that are not explicitly specified. cCs|d}|dkr td|dkr|dt|}g}g}|}|D]}|dkr+|}q"||||vr<|||q"t||||dd<|S)aR Expands the ``'...'`` item in the sequence into the appropriate column names that should be placed there. arguments: columns (list): list of column names. returns: The current instance. raises: `ValueError` if the sequence is invalid for the columns. z...z.'...' must be used at most once in a sequence.rN)count ValueErrorappendlistpopindexr)selfcolumnsellipsesheadtailtargetnamerK/var/www/ideatree/venv/lib/python3.10/site-packages/django_tables2/utils.pyexpands&   zSequence.expandN)__name__ __module__ __qualname____doc__rrrrrr s rcs\eZdZdZdZfddZeddZeddZed d Z ed d Z d dZ Z S)OrderByz} A single item in an `.OrderByTuple` object. This class is essentially just a `str` with some extra properties. __cs6t||}tj|vrd|}tj|tdd|SNzvUse '__' to separate path components, not '.' in accessor '{}' (fallback will be removed in django_tables2 version 3).) stacklevel)super__new__AccessorLEGACY_SEPARATORformatwarningswarnDeprecationWarningclsvalueinstancemessage __class__rrr$Gs zOrderBy.__new__cCs$|dddkrt|ddS|S)z Returns: `.OrderBy`: the bare form. The *bare form* is the non-prefixed form. Typically the bare form is just the ascending form. Example: ``age`` is the bare form of ``-age`` Nr -)rrrrrbareSs$ z OrderBy.barecCs"|jr t|ddStd|S)a Provides the opposite of the current sorting direction. Returns: `.OrderBy`: object with an opposite sort influence. Example:: >>> order_by = OrderBy('name') >>> order_by.opposite '-name' r Nr2) is_descendingrr3rrroppositeas"zOrderBy.oppositecCs |dS)zN Returns `True` if this object induces *descending* ordering. r2) startswithr3rrrr5rs zOrderBy.is_descendingcCs|j S)zM Returns `True` if this object induces *ascending* ordering. )r5r3rrr is_ascendingyszOrderBy.is_ascendingcCs|tjtjS)zf Returns the current instance usable in Django QuerySet's order_by arguments. )replacer%r&rQUERYSET_SEPARATORr3rrr for_querysetszOrderBy.for_queryset) rrrrr:r$propertyr4r6r5r8r; __classcell__rrr0rr>s     rcs\eZdZdZfddZddZddZfdd Zed d Z d d Z eddZ Z S) OrderByTuplea Stores ordering as (as `.OrderBy` objects). The `~.Table.order_by` property is always converted to an `.OrderByTuple` object. This class is essentially just a `tuple` with some useful extras. Example:: >>> x = OrderByTuple(('name', '-age')) >>> x['age'] '-age' >>> x['age'].is_descending True >>> x['age'].opposite 'age' cs8g}|D]}t|tst|}||qt||SN) isinstancerr r#r$)r,iterable transformeditemr0rrr$s   zOrderByTuple.__new__cCs d|S)N,)joinr3rrr__str__ zOrderByTuple.__str__cCs(t|j}|D] }|j|krdSqdS)a Determine if a column has an influence on ordering. Example:: >>> x = OrderByTuple(('name', )) >>> 'name' in x True >>> '-name' in x True Arguments: name (str): The name of a column. (optionally prefixed) Returns: bool: `True` if the column with `name` influences the ordering. TF)rr4)rrorder_byrrr __contains__s  zOrderByTuple.__contains__cs>t|tr|D]}||ks|j|kr|Sqtt|S)a Allows an `.OrderBy` object to be extracted via named or integer based indexing. When using named based indexing, it's fine to used a prefixed named:: >>> x = OrderByTuple(('name', '-age')) >>> x[0] 'name' >>> x['age'] '-age' >>> x['-age'] '-age' Arguments: index (int): Index to query the ordering for. Returns: `.OrderBy`: for the ordering at the index. )r@strr4KeyErrorr# __getitem__)rrrHr0rrrLs  zOrderByTuple.__getitem__csJgg|D]}t|j|jqtGfddd}|S)Ncs.eZdZddZfddZfddZdS)z$OrderByTuple.key..ComparatorcSs ||_dSr?)obj)rrMrrr__init__rGz-OrderByTuple.key..Comparator.__init__cs<D]}|j|jdd}|j|jdd}||ksdSqdSNTquietF)resolverM)rotheraccessorab) accessorsrr__eq__sz+OrderByTuple.key..Comparator.__eq__c stD]^\}}|j|jdd}|j|jdd}||krq|r%||}}z||kWStyct|t|urGt|t|kYSt|}t|}t|t|ft|t|fkYSwdSrO)ziprRrM TypeErrorbooltypereprid)rrSrTreverserUrVa_typeb_typerW reversingrr__lt__s"  ( z+OrderByTuple.key..Comparator.__lt__N)rrrrNrXrdrrbrr Comparators re)r r%r4r5r)rrHrerrbrkeys%zOrderByTuple.keyc Cs&z||WSttfy|YSw)zJ Identical to `__getitem__`, but supports fallback value. )rK IndexError)rrffallbackrrrget s  zOrderByTuple.getcCst|dd|DS)z Return version with each `.OrderBy` prefix toggled:: >>> order_by = OrderByTuple(('name', '-age')) >>> order_by.opposite ('-name', 'age') css|]}|jVqdSr?)r6).0orrr sz(OrderByTuple.opposite..)r\r3rrrr6s zOrderByTuple.opposite) rrrrr$rFrIrLr<rfrir6r=rrr0rr>s   / r>csXeZdZdZdZdZdZdZfddZdd d Z e d d Z ddZ dddZ ZS)r%a A string describing a path from one object to another via attribute/index accesses. For convenience, the class has an alias `.A` to allow for more concise code. Relations are separated by a ``__`` character. To support list-of-dicts from ``QuerySet.values()``, if the context is a dictionary, and the accessor is a key in the dictionary, it is returned right away. .rz9Refusing to call {method}() because `.alters_data = True`zRFailed lookup for key [{key}] in {context}, when resolving the accessor {accessor}cs>t||}|j|vr|j|_d|}tj|tdd|Sr )r#r$r& SEPARATORr'r(r)r*r+r0rrr$2s zAccessor.__new__TFcCs>t|tr ||vr ||Sz|}|jD]{}z||}WnJtttfyezt||}Wn6ttfybz|t|}Wn"tt ttfy_t|t j rRt |n|}t |j j|||dwYnwYnwt|r|r}t|ddr}t |jjt|dt|dds|}|dur|WSq|WSty|sYdSw)a Return an object described by the accessor by traversing the attributes of *context*. Lookups are attempted in the following order: - dictionary (e.g. ``obj[related]``) - attribute (e.g. ``obj.related``) - list-index lookup (e.g. ``obj[int(related)]``) Callable objects are called, and their result is used, before proceeding with the resolving. Example:: >>> x = Accessor("__len__") >>> x.resolve("brad") 4 >>> x = Accessor("0__upper") >>> x.resolve("brad") "B" If the context is a dictionary and the accessor-value is a key in it, the value for that key is immediately returned:: >>> x = Accessor("user__first_name") >>> x.resolve({"user__first_name": "brad"}) "brad" Arguments: context : The root/first object to traverse. safe (bool): Don't call anything with `alters_data = True` quiet (bool): Smother all exceptions and instead return `None` Returns: target object Raises: TypeError`, `AttributeError`, `KeyError`, `ValueError` (unless `quiet` == `True`) )rfcontextrT alters_dataF)methoddo_not_call_in_templatesN)r@dictbitsrZAttributeErrorrKgetattrintrgr rModelr\LOOKUP_ERROR_FMTr'callableALTERS_DATA_ERROR_FMTr] Exception)rrosaferQcurrentbitcurrent_contextrrrrR@s\,     zAccessor.resolvecCs|dkrdS||jS)Nr)splitrnr3rrrrts z Accessor.bitsc Cslt|dsdSd}|jD]'}z|j|}Wn ty!Y|Swt|dr3t|dd}t|d|}q |S)zZ Return the django model field for model in context, following relations. _metaN remote_fieldmodel)hasattrrtr get_fieldrrv)rrfieldrrelrrrrs      zAccessor.get_fieldcCs(||j\}}}t|j||d|fS)a* Split the accessor on the right-most separator ('__'), return a tuple with: - the resolved left part. - the remainder Example:: >>> Accessor("a__b__c").penultimate({"a": {"a": 1, "b": {"c": 2, "d": 4}}}) ({"c": 2, "d": 4}, "c") rP) rpartitionrnArR)rrorQpath_ remainderrrr penultimates zAccessor.penultimate)TF)T)rrrrr&rnr{ryr$rRr<rtrrr=rrr0rr%s   X r%c@s$eZdZdZdZddZddZdS) AttributeDicta$ A wrapper around `collections.OrderedDict` that knows how to render itself as HTML style tag attributes. Any key with ``value is None`` will be skipped. The returned string is marked safe, so it can be used safely in a template. See `.as_html` for a usage example. )thtd _orderingtheadtbodytfootccsF|D]\}}t|r|n|}||jvr |dur ||fVqdSr?)itemsrz blacklist)rrfvr-rrr _iteritemss zAttributeDict._iteritemscCstdd|S)ay Render to HTML tag attributes. Example: .. code-block:: python >>> from django_tables2.utils import AttributeDict >>> attrs = AttributeDict({'class': 'mytable', 'id': 'someid'}) >>> attrs.as_html() 'class="mytable" id="someid"' returns: `~django.utils.safestring.SafeUnicode` object  z{}="{}")rrr3rrras_htmlszAttributeDict.as_htmlN)rrrrrrrrrrrrs   rc cs|s|sdS|D]R\}}|t|t|jt|ji}|D];\}}t|dt|t|kr\t|}||=|t|d}|rVt||D] } tt |g| VqIq!t|gVq!q dS)a Translates a flat sequence of items into a set of prefixed aliases. This allows the value set by `.QuerySet.order_by` to be translated into a list of columns that would have the same result. These are called "order by aliases" which are optionally prefixed column names:: >>> list(segment(('a', '-b', 'c'), ... {'x': ('a'), ... 'y': ('b', '-c'), ... 'z': ('-b', 'c')})) [('x', '-y'), ('x', 'z')] N) rr>rr6r lenrssegmenttupler) sequencealiasesaliaspartsvariantsvaliasvparts tail_aliases tail_sequencerrrrrs( rcCs\t|}g}d}|jD]}|j|jkr|j}q|j|jkr!q||jqt ||fS)z Returns: tuple: Returns a (arguments, kwarg_name)-tuple: - the arguments (positional or keyword) - the name of the ** kwarg catch all. The self-argument for methods is always removed. N) inspect signature parametersvalueskind VAR_KEYWORDrVAR_POSITIONALr r)fnrargskeywordsargrrrrs    rcsLt|\}|sfddDtfddDrdS|diS)aE Calls the function ``fn`` with the keyword arguments from ``kwargs`` it expects If the kwargs argument is defined, pass all arguments, else provide exactly the arguments wanted. If one of the arguments of ``fn`` are not contained in kwargs, ``fn`` will not be called and ``None`` will be returned. csi|] }|vr||qSrr)rjrfrkwargsrr 6sz)call_with_appropriate..c3s|]}|vVqdSr?r)rjrrrrrl9sz(call_with_appropriate..Nr)rany)rr kwargs_namerrrcall_with_appropriate)s rcCsT|pi}i}|D]\}}t|rt||d}t|tr#t||d}|||<q |S)a# Returns a new `dict` that has callable values replaced with the return values. Example:: >>> compute_values({'foo': lambda: 'bar'}) {'foo': 'bar'} Arbitrarily deep structures are supported. The logic is as follows: 1. If the value is callable, call it and make that the new value. 2. If the value is an instance of dict, use ComputableDict to compute its keys. Example:: >>> def parents(): ... return { ... 'father': lambda: 'Foo', ... 'mother': 'Bar' ... } ... >>> a = { ... 'name': 'Brad', ... 'parents': parents ... } ... >>> computed_values(a) {'name': 'Brad', 'parents': {'father': 'Foo', 'mother': 'Bar'}} Arguments: d (dict): The original dictionary. kwargs: any extra keyword arguments will be passed to the callables, if the callable takes an argument with such a name. Returns: dict: with callable values replaced. r)rrzrr@rscomputed_values)drresultkrrrrr?s&    rr?)rr( collectionsr functoolsr itertoolsrdjango.core.exceptionsr django.dbrdjango.utils.htmlrr rrJrrr>r%rrrrrrrrrrs(      2J$&%