^Q\G@s:ddlmZmZddlmZddlmZddlmZddl m Z ddl m Z ddl mZddlmZGd d d eZGd d d eZejGd ddeZGdddeZeZGdddeZddZddZddZdddZdS))absolute_importunicode_literals) OrderedDict)total_ordering)chain)models)FieldDoesNotExist)six)format_html_joinc@s"eZdZdZddZdS)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 aren't explicitly specified. cCs|jd}|dkr*tdn|dkrF|jdnt|}g}g}|}xX|D]P}|dkr|}qkn|j|||krk|j|j|qkqkWt||||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)selfcolumnsZellipsesheadtailtargetnamerI/var/www/dbchiro/venv/lib/python3.4/site-packages/django_tables2/utils.pyexpands$        zSequence.expandN)__name__ __module__ __qualname____doc__rrrrrr s r c@speZdZdZdZeddZeddZeddZed d Z d d Z d S)OrderByz| A single item in an `.OrderByTuple` object. This class is essentially just a `str` with some extra properties. __cCs.|dddkr*t|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 -)r )rrrrbareGs z OrderBy.barecCs+|jrt|ddStd|S)a Provides the opposite of the current sorting directon. Returns: `.OrderBy`: object with an opposite sort influence. Example:: >>> order_by = OrderBy('name') >>> order_by.opposite '-name' r Nr") is_descendingr )rrrroppositeUszOrderBy.oppositecCs |jdS)zN Returns `True` if this object induces *descending* ordering. r") startswith)rrrrr$fszOrderBy.is_descendingcCs|j S)zM Returns `True` if this object induces *ascending* ordering. )r$)rrrr is_ascendingmszOrderBy.is_ascendingcCs|jtjtjS)zf Returns the current instance usable in Django QuerySet's order_by arguments. )replaceAccessor SEPARATORr QUERYSET_SEPARATOR)rrrr for_querysettszOrderBy.for_querysetN) rrrrr+propertyr#r%r$r'r,rrrrr ?s r cseZdZdZfddZddZddZfdd Zed d Z d d Z eddZ 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' cs[g}x9|D]1}t|ts1t|}n|j|q Wtt|j||S)N) isinstancer rsuperr.__new__)clsiterableZ transformeditem) __class__rrr1s  zOrderByTuple.__new__cCs dj|S)N,)join)rrrr__str__szOrderByTuple.__str__cCs7t|j}x!|D]}|j|krdSqWdS)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)r r#)rrorder_byrrr __contains__s  zOrderByTuple.__contains__csat|tjrKx-|D]%}||ks:|j|kr|SqWtntt|j|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/r Z string_typesr#KeyErrorr0r. __getitem__)rrr9)r5rrr<s   zOrderByTuple.__getitem__cslggx4|D],}jt|jj|jqWtGfdddt}|S)NcsCeZdZddZfddZfddZdS)z$OrderByTuple.key..ComparatorcSs ||_dS)N)obj)rr=rrr__init__sz-OrderByTuple.key..Comparator.__init__csUxND]F}|j|jdd}|j|jdd}||ksdSqWdS)NquietTF)resolver=)rotheraccessorab) accessorsrr__eq__s   z+OrderByTuple.key..Comparator.__eq__c sxtjjD]\}}|j|jdd}|j|jdd}||krdqn|rz||}}ny||kSWqtk rt|t|k rt|t|kSt|}t|}t|t |ft|t |fkSYqXqWdS)Nr?TF) r Zmoveszipr@r= TypeErrorbooltypereprid)rrArBreverserCrDZa_typeZb_type)rE reversingrr__lt__s "    7z+OrderByTuple.key..Comparator.__lt__N)rrrr>rFrOr)rErNrr Comparators  rP)rr)r#r$robject)rr9rPr)rErNrkeys  $zOrderByTuple.keyc Cs/y ||SWnttfk r*|SYnXdS)zH Identical to __getitem__, but supports fallback value. N)r; IndexError)rrRfallbackrrrgets zOrderByTuple.getcCst|dd|DS)z Return version with each `.OrderBy` prefix toggled:: >>> order_by = OrderByTuple(('name', '-age')) >>> order_by.opposite ('-name', 'age') css|]}|jVqdS)N)r%).0orrr sz(OrderByTuple.opposite..)rJ)rrrrr%s zOrderByTuple.opposite) rrrrr1r8r:r<r-rRrUr%rr)r5rr.|s   / r.c@sgeZdZdZdZdZdZddddZed d Z d d Z dd dZ dS)r)z 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. .z9Refusing to call {method}() because `.alters_data = True`zRFailed lookup for key [{key}] in {context}, when resolving the accessor {accessor}TFc!Csyu|}xd|jD]Y}y||}Wntttfk ryt||}Wnttfk ry|t|}Wnittttfk rt|t j rt |n|}t|j j d|d|d|YnXYnXYnXt|r\|r;t|ddr;t|jj dt|nt|dds\|}q\n|dkrPqqW|SWntk r|snYnXdS) 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' Arguments: context (object): 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`) rRcontextrBZ alters_dataFmethodZdo_not_call_in_templatesN)bitsrHAttributeErrorr;getattrintrSrr/rZModelrJLOOKUP_ERROR_FMTformatcallableALTERS_DATA_ERROR_FMTrK Exception)rrZsafer?currentbitZcurrent_contextrrrr@s<$$3 !  zAccessor.resolvecCs |dkrfS|j|jS)N)splitr*)rrrrr\hs z Accessor.bitsc Cst|dsdSd}xs|jD]h}y|jj|}Wntk rTPYnXt|dr#t|dd}t|d|}q#q#W|S)zZ Return the django model field for model in context, following relations. _metaNZ remote_fieldmodel)hasattrr\rj get_fieldrr^)rrkfieldrgrelrrrrmns zAccessor.get_fieldcCs7|jd\}}}t|j|d||fS)a Split the accessor on the right-most dot '.', 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') rYr?) rpartitionAr@)rrZr?path_ remainderrrr penultimates zAccessor.penultimateN) rrrrr*rcr`r@r-r\rmrurrrrr)s J r)c@s4eZdZdZd ZddZddZd S) 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 _orderingccshxatj|D]P\}}t|r1|n|}||jkr|dk r||fVqqWdS)N)r iteritemsrb blacklist)rkvvaluerrr _iteritemsszAttributeDict._iteritemscCstdd|jS)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{}="{}")r r)rrrras_htmlszAttributeDict.as_htmlN)zthztdry)rrrrr{rrrrrrrvs  rvc cs|p |sdSx|jD]\}}it||6t|jt|j6}x|jD]\}}t|dt|t|krbt|}||=|t|d}|rxBt||D]} tt |g| VqWqbq t|gVqbqbWqWdS)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) itemsr.r%r rlendictsegmenttupler) sequencealiasesaliaspartsZvariantsZvaliasZvpartsZ tail_aliasesZ tail_sequencerrrrrs   ( rcCsddl}tjr{|j|}|j}t|dkrnt|ddkrb|ddn|}n||jfS|j|}g}d}x]|j j D]L}|j |j kr|j }q|j |jkrqq|j|j qWt||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. rNrr )inspectr ZPY2Z getargspecargsrrkeywords signature parametersvalueskindZ VAR_KEYWORDrZVAR_POSITIONALr)fnrZargspecrrrargrrrrs"   /  rcsdt|\}|sZfddDtfddDrZdSn|S)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. cs)i|]}|kr||qSrr)rVrR)rkwargsrr s z)call_with_appropriate..c3s|]}|kVqdS)Nr)rVr)rrrrXsz(call_with_appropriate..N)rany)rrZ kwargs_namer)rrrcall_with_appropriates rNcCs|p i}i}xltj|D][\}}t|rOt|d|}nt|trst|d|}n|||>> 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)r rzrbrr/rcomputed_values)drresultr|r}rrrrs&  r) __future__rr collectionsr functoolsr itertoolsrZ django.dbrZdjango.db.models.fieldsrZ django.utilsr Zdjango.utils.htmlr rr strr Zpython_2_unicode_compatiblerr.r)rqrvrrrrrrrrs$1= % % %